JVM_IR KT-36646 fuze primitive equality with safe call

.bunch

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

.devcontainer/devcontainer.json

@@ -1,12 +0,0 @@
-{
-  "name": "Java",
-  "image": "mcr.microsoft.com/devcontainers/java:1-21",
-  "features": {
-    "ghcr.io/devcontainers/features/java:1": {
-      "version": "none",
-      "installMaven": "true",
-      "mavenVersion": "3.8.6",
-      "installGradle": "true"
-    }
-  }
-}

.github/workflows/junie.yml

@@ -1,22 +0,0 @@
-name: Junie
-run-name: Junie run ${{ inputs.run_id }}
-
-permissions:
-  contents: write
-  pull-requests: write
-
-on:
-  workflow_dispatch:
-    inputs:
-      run_id:
-        description: "id of workflow process"
-        required: true
-      workflow_params:
-        description: "stringified params"
-        required: true
-
-jobs:
-  call-workflow-passing-data:
-    uses: jetbrains-junie/junie-workflows/.github/workflows/ej-issue.yml@main
-    with:
-      workflow_params: ${{ inputs.workflow_params }}

.gitignore

@@ -12,7 +12,6 @@
 /android-studio/sdk
 out/
 /tmp
-/intellij
 workspace.xml
 *.versionsBackup
 /idea/testData/debugger/tinyApp/classes*
@@ -58,7 +57,7 @@ build/
 .idea/artifacts/kotlin_stdlib_wasm_*
 .idea/jarRepositories.xml
 .idea/csv-plugin.xml
-.idea/libraries-with-intellij-classes.xml
+kotlin-ultimate/
 node_modules/
 .rpt2_cache/
 libraries/tools/kotlin-test-js-runner/lib/
@@ -68,4 +67,3 @@ distTmp/
 outTmp/
 /test.output
 /kotlin-native/dist
-kotlin-ide/

.idea/dictionaries/igor.xml

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

.idea/dictionaries/skuzmich.xml

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

.idea/kotlinc.xml

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

.idea/runConfigurations/Generate_FIR_Checker_Components_and_FIR_IDE_Diagnostics.xml

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

.idea/runConfigurations/IDEA.xml

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

.idea/runConfigurations/IDEA_Ultimate.xml

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

.idea/runConfigurations/IDEA_Ultimate__No_ProcessCanceledException__.xml

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

.idea/runConfigurations/IDEA__No_ProcessCanceledException_.xml

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

.idea/runConfigurations/IDEA__Not_Internal_.xml

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

.idea/runConfigurations/Test__Commonizer.xml

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

.idea/runConfigurations/Test__Commonizer___Light.xml

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

.idea/vcs.xml

@@ -8,18 +8,6 @@
       <inspection_tool class="SubjectLimit" enabled="true" level="WARNING" enabled_by_default="true" />
     </profile>
   </component>
-  <component name="GithubSharedProjectSettings">
-    <option name="branchProtectionPatterns">
-      <list>
-        <option value="master" />
-        <option value="1\.5\.0-M2" />
-        <option value="1\.5\.0" />
-        <option value="1\.5\.20" />
-        <option value="1\.5\.20-M1-release" />
-        <option value="1\.5\.20-RC-release" />
-      </list>
-    </option>
-  </component>
   <component name="IssueNavigationConfiguration">
     <option name="links">
       <list>

ReadMe.md

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

benchmarks/build.gradle.kts

@@ -1,11 +1,11 @@
 import kotlinx.benchmark.gradle.benchmark
 
-val benchmarks_version = "0.3.1"
+val benchmarks_version = "0.3.0"
 
 plugins {
     java
     kotlin("jvm")
-    id("org.jetbrains.kotlinx.benchmark") version "0.3.1"
+    id("org.jetbrains.kotlinx.benchmark") version "0.3.0"
 }
 
 dependencies {

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

@@ -12,7 +12,6 @@ import com.intellij.psi.PsiFileFactory
 import com.intellij.psi.impl.PsiFileFactoryImpl
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.testFramework.LightVirtualFile
-import org.jetbrains.kotlin.ObsoleteTestInfrastructure
 import org.jetbrains.kotlin.asJava.finder.JavaElementFinder
 import org.jetbrains.kotlin.builtins.jvm.JvmBuiltIns
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
@@ -25,7 +24,6 @@ import org.jetbrains.kotlin.context.withModule
 import org.jetbrains.kotlin.context.withProject
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.diagnostics.Severity
-import org.jetbrains.kotlin.fir.builder.PsiHandlingMode
 import org.jetbrains.kotlin.fir.builder.RawFirBuilder
 import org.jetbrains.kotlin.fir.createSessionForTests
 import org.jetbrains.kotlin.fir.java.FirJavaElementFinder
@@ -149,13 +147,12 @@ abstract class AbstractSimpleFileBenchmark {
         bh.consume(result.shouldGenerateCode)
     }
 
-    @OptIn(ObsoleteTestInfrastructure::class)
     private fun analyzeGreenFileIr(bh: Blackhole) {
         val scope = GlobalSearchScope.filesScope(env.project, listOf(file.virtualFile))
             .uniteWith(TopDownAnalyzerFacadeForJVM.AllJavaSourcesInProjectScope(env.project))
         val session = createSessionForTests(env, scope)
         val firProvider = session.firProvider as FirProviderImpl
-        val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider, PsiHandlingMode.COMPILER)
+        val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider)
 
         val totalTransformer = FirTotalResolveProcessor(session)
         val firFile = builder.buildFirFile(file).also(firProvider::recordFile)

build-common/build.gradle.kts

@@ -23,6 +23,9 @@ dependencies {
     testCompile(commonDep("junit:junit"))
     testCompile(protobufFull())
     testCompile(kotlinStdlib())
+    Platform[193].orLower {
+        testCompileOnly(intellijDep()) { includeJars("openapi", rootProject = rootProject) }
+    }
     testRuntime(project(":kotlin-reflect"))
 }
 

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

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

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

@@ -39,4 +39,4 @@ class GeneratedJvmClass(
     }
 }
 
-fun File.isModuleMappingFile() = extension == ModuleMapping.MAPPING_FILE_EXT && parentFile.name == "META-INF"
+fun File.isModuleMappingFile() = extension == ModuleMapping.MAPPING_FILE_EXT && parentFile.name == "META-INF"

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

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

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

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

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

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

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

@@ -1,76 +0,0 @@
-/*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.incremental
-
-import org.jetbrains.kotlin.name.FqName
-import java.io.ObjectInputStream
-import java.io.ObjectOutputStream
-import java.io.Serializable
-
-/**
- * Changes to the classpath of the `KotlinCompile` task, used to compute the source files that need to be recompiled during an incremental
- * run.
- */
-sealed class ClasspathChanges : Serializable {
-
-    class Available() : ClasspathChanges() {
-
-        lateinit var lookupSymbols: List<LookupSymbol>
-            private set
-
-        lateinit var fqNames: List<FqName>
-            private set
-
-        constructor(lookupSymbols: List<LookupSymbol>, fqNames: List<FqName>) : this() {
-            this.lookupSymbols = lookupSymbols
-            this.fqNames = fqNames
-        }
-
-        private fun writeObject(out: ObjectOutputStream) {
-            out.writeInt(lookupSymbols.size)
-            lookupSymbols.forEach {
-                out.writeUTF(it.name)
-                out.writeUTF(it.scope)
-            }
-
-            out.writeInt(fqNames.size)
-            fqNames.forEach {
-                out.writeUTF(it.asString())
-            }
-        }
-
-        private fun readObject(ois: ObjectInputStream) {
-            val lookupSymbolsSize = ois.readInt()
-            val lookupSymbols = ArrayList<LookupSymbol>(lookupSymbolsSize)
-            repeat(lookupSymbolsSize) {
-                val name = ois.readUTF()
-                val scope = ois.readUTF()
-                lookupSymbols.add(LookupSymbol(name, scope))
-            }
-            this.lookupSymbols = lookupSymbols
-
-            val fqNamesSize = ois.readInt()
-            val fqNames = ArrayList<FqName>(fqNamesSize)
-            repeat(fqNamesSize) {
-                val fqNameString = ois.readUTF()
-                fqNames.add(FqName(fqNameString))
-            }
-            this.fqNames = fqNames
-        }
-
-        companion object {
-            private const val serialVersionUID = 0L
-        }
-    }
-
-    sealed class NotAvailable : ClasspathChanges() {
-        object UnableToCompute : NotAvailable()
-        object ForNonIncrementalRun : NotAvailable()
-        object ClasspathSnapshotIsDisabled : NotAvailable()
-        object ReservedForTestsOnly : NotAvailable()
-        object ForJSCompiler : NotAvailable()
-    }
-}

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

@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.incremental
 
 import com.intellij.util.io.DataExternalizer
-import org.jetbrains.kotlin.build.GeneratedFile
 import org.jetbrains.kotlin.incremental.js.IncrementalResultsConsumerImpl
 import org.jetbrains.kotlin.incremental.js.IrTranslationResultValue
 import org.jetbrains.kotlin.incremental.js.TranslationResultValue
@@ -49,7 +48,6 @@ open class IncrementalJsCache(
         private const val INLINE_FUNCTIONS = "inline-functions"
         private const val HEADER_FILE_NAME = "header.meta"
         private const val PACKAGE_META_FILE = "packages-meta"
-        private const val SOURCE_TO_JS_OUTPUT = "source-to-js-output"
 
         fun hasHeaderFile(cachesDir: File) = File(cachesDir, HEADER_FILE_NAME).exists()
     }
@@ -62,7 +60,6 @@ open class IncrementalJsCache(
     private val irTranslationResults = registerMap(IrTranslationResultMap(IR_TRANSLATION_RESULT_MAP.storageFile, pathConverter))
     private val inlineFunctions = registerMap(InlineFunctionsMap(INLINE_FUNCTIONS.storageFile, pathConverter))
     private val packageMetadata = registerMap(PackageMetadataMap(PACKAGE_META_FILE.storageFile))
-    private val sourceToJsOutputsMap = registerMap(SourceToJsOutputMap(SOURCE_TO_JS_OUTPUT.storageFile, pathConverter))
 
     private val dirtySources = hashSetOf<File>()
 
@@ -78,7 +75,6 @@ open class IncrementalJsCache(
 
     override fun markDirty(removedAndCompiledSources: Collection<File>) {
         removedAndCompiledSources.forEach { sourceFile ->
-            sourceToJsOutputsMap.remove(sourceFile)
             // The common prefix of all FQN parents has to be the file package
             sourceToClassesMap[sourceFile].map { it.parentOrNull()?.asString() ?: "" }.minByOrNull { it.length }?.let {
                 packageMetadata.remove(it)
@@ -99,10 +95,6 @@ open class IncrementalJsCache(
         }
     }
 
-    fun getOutputsBySource(sourceFile: File): Collection<File> {
-        return sourceToJsOutputsMap.get(sourceFile)
-    }
-
     fun compareAndUpdate(incrementalResults: IncrementalResultsConsumerImpl, changesCollector: ChangesCollector) {
         val translatedFiles = incrementalResults.packageParts
 
@@ -137,8 +129,8 @@ open class IncrementalJsCache(
         }
 
         for ((srcFile, irData) in incrementalResults.irFileData) {
-            val (fileData, types, signatures, strings, declarations, bodies, fqn, debugInfos) = irData
-            irTranslationResults.put(srcFile, fileData, types, signatures, strings, declarations, bodies, fqn, debugInfos)
+            val (fileData, types, signatures, strings, declarations, bodies, fqn) = irData
+            irTranslationResults.put(srcFile, fileData, types, signatures, strings, declarations, bodies, fqn)
         }
     }
 
@@ -183,17 +175,6 @@ open class IncrementalJsCache(
                 }
             }
         }
-
-    fun updateSourceToOutputMap(
-        generatedFiles: Iterable<GeneratedFile>,
-    ) {
-        for (generatedFile in generatedFiles) {
-            for (source in generatedFile.sourceFiles) {
-                if (dirtySources.contains(source))
-                    sourceToJsOutputsMap.add(source, generatedFile.outputFile)
-            }
-        }
-    }
 }
 
 private object TranslationResultValueExternalizer : DataExternalizer<TranslationResultValue> {
@@ -234,20 +215,17 @@ private class TranslationResultMap(
     override fun dumpValue(value: TranslationResultValue): String =
         "Metadata: ${value.metadata.md5()}, Binary AST: ${value.binaryAst.md5()}, InlineData: ${value.inlineData.md5()}"
 
-    @Synchronized
     fun put(sourceFile: File, newMetadata: ByteArray, newBinaryAst: ByteArray, newInlineData: ByteArray) {
         storage[pathConverter.toPath(sourceFile)] =
             TranslationResultValue(metadata = newMetadata, binaryAst = newBinaryAst, inlineData = newInlineData)
     }
 
-    @Synchronized
     operator fun get(sourceFile: File): TranslationResultValue? =
         storage[pathConverter.toPath(sourceFile)]
 
     fun keys(): Collection<File> =
         storage.keys.map { pathConverter.toFile(it) }
 
-    @Synchronized
     fun remove(sourceFile: File, changesCollector: ChangesCollector) {
         val path = pathConverter.toPath(sourceFile)
         val protoBytes = storage[path]!!.metadata
@@ -269,7 +247,6 @@ private object IrTranslationResultValueExternalizer : DataExternalizer<IrTransla
         output.writeArray(value.declarations)
         output.writeArray(value.bodies)
         output.writeArray(value.fqn)
-        value.debugInfo?.let { output.writeArray(it) }
     }
 
     private fun DataOutput.writeArray(array: ByteArray) {
@@ -284,17 +261,6 @@ private object IrTranslationResultValueExternalizer : DataExternalizer<IrTransla
         return filedata
     }
 
-    private fun DataInput.readArrayOrNull(): ByteArray? {
-        try {
-            val dataSize = readInt()
-            val filedata = ByteArray(dataSize)
-            readFully(filedata)
-            return filedata
-        } catch (e: Throwable) {
-            return null
-        }
-    }
-
     override fun read(input: DataInput): IrTranslationResultValue {
         val fileData = input.readArray()
         val types = input.readArray()
@@ -303,9 +269,8 @@ private object IrTranslationResultValueExternalizer : DataExternalizer<IrTransla
         val declarations = input.readArray()
         val bodies = input.readArray()
         val fqn = input.readArray()
-        val debugInfos = input.readArrayOrNull()
 
-        return IrTranslationResultValue(fileData, types, signatures, strings, declarations, bodies, fqn, debugInfos)
+        return IrTranslationResultValue(fileData, types, signatures, strings, declarations, bodies, fqn)
     }
 }
 
@@ -330,11 +295,10 @@ private class IrTranslationResultMap(
         newStrings: ByteArray,
         newDeclarations: ByteArray,
         newBodies: ByteArray,
-        fqn: ByteArray,
-        debugInfos: ByteArray?
+        fqn: ByteArray
     ) {
         storage[pathConverter.toPath(sourceFile)] =
-            IrTranslationResultValue(newFiledata, newTypes, newSignatures, newStrings, newDeclarations, newBodies, fqn, debugInfos)
+            IrTranslationResultValue(newFiledata, newTypes, newSignatures, newStrings, newDeclarations, newBodies, fqn)
     }
 
     operator fun get(sourceFile: File): IrTranslationResultValue? =
@@ -395,7 +359,6 @@ private class InlineFunctionsMap(
     storageFile: File,
     private val pathConverter: FileToPathConverter
 ) : BasicStringMap<Map<String, Long>>(storageFile, StringToLongMapExternalizer) {
-    @Synchronized
     fun process(srcFile: File, newMap: Map<String, Long>, changesCollector: ChangesCollector) {
         val key = pathConverter.toPath(srcFile)
         val oldMap = storage[key] ?: emptyMap()
@@ -413,7 +376,6 @@ private class InlineFunctionsMap(
         }
     }
 
-    @Synchronized
     fun remove(sourceFile: File) {
         storage.remove(pathConverter.toPath(sourceFile))
     }

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

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

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

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

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

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

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

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

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

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

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

@@ -47,16 +47,10 @@ abstract class BasicMap<K : Comparable<K>, V>(
         storage.flush(memoryCachesOnly)
     }
 
-    // avoid unsynchronized close
     fun close() {
         storage.close()
     }
 
-    @TestOnly
-    fun closeForTest() {
-        close()
-    }
-
     @TestOnly
     fun dump(): String {
         return with(StringBuilder()) {

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

@@ -33,52 +33,45 @@ class CachingLazyStorage<K, V>(
     private val valueExternalizer: DataExternalizer<V>
 ) : LazyStorage<K, V> {
     private var storage: PersistentHashMap<K, V>? = null
-    private var isStorageFileExist = true
 
+    @Synchronized
     private fun getStorageIfExists(): PersistentHashMap<K, V>? {
         if (storage != null) return storage
 
-        if (!isStorageFileExist) return null
-
         if (storageFile.exists()) {
             storage = createMap()
             return storage
         }
 
-        isStorageFileExist = false
         return null
     }
 
+    @Synchronized
     private fun getStorageOrCreateNew(): PersistentHashMap<K, V> {
         if (storage == null) {
             storage = createMap()
         }
+
         return storage!!
     }
 
     override val keys: Collection<K>
-        @Synchronized
         get() = getStorageIfExists()?.allKeysWithExistingMapping ?: listOf()
 
-    @Synchronized
     override operator fun contains(key: K): Boolean =
         getStorageIfExists()?.containsMapping(key) ?: false
 
-    @Synchronized
     override operator fun get(key: K): V? =
         getStorageIfExists()?.get(key)
 
-    @Synchronized
     override operator fun set(key: K, value: V) {
         getStorageOrCreateNew().put(key, value)
     }
 
-    @Synchronized
     override fun remove(key: K) {
         getStorageIfExists()?.remove(key)
     }
 
-    @Synchronized
     override fun append(key: K, value: V) {
         getStorageOrCreateNew().appendData(key, { valueExternalizer.save(it, value) })
     }
@@ -110,11 +103,7 @@ class CachingLazyStorage<K, V>(
 
     @Synchronized
     override fun close() {
-        try {
-            storage?.close()
-        } finally {
-            storage = null
-        }
+        storage?.close()
     }
 
     private fun createMap(): PersistentHashMap<K, V> = PersistentHashMap(storageFile, keyDescriptor, valueExternalizer)

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

@@ -28,7 +28,6 @@ internal open class ClassOneToManyMap(storageFile: File) : BasicStringMap<Collec
         storage.append(key.asString(), listOf(value.asString()))
     }
 
-    @Synchronized
     operator fun get(key: FqName): Collection<FqName> =
         storage[key.asString()]?.map(::FqName) ?: setOf()
 

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

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

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

@@ -31,6 +31,7 @@ class NonCachingLazyStorage<K, V>(
 ) : LazyStorage<K, V> {
     private var storage: PersistentHashMap<K, V>? = null
 
+    @Synchronized
     private fun getStorageIfExists(): PersistentHashMap<K, V>? {
         if (storage != null) return storage
 
@@ -42,6 +43,7 @@ class NonCachingLazyStorage<K, V>(
         return null
     }
 
+    @Synchronized
     private fun getStorageOrCreateNew(): PersistentHashMap<K, V> {
         if (storage == null) {
             storage = createMap()
@@ -51,28 +53,22 @@ class NonCachingLazyStorage<K, V>(
     }
 
     override val keys: Collection<K>
-        @Synchronized
         get() = getStorageIfExists()?.allKeysWithExistingMapping ?: listOf()
 
-    @Synchronized
     override operator fun contains(key: K): Boolean =
         getStorageIfExists()?.containsMapping(key) ?: false
 
-    @Synchronized
     override operator fun get(key: K): V? =
         getStorageIfExists()?.get(key)
 
-    @Synchronized
     override operator fun set(key: K, value: V) {
         getStorageOrCreateNew().put(key, value)
     }
 
-    @Synchronized
     override fun remove(key: K) {
         getStorageIfExists()?.remove(key)
     }
 
-    @Synchronized
     override fun append(key: K, value: V) {
         getStorageOrCreateNew().appendData(key) { dataOutput -> valueExternalizer.save(dataOutput, value) }
     }
@@ -104,11 +100,7 @@ class NonCachingLazyStorage<K, V>(
 
     @Synchronized
     override fun close() {
-        try {
-            storage?.close()
-        } finally {
-            storage = null
-        }
+        storage?.close()
     }
 
     private fun createMap(): PersistentHashMap<K, V> =

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

@@ -1,43 +0,0 @@
-/*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.incremental.storage
-
-import org.jetbrains.kotlin.incremental.dumpCollection
-import java.io.File
-
-class SourceToJsOutputMap(storageFile: File, private val pathConverter: FileToPathConverter) : BasicStringMap<Collection<String>>(storageFile, StringCollectionExternalizer) {
-    override fun dumpValue(value: Collection<String>): String = value.dumpCollection()
-
-    @Synchronized
-    fun add(key: File, value: File) {
-        storage.append(pathConverter.toPath(key), listOf(pathConverter.toPath(value)))
-    }
-
-    operator fun get(sourceFile: File): Collection<File> =
-        storage[pathConverter.toPath(sourceFile)]?.map { pathConverter.toFile(it) } ?: setOf()
-
-
-    @Synchronized
-    operator fun set(key: File, values: Collection<File>) {
-        if (values.isEmpty()) {
-            remove(key)
-            return
-        }
-
-        storage[pathConverter.toPath(key)] = values.map { pathConverter.toPath(it) }
-    }
-
-    @Synchronized
-    fun remove(key: File) {
-        storage.remove(pathConverter.toPath(key))
-    }
-
-    @Synchronized
-    fun removeValues(key: File, removed: Set<File>) {
-        val notRemoved = this[key].filter { it !in removed }
-        this[key] = notRemoved
-    }
-}

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

@@ -17,53 +17,27 @@
 package org.jetbrains.kotlin.incremental.storage
 
 import com.intellij.openapi.util.io.FileUtil
-import com.intellij.openapi.util.text.StringUtil
 import com.intellij.util.io.DataExternalizer
 import com.intellij.util.io.EnumeratorStringDescriptor
 import com.intellij.util.io.IOUtil
 import com.intellij.util.io.KeyDescriptor
-import org.jetbrains.kotlin.cli.common.CompilerSystemProperties
-import org.jetbrains.kotlin.cli.common.toBooleanLenient
 import java.io.DataInput
 import java.io.DataInputStream
 import java.io.DataOutput
+import java.io.File
 import java.util.*
 
-/**
- * Storage versioning:
- * 0 - only name and value hashes are saved
- * 1 - name and scope are saved
- */
 object LookupSymbolKeyDescriptor : KeyDescriptor<LookupSymbolKey> {
     override fun read(input: DataInput): LookupSymbolKey {
-        val version = input.readByte()
-        return when (version.toInt()) {
-            0 -> {
-                val name = input.readUTF()
-                val scope = input.readUTF()
-                LookupSymbolKey(name.hashCode(), scope.hashCode(), name, scope)
-            }
-            1 -> {
-                val first = input.readInt()
-                val second = input.readInt()
-                LookupSymbolKey(first, second, "", "")
-            }
-            else -> throw RuntimeException("Unknown version of LookupSymbolKeyDescriptor=${version}")
-        }
+        val first = input.readInt()
+        val second = input.readInt()
+
+        return LookupSymbolKey(first, second)
     }
 
-    private val storeFullFqName = CompilerSystemProperties.COMPILE_INCREMENTAL_WITH_CLASSPATH_SHAPSHOTS.value.toBooleanLenient() ?: false
-
     override fun save(output: DataOutput, value: LookupSymbolKey) {
-        if (storeFullFqName) {
-            output.writeByte(0)
-            output.writeUTF(value.name)
-            output.writeUTF(value.scope)
-        } else {
-            output.writeByte(1)
-            output.writeInt(value.nameHash)
-            output.writeInt(value.scopeHash)
-        }
+        output.writeInt(value.nameHash)
+        output.writeInt(value.scopeHash)
     }
 
     override fun getHashCode(value: LookupSymbolKey): Int = value.hashCode()
@@ -94,12 +68,13 @@ object ProtoMapValueExternalizer : DataExternalizer<ProtoMapValue> {
     }
 }
 
+
 abstract class StringMapExternalizer<T> : DataExternalizer<Map<String, T>> {
     override fun save(output: DataOutput, map: Map<String, T>?) {
         output.writeInt(map!!.size)
 
         for ((key, value) in map.entries) {
-            output.writeString(key)
+            IOUtil.writeString(key, output)
             writeValue(output, value)
         }
     }
@@ -109,7 +84,7 @@ abstract class StringMapExternalizer<T> : DataExternalizer<Map<String, T>> {
         val map = HashMap<String, T>(size)
 
         repeat(size) {
-            val name = input.readString()
+            val name = IOUtil.readString(input)!!
             map[name] = readValue(input)
         }
 
@@ -120,6 +95,7 @@ abstract class StringMapExternalizer<T> : DataExternalizer<Map<String, T>> {
     protected abstract fun readValue(input: DataInput): T
 }
 
+
 object StringToLongMapExternalizer : StringMapExternalizer<Long>() {
     override fun readValue(input: DataInput): Long = input.readLong()
 
@@ -128,43 +104,58 @@ object StringToLongMapExternalizer : StringMapExternalizer<Long>() {
     }
 }
 
-/** [DataExternalizer] for a Kotlin constant. */
-object ConstantExternalizer : DataExternalizer<Any> {
-
-    override fun save(output: DataOutput, value: Any) {
-        when (value) {
-            is Int -> {
-                output.writeByte(Kind.INT.ordinal)
-                output.writeInt(value)
+object ConstantsMapExternalizer : DataExternalizer<Map<String, Any>> {
+    override fun save(output: DataOutput, map: Map<String, Any>?) {
+        output.writeInt(map!!.size)
+        for (name in map.keys.sorted()) {
+            IOUtil.writeString(name, output)
+            val value = map[name]!!
+            when (value) {
+                is Int -> {
+                    output.writeByte(Kind.INT.ordinal)
+                    output.writeInt(value)
+                }
+                is Float -> {
+                    output.writeByte(Kind.FLOAT.ordinal)
+                    output.writeFloat(value)
+                }
+                is Long -> {
+                    output.writeByte(Kind.LONG.ordinal)
+                    output.writeLong(value)
+                }
+                is Double -> {
+                    output.writeByte(Kind.DOUBLE.ordinal)
+                    output.writeDouble(value)
+                }
+                is String -> {
+                    output.writeByte(Kind.STRING.ordinal)
+                    IOUtil.writeString(value, output)
+                }
+                else -> throw IllegalStateException("Unexpected constant class: ${value::class.java}")
             }
-            is Float -> {
-                output.writeByte(Kind.FLOAT.ordinal)
-                output.writeFloat(value)
-            }
-            is Long -> {
-                output.writeByte(Kind.LONG.ordinal)
-                output.writeLong(value)
-            }
-            is Double -> {
-                output.writeByte(Kind.DOUBLE.ordinal)
-                output.writeDouble(value)
-            }
-            is String -> {
-                output.writeByte(Kind.STRING.ordinal)
-                output.writeString(value)
-            }
-            else -> throw IllegalStateException("Unexpected constant class: ${value::class.java}")
         }
     }
 
-    override fun read(input: DataInput): Any {
-        return when (Kind.values()[input.readByte().toInt()]) {
-            Kind.INT -> input.readInt()
-            Kind.FLOAT -> input.readFloat()
-            Kind.LONG -> input.readLong()
-            Kind.DOUBLE -> input.readDouble()
-            Kind.STRING -> input.readString()
+    override fun read(input: DataInput): Map<String, Any>? {
+        val size = input.readInt()
+        val map = HashMap<String, Any>(size)
+
+        repeat(size) {
+            val name = IOUtil.readString(input)!!
+            val kind = Kind.values()[input.readByte().toInt()]
+
+            val value: Any = when (kind) {
+                Kind.INT -> input.readInt()
+                Kind.FLOAT -> input.readFloat()
+                Kind.LONG -> input.readLong()
+                Kind.DOUBLE -> input.readDouble()
+                Kind.STRING -> IOUtil.readString(input)!!
+            }
+
+            map[name] = value
         }
+
+        return map
     }
 
     private enum class Kind {
@@ -173,47 +164,22 @@ object ConstantExternalizer : DataExternalizer<Any> {
 }
 
 object IntExternalizer : DataExternalizer<Int> {
-    override fun save(output: DataOutput, value: Int) = output.writeInt(value)
     override fun read(input: DataInput): Int = input.readInt()
+
+    override fun save(output: DataOutput, value: Int) {
+        output.writeInt(value)
+    }
 }
 
-object LongExternalizer : DataExternalizer<Long> {
-    override fun save(output: DataOutput, value: Long) = output.writeLong(value)
-    override fun read(input: DataInput): Long = input.readLong()
-}
-
-object StringExternalizer : DataExternalizer<String> {
-    override fun save(output: DataOutput, value: String) = IOUtil.writeString(value, output)
-    override fun read(input: DataInput): String = IOUtil.readString(input)
-}
-
-
-// Should be consistent with org.jetbrains.jps.incremental.storage.PathStringDescriptor for correct work of portable caches
 object PathStringDescriptor : EnumeratorStringDescriptor() {
-    private const val PORTABLE_CACHES_PROPERTY = "org.jetbrains.jps.portable.caches"
-    private val PORTABLE_CACHES = java.lang.Boolean.getBoolean(PORTABLE_CACHES_PROPERTY)
+    override fun getHashCode(value: String) = FileUtil.pathHashCode(value)
 
-    override fun getHashCode(path: String): Int {
-        if (!PORTABLE_CACHES) return FileUtil.pathHashCode(path)
-        // On case insensitive OS hash calculated from value converted to lower case
-        return if (StringUtil.isEmpty(path)) 0 else FileUtil.toCanonicalPath(path).hashCode()
-    }
-
-    override fun isEqual(val1: String, val2: String?): Boolean {
-        if (!PORTABLE_CACHES) return FileUtil.pathsEqual(val1, val2)
-        // On case insensitive OS hash calculated from path converted to lower case
-        if (val1 == val2) return true
-        if (val2 == null) return false
-
-        val path1 = FileUtil.toCanonicalPath(val1)
-        val path2 = FileUtil.toCanonicalPath(val2)
-        return path1 == path2
-    }
+    override fun isEqual(val1: String, val2: String?) = FileUtil.pathsEqual(val1, val2)
 }
 
 open class CollectionExternalizer<T>(
-    private val elementExternalizer: DataExternalizer<T>,
-    private val newCollection: () -> MutableCollection<T>
+        private val elementExternalizer: DataExternalizer<T>,
+        private val newCollection: () -> MutableCollection<T>
 ) : DataExternalizer<Collection<T>> {
     override fun read(input: DataInput): Collection<T> {
         val result = newCollection()
@@ -234,69 +200,3 @@ open class CollectionExternalizer<T>(
 object StringCollectionExternalizer : CollectionExternalizer<String>(EnumeratorStringDescriptor(), { HashSet() })
 
 object IntCollectionExternalizer : CollectionExternalizer<Int>(IntExternalizer, { HashSet() })
-
-fun DataOutput.writeString(value: String) = StringExternalizer.save(this, value)
-
-fun DataInput.readString(): String = StringExternalizer.read(this)
-
-class ListExternalizer<T>(
-    private val elementExternalizer: DataExternalizer<T>
-) : DataExternalizer<List<T>> {
-
-    override fun save(output: DataOutput, value: List<T>) {
-        output.writeInt(value.size)
-        value.forEach {
-            elementExternalizer.save(output, it)
-        }
-    }
-
-    override fun read(input: DataInput): List<T> {
-        val size = input.readInt()
-        val list = ArrayList<T>(size)
-        repeat(size) {
-            list.add(elementExternalizer.read(input))
-        }
-        return list
-    }
-}
-
-class LinkedHashMapExternalizer<K, V>(
-    private val keyExternalizer: DataExternalizer<K>,
-    private val valueExternalizer: DataExternalizer<V>
-) : DataExternalizer<LinkedHashMap<K, V>> {
-
-    override fun save(output: DataOutput, map: LinkedHashMap<K, V>) {
-        output.writeInt(map.size)
-        for ((key, value) in map) {
-            keyExternalizer.save(output, key)
-            valueExternalizer.save(output, value)
-        }
-    }
-
-    override fun read(input: DataInput): LinkedHashMap<K, V> {
-        val size = input.readInt()
-        val map = LinkedHashMap<K, V>(size)
-        repeat(size) {
-            val key = keyExternalizer.read(input)
-            val value = valueExternalizer.read(input)
-            map[key] = value
-        }
-        return map
-    }
-}
-
-class NullableValueExternalizer<T>(private val valueExternalizer: DataExternalizer<T>) : DataExternalizer<T> {
-
-    override fun save(output: DataOutput, value: T?) {
-        output.writeBoolean(value != null)
-        value?.let {
-            valueExternalizer.save(output, it)
-        }
-    }
-
-    override fun read(input: DataInput): T? {
-        return if (input.readBoolean()) {
-            valueExternalizer.read(input)
-        } else null
-    }
-}

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

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

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

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

build.gradle.kts

@@ -1,6 +1,7 @@
 import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 import org.gradle.crypto.checksum.Checksum
 import org.gradle.plugins.ide.idea.model.IdeaModel
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import proguard.gradle.ProGuardTask
 
 buildscript {
@@ -13,11 +14,8 @@ buildscript {
 
         if (cacheRedirectorEnabled) {
             maven("https://cache-redirector.jetbrains.com/plugins.gradle.org/m2")
-            maven("https://cache-redirector.jetbrains.com/repo.maven.apache.org/maven2")
-
         } else {
             maven("https://plugins.gradle.org/m2")
-            mavenCentral()
         }
     }
 
@@ -29,13 +27,18 @@ buildscript {
     dependencies {
         bootstrapCompilerClasspath(kotlin("compiler-embeddable", bootstrapKotlinVersion))
 
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.32")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.26")
         classpath(kotlin("gradle-plugin", bootstrapKotlinVersion))
         classpath(kotlin("serialization", bootstrapKotlinVersion))
         classpath("org.jetbrains.dokka:dokka-gradle-plugin:0.9.17")
+        classpath("org.jfrog.buildinfo:build-info-extractor-gradle:4.17.2")
     }
 }
 
+if (kotlinBuildProperties.buildScanServer != null) {
+    apply(from = "gradle/buildScanUserData.gradle")
+}
+
 plugins {
     base
     idea
@@ -55,6 +58,13 @@ pill {
 
 val isTeamcityBuild = project.kotlinBuildProperties.isTeamcityBuild
 
+val configuredJdks: List<JdkId> =
+    getConfiguredJdks().also {
+        it.forEach { jdkId ->
+            logger.info("Using ${jdkId.majorVersion} home: ${jdkId.homeDir}")
+        }
+    }
+
 val defaultSnapshotVersion: String by extra
 val buildNumber by extra(findProperty("build.number")?.toString() ?: defaultSnapshotVersion)
 val kotlinVersion by extra(
@@ -80,8 +90,10 @@ val distKotlinHomeDir by extra("$distDir/kotlinc")
 val distLibDir = "$distKotlinHomeDir/lib"
 val commonLocalDataDir = "$rootDir/local"
 val ideaSandboxDir = "$commonLocalDataDir/ideaSandbox"
+val ideaUltimateSandboxDir = "$commonLocalDataDir/ideaUltimateSandbox"
 val artifactsDir = "$distDir/artifacts"
 val ideaPluginDir = "$artifactsDir/ideaPlugin/Kotlin"
+val ideaUltimatePluginDir = "$artifactsDir/ideaUltimatePlugin/Kotlin"
 
 extra["ktorExcludesForDaemon"] = listOf(
     "org.jetbrains.kotlin" to "kotlin-reflect",
@@ -99,13 +111,46 @@ extra["distLibDir"] = project.file(distLibDir)
 extra["libsDir"] = project.file(distLibDir)
 extra["commonLocalDataDir"] = project.file(commonLocalDataDir)
 extra["ideaSandboxDir"] = project.file(ideaSandboxDir)
+extra["ideaUltimateSandboxDir"] = project.file(ideaUltimateSandboxDir)
 extra["ideaPluginDir"] = project.file(ideaPluginDir)
+extra["ideaUltimatePluginDir"] = project.file(ideaUltimatePluginDir)
 extra["isSonatypeRelease"] = false
 val kotlinNativeVersionObject = project.kotlinNativeVersionValue()
 subprojects {
     extra["kotlinNativeVersion"] = kotlinNativeVersionObject
 }
 
+// Work-around necessary to avoid setting null javaHome. Will be removed after support of lazy task configuration
+val jdkNotFoundConst = "JDK NOT FOUND"
+
+if (isTeamcityBuild) {
+    extra["JDK_16"] = jdkPath("1.6")
+    extra["JDK_17"] = jdkPath("1.7")
+} else {
+    extra["JDK_16"] = jdkPath("1.6", "1.8")
+    extra["JDK_17"] = jdkPath("1.7", "1.8")
+}
+extra["JDK_18"] = jdkPath("1.8")
+extra["JDK_9"] = jdkPath("9")
+extra["JDK_10"] = jdkPath("10")
+extra["JDK_11"] = jdkPath("11")
+extra["JDK_15"] = jdkPath("15")
+
+// allow opening the project without setting up all env variables (see KT-26413)
+if (!kotlinBuildProperties.isInIdeaSync) {
+    checkJDK()
+}
+
+fun checkJDK() {
+    val missingEnvVars = JdkMajorVersion.values()
+        .filter { it.isMandatory() && extra[it.name] == jdkNotFoundConst }
+        .mapTo(ArrayList()) { it.name }
+
+    if (missingEnvVars.isNotEmpty()) {
+        throw GradleException("Required environment variables are missing: ${missingEnvVars.joinToString()}")
+    }
+}
+
 rootProject.apply {
     from(rootProject.file("gradle/versions.gradle.kts"))
     from(rootProject.file("gradle/report.gradle.kts"))
@@ -128,9 +173,8 @@ extra["versions.junit"] = "4.12"
 extra["versions.javaslang"] = "2.0.6"
 extra["versions.ant"] = "1.10.7"
 extra["versions.android"] = "2.3.1"
-extra["versions.kotlinx-coroutines-core"] = "1.5.0"
-extra["versions.kotlinx-coroutines-core-jvm"] = "1.5.0"
-extra["versions.kotlinx-coroutines-jdk8"] = "1.5.0"
+extra["versions.kotlinx-coroutines-core"] = "1.3.8"
+extra["versions.kotlinx-coroutines-jdk8"] = "1.3.8"
 extra["versions.json"] = "20160807"
 extra["versions.native-platform"] = "0.14"
 extra["versions.robolectric"] = "4.0"
@@ -139,7 +183,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.3"
-extra["versions.r8"] = "2.2.64"
+extra["versions.r8"] = "2.1.96"
 val immutablesVersion = "0.3.1"
 extra["versions.kotlinx-collections-immutable"] = immutablesVersion
 extra["versions.kotlinx-collections-immutable-jvm"] = immutablesVersion
@@ -148,9 +192,13 @@ extra["versions.kotlinx-collections-immutable-jvm"] = immutablesVersion
 extra["versions.ktor-network"] = "1.0.1"
 
 if (!project.hasProperty("versions.kotlin-native")) {
-    extra["versions.kotlin-native"] = "1.6.0-dev-2972"
+    extra["versions.kotlin-native"] = "1.5.20-dev-5613"
 }
 
+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.kotlinBuildProperties.useIR)
 val useJvmFir by extra(project.kotlinBuildProperties.useFir)
 
 val intellijSeparateSdks = project.getBooleanProperty("intellijSeparateSdks") ?: false
@@ -159,11 +207,15 @@ extra["intellijSeparateSdks"] = intellijSeparateSdks
 
 extra["IntellijCoreDependencies"] =
     listOf(
-        "asm-all-9.0",
+        when {
+            Platform[202].orHigher() -> "asm-all-8.0.1"
+            else -> "asm-all-7.0.1"
+        },
         "guava",
         "jdom",
         "jna",
         "log4j",
+        if (Platform[201].orHigher()) null else "picocontainer",
         "snappy-in-java",
         "streamex",
         "trove4j"
@@ -211,7 +263,6 @@ extra["compilerModules"] = arrayOf(
     ":compiler:incremental-compilation-impl",
     ":compiler:compiler.version",
     ":js:js.ast",
-    ":js:js.sourcemap",
     ":js:js.serializer",
     ":js:js.parser",
     ":js:js.config",
@@ -247,7 +298,6 @@ extra["compilerModules"] = arrayOf(
     ":compiler:fir:java",
     ":compiler:fir:jvm",
     ":compiler:fir:checkers",
-    ":compiler:fir:checkers:checkers.jvm",
     ":compiler:fir:entrypoint",
     ":compiler:fir:analysis-tests",
     ":compiler:fir:analysis-tests:legacy-fir-tests",
@@ -267,6 +317,7 @@ extra["compilerModulesForJps"] = listOf(
     ":core:compiler.common.jvm",
     ":core:descriptors",
     ":core:descriptors.jvm",
+    ":idea:idea-jps-common",
     ":kotlin-preloader",
     ":compiler:util",
     ":compiler:config",
@@ -276,46 +327,13 @@ extra["compilerModulesForJps"] = listOf(
     ":compiler:compiler.version"
 )
 
-extra["compilerArtifactsForIde"] = listOf(
-    ":prepare:ide-plugin-dependencies:android-extensions-compiler-plugin-for-ide",
-    ":prepare:ide-plugin-dependencies:allopen-compiler-plugin-for-ide",
-    ":prepare:ide-plugin-dependencies:incremental-compilation-impl-tests-for-ide",
-    ":prepare:ide-plugin-dependencies:js-ir-runtime-for-ide",
-    ":prepare:ide-plugin-dependencies:kotlin-build-common-tests-for-ide",
-    ":prepare:ide-plugin-dependencies:kotlin-compiler-for-ide",
-    ":prepare:ide-plugin-dependencies:kotlin-compiler-cli-for-ide",
-    ":prepare:ide-plugin-dependencies:kotlin-gradle-statistics-for-ide",
-    ":prepare:ide-plugin-dependencies:kotlinx-serialization-compiler-plugin-for-ide",
-    ":prepare:ide-plugin-dependencies:noarg-compiler-plugin-for-ide",
-    ":prepare:ide-plugin-dependencies:sam-with-receiver-compiler-plugin-for-ide",
-    ":prepare:ide-plugin-dependencies:compiler-components-for-jps",
-    ":prepare:ide-plugin-dependencies:parcelize-compiler-plugin-for-ide",
-    ":prepare:ide-plugin-dependencies:lombok-compiler-plugin-for-ide",
-    ":prepare:ide-plugin-dependencies:kotlin-compiler-tests-for-ide",
-    ":prepare:ide-plugin-dependencies:kotlin-compiler-testdata-for-ide",
-    ":prepare:ide-plugin-dependencies:kotlin-stdlib-minimal-for-test-for-ide",
-    ":prepare:ide-plugin-dependencies:low-level-api-fir-for-ide",
-    ":prepare:ide-plugin-dependencies:high-level-api-for-ide",
-    ":prepare:ide-plugin-dependencies:high-level-api-fir-for-ide",
-    ":prepare:ide-plugin-dependencies:high-level-api-fir-tests-for-ide",
-    ":kotlin-script-runtime",
-    ":kotlin-script-util",
-    ":kotlin-scripting-common",
-    ":kotlin-scripting-jvm",
-    ":kotlin-scripting-compiler",
-    ":kotlin-scripting-compiler-impl",
-    ":kotlin-android-extensions-runtime",
-    ":kotlin-stdlib-common",
-    ":kotlin-stdlib",
-    ":kotlin-stdlib-jdk7",
-    ":kotlin-stdlib-jdk8",
-    ":kotlin-reflect",
-    ":kotlin-main-kts"
-)
-
 // TODO: fix remaining warnings and remove this property.
 extra["tasksWithWarnings"] = listOf(
-    ":kotlin-gradle-plugin:compileKotlin"
+    ":kotlin-stdlib:compileTestKotlin",
+    ":kotlin-stdlib-jdk7:compileTestKotlin",
+    ":kotlin-stdlib-jdk8:compileTestKotlin",
+    ":plugins:uast-kotlin:compileKotlin",
+    ":plugins:uast-kotlin:compileTestKotlin"
 )
 
 val tasksWithWarnings: List<String> by extra
@@ -340,12 +358,7 @@ val coreLibProjects = listOfNotNull(
 val projectsWithDisabledFirBootstrap = coreLibProjects + listOf(
     ":kotlin-gradle-plugin",
     ":kotlinx-metadata",
-    ":kotlinx-metadata-jvm",
-    // For some reason stdlib isn't imported correctly for this module
-    // Probably it's related to kotlin-test module usage
-    ":kotlin-gradle-statistics",
-    // Requires serialization plugin
-    ":wasm:wasm.ir"
+    ":kotlinx-metadata-jvm"
 )
 
 val gradlePluginProjects = listOf(
@@ -365,7 +378,7 @@ apply {
 }
 
 apply {
-    if (extra["isDeployStagingRepoGenerationRequired"] as? Boolean == true) {
+    if (extra["isSonatypeRelease"] as? Boolean == true) {
         logger.info("Applying configuration for sonatype release")
         from("libraries/prepareSonatypeStaging.gradle")
     }
@@ -379,9 +392,39 @@ fun Task.listConfigurationContents(configName: String) {
     }
 }
 
+val defaultJvmTarget = "1.8"
+val defaultJavaHome = jdkPath(if (Platform[203].orHigher()) "11" else defaultJvmTarget)
 val ignoreTestFailures by extra(project.kotlinBuildProperties.ignoreTestFailures)
 
 allprojects {
+
+    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"))
+        }
+    }
+
+    jvmTarget = defaultJvmTarget
+    javaHome = defaultJavaHome
+
+    // There are problems with common build dir:
+    //  - some tests (in particular js and binary-compatibility-validator depend on the fixed (default) location
+    //  - idea seems unable to exclude common buildDir from indexing
+    // therefore it is disabled by default
+    // buildDir = File(commonBuildDir, project.name)
+
     val mirrorRepo: String? = findProperty("maven.repository.mirror")?.toString()
 
     repositories {
@@ -402,47 +445,11 @@ allprojects {
         jcenter()
     }
 
-    if (path.startsWith(":kotlin-ide.")) {
-        return@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"))
-        }
-    }
-
-    // There are problems with common build dir:
-    //  - some tests (in particular js and binary-compatibility-validator depend on the fixed (default) location
-    //  - idea seems unable to exclude common buildDir from indexing
-    // therefore it is disabled by default
-    // buildDir = File(commonBuildDir, project.name)
-
-    project.configureJvmDefaultToolchain()
-    plugins.withId("java-base") {
-        project.configureShadowJarSubstitutionInCompileClasspath()
-    }
-
-    tasks.withType<JavaCompile> {
-        options.compilerArgs.add("-Xlint:deprecation")
-        options.compilerArgs.add("-Xlint:unchecked")
-        options.compilerArgs.add("-Werror")
-    }
+    configureJvmProject(javaHome!!, jvmTarget!!)
 
     val commonCompilerArgs = listOfNotNull(
         "-Xopt-in=kotlin.RequiresOptIn",
+        "-Xread-deserialized-contracts",
         "-progressive".takeIf { hasProperty("test.progressive.mode") }
     )
 
@@ -458,26 +465,34 @@ allprojects {
         "-Xjvm-default=compatibility",
         "-Xno-optimized-callable-references",
         "-Xno-kotlin-nothing-value-exception",
-        "-Xskip-runtime-version-check",
-        "-Xsuppress-deprecated-jvm-target-warning" // Remove as soon as there are no modules for JDK 1.6 & 1.7
+        "-Xnormalize-constructor-calls=enable"
     )
 
     tasks.withType<org.jetbrains.kotlin.gradle.dsl.KotlinJvmCompile> {
         kotlinOptions {
             freeCompilerArgs = commonCompilerArgs + jvmCompilerArgs
 
-            if (useJvmFir && this@allprojects.path !in projectsWithDisabledFirBootstrap) {
+            if (useJvmIrBackend) {
+                useIR = true
+            }
+
+            if (useJvmFir && this@allprojects.name !in projectsWithDisabledFirBootstrap) {
                 freeCompilerArgs += "-Xuse-fir"
                 freeCompilerArgs += "-Xabi-stability=stable"
             }
         }
     }
 
-    if (!kotlinBuildProperties.disableWerror) {
-        tasks.withType<org.jetbrains.kotlin.gradle.dsl.KotlinJvmCompile> {
-            if (path !in tasksWithWarnings) {
-                kotlinOptions {
-                    allWarningsAsErrors = true
+    if (!kotlinBuildProperties.isInJpsBuildIdeaSync && !kotlinBuildProperties.useFir && !kotlinBuildProperties.disableWerror) {
+        // For compiler and stdlib, allWarningsAsErrors is configured in the corresponding "root" projects
+        // (compiler/build.gradle.kts and libraries/commonConfiguration.gradle).
+        val projectsWithWarningsAsErrors = listOf("core", "plugins").map { File(it).absoluteFile }
+        if (projectsWithWarningsAsErrors.any(projectDir::startsWith)) {
+            tasks.withType<org.jetbrains.kotlin.gradle.dsl.KotlinJvmCompile> {
+                if (path !in tasksWithWarnings) {
+                    kotlinOptions {
+                        allWarningsAsErrors = true
+                    }
                 }
             }
         }
@@ -504,16 +519,12 @@ allprojects {
         outputs.doNotCacheIf("https://youtrack.jetbrains.com/issue/KTI-112") { true }
     }
 
-    if (isConfigurationCacheDisabled) {
-        // Custom input normolization isn't supported by configuration cache at the moment
-        // See https://github.com/gradle/gradle/issues/13706
-        normalization {
-            runtimeClasspath {
-                ignore("META-INF/MANIFEST.MF")
-                ignore("META-INF/compiler.version")
-                ignore("META-INF/plugin.xml")
-                ignore("kotlin/KotlinVersionCurrentValue.class")
-            }
+    normalization {
+        runtimeClasspath {
+            ignore("META-INF/MANIFEST.MF")
+            ignore("META-INF/compiler.version")
+            ignore("META-INF/plugin.xml")
+            ignore("kotlin/KotlinVersionCurrentValue.class")
         }
     }
 
@@ -528,9 +539,12 @@ allprojects {
         register("checkBuild")
     }
 
-    apply(from = "$rootDir/gradle/cacheRedirector.gradle.kts")
-
     afterEvaluate {
+        if (javaHome != defaultJavaHome || jvmTarget != defaultJvmTarget) {
+            logger.info("configuring project $name to compile to the target jvm version $jvmTarget using jdk: $javaHome")
+            configureJvmProject(javaHome!!, jvmTarget!!)
+        } // else we will actually fail during the first task execution. We could not fail before configuration is done due to impact on import in IDE
+
         fun File.toProjectRootRelativePathOrSelf() = (relativeToOrNull(rootDir)?.takeUnless { it.startsWith("..") } ?: this).path
 
         fun FileCollection.printClassPath(role: String) =
@@ -559,6 +573,7 @@ allprojects {
                 ?.exclude("org.jetbrains.kotlin", "kotlin-scripting-compiler-embeddable")
         }
 
+        apply(from = "$rootDir/gradle/cacheRedirector.gradle.kts")
         apply(from = "$rootDir/gradle/testRetry.gradle.kts")
     }
 }
@@ -766,7 +781,6 @@ tasks {
 
     register("distTest") {
         dependsOn("compilerTest")
-        dependsOn("frontendApiTests")
         dependsOn("toolsTest")
         dependsOn("gradlePluginTest")
         dependsOn("examplesTest")
@@ -828,22 +842,12 @@ tasks {
         dependsOn("dist")
         dependsOn(
             ":idea:idea-fir:test",
-            ":idea:idea-frontend-fir:fir-low-level-api-ide-impl:test",
-            ":plugins:uast-kotlin-fir:test",
-            ":idea:idea-fir-fe10-binding:test"
+            ":idea:idea-frontend-api:test",
+            ":idea:idea-frontend-fir:test",
+            ":idea:idea-frontend-fir:idea-fir-low-level-api:test"
         )
     }
 
-    register("frontendApiTests") {
-        dependsOn("dist")
-        dependsOn(
-            ":idea-frontend-api:test",
-            ":idea-frontend-fir:test",
-            ":idea-frontend-fir:idea-fir-low-level-api:test"
-        )
-    }
-
-
 
     register("android-ide-tests") {
         dependsOn("dist")
@@ -890,6 +894,7 @@ tasks {
         }
     }
 
+
     register("kaptIdeTest") {
         dependsOn(":kotlin-annotation-processing:test")
         dependsOn(":kotlin-annotation-processing-base:test")
@@ -903,6 +908,22 @@ tasks {
         )
     }
 
+    register("kmmTest", AggregateTest::class) {
+        dependsOn(
+            ":idea:idea-gradle:test",
+            ":idea:test",
+            ":compiler:test",
+            ":compiler:container:test",
+            ":js:js.tests:test"
+        )
+
+        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 {
             throw GradleException("Don't use directly, use aggregate tasks *-check instead")
@@ -929,13 +950,32 @@ tasks {
 
     register("publishIdeArtifacts") {
         idePluginDependency {
-            dependsOn((rootProject.extra["compilerArtifactsForIde"] as List<String>).map { "$it:publish" })
-        }
-    }
-
-    register("installIdeArtifacts") {
-        idePluginDependency {
-            dependsOn((rootProject.extra["compilerArtifactsForIde"] as List<String>).map { "$it:install" })
+            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: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-gradle-statistics-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:kotlinx-serialization-compiler-plugin-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:noarg-compiler-plugin-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:sam-with-receiver-compiler-plugin-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:compiler-components-for-jps:publish",
+                ":prepare:ide-plugin-dependencies:parcelize-compiler-plugin-for-ide:publish",
+                ":kotlin-script-runtime:publish",
+                ":kotlin-script-util:publish",
+                ":kotlin-scripting-common:publish",
+                ":kotlin-scripting-jvm:publish",
+                ":kotlin-scripting-compiler:publish",
+                ":kotlin-scripting-compiler-impl:publish",
+                ":kotlin-android-extensions-runtime:publish",
+                ":kotlin-stdlib-common:publish",
+                ":kotlin-stdlib:publish",
+                ":kotlin-stdlib-jdk7:publish",
+                ":kotlin-stdlib-jdk8:publish",
+                ":kotlin-reflect:publish",
+                ":kotlin-main-kts:publish"
+            )
         }
     }
 }
@@ -987,7 +1027,8 @@ val zipTestData by task<Zip> {
 val zipPlugin by task<Zip> {
     val src = when (project.findProperty("pluginArtifactDir") as String?) {
         "Kotlin" -> ideaPluginDir
-        null -> ideaPluginDir
+        "KotlinUltimate" -> ideaUltimatePluginDir
+        null -> if (project.hasProperty("ultimate")) ideaUltimatePluginDir else ideaPluginDir
         else -> error("Unsupported plugin artifact dir")
     }
     val destPath = project.findProperty("pluginZipPath") as String?
@@ -1044,6 +1085,66 @@ configure<IdeaModel> {
     }
 }
 
+fun jdkPathOrNull(version: String): String? {
+    val jdkName = "JDK_${version.replace(".", "")}"
+    val jdkMajorVersion = JdkMajorVersion.valueOf(jdkName)
+    return configuredJdks.find { it.majorVersion == jdkMajorVersion }?.homeDir?.canonicalPath
+}
+
+fun jdkPath(version: String, vararg replacementVersions: String): String {
+    return jdkPathOrNull(version) ?: run {
+        replacementVersions.asSequence().map { jdkPathOrNull(it) }.find { it != null }
+    } ?: jdkNotFoundConst
+}
+
+fun Project.configureJvmProject(javaHome: String, javaVersion: String) {
+    val currentJavaHome = File(System.getProperty("java.home")!!).canonicalPath
+    val shouldFork = !currentJavaHome.startsWith(File(javaHome).canonicalPath)
+
+    tasks.withType<JavaCompile> {
+        if (name != "compileJava9Java") {
+            sourceCompatibility = javaVersion
+            targetCompatibility = javaVersion
+            options.isFork = shouldFork
+            options.forkOptions.javaHome = file(javaHome)
+            options.compilerArgs.add("-proc:none")
+            options.encoding = "UTF-8"
+        }
+    }
+
+    tasks.withType<KotlinCompile> {
+        kotlinOptions.jdkHome = javaHome
+        kotlinOptions.jvmTarget = javaVersion
+        kotlinOptions.freeCompilerArgs += "-Xjvm-default=compatibility"
+    }
+
+    tasks.withType<Test> {
+        executable = File(javaHome, "bin/java").canonicalPath
+    }
+
+    plugins.withId("java-base") {
+        configureShadowJarSubstitutionInCompileClasspath()
+    }
+}
+
+fun Project.configureShadowJarSubstitutionInCompileClasspath() {
+    val substitutionMap = mapOf(":kotlin-reflect" to ":kotlin-reflect-api")
+
+    fun configureSubstitution(substitution: DependencySubstitution) {
+        val requestedProject = (substitution.requested as? ProjectComponentSelector)?.projectPath ?: return
+        val replacementProject = substitutionMap[requestedProject] ?: return
+        substitution.useTarget(project(replacementProject), "Non-default shadow jars should not be used in compile classpath")
+    }
+
+    sourceSets.all {
+        for (configName in listOf(compileOnlyConfigurationName, compileClasspathConfigurationName)) {
+            configurations.getByName(configName).resolutionStrategy.dependencySubstitution {
+                all(::configureSubstitution)
+            }
+        }
+    }
+}
+
 tasks.register("findShadowJarsInClasspath") {
     doLast {
         fun Collection<File>.printSorted(indent: String = "    ") {
@@ -1111,19 +1212,3 @@ if (disableVerificationTasks) {
         }
     }
 }
-
-plugins.withType(org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsRootPlugin::class) {
-    extensions.configure(org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsRootExtension::class.java) {
-        nodeVersion = "16.2.0"
-    }
-}
-
-afterEvaluate {
-    val cacheRedirectorEnabled = findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() == true
-    if (cacheRedirectorEnabled) {
-        rootProject.plugins.withType(org.jetbrains.kotlin.gradle.targets.js.yarn.YarnPlugin::class.java) {
-            rootProject.the<org.jetbrains.kotlin.gradle.targets.js.yarn.YarnRootExtension>().downloadBaseUrl =
-                "https://cache-redirector.jetbrains.com/github.com/yarnpkg/yarn/releases/download"
-        }
-    }
-}

buildSrc/build.gradle.kts

@@ -22,7 +22,7 @@ buildscript {
     }
 
     dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.32")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.26")
         classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${project.bootstrapKotlinVersion}")
         classpath("org.jetbrains.kotlin:kotlin-sam-with-receiver:${project.bootstrapKotlinVersion}")
     }
@@ -69,6 +69,7 @@ rootProject.apply {
 }
 
 val isTeamcityBuild = kotlinBuildProperties.isTeamcityBuild
+val intellijUltimateEnabled by extra(kotlinBuildProperties.intellijUltimateEnabled)
 val intellijSeparateSdks by extra(project.getBooleanProperty("intellijSeparateSdks") ?: false)
 
 extra["intellijReleaseType"] = when {
@@ -143,7 +144,7 @@ java {
 dependencies {
     implementation(kotlin("stdlib", embeddedKotlinVersion))
     implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:${project.bootstrapKotlinVersion}")
-    implementation("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.32")
+    implementation("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.26")
     implementation("com.gradle.publish:plugin-publish-plugin:0.14.0")
 
     implementation("net.rubygrapefruit:native-platform:${property("versions.native-platform")}")
@@ -155,10 +156,10 @@ dependencies {
     implementation("net.sf.proguard:proguard-gradle:6.2.2")
     implementation("org.jetbrains.intellij.deps:asm-all:8.0.1")
 
-    implementation("gradle.plugin.org.jetbrains.gradle.plugin.idea-ext:gradle-idea-ext:1.0.1")
+    implementation("gradle.plugin.org.jetbrains.gradle.plugin.idea-ext:gradle-idea-ext:0.5")
 
     implementation("org.gradle:test-retry-gradle-plugin:1.2.0")
-    implementation("com.gradle.enterprise:test-distribution-gradle-plugin:2.1")
+    implementation("com.gradle.enterprise:test-distribution-gradle-plugin:1.2.1")
 
     compileOnly(gradleApi())
 

buildSrc/prepare-deps/build.gradle.kts

@@ -15,28 +15,30 @@ plugins {
     base
 }
 
+val intellijUltimateEnabled: Boolean by rootProject.extra
 val intellijReleaseType: String by rootProject.extra
 val intellijVersion = rootProject.extra["versions.intellijSdk"] as String
-val intellijVersionForIde = rootProject.intellijSdkVersionForIde()
 val asmVersion = rootProject.findProperty("versions.jar.asm-all") as String?
 val androidStudioRelease = rootProject.findProperty("versions.androidStudioRelease") as String?
 val androidStudioBuild = rootProject.findProperty("versions.androidStudioBuild") as String?
 val intellijSeparateSdks: Boolean by rootProject.extra
+val installIntellijCommunity = !intellijUltimateEnabled || intellijSeparateSdks
+val installIntellijUltimate = intellijUltimateEnabled && androidStudioRelease == null
 
-fun checkIntellijVersion(intellijVersion: String) {
-    val intellijVersionDelimiterIndex = intellijVersion.indexOfAny(charArrayOf('.', '-'))
-    if (intellijVersionDelimiterIndex == -1) {
-        error("Invalid IDEA version $intellijVersion")
-    }
+val intellijVersionDelimiterIndex = intellijVersion.indexOfAny(charArrayOf('.', '-'))
+if (intellijVersionDelimiterIndex == -1) {
+    error("Invalid IDEA version $intellijVersion")
 }
-checkIntellijVersion(intellijVersion)
-intellijVersionForIde?.let { checkIntellijVersion(it) }
 
+val platformBaseVersion = intellijVersion.substring(0, intellijVersionDelimiterIndex)
+
+logger.info("intellijUltimateEnabled: $intellijUltimateEnabled")
 logger.info("intellijVersion: $intellijVersion")
-logger.info("intellijVersionForIde: $intellijVersionForIde")
 logger.info("androidStudioRelease: $androidStudioRelease")
 logger.info("androidStudioBuild: $androidStudioBuild")
 logger.info("intellijSeparateSdks: $intellijSeparateSdks")
+logger.info("installIntellijCommunity: $installIntellijCommunity")
+logger.info("installIntellijUltimate: $installIntellijUltimate")
 
 val androidStudioOs by lazy {
     when {
@@ -71,14 +73,12 @@ repositories {
 }
 
 val intellij by configurations.creating
-val intellijForIde by configurations.creating
+val intellijUltimate by configurations.creating
 val androidStudio by configurations.creating
 val sources by configurations.creating
-val sourcesForIde by configurations.creating
 val jpsStandalone by configurations.creating
-val jpsStandaloneForIde by configurations.creating
 val intellijCore by configurations.creating
-val intellijCoreForIde by configurations.creating
+val nodeJSPlugin by configurations.creating
 
 /**
  * Special repository for annotations.jar required for idea runtime only.
@@ -93,6 +93,7 @@ val dependenciesDir = (findProperty("kotlin.build.dependencies.dir") as String?)
 val customDepsRepoDir = dependenciesDir.resolve("repo")
 
 val customDepsOrg: String by rootProject.extra
+val customDepsRevision = intellijVersion
 val repoDir = File(customDepsRepoDir, customDepsOrg)
 
 dependencies {
@@ -104,8 +105,12 @@ dependencies {
 
         androidStudio("google:android-studio-ide:$androidStudioBuild@$extension")
     } else {
-        intellij("com.jetbrains.intellij.idea:ideaIC:$intellijVersion")
-        intellijVersionForIde?.let { intellijForIde("com.jetbrains.intellij.idea:ideaIC:$it") }
+        if (installIntellijCommunity) {
+            intellij("com.jetbrains.intellij.idea:ideaIC:$intellijVersion")
+        }
+        if (installIntellijUltimate) {
+            intellijUltimate("com.jetbrains.intellij.idea:ideaIU:$intellijVersion")
+        }
     }
 
     if (asmVersion != null) {
@@ -113,104 +118,102 @@ dependencies {
     }
 
     sources("com.jetbrains.intellij.idea:ideaIC:$intellijVersion:sources@jar")
-    intellijVersionForIde?.let { sourcesForIde("com.jetbrains.intellij.idea:ideaIC:$it:sources@jar") }
     jpsStandalone("com.jetbrains.intellij.idea:jps-standalone:$intellijVersion")
-    intellijVersionForIde?.let { jpsStandaloneForIde("com.jetbrains.intellij.idea:jps-standalone:$it") }
     intellijCore("com.jetbrains.intellij.idea:intellij-core:$intellijVersion")
-    intellijVersionForIde?.let { intellijCoreForIde("com.jetbrains.intellij.idea:intellij-core:$it") }
+    if (intellijUltimateEnabled) {
+        nodeJSPlugin("com.jetbrains.plugins:NodeJS:${rootProject.extra["versions.idea.NodeJS"]}@zip")
+    }
 }
 
-fun prepareDeps(
-    intellij: Configuration,
-    intellijCore: Configuration,
-    sources: Configuration,
-    jpsStandalone: Configuration,
-    intellijVersion: String
-) {
-    val makeIntellijCore = buildIvyRepositoryTask(intellijCore, customDepsOrg, customDepsRepoDir)
+val makeIntellijCore = buildIvyRepositoryTask(intellijCore, customDepsOrg, customDepsRepoDir)
 
-    val makeIntellijAnnotations = tasks.register("makeIntellijAnnotations${intellij.name.capitalize()}", Copy::class) {
-        dependsOn(makeIntellijCore)
+val makeIntellijAnnotations by tasks.registering(Copy::class) {
+    dependsOn(makeIntellijCore)
 
-        val intellijCoreRepo = CleanableStore[repoDir.resolve("intellij-core").absolutePath][intellijVersion].use()
-        from(intellijCoreRepo.resolve("artifacts/annotations.jar"))
+    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()
-        into(targetDir)
+    val annotationsStore = CleanableStore[repoDir.resolve(intellijRuntimeAnnotations).absolutePath]
+    val targetDir = annotationsStore[intellijVersion].use()
+    into(targetDir)
 
-        val ivyFile = File(targetDir, "$intellijRuntimeAnnotations.ivy.xml")
-        outputs.files(ivyFile)
+    val ivyFile = File(targetDir, "$intellijRuntimeAnnotations.ivy.xml")
+    outputs.files(ivyFile)
 
-        doFirst {
-            annotationsStore.cleanStore()
-        }
-
-        doLast {
-            writeIvyXml(
-                customDepsOrg,
-                intellijRuntimeAnnotations,
-                intellijVersion,
-                intellijRuntimeAnnotations,
-                targetDir,
-                targetDir,
-                targetDir,
-                allowAnnotations = true
-            )
-        }
+    doFirst {
+        annotationsStore.cleanStore()
     }
 
-    val mergeSources = tasks.create("mergeSources${intellij.name.capitalize()}", Jar::class.java) {
-        dependsOn(sources)
-        isPreserveFileTimestamps = false
-        isReproducibleFileOrder = true
-        isZip64 = true
-        if (!kotlinBuildProperties.isTeamcityBuild) {
-            from(provider { sources.map(::zipTree) })
-        }
-        destinationDirectory.set(File(repoDir, sources.name))
-        archiveBaseName.set("intellij")
-        archiveClassifier.set("sources")
-        archiveVersion.set(intellijVersion)
-    }
-
-    val sourcesFile = mergeSources.outputs.files.singleFile
-
-    val makeIde = if (androidStudioBuild != null) {
-        buildIvyRepositoryTask(
-            androidStudio,
+    doLast {
+        writeIvyXml(
             customDepsOrg,
-            customDepsRepoDir,
-            if (androidStudioOs == "mac")
-                ::skipContentsDirectory
-            else
-                ::skipToplevelDirectory
-        )
-    } else {
-        val task = buildIvyRepositoryTask(intellij, customDepsOrg, customDepsRepoDir, null, sourcesFile)
-
-        task.configure {
-            dependsOn(mergeSources)
-        }
-
-        task
-    }
-
-    val buildJpsStandalone = buildIvyRepositoryTask(jpsStandalone, customDepsOrg, customDepsRepoDir, null, sourcesFile)
-
-    tasks.named("build") {
-        dependsOn(
-            makeIntellijCore,
-            makeIde,
-            buildJpsStandalone,
-            makeIntellijAnnotations
+            intellijRuntimeAnnotations,
+            intellijVersion,
+            intellijRuntimeAnnotations,
+            targetDir,
+            targetDir,
+            targetDir,
+            allowAnnotations = true
         )
     }
 }
 
-prepareDeps(intellij, intellijCore, sources, jpsStandalone, intellijVersion)
-if (intellijVersionForIde != null) {
-    prepareDeps(intellijForIde, intellijCoreForIde, sourcesForIde, jpsStandaloneForIde, intellijVersionForIde)
+val mergeSources by tasks.creating(Jar::class.java) {
+    dependsOn(sources)
+    isPreserveFileTimestamps = false
+    isReproducibleFileOrder = true
+    isZip64 = true
+    if (!kotlinBuildProperties.isTeamcityBuild) {
+        from(provider { sources.map(::zipTree) })
+    }
+    destinationDirectory.set(File(repoDir, sources.name))
+    archiveBaseName.set("intellij")
+    archiveClassifier.set("sources")
+    archiveVersion.set(intellijVersion)
+}
+
+val sourcesFile = mergeSources.outputs.files.singleFile
+
+val makeIde = if (androidStudioBuild != null) {
+    buildIvyRepositoryTask(
+        androidStudio,
+        customDepsOrg,
+        customDepsRepoDir,
+        if (androidStudioOs == "mac")
+            ::skipContentsDirectory
+        else
+            ::skipToplevelDirectory
+    )
+} else {
+    val task = if (installIntellijUltimate) {
+        buildIvyRepositoryTask(intellijUltimate, customDepsOrg, customDepsRepoDir, null, sourcesFile)
+    } else {
+        buildIvyRepositoryTask(intellij, customDepsOrg, customDepsRepoDir, null, sourcesFile)
+    }
+
+    task.configure {
+        dependsOn(mergeSources)
+    }
+
+    task
+}
+
+val buildJpsStandalone = buildIvyRepositoryTask(jpsStandalone, customDepsOrg, customDepsRepoDir, null, sourcesFile)
+
+tasks.named("build") {
+    dependsOn(
+        makeIntellijCore,
+        makeIde,
+        buildJpsStandalone,
+        makeIntellijAnnotations
+    )
+
+}
+
+if (installIntellijUltimate) {
+    val buildNodeJsPlugin =
+        buildIvyRepositoryTask(nodeJSPlugin, customDepsOrg, customDepsRepoDir, ::skipToplevelDirectory, sourcesFile)
+    tasks.named("build") { dependsOn(buildNodeJsPlugin) }
 }
 
 tasks.named<Delete>("clean") {
@@ -397,11 +400,6 @@ fun skipToplevelDirectory(path: String) = path.substringAfter('/')
 
 fun skipContentsDirectory(path: String) = path.substringAfter("Contents/")
 
-fun Project.intellijSdkVersionForIde(): String? {
-    val majorVersion = kotlinBuildProperties.getOrNull("attachedIntellijVersion") as? String ?: return null
-    return rootProject.findProperty("versions.intellijSdk.forIde.$majorVersion") as? String
-}
-
 class XMLWriter(private val outputStreamWriter: OutputStreamWriter) : Closeable {
 
     private val xmlStreamWriter = XMLOutputFactory.newInstance().createXMLStreamWriter(outputStreamWriter)

buildSrc/settings.gradle

@@ -18,11 +18,55 @@ buildscript {
         } else {
             maven { url "https://maven.pkg.jetbrains.space/kotlin/p/kotlin/kotlin-dependencies" }
         }
-        mavenCentral()
     }
     dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.30")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.26")
     }
 }
 
-include "prepare-deps"
+def buildProperties = BuildPropertiesKt.getKotlinBuildPropertiesForSettings(settings)
+def projectVersions = file("../gradle/versions.properties").text
+
+include "prepare-deps"
+
+def target_AppCode_Clion = buildProperties.includeCidrPlugins && !projectVersions.contains("versions.androidStudioRelease")
+def target_AndroidStudio = buildProperties.includeCidrPlugins && projectVersions.contains("versions.androidStudioRelease")
+def target_IdeaUltimate = buildProperties.includeUltimate
+
+if (target_AppCode_Clion) {
+    logger.info("Including modules for AC and CL in buildSrc/settings.gradle")
+
+    include ":prepare-deps:kotlin-native-platform-deps"
+    include ":prepare-deps:native-debug-plugin"
+
+    project(":prepare-deps:kotlin-native-platform-deps").projectDir =
+            file("${buildProperties.propertiesProvider.rootProjectDir}/kotlin-ultimate/buildSrc/prepare-deps/kotlin-native-platform-deps")
+    project(":prepare-deps:native-debug-plugin").projectDir =
+            file("${buildProperties.propertiesProvider.rootProjectDir}/kotlin-ultimate/buildSrc/prepare-deps/native-debug-plugin")
+} else if (target_AndroidStudio) {
+    logger.info("Including modules for AS (mobile plugin) in buildSrc/settings.gradle")
+
+    include ":prepare-deps:appcode-binaries"
+    include ":prepare-deps:lldb-framework"
+    include ":prepare-deps:lldb-frontend"
+
+    project(":prepare-deps:appcode-binaries").projectDir =
+            file("${buildProperties.propertiesProvider.rootProjectDir}/kotlin-ultimate/buildSrc/prepare-deps/appcode-binaries")
+    project(":prepare-deps:lldb-framework").projectDir =
+            file("${buildProperties.propertiesProvider.rootProjectDir}/kotlin-ultimate/buildSrc/prepare-deps/lldb-framework")
+    project(":prepare-deps:lldb-frontend").projectDir =
+            file("${buildProperties.propertiesProvider.rootProjectDir}/kotlin-ultimate/buildSrc/prepare-deps/lldb-frontend")
+} else if (target_IdeaUltimate) {
+    logger.info("Including modules for IU in buildSrc/settings.gradle")
+
+    include ":prepare-deps:lldb-frontend"
+    include ":prepare-deps:native-debug-plugin"
+
+    project(":prepare-deps:lldb-frontend").projectDir =
+            file("${buildProperties.propertiesProvider.rootProjectDir}/kotlin-ultimate/buildSrc/prepare-deps/lldb-frontend")
+    project(":prepare-deps:native-debug-plugin").projectDir =
+            file("${buildProperties.propertiesProvider.rootProjectDir}/kotlin-ultimate/buildSrc/prepare-deps/native-debug-plugin")
+
+} else {
+    logger.info("Not including extra modules in buildSrc/settings.gradle")
+}

buildSrc/src/main/kotlin/BuildPropertiesExt.kt

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

buildSrc/src/main/kotlin/CacheableProguradTask.kt

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

buildSrc/src/main/kotlin/CommonUtil.kt

@@ -81,12 +81,3 @@ fun Task.singleOutputFile(): File = when (this) {
     is ProGuardTask -> project.file(outJarFiles.single()!!)
     else -> outputs.files.singleFile
 }
-
-val Project.isConfigurationCacheDisabled
-    get() = (gradle.startParameter as? org.gradle.api.internal.StartParameterInternal)?.isConfigurationCache != true
-
-val Project.isIdeaActive
-    get() = providers.systemProperty("idea.active").forUseAtConfigurationTime().isPresent
-
-val Project.intellijCommunityDir: File
-    get() = rootDir.resolve("intellij/community").takeIf { it.isDirectory } ?: rootDir.resolve("intellij")

buildSrc/src/main/kotlin/ComponentsXmlResourceTransformerPatched.kt

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

buildSrc/src/main/kotlin/IdeCompatibilityDsl.kt

@@ -26,7 +26,7 @@ fun CompatibilityPredicate.or(other: CompatibilityPredicate): CompatibilityPredi
 }
 
 enum class Platform : CompatibilityPredicate {
-    P203;
+    P183, P191, P192, P193, P201, P202, P203;
 
     val version: Int = name.drop(1).toInt()
 
@@ -43,7 +43,18 @@ enum class Platform : CompatibilityPredicate {
 }
 
 enum class Ide(val platform: Platform) : CompatibilityPredicate {
-    IJ203(Platform.P203);
+    IJ191(Platform.P191),
+    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),
+    AS42(Platform.P202);
 
     val kind = Kind.values().first { it.shortName == name.take(2) }
     val version = name.dropWhile { !it.isDigit() }.toInt()

buildSrc/src/main/kotlin/JvmToolchain.kt

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

buildSrc/src/main/kotlin/LibrariesCommon.kt

@@ -1,57 +0,0 @@
-/*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-@file:JvmName("LibrariesCommon")
-
-import org.gradle.api.JavaVersion
-import org.gradle.api.Project
-import org.gradle.api.file.FileCollection
-import org.gradle.api.tasks.compile.JavaCompile
-import org.gradle.kotlin.dsl.get
-import org.gradle.process.CommandLineArgumentProvider
-
-@JvmOverloads
-fun Project.configureJava9Compilation(
-    moduleName: String,
-    moduleOutputs: Collection<FileCollection> = setOf(sourceSets["main"].output)
-) {
-    configurations["java9CompileClasspath"].extendsFrom(configurations["compileClasspath"])
-
-    tasks.named("compileJava9Java", JavaCompile::class.java) {
-        dependsOn(moduleOutputs)
-
-        targetCompatibility = JavaVersion.VERSION_1_9.toString()
-        sourceCompatibility = JavaVersion.VERSION_1_9.toString()
-        configureTaskToolchain(JdkMajorVersion.JDK_9)
-
-        // module-info.java should be in java9 source set by convention
-        val java9SourceSet = sourceSets["java9"].java
-        destinationDir = file("${java9SourceSet.outputDir}/META-INF/versions/9")
-        options.sourcepath = files(java9SourceSet.srcDirs)
-        val compileClasspath = configurations["java9CompileClasspath"]
-        val moduleFiles = objects.fileCollection().from(moduleOutputs)
-        val modulePath = compileClasspath.filter { it !in moduleFiles.files }
-        classpath = objects.fileCollection().from()
-        options.compilerArgumentProviders.add(
-            Java9AdditionalArgumentsProvider(
-                moduleName,
-                moduleFiles,
-                modulePath
-            )
-        )
-    }
-}
-
-private class Java9AdditionalArgumentsProvider(
-    private val moduleName: String,
-    private val moduleFiles: FileCollection,
-    private val modulePath: FileCollection
-) : CommandLineArgumentProvider {
-    override fun asArguments(): Iterable<String> = listOf(
-        "--module-path", modulePath.asPath,
-        "--patch-module", "$moduleName=${moduleFiles.asPath}",
-        "-Xlint:-requires-transitive-automatic" // suppress automatic module transitive dependencies in kotlin.test
-    )
-}

buildSrc/src/main/kotlin/artifacts.kt

@@ -1,6 +1,6 @@
 @file:Suppress("unused") // usages in build scripts are not tracked properly
 
-import com.gradle.publish.PublishTask
+import org.gradle.api.GradleException
 import org.gradle.api.Project
 import org.gradle.api.Task
 import org.gradle.api.artifacts.ConfigurablePublishArtifact
@@ -22,12 +22,12 @@ import org.gradle.api.publish.PublishingExtension
 import org.gradle.api.publish.maven.MavenPublication
 import org.gradle.api.publish.tasks.GenerateModuleMetadata
 import org.gradle.api.tasks.TaskProvider
+import org.gradle.api.tasks.Upload
 import org.gradle.api.tasks.javadoc.Javadoc
 import org.gradle.jvm.tasks.Jar
 import org.gradle.kotlin.dsl.*
 import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSetContainer
 import plugins.KotlinBuildPublishingPlugin
-import plugins.mainPublicationName
 
 
 private const val MAGIC_DO_NOT_CHANGE_TEST_JAR_TASK_NAME = "testJar"
@@ -62,6 +62,8 @@ fun Project.removeArtifacts(configuration: Configuration, task: Task) {
 
 fun Project.noDefaultJar() {
     tasks.named("jar").configure {
+        enabled = false
+        actions = emptyList()
         configurations.forEach { cfg ->
             removeArtifacts(cfg, this)
         }
@@ -110,8 +112,6 @@ fun <T : Jar> Project.runtimeJar(task: TaskProvider<T>, body: T.() -> Unit = {})
         addVariantsFromConfiguration(runtimeJar) { }
     }
 
-    (components.findByName("java") as AdhocComponentWithVariants?)?.addVariantsFromConfiguration(runtimeJar) { }
-
     return task
 }
 
@@ -225,20 +225,24 @@ fun Project.publish(moduleMetadata: Boolean = false, configure: MavenPublication
 
     val publication = extensions.findByType<PublishingExtension>()
         ?.publications
-        ?.findByName(mainPublicationName) as MavenPublication
+        ?.findByName(KotlinBuildPublishingPlugin.PUBLICATION_NAME) as MavenPublication
     publication.configure()
 }
 
-fun Project.publishGradlePlugin() {
-    mainPublicationName = "pluginMaven"
-    publish()
+fun Project.publishWithLegacyMavenPlugin(body: Upload.() -> Unit = {}): Upload {
+    apply<plugins.PublishedKotlinModule>()
+
+    if (artifactsRemovedDiagnosticFlag) {
+        error("`publish()` should be called before removing artifacts typically done in `noDefaultJar()` or `runtimeJar()` call")
+    }
 
     afterEvaluate {
-        tasks.withType<PublishTask> {
-            // Makes plugin publication task reuse poms and metadata from publication named "pluginMaven"
-            useAutomatedPublishing()
-            useGradleModuleMetadataIfAvailable()
-        }
+        if (configurations.findByName("classes-dirs") != null)
+            throw GradleException("classesDirsArtifact() is incompatible with publish(), see sources comments for details")
+    }
+
+    return (tasks.getByName("uploadArchives") as Upload).apply {
+        body()
     }
 }
 
@@ -249,41 +253,6 @@ fun Project.idePluginDependency(block: () -> Unit) {
     }
 }
 
-fun Project.publishJarsForIde(projects: List<String>, libraryDependencies: List<String> = emptyList()) {
-    idePluginDependency {
-        publishProjectJars(projects, libraryDependencies)
-    }
-    configurations.all {
-        // Don't allow `ideaIC` from compiler to leak into Kotlin plugin modules. Compiler and
-        // plugin may depend on different versions of IDEA and it will lead to version conflict
-        exclude(module = ideModuleName())
-    }
-    dependencies {
-        projects.forEach {
-            jpsLikeJarDependency(project(it), JpsDepScope.COMPILE, { isTransitive = false }, exported = true)
-        }
-        libraryDependencies.forEach {
-            jpsLikeJarDependency(it, JpsDepScope.COMPILE, exported = true)
-        }
-    }
-}
-
-fun Project.publishTestJarsForIde(projectNames: List<String>) {
-    idePluginDependency {
-        publishTestJar(projectNames)
-    }
-    configurations.all {
-        // Don't allow `ideaIC` from compiler to leak into Kotlin plugin modules. Compiler and
-        // plugin may depend on different versions of IDEA and it will lead to version conflict
-        exclude(module = ideModuleName())
-    }
-    dependencies {
-        for (projectName in projectNames) {
-            jpsLikeJarDependency(projectTests(projectName), JpsDepScope.COMPILE, exported = true)
-        }
-    }
-}
-
 fun Project.publishProjectJars(projects: List<String>, libraryDependencies: List<String> = emptyList()) {
     apply<JavaPlugin>()
 
@@ -322,15 +291,13 @@ fun Project.publishProjectJars(projects: List<String>, libraryDependencies: List
     javadocJar()
 }
 
-fun Project.publishTestJar(projects: List<String>) {
+fun Project.publishTestJar(projectName: String) {
     apply<JavaPlugin>()
 
     val fatJarContents by configurations.creating
 
     dependencies {
-        for (projectName in projects) {
-            fatJarContents(project(projectName, configuration = "tests-jar")) { isTransitive = false }
-        }
+        fatJarContents(project(projectName, configuration = "tests-jar")) { isTransitive = false }
     }
 
     publish()
@@ -347,7 +314,7 @@ fun Project.publishTestJar(projects: List<String>) {
 
     sourcesJar {
         from {
-            projects.map { project(it).testSourceSet.allSource }
+            project(projectName).testSourceSet.allSource
         }
     }
 

buildSrc/src/main/kotlin/dependencies.kt

@@ -9,15 +9,13 @@
 
 import org.gradle.api.GradleException
 import org.gradle.api.Project
-import org.gradle.api.artifacts.*
+import org.gradle.api.artifacts.Dependency
+import org.gradle.api.artifacts.ExternalModuleDependency
+import org.gradle.api.artifacts.ProjectDependency
 import org.gradle.api.artifacts.dsl.DependencyHandler
 import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.FileCollection
-import org.gradle.internal.jvm.Jvm
-import org.gradle.jvm.toolchain.JavaLanguageVersion
 import org.gradle.kotlin.dsl.accessors.runtime.addDependencyTo
-import org.gradle.kotlin.dsl.closureOf
-import org.gradle.kotlin.dsl.exclude
 import org.gradle.kotlin.dsl.extra
 import org.gradle.kotlin.dsl.project
 import java.io.File
@@ -36,7 +34,7 @@ val Project.internalBootstrapRepo: String? get() =
     when {
         bootstrapKotlinRepo?.startsWith("https://buildserver.labs.intellij.net") == true ->
             bootstrapKotlinRepo!!.replace("artifacts/content/maven", "artifacts/content/internal/repo")
-        else -> "https://teamcity.jetbrains.com/guestAuth/app/rest/builds/buildType:(id:Kotlin_KotlinPublic_Aggregate),number:$bootstrapKotlinVersion," +
+        else -> "https://teamcity.jetbrains.com/guestAuth/app/rest/builds/buildType:(id:Kotlin_KotlinPublic_Compiler),number:$bootstrapKotlinVersion," +
                 "branch:default:any/artifacts/content/internal/repo/"
     }
 
@@ -91,6 +89,12 @@ fun Project.preloadedDeps(
     return files(*matchingFiles.map { it.canonicalPath }.toTypedArray())
 }
 
+fun Project.ideaUltimatePreloadedDeps(vararg artifactBaseNames: String, subdir: String? = null): ConfigurableFileCollection {
+    val ultimateDepsDir = fileFrom(rootDir, "ultimate", "dependencies")
+    return if (ultimateDepsDir.isDirectory) preloadedDeps(*artifactBaseNames, baseDir = ultimateDepsDir, subdir = subdir)
+    else files()
+}
+
 fun Project.kotlinDep(artifactBaseName: String, version: String, classifier: String? = null): String =
     listOfNotNull("org.jetbrains.kotlin:kotlin-$artifactBaseName:$version", classifier).joinToString(":")
 
@@ -111,95 +115,6 @@ fun DependencyHandler.projectTests(name: String): ProjectDependency = project(na
 fun DependencyHandler.projectRuntimeJar(name: String): ProjectDependency = project(name, configuration = "runtimeJar")
 fun DependencyHandler.projectArchives(name: String): ProjectDependency = project(name, configuration = "archives")
 
-enum class JpsDepScope {
-    COMPILE, TEST, RUNTIME, PROVIDED
-}
-
-fun DependencyHandler.add(configurationName: String, dependencyNotation: Any, configure: (ModuleDependency.() -> Unit)?) {
-    // Avoid `dependencyNotation` to `ModuleDependency` class cast exception if possible
-    if (configure != null) {
-        add(configurationName, dependencyNotation, closureOf(configure))
-    } else {
-        add(configurationName, dependencyNotation)
-    }
-}
-
-fun Project.disableDependencyVerification() {
-    configurations.all {
-        resolutionStrategy {
-            disableDependencyVerification()
-        }
-    }
-}
-
-fun DependencyHandler.jpsLikeJarDependency(
-    dependencyNotation: Any,
-    scope: JpsDepScope,
-    dependencyConfiguration: (ModuleDependency.() -> Unit)? = null,
-    exported: Boolean = false
-) {
-    when (scope) {
-        JpsDepScope.COMPILE -> {
-            if (exported) {
-                add("api", dependencyNotation, dependencyConfiguration)
-                add("testCompile", dependencyNotation, dependencyConfiguration)
-            } else {
-                add("implementation", dependencyNotation, dependencyConfiguration)
-            }
-        }
-        JpsDepScope.TEST -> {
-            if (exported) {
-                add("testCompile", dependencyNotation, dependencyConfiguration)
-            } else {
-                add("testImplementation", dependencyNotation, dependencyConfiguration)
-            }
-        }
-        JpsDepScope.RUNTIME -> {
-            add("testRuntimeOnly", dependencyNotation, dependencyConfiguration)
-        }
-        JpsDepScope.PROVIDED -> {
-            if (exported) {
-                add("compileOnlyApi", dependencyNotation, dependencyConfiguration)
-                add("testCompile", dependencyNotation, dependencyConfiguration)
-            } else {
-                add("compileOnly", dependencyNotation, dependencyConfiguration)
-                add("testImplementation", dependencyNotation, dependencyConfiguration)
-            }
-        }
-    }
-}
-
-fun DependencyHandler.jpsLikeModuleDependency(moduleName: String, scope: JpsDepScope, exported: Boolean = false) {
-    jpsLikeJarDependency(project(moduleName), scope, exported = exported)
-    when (scope) {
-        JpsDepScope.COMPILE -> {
-            if (exported) {
-                add("testCompile", projectTests(moduleName))
-            } else {
-                add("testImplementation", projectTests(moduleName))
-            }
-        }
-        JpsDepScope.TEST -> {
-            if (exported) {
-                add("testCompile", projectTests(moduleName))
-            } else {
-                add("testImplementation", projectTests(moduleName))
-            }
-        }
-        JpsDepScope.RUNTIME -> {
-            add("runtimeOnly", projectTests(moduleName))
-        }
-        JpsDepScope.PROVIDED -> {
-            if (exported) {
-                add("testCompile", projectTests(moduleName))
-            } else {
-                add("testImplementation", projectTests(moduleName))
-            }
-        }
-    }
-}
-
-
 fun Project.testApiJUnit5(
     vintageEngine: Boolean = false,
     runner: Boolean = false,
@@ -289,16 +204,14 @@ fun Project.firstFromJavaHomeThatExists(vararg paths: String, jdkHome: File = Fi
 
 fun Project.toolsJarApi(): Any =
     if (kotlinBuildProperties.isInJpsBuildIdeaSync)
-        toolsJar()
+        files(toolsJarFile() ?: error("tools.jar is not found!"))
     else
         dependencies.project(":dependencies:tools-jar-api")
 
-fun Project.toolsJar(): FileCollection = files(
-    getToolchainLauncherFor(JdkMajorVersion.JDK_1_8)
-        .map {
-            Jvm.forHome(it.metadata.installationPath.asFile).toolsJar ?: throw GradleException("tools.jar not found!")
-        }
-)
+fun Project.toolsJar(): FileCollection = files(toolsJarFile() ?: error("tools.jar is not found!"))
+
+fun Project.toolsJarFile(jdkHome: File = File(this.property("JDK_18") as String)): File? =
+    firstFromJavaHomeThatExists("lib/tools.jar", jdkHome = jdkHome)
 
 val compilerManifestClassPath
     get() = "annotations-13.0.jar kotlin-stdlib.jar kotlin-reflect.jar kotlin-script-runtime.jar trove4j.jar"

buildSrc/src/main/kotlin/embeddable.kt

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

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

@@ -1,51 +0,0 @@
-/*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-
-plugins {
-    kotlin("jvm")
-}
-
-publishGradlePlugin()
-standardPublicJars()
-
-extensions.extraProperties["kotlin.stdlib.default.dependency"] = "false"
-
-dependencies {
-    compileOnly(kotlinStdlib())
-    compileOnly(gradleApi())
-}
-
-// These dependencies will be provided by Gradle and we should prevent version conflict
-fun Configuration.excludeGradleCommonDependencies() {
-    exclude(group = "org.jetbrains.kotlin", module = "kotlin-stdlib")
-    exclude(group = "org.jetbrains.kotlin", module = "kotlin-stdlib-jdk7")
-    exclude(group = "org.jetbrains.kotlin", module = "kotlin-stdlib-jdk8")
-    exclude(group = "org.jetbrains.kotlin", module = "kotlin-stdlib-common")
-    exclude(group = "org.jetbrains.kotlin", module = "kotlin-reflect")
-    exclude(group = "org.jetbrains.kotlin", module = "kotlin-script-runtime")
-}
-configurations {
-    "implementation" {
-        excludeGradleCommonDependencies()
-    }
-    "api" {
-        excludeGradleCommonDependencies()
-    }
-}
-
-tasks.withType<KotlinCompile> {
-    kotlinOptions.languageVersion = "1.4"
-    kotlinOptions.apiVersion = "1.4"
-    kotlinOptions.freeCompilerArgs += listOf(
-        "-Xskip-prerelease-check",
-        "-Xsuppress-version-warnings",
-        "-Xuse-ir" // Needed as long as languageVersion is less than 1.5.
-    )
-}
-
-tasks.named<Jar>("jar") {
-    callGroovy("manifestAttributes", manifest, project)
-}

buildSrc/src/main/kotlin/ideaExtKotlinDsl.kt

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

buildSrc/src/main/kotlin/jdksFinder.kt

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

buildSrc/src/main/kotlin/localDependencies.kt

@@ -17,11 +17,16 @@
 // usages in build scripts are not tracked properly
 @file:Suppress("unused")
 
+import org.gradle.api.GradleException
 import org.gradle.api.Project
 import org.gradle.api.artifacts.ModuleDependency
 import org.gradle.api.artifacts.dsl.RepositoryHandler
 import org.gradle.api.artifacts.repositories.IvyArtifactRepository
+import org.gradle.api.tasks.JavaExec
+import org.gradle.api.tasks.TaskProvider
+import org.gradle.kotlin.dsl.DependencyHandlerScope
 import org.gradle.kotlin.dsl.extra
+import org.gradle.kotlin.dsl.register
 import java.io.File
 
 private fun Project.kotlinBuildLocalDependenciesDir(): File =
@@ -30,26 +35,16 @@ private fun Project.kotlinBuildLocalDependenciesDir(): File =
 
 private fun Project.kotlinBuildLocalRepoDir(): File = kotlinBuildLocalDependenciesDir().resolve("repo")
 
-fun Project.ideModuleName() = when (IdeVersionConfigurator.currentIde.kind) {
+private fun Project.ideModuleName() = when (IdeVersionConfigurator.currentIde.kind) {
     Ide.Kind.AndroidStudio -> "android-studio-ide"
-    Ide.Kind.IntelliJ -> "ideaIC"
-}
-
-private fun Project.ideModuleVersion(forIde: Boolean) = when (IdeVersionConfigurator.currentIde.kind) {
-    Ide.Kind.AndroidStudio -> rootProject.findProperty("versions.androidStudioBuild")
     Ide.Kind.IntelliJ -> {
-        if (forIde) {
-            intellijSdkVersionForIde()
-                ?: error("Please specify 'attachedIntellijVersion' in your local.properties")
-        } else {
-            rootProject.findProperty("versions.intellijSdk")
-        }
+        if (kotlinBuildProperties.intellijUltimateEnabled) "ideaIU" else "ideaIC"
     }
 }
 
-fun Project.intellijSdkVersionForIde(): String? {
-    val majorVersion = kotlinBuildProperties.getOrNull("attachedIntellijVersion") as? String ?: return null
-    return rootProject.findProperty("versions.intellijSdk.forIde.$majorVersion") as? String
+private fun Project.ideModuleVersion() = when (IdeVersionConfigurator.currentIde.kind) {
+    Ide.Kind.AndroidStudio -> rootProject.findProperty("versions.androidStudioBuild")
+    Ide.Kind.IntelliJ -> rootProject.findProperty("versions.intellijSdk")
 }
 
 fun RepositoryHandler.kotlinBuildLocalRepo(project: Project): IvyArtifactRepository = ivy {
@@ -63,7 +58,6 @@ fun RepositoryHandler.kotlinBuildLocalRepo(project: Project): IvyArtifactReposit
 
         artifact("[organisation]/[module]/[revision]/artifacts/lib/[artifact](-[classifier]).[ext]")
         artifact("[organisation]/[module]/[revision]/artifacts/[artifact](-[classifier]).[ext]")
-        artifact("[organisation]/intellij-core/[revision]/artifacts/[artifact](-[classifier]).[ext]")
         artifact("[organisation]/${project.ideModuleName()}/[revision]/artifacts/plugins/[module]/lib/[artifact](-[classifier]).[ext]") // bundled plugins
         artifact("[organisation]/sources/[artifact]-[revision](-[classifier]).[ext]")
         artifact("[organisation]/[module]/[revision]/[artifact](-[classifier]).[ext]")
@@ -74,14 +68,14 @@ fun RepositoryHandler.kotlinBuildLocalRepo(project: Project): IvyArtifactReposit
     }
 }
 
-@JvmOverloads
-fun Project.intellijDep(module: String? = null, forIde: Boolean = false) =
-    "kotlin.build:${module ?: ideModuleName()}:${ideModuleVersion(forIde)}"
+fun Project.intellijDep(module: String? = null) = "kotlin.build:${module ?: ideModuleName()}:${ideModuleVersion()}"
 
 fun Project.intellijCoreDep() = "kotlin.build:intellij-core:${rootProject.extra["versions.intellijSdk"]}"
 
 fun Project.jpsStandalone() = "kotlin.build:jps-standalone:${rootProject.extra["versions.intellijSdk"]}"
 
+fun Project.nodeJSPlugin() = "kotlin.build:NodeJS:${rootProject.extra["versions.idea.NodeJS"]}"
+
 fun Project.jpsBuildTest() = "com.jetbrains.intellij.idea:jps-build-test:${rootProject.extra["versions.intellijSdk"]}"
 
 fun Project.kotlinxCollectionsImmutable() = "org.jetbrains.kotlinx:kotlinx-collections-immutable-jvm:${rootProject.extra["versions.kotlinx-collections-immutable"]}"
@@ -99,7 +93,11 @@ fun Project.kotlinxCollectionsImmutable() = "org.jetbrains.kotlinx:kotlinx-colle
  */
 fun Project.intellijRuntimeAnnotations() = "kotlin.build:intellij-runtime-annotations:${rootProject.extra["versions.intellijSdk"]}"
 
-fun Project.intellijPluginDep(plugin: String, forIde: Boolean = false) = intellijDep(plugin, forIde)
+fun Project.intellijPluginDep(plugin: String) = intellijDep(plugin)
+
+fun Project.intellijUltimateDep() = intellijDep("ideaIU")
+
+fun Project.intellijUltimatePluginDep(plugin: String) = intellijDep(plugin)
 
 fun ModuleDependency.includeJars(vararg names: String, rootProject: Project? = null) {
     names.forEach {
@@ -127,7 +125,7 @@ object IntellijRootUtils {
     fun getIntellijRootDir(project: Project): File = with(project.rootProject) {
         return File(
             getRepositoryRootDir(this),
-            "${ideModuleName()}/${ideModuleVersion(forIde = false)}/artifacts"
+            "${ideModuleName()}/${ideModuleVersion()}/artifacts"
         )
     }
 }
@@ -139,4 +137,83 @@ fun ModuleDependency.includeIntellijCoreJarDependencies(project: Project, jarsFi
         rootProject = project.rootProject
     )
 
-fun Project.intellijRootDir() = IntellijRootUtils.getIntellijRootDir(project)
+fun Project.isIntellijCommunityAvailable() =
+    !(rootProject.extra["intellijUltimateEnabled"] as Boolean) || rootProject.extra["intellijSeparateSdks"] as Boolean
+
+fun Project.isIntellijUltimateSdkAvailable() = (rootProject.extra["intellijUltimateEnabled"] as Boolean)
+
+fun Project.intellijRootDir() = IntellijRootUtils.getIntellijRootDir(project)
+
+fun Project.intellijUltimateRootDir() =
+    if (isIntellijUltimateSdkAvailable())
+        File(kotlinBuildLocalRepoDir(), "kotlin.build/ideaIU/${rootProject.extra["versions.intellijSdk"]}/artifacts")
+    else
+        throw GradleException("intellij ultimate SDK is not available")
+
+fun DependencyHandlerScope.excludeInAndroidStudio(rootProject: Project, block: DependencyHandlerScope.() -> Unit) {
+    if (!rootProject.extra.has("versions.androidStudioRelease")) {
+        block()
+    }
+}
+
+fun Project.runIdeTask(name: String, ideaPluginDir: File, ideaSandboxDir: File, body: JavaExec.() -> Unit): TaskProvider<JavaExec> {
+
+    return tasks.register<JavaExec>(name) {
+        val ideaSandboxConfigDir = File(ideaSandboxDir, "config")
+
+        classpath = mainSourceSet.runtimeClasspath
+
+        mainClass.set("com.intellij.idea.Main")
+
+        workingDir = File(intellijRootDir(), "bin")
+
+        jvmArgs(
+            "-Xmx1250m",
+            "-XX:ReservedCodeCacheSize=240m",
+            "-XX:+HeapDumpOnOutOfMemoryError",
+            "-ea",
+            "-Didea.debug.mode=true",
+            "-Didea.system.path=$ideaSandboxDir",
+            "-Didea.config.path=$ideaSandboxConfigDir",
+            "-Didea.tooling.debug=true",
+            "-Dfus.internal.test.mode=true",
+            "-Dapple.laf.useScreenMenuBar=true",
+            "-Dapple.awt.graphics.UseQuartz=true",
+            "-Dsun.io.useCanonCaches=false",
+            "-Dplugin.path=${ideaPluginDir.absolutePath}"
+        )
+
+        if (Platform[201].orHigher() && !isIntellijUltimateSdkAvailable()) {
+            jvmArgs("-Didea.platform.prefix=Idea")
+        }
+
+        if (rootProject.findProperty("versions.androidStudioRelease") != null) {
+            jvmArgs("-Didea.platform.prefix=AndroidStudio")
+        }
+
+        if (project.hasProperty("noPCE")) {
+            jvmArgs("-Didea.ProcessCanceledException=disabled")
+        }
+
+        jvmArgs("-Didea.is.internal=${project.findProperty("idea.is.internal") ?: true}")
+
+        project.findProperty("idea.args")?.let { arguments ->
+            jvmArgs(arguments.toString().split(" "))
+        }
+
+        args()
+
+        doFirst {
+            val disabledPluginsFile = File(ideaSandboxConfigDir, "disabled_plugins.txt")
+            val disabledPluginsContents = disabledPluginsFile.takeIf { it.isFile }?.readLines()
+            val filteredContents = disabledPluginsContents?.filterNot { it.contains("org.jetbrains.kotlin") }
+            if (filteredContents != null && filteredContents.size != disabledPluginsContents.size) {
+                with(disabledPluginsFile.printWriter()) {
+                    filteredContents.forEach(this::println)
+                }
+            }
+        }
+
+        body()
+    }
+}

buildSrc/src/main/kotlin/pluginMarkers.kt

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

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

@@ -68,7 +68,7 @@ class KotlinBuildPublishingPlugin @Inject constructor(
 
         configure<PublishingExtension> {
             publications {
-                create<MavenPublication>(project.mainPublicationName) {
+                create<MavenPublication>(PUBLICATION_NAME) {
                     from(kotlinLibraryComponent)
 
                     configureKotlinPomAttributes(project)
@@ -79,26 +79,16 @@ class KotlinBuildPublishingPlugin @Inject constructor(
     }
 
     companion object {
-        const val DEFAULT_MAIN_PUBLICATION_NAME = "Main"
-        const val MAIN_PUBLICATION_NAME_PROPERTY = "MainPublicationName"
+        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"
+
     }
 }
 
-var Project.mainPublicationName: String
-    get() {
-        return if (project.extra.has(KotlinBuildPublishingPlugin.MAIN_PUBLICATION_NAME_PROPERTY))
-            project.extra.get(KotlinBuildPublishingPlugin.MAIN_PUBLICATION_NAME_PROPERTY) as String
-        else KotlinBuildPublishingPlugin.DEFAULT_MAIN_PUBLICATION_NAME
-    }
-    set(value) {
-        project.extra.set(KotlinBuildPublishingPlugin.MAIN_PUBLICATION_NAME_PROPERTY, value)
-    }
-
 @OptIn(ExperimentalStdlibApi::class)
 private fun humanReadableName(name: String) =
     name.split("-").joinToString(separator = " ") { it.capitalize(Locale.ROOT) }
@@ -171,22 +161,10 @@ fun Project.configureDefaultPublishing() {
         .all { configureRepository() }
 }
 
-private fun Project.getSensitiveProperty(name: String): String? {
-    return project.findProperty(name) as? String ?: System.getenv(name)
-}
-
 private fun Project.configureSigning() {
     configure<SigningExtension> {
         sign(extensions.getByType<PublishingExtension>().publications) // all publications
-
-        val signKeyId = project.getSensitiveProperty("signKeyId")
-        if (!signKeyId.isNullOrBlank()) {
-            val signKeyPrivate = project.getSensitiveProperty("signKeyPrivate") ?: error("Parameter `signKeyPrivate` not found")
-            val signKeyPassphrase = project.getSensitiveProperty("signKeyPassphrase") ?: error("Parameter `signKeyPassphrase` not found")
-            useInMemoryPgpKeys(signKeyId, signKeyPrivate, signKeyPassphrase)
-        } else {
-            useGpgCmd()
-        }
+        useGpgCmd()
     }
 }
 

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

@@ -0,0 +1,173 @@
+@file:Suppress("DEPRECATION")
+package plugins
+
+import org.codehaus.groovy.runtime.InvokerHelper
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.artifacts.Dependency
+import org.gradle.api.artifacts.maven.Conf2ScopeMappingContainer
+import org.gradle.api.artifacts.maven.MavenDeployment
+import org.gradle.api.artifacts.maven.MavenResolver
+import org.gradle.api.plugins.MavenPluginConvention
+import org.gradle.api.plugins.MavenRepositoryHandlerConvention
+import org.gradle.api.publication.maven.internal.deployer.MavenRemoteRepository
+import org.gradle.api.tasks.Upload
+import org.gradle.kotlin.dsl.*
+import org.gradle.plugins.signing.Sign
+import org.gradle.plugins.signing.SigningExtension
+import kotlin.properties.Delegates
+
+/**
+ * Configures a Kotlin module for publication.
+ */
+open class PublishedKotlinModule : Plugin<Project> {
+
+    private fun String.toBooleanOrNull() = listOf(true, false).firstOrNull { it.toString().equals(this, ignoreCase = true) }
+
+    override fun apply(project: Project) {
+
+        project.run {
+
+            plugins.apply("maven")
+
+            configurations.maybeCreate("publishedRuntime").apply {
+                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")
+
+                val signingRequired = project.findProperty("signingRequired")?.toString()?.toBooleanOrNull()
+                                      ?: project.property("isSonatypeRelease") as Boolean
+
+                configure<SigningExtension> {
+                    isRequired = signingRequired
+                    sign(configurations["archives"])
+                    useGpgCmd()
+                }
+
+                tasks.named<Sign>("signArchives").configure {
+                    enabled = signingRequired
+                }
+            }
+
+            fun MavenResolver.configurePom() {
+                pom.project {
+                    withGroovyBuilder {
+                        "licenses" {
+                            "license" {
+                                "name"("The Apache Software License, Version 2.0")
+                                "url"("http://www.apache.org/licenses/LICENSE-2.0.txt")
+                                "distribution"("repo")
+                            }
+                        }
+                        "name"("${project.group}:${project.name}")
+                        "packaging"("jar")
+                        // optionally artifactId can be defined here
+                        "description"(project.description)
+                        "url"("https://kotlinlang.org/")
+                        "licenses" {
+                            "license" {
+                                "name"("The Apache License, Version 2.0")
+                                "url"("http://www.apache.org/licenses/LICENSE-2.0.txt")
+                            }
+                        }
+                        "scm" {
+                            "url"("https://github.com/JetBrains/kotlin")
+                            "connection"("scm:git:https://github.com/JetBrains/kotlin.git")
+                            "developerConnection"("scm:git:https://github.com/JetBrains/kotlin.git")
+                        }
+                        "developers" {
+                            "developer" {
+                                "name"("Kotlin Team")
+                                setProperty("organization", "JetBrains")
+                                "organizationUrl"("https://www.jetbrains.com")
+                            }
+                        }
+                    }
+                }
+                pom.whenConfigured {
+                    dependencies.removeIf {
+                        InvokerHelper.getMetaClass(it).getProperty(it, "scope") == "test"
+                    }
+
+                    dependencies
+                        .find {
+                            InvokerHelper.getMetaClass(it).getProperty(it, "groupId") == "org.jetbrains.kotlin"
+                                    && InvokerHelper.getMetaClass(it).getProperty(it, "artifactId") == "kotlin-stdlib"
+                        }
+                        ?.also {
+                            InvokerHelper.getMetaClass(it).setProperty(it, "exclusions", emptyList<Any>())
+                            logger.warn("WARNING! Removed exclusions from kotlin-stdlib dependency of ${this.artifactId} artifact's maven metadata, check kotlin-stdlib dependency of ${project.path} project")
+                        }
+                }
+            }
+
+            tasks.named<Upload>("uploadArchives").configure {
+
+                val preparePublication = project.rootProject.tasks.named("preparePublication").get()
+
+                dependsOn(preparePublication)
+
+                val username: String? by preparePublication.extra
+                val password: String? by preparePublication.extra
+                val repoUrl: String by preparePublication.extra
+
+                var repository by Delegates.notNull<MavenRemoteRepository>()
+
+                repositories {
+                    withConvention(MavenRepositoryHandlerConvention::class) {
+
+                        mavenDeployer {
+                            withGroovyBuilder {
+                                "beforeDeployment" {
+                                    val signing = project.the<SigningExtension>()
+                                    if (signing.isRequired)
+                                        signing.signPom(delegate as MavenDeployment)
+                                }
+
+                                "repository"("url" to repoUrl)!!.also { repository = it as MavenRemoteRepository }.withGroovyBuilder {
+                                    if (username != null && password != null) {
+                                        "authentication"("userName" to username, "password" to password)
+                                    }
+                                }
+                            }
+
+                            configurePom()
+                        }
+                    }
+                }
+
+                doFirst {
+                    repository.url = repoUrl
+                }
+            }
+
+            val install = if (tasks.names.contains("install")) tasks.getByName("install") as Upload
+                          else tasks.create("install", Upload::class.java)
+            install.apply {
+                configuration = project.configurations.getByName(Dependency.ARCHIVES_CONFIGURATION)
+                description = "Installs the 'archives' artifacts into the local Maven repository."
+                repositories {
+                    withConvention(MavenRepositoryHandlerConvention::class) {
+                        mavenInstaller {
+                            configurePom()
+                        }
+                    }
+                }
+            }
+
+            tasks.register("publish") {
+                dependsOn(tasks.named("uploadArchives"))
+            }
+        }
+    }
+}

buildSrc/src/main/kotlin/tasks.kt

@@ -194,7 +194,9 @@ fun Project.projectTest(
         systemProperty("kotlin.ni", if (project.rootProject.hasProperty("newInferenceTests")) "true" else "false")
         systemProperty("org.jetbrains.kotlin.skip.muted.tests", if (project.rootProject.hasProperty("skipMutedTests")) "true" else "false")
 
-        systemProperty("idea.ignore.disabled.plugins", "true")
+        if (Platform[202].orHigher()) {
+            systemProperty("idea.ignore.disabled.plugins", "true")
+        }
 
         var subProjectTempRoot: Path? = null
         val projectName = project.name

buildSrc/src/main/kotlin/testDistribution.kt

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

compiler/android-tests/build.gradle.kts

@@ -24,18 +24,24 @@ dependencies {
     testApi(projectTests(":compiler:tests-compiler-utils"))
     testApi(projectTests(":compiler:tests-common-new"))
 
+    testCompile(projectTests(":jps-plugin"))
     testCompile(commonDep("junit:junit"))
 
-    testCompile(intellijDep()) { includeJars("util", "idea", "idea_rt", rootProject = rootProject) }
-    testCompile(intellijDep()) { includeJars("groovy", rootProject = rootProject) }
+    Platform[193].orLower {
+        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(intellijPluginDep("java")) { includeJars("jps-builders") }
     testCompile(jpsStandalone()) { includeJars("jps-model") }
     testCompile(jpsBuildTest())
 
-    testRuntimeOnly(compile(intellijCoreDep()) { includeJars("intellij-core") })
-    testRuntimeOnly(compile(intellijDep()) { includeJars("jna", rootProject = rootProject) })
-
     testCompile("org.junit.platform:junit-platform-launcher:${commonVer("org.junit.platform", "")}")
 }
 

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

@@ -15,10 +15,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.codegen.CodegenTestFiles
 import org.jetbrains.kotlin.codegen.GenerationUtils
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
-import org.jetbrains.kotlin.config.CommonConfigurationKeys
-import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.config.JvmTarget
-import org.jetbrains.kotlin.config.languageVersionSettings
+import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.psi.KtFile
@@ -26,11 +23,11 @@ import org.jetbrains.kotlin.test.*
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.model.DependencyKind
 import org.jetbrains.kotlin.test.model.FrontendKinds
-import org.jetbrains.kotlin.test.model.ResultingArtifact
 import org.jetbrains.kotlin.test.runners.AbstractKotlinCompilerTest
 import org.jetbrains.kotlin.test.services.*
 import org.jetbrains.kotlin.test.services.configuration.CommonEnvironmentConfigurator
 import org.jetbrains.kotlin.test.services.configuration.JvmEnvironmentConfigurator
+import org.jetbrains.kotlin.test.services.impl.BackendKindExtractorImpl
 import org.jetbrains.kotlin.test.services.impl.TemporaryDirectoryManagerImpl
 import org.jetbrains.kotlin.test.services.sourceProviders.AdditionalDiagnosticsSourceFilesProvider
 import org.jetbrains.kotlin.test.services.sourceProviders.CodegenHelpersSourceFilesProvider
@@ -357,8 +354,8 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
                         extractor.provideConfigurationKeys()
                         extractor.configure(keyConfiguration, module.directives)
                     }
-                    val kind = JvmEnvironmentConfigurator.extractConfigurationKind(module.directives)
-                    val jdkKind = JvmEnvironmentConfigurator.extractJdkKind(module.directives)
+                    val kind = configuratorForFlags.extractConfigurationKind(module.directives)
+                    val jdkKind = configuratorForFlags.extractJdkKind(module.directives)
 
                     keyConfiguration.languageVersionSettings = module.languageVersionSettings
 
@@ -385,7 +382,6 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
                 "test${testDataFile.nameWithoutExtension.replaceFirstChar(Char::uppercaseChar)}",
                 emptySet()
             )
-            startingArtifactFactory = { ResultingArtifact.Source() }
         }.build(testDataFile.path)
     }
 
@@ -410,6 +406,7 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
 
         assertions = JUnit5Assertions
         useAdditionalService<TemporaryDirectoryManager>(::TemporaryDirectoryManagerImpl)
+        useAdditionalService<BackendKindExtractor>(::BackendKindExtractorImpl)
         useSourcePreprocessor(*AbstractKotlinCompilerTest.defaultPreprocessors.toTypedArray())
         useDirectives(*AbstractKotlinCompilerTest.defaultDirectiveContainers.toTypedArray())
     }

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

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

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

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

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

@@ -5,15 +5,21 @@
 
 package org.jetbrains.kotlin.backend.common
 
-import org.jetbrains.kotlin.builtins.StandardNames
+import org.jetbrains.kotlin.config.LanguageFeature
+import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.config.coroutinesIntrinsicsPackageFqName
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.isTopLevelInPackage
 import org.jetbrains.kotlin.name.Name
 
 val COROUTINE_SUSPENDED_NAME = Name.identifier("COROUTINE_SUSPENDED")
 
-fun FunctionDescriptor.isBuiltInSuspendCoroutineUninterceptedOrReturn(): Boolean =
+fun FunctionDescriptor.isBuiltInIntercepted(languageVersionSettings: LanguageVersionSettings): Boolean =
+    !languageVersionSettings.supportsFeature(LanguageFeature.ReleaseCoroutines) &&
+            isTopLevelInPackage("intercepted", languageVersionSettings.coroutinesIntrinsicsPackageFqName().asString())
+
+fun FunctionDescriptor.isBuiltInSuspendCoroutineUninterceptedOrReturn(languageVersionSettings: LanguageVersionSettings): Boolean =
     isTopLevelInPackage(
         "suspendCoroutineUninterceptedOrReturn",
-        StandardNames.COROUTINES_INTRINSICS_PACKAGE_FQ_NAME.asString()
+        languageVersionSettings.coroutinesIntrinsicsPackageFqName().asString()
     )

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

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

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

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

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

@@ -34,10 +34,10 @@ import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.AnnotationChecker;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.InlineClassesUtilsKt;
+import org.jetbrains.kotlin.resolve.checkers.ExpectedActualDeclarationChecker;
 import org.jetbrains.kotlin.resolve.constants.*;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
 import org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt;
-import org.jetbrains.kotlin.resolve.multiplatform.OptionalAnnotationUtil;
 import org.jetbrains.kotlin.types.FlexibleType;
 import org.jetbrains.kotlin.types.FlexibleTypesKt;
 import org.jetbrains.kotlin.types.KotlinType;
@@ -376,7 +376,7 @@ public abstract class AnnotationCodegen {
         // We do not generate annotations whose classes are optional (annotated with `@OptionalExpectation`) because if an annotation entry
         // is resolved to the expected declaration, this means that annotation has no actual class, and thus should not be generated.
         // (Otherwise we would've resolved the entry to the actual annotation class.)
-        if (OptionalAnnotationUtil.isOptionalAnnotationClass(classDescriptor)) {
+        if (ExpectedActualDeclarationChecker.isOptionalAnnotationClass(classDescriptor)) {
             return null;
         }
 

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

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

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

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

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

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

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

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

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

@@ -12,7 +12,6 @@ import kotlin.Unit;
 import kotlin.collections.CollectionsKt;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.backend.common.SamType;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.codegen.binding.CalculatedClosure;
 import org.jetbrains.kotlin.codegen.context.ClosureContext;
@@ -32,6 +31,7 @@ import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader;
 import org.jetbrains.kotlin.metadata.ProtoBuf;
 import org.jetbrains.kotlin.psi.KtElement;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
+import org.jetbrains.kotlin.resolve.InlineClassesUtilsKt;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKt;
@@ -40,7 +40,7 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.TransientReceiver;
 import org.jetbrains.kotlin.serialization.DescriptorSerializer;
 import org.jetbrains.kotlin.types.KotlinType;
 import org.jetbrains.kotlin.types.SimpleType;
-import org.jetbrains.kotlin.types.TypeUtils;
+import org.jetbrains.kotlin.backend.common.SamType;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
 import org.jetbrains.kotlin.util.OperatorNameConventions;
 import org.jetbrains.org.objectweb.asm.MethodVisitor;
@@ -376,12 +376,10 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
                 value = StackValue.local(slot, type, bridgeParameterKotlinTypes.get(i));
                 slot += type.getSize();
             }
-            if (InlineClassesCodegenUtilKt.isInlineClassWithUnderlyingTypeAnyOrAnyN(parameterType) && functionReferenceCall == null) {
-                ClassDescriptor descriptor = TypeUtils.getClassDescriptor(parameterType);
-                InlineClassRepresentation<SimpleType> representation =
-                        descriptor != null ? descriptor.getInlineClassRepresentation() : null;
-                assert representation != null : "Not an inline class type: " + parameterType;
-                parameterType = representation.getUnderlyingType();
+            if (InlineClassesCodegenUtilKt.isInlineClassWithUnderlyingTypeAnyOrAnyN(parameterType) &&
+                functionReferenceCall == null
+            ) {
+                parameterType = InlineClassesUtilsKt.unsubstitutedUnderlyingParameter(parameterType).getType();
             }
             value.put(typeMapper.mapType(calleeParameter), parameterType, iv);
         }
@@ -475,7 +473,7 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
 
             List<Type> superCtorArgTypes = new ArrayList<>();
             if (superClassAsmType.equals(LAMBDA) || functionReferenceTarget != null ||
-                CoroutineCodegenUtilKt.isCoroutineSuperClass(superClassAsmType.getInternalName())
+                CoroutineCodegenUtilKt.isCoroutineSuperClass(state.getLanguageVersionSettings(), superClassAsmType.getInternalName())
             ) {
                 iv.iconst(CodegenUtilKt.getArity(funDescriptor));
                 superCtorArgTypes.add(Type.INT_TYPE);

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

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

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

@@ -72,7 +72,7 @@ class ErasedInlineClassBodyCodegen(
     }
 
     private fun generateUnboxMethod() {
-        val boxMethodDescriptor = InlineClassDescriptorResolver.createBoxFunctionDescriptor(descriptor)
+        val boxMethodDescriptor = InlineClassDescriptorResolver.createBoxFunctionDescriptor(descriptor) ?: return
 
         functionCodegen.generateMethod(
             Synthetic(null, boxMethodDescriptor), boxMethodDescriptor, object : FunctionGenerationStrategy.CodegenBased(state) {
@@ -103,7 +103,7 @@ class ErasedInlineClassBodyCodegen(
     }
 
     private fun generateSpecializedEqualsStub() {
-        val specializedEqualsDescriptor = InlineClassDescriptorResolver.createSpecializedEqualsDescriptor(descriptor)
+        val specializedEqualsDescriptor = InlineClassDescriptorResolver.createSpecializedEqualsDescriptor(descriptor) ?: return
 
         functionCodegen.generateMethod(
             Synthetic(null, specializedEqualsDescriptor), specializedEqualsDescriptor, object : FunctionGenerationStrategy.CodegenBased(state) {

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

@@ -20,7 +20,6 @@ import kotlin.text.StringsKt;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.backend.common.CodegenUtil;
-import org.jetbrains.kotlin.backend.common.SamType;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.codegen.binding.CalculatedClosure;
 import org.jetbrains.kotlin.codegen.binding.CodegenBinding;
@@ -89,9 +88,11 @@ import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor;
 import org.jetbrains.kotlin.types.*;
 import org.jetbrains.kotlin.types.checker.ClassicTypeSystemContextImpl;
 import org.jetbrains.kotlin.types.expressions.DoubleColonLHS;
+import org.jetbrains.kotlin.types.model.KotlinTypeMarker;
 import org.jetbrains.kotlin.types.model.TypeParameterMarker;
 import org.jetbrains.kotlin.types.typesApproximation.CapturedTypeApproximationKt;
 import org.jetbrains.kotlin.util.OperatorNameConventions;
+import org.jetbrains.kotlin.backend.common.SamType;
 import org.jetbrains.org.objectweb.asm.Label;
 import org.jetbrains.org.objectweb.asm.MethodVisitor;
 import org.jetbrains.org.objectweb.asm.Opcodes;
@@ -106,7 +107,6 @@ import java.util.stream.Collectors;
 import static org.jetbrains.kotlin.builtins.KotlinBuiltIns.isInt;
 import static org.jetbrains.kotlin.codegen.AsmUtil.boxType;
 import static org.jetbrains.kotlin.codegen.AsmUtil.*;
-import static org.jetbrains.kotlin.codegen.BaseExpressionCodegenKt.putReifiedOperationMarkerIfTypeIsReifiedParameter;
 import static org.jetbrains.kotlin.codegen.CodegenUtilKt.*;
 import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.boxType;
 import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.*;
@@ -265,23 +265,13 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         );
     }
 
-    private static void addReifiedParametersFromSignature(@NotNull MemberCodegen<?> member, @NotNull ClassDescriptor descriptor) {
+    private static void addReifiedParametersFromSignature(@NotNull MemberCodegen member, @NotNull ClassDescriptor descriptor) {
         for (KotlinType type : descriptor.getTypeConstructor().getSupertypes()) {
-            processTypeArguments(member, type);
-        }
-    }
-
-    private static void processTypeArguments(@NotNull MemberCodegen<?> member, KotlinType type) {
-        for (TypeProjection supertypeArgument : type.getArguments()) {
-            if (supertypeArgument.isStarProjection()) continue;
-
-            TypeParameterDescriptor parameterDescriptor = TypeUtils.getTypeParameterDescriptorOrNull(supertypeArgument.getType());
-            if (parameterDescriptor != null) {
-                if (parameterDescriptor.isReified()) {
+            for (TypeProjection supertypeArgument : type.getArguments()) {
+                TypeParameterDescriptor parameterDescriptor = TypeUtils.getTypeParameterDescriptorOrNull(supertypeArgument.getType());
+                if (parameterDescriptor != null && parameterDescriptor.isReified()) {
                     member.getReifiedTypeParametersUsages().addUsedReifiedParameter(parameterDescriptor.getName().asString());
                 }
-            } else {
-                processTypeArguments(member, supertypeArgument.getType());
             }
         }
     }
@@ -1261,9 +1251,9 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             if (closure.isSuspendLambda()) {
                 // When inlining crossinline lambda, the ACONST_NULL is never popped.
                 // Thus, do not generate it. Otherwise, it leads to VerifyError on run-time.
-                boolean isCrossinlineLambda = (callGenerator instanceof PsiInlineCodegen) &&
-                                              Objects.requireNonNull(((PsiInlineCodegen) callGenerator).getActiveLambda(),
-                                                                     "no active lambda found").isCrossInline();
+                boolean isCrossinlineLambda = (callGenerator instanceof InlineCodegen<?>) &&
+                                              Objects.requireNonNull(((InlineCodegen) callGenerator).getActiveLambda(),
+                                                                     "no active lambda found").isCrossInline;
                 if (!isCrossinlineLambda) {
                     v.aconst(null);
                 }
@@ -1287,11 +1277,11 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
 
     @NotNull
     private static CallableDescriptor unwrapOriginalReceiverOwnerForSuspendLambda(@NotNull MethodContext context) {
-        FunctionDescriptor originalForInvokeSuspend =
-                context.getFunctionDescriptor().getUserData(CoroutineCodegenUtilKt.INITIAL_SUSPEND_DESCRIPTOR_FOR_INVOKE_SUSPEND);
+        FunctionDescriptor originalForDoResume =
+                context.getFunctionDescriptor().getUserData(CoroutineCodegenUtilKt.INITIAL_SUSPEND_DESCRIPTOR_FOR_DO_RESUME);
 
-        if (originalForInvokeSuspend != null) {
-            return originalForInvokeSuspend;
+        if (originalForDoResume != null) {
+            return originalForDoResume;
         }
 
         if (context.getFunctionDescriptor().isSuspend()) {
@@ -2024,12 +2014,10 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
                     // Do not unbox parameters of suspend lambda, they are unboxed in `invoke` method
                     !CoroutineCodegenUtilKt.isInvokeSuspendOfLambda(context.getFunctionDescriptor())
                 ) {
-                    ClassDescriptor inlineClass = (ClassDescriptor) inlineClassType.getConstructor().getDeclarationDescriptor();
-                    InlineClassRepresentation<SimpleType> representation =
-                            inlineClass != null ? inlineClass.getInlineClassRepresentation() : null;
-                    assert representation != null : "Not an inline class: " + inlineClassType;
-                    KotlinType underlyingType = representation.getUnderlyingType();
-                    return StackValue.underlyingValueOfInlineClass(typeMapper.mapType(underlyingType), underlyingType, localOrCaptured);
+                    KotlinType underlyingType = InlineClassesUtilsKt.underlyingRepresentation(
+                            (ClassDescriptor) inlineClassType.getConstructor().getDeclarationDescriptor()).getType();
+                    return StackValue.underlyingValueOfInlineClass(
+                            typeMapper.mapType(underlyingType), underlyingType, localOrCaptured);
                 }
             }
             return localOrCaptured;
@@ -2616,6 +2604,26 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
                 ? coroutineInstanceValueForSuspensionPoint
                 : getContinuationParameterFromEnclosingSuspendFunction(resolvedCall);
 
+        if (coroutineInstanceValue != null && needsExperimentalCoroutinesWrapper(resolvedCall.getCandidateDescriptor())) {
+            StackValue releaseContinuation = coroutineInstanceValue;
+            coroutineInstanceValue = new StackValue(CoroutineCodegenUtilKt.EXPERIMENTAL_CONTINUATION_ASM_TYPE) {
+                @Override
+                public void putSelector(
+                        @NotNull Type type, @Nullable KotlinType kotlinType, @NotNull InstructionAdapter v
+                ) {
+                    releaseContinuation.put(CoroutineCodegenUtilKt.RELEASE_CONTINUATION_ASM_TYPE, v);
+                    invokeCoroutineMigrationMethod(
+                            v,
+                            "toExperimentalContinuation",
+                            Type.getMethodDescriptor(
+                                    CoroutineCodegenUtilKt.EXPERIMENTAL_CONTINUATION_ASM_TYPE,
+                                    CoroutineCodegenUtilKt.RELEASE_CONTINUATION_ASM_TYPE
+                            )
+                    );
+                }
+            };
+        }
+
         tempVariables.put(continuationExpression, coroutineInstanceValue);
     }
 
@@ -2753,15 +2761,14 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         }
 
         SuspensionPointKind suspensionPointKind =
-                CoroutineCodegenUtilKt.isSuspensionPoint(resolvedCall, this);
+                CoroutineCodegenUtilKt.isSuspensionPoint(resolvedCall, this, state.getLanguageVersionSettings());
         boolean maybeSuspensionPoint = suspensionPointKind != SuspensionPointKind.NEVER && !insideCallableReference();
         boolean isConstructor = resolvedCall.getResultingDescriptor() instanceof ConstructorDescriptor;
         if (!(callableMethod instanceof IntrinsicWithSpecialReceiver)) {
             putReceiverAndInlineMarkerIfNeeded(callableMethod, resolvedCall, receiver, maybeSuspensionPoint, isConstructor);
         }
 
-        callGenerator.processHiddenParameters();
-        callGenerator.putHiddenParamsIntoLocals();
+        callGenerator.processAndPutHiddenParameters(false);
 
         List<ResolvedValueArgument> valueArguments = resolvedCall.getValueArgumentsByIndex();
         assert valueArguments != null : "Failed to arrange value arguments by index: " + resolvedCall.getResultingDescriptor();
@@ -2812,7 +2819,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             KotlinType unboxedInlineClass = CoroutineCodegenUtilKt.originalReturnTypeOfSuspendFunctionReturningUnboxedInlineClass(
                     (FunctionDescriptor) resolvedCall.getResultingDescriptor(), typeMapper);
             if (unboxedInlineClass != null) {
-                CoroutineCodegenUtilKt.generateCoroutineSuspendedCheck(v);
+                CoroutineCodegenUtilKt.generateCoroutineSuspendedCheck(v, state.getLanguageVersionSettings());
             }
         }
 
@@ -2927,15 +2934,16 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         FunctionDescriptor original =
                 CoroutineCodegenUtilKt.getOriginalSuspendFunctionView(
                         unwrapInitialSignatureDescriptor(DescriptorUtils.unwrapFakeOverride((FunctionDescriptor) descriptor.getOriginal())),
-                        bindingContext
+                        bindingContext, state
                 );
 
+        PsiSourceCompilerForInline sourceCompiler = new PsiSourceCompilerForInline(this, callElement);
         FunctionDescriptor functionDescriptor =
                 InlineUtil.isArrayConstructorWithLambda(original)
                 ? FictitiousArrayConstructor.create((ConstructorDescriptor) original) : original.getOriginal();
-        PsiSourceCompilerForInline sourceCompiler = new PsiSourceCompilerForInline(this, callElement, functionDescriptor);
 
-        JvmMethodSignature signature = typeMapper.mapSignatureWithGeneric(functionDescriptor, sourceCompiler.getContext().getContextKind());
+        sourceCompiler.initializeInlineFunctionContext(functionDescriptor);
+        JvmMethodSignature signature = typeMapper.mapSignatureWithGeneric(functionDescriptor, sourceCompiler.getContextKind());
         if (signature.getAsmMethod().getName().contains("-") &&
             !state.getConfiguration().getBoolean(JVMConfigurationKeys.USE_OLD_INLINE_CLASSES_MANGLING_SCHEME)
         ) {
@@ -2943,17 +2951,17 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
                     InlineClassesCodegenUtilKt.classFileContainsMethod(functionDescriptor, state, signature.getAsmMethod());
             if (classFileContainsMethod != null && !classFileContainsMethod) {
                 typeMapper.setUseOldManglingRulesForFunctionAcceptingInlineClass(true);
-                signature = typeMapper.mapSignatureWithGeneric(functionDescriptor, sourceCompiler.getContext().getContextKind());
+                signature = typeMapper.mapSignatureWithGeneric(functionDescriptor, sourceCompiler.getContextKind());
                 typeMapper.setUseOldManglingRulesForFunctionAcceptingInlineClass(false);
             }
         }
+        Type methodOwner = typeMapper.mapImplementationOwner(functionDescriptor);
         if (isDefaultCompilation) {
-            return new InlineCodegenForDefaultBody(functionDescriptor, this, state, signature, sourceCompiler);
-        } else {
-            return new PsiInlineCodegen(
-                    this, state, functionDescriptor, signature, typeParameterMappings, sourceCompiler,
-                    typeMapper.mapImplementationOwner(functionDescriptor), typeMapper.mapOwner(descriptor), callElement
-            );
+            return new InlineCodegenForDefaultBody(functionDescriptor, this, state, methodOwner, signature, sourceCompiler);
+        }
+        else {
+            return new PsiInlineCodegen(this, state, functionDescriptor, methodOwner, signature, typeParameterMappings, sourceCompiler,
+                                        typeMapper.mapOwner(descriptor));
         }
     }
 
@@ -3537,7 +3545,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
                 if (TypeUtils.isTypeParameter(type)) {
                     assert TypeUtils.isReifiedTypeParameter(type) :
                             "Non-reified type parameter under ::class should be rejected by type checker: " + type;
-                    putReifiedOperationMarkerIfTypeIsReifiedParameter(this, type, ReifiedTypeInliner.OperationKind.JAVA_CLASS);
+                    putReifiedOperationMarkerIfTypeIsReifiedParameter(type, ReifiedTypeInliner.OperationKind.JAVA_CLASS);
                 }
 
                 putJavaLangClassInstance(v, typeMapper.mapType(type), type, typeMapper);
@@ -4910,7 +4918,10 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
     public void newArrayInstruction(@NotNull KotlinType arrayType) {
         if (KotlinBuiltIns.isArray(arrayType)) {
             KotlinType elementJetType = arrayType.getArguments().get(0).getType();
-            putReifiedOperationMarkerIfTypeIsReifiedParameter(this, elementJetType, ReifiedTypeInliner.OperationKind.NEW_ARRAY);
+            putReifiedOperationMarkerIfTypeIsReifiedParameter(
+                    elementJetType,
+                    ReifiedTypeInliner.OperationKind.NEW_ARRAY
+            );
             v.newarray(boxType(typeMapper.mapTypeAsDeclaration(elementJetType)));
         }
         else {
@@ -5214,7 +5225,7 @@ The "returned" value of try expression with no finally is either the last expres
 
             boolean safeAs = opToken == KtTokens.AS_SAFE;
             if (TypeUtils.isReifiedTypeParameter(rightKotlinType)) {
-                putReifiedOperationMarkerIfTypeIsReifiedParameter(this, rightKotlinType,
+                putReifiedOperationMarkerIfTypeIsReifiedParameter(rightKotlinType,
                                                                   safeAs ? ReifiedTypeInliner.OperationKind.SAFE_AS
                                                                          : ReifiedTypeInliner.OperationKind.AS);
                 v.checkcast(boxedRightType);
@@ -5222,7 +5233,7 @@ The "returned" value of try expression with no finally is either the last expres
             }
 
             CodegenUtilKt.generateAsCast(
-                    v, rightKotlinType, boxedRightType, safeAs, state.getUnifiedNullChecks()
+                    v, rightKotlinType, boxedRightType, safeAs, state.getLanguageVersionSettings(), state.getUnifiedNullChecks()
             );
 
             return Unit.INSTANCE;
@@ -5271,12 +5282,12 @@ The "returned" value of try expression with no finally is either the last expres
 
             Type type = boxType(typeMapper.mapTypeAsDeclaration(rhsKotlinType));
             if (TypeUtils.isReifiedTypeParameter(rhsKotlinType)) {
-                putReifiedOperationMarkerIfTypeIsReifiedParameter(this, rhsKotlinType, ReifiedTypeInliner.OperationKind.IS);
+                putReifiedOperationMarkerIfTypeIsReifiedParameter(rhsKotlinType, ReifiedTypeInliner.OperationKind.IS);
                 v.instanceOf(type);
                 return null;
             }
 
-            CodegenUtilKt.generateIsCheck(v, rhsKotlinType, type);
+            CodegenUtilKt.generateIsCheck(v, rhsKotlinType, type, state.getLanguageVersionSettings().supportsFeature(LanguageFeature.ReleaseCoroutines));
             return null;
         });
     }
@@ -5523,4 +5534,11 @@ The "returned" value of try expression with no finally is either the last expres
             parentCodegen.getReifiedTypeParametersUsages().addUsedReifiedParameter(typeParameterDescriptor.getName().asString());
         }
     }
+
+    @Override
+    public void putReifiedOperationMarkerIfTypeIsReifiedParameter(
+            @NotNull KotlinTypeMarker type, @NotNull ReifiedTypeInliner.OperationKind operationKind
+    ) {
+        BaseExpressionCodegen.DefaultImpls.putReifiedOperationMarkerIfTypeIsReifiedParameter(this, type, operationKind);
+    }
 }

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

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

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

@@ -53,7 +53,6 @@ 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.types.KotlinType;
-import org.jetbrains.kotlin.types.SimpleType;
 import org.jetbrains.kotlin.types.TypeUtils;
 import org.jetbrains.org.objectweb.asm.Label;
 import org.jetbrains.org.objectweb.asm.MethodVisitor;
@@ -370,22 +369,23 @@ public class FunctionCodegen {
     public static void generateMethodInsideInlineClassWrapper(
             @NotNull JvmDeclarationOrigin origin,
             @NotNull FunctionDescriptor functionDescriptor,
-            @NotNull ClassDescriptor inlineClass,
+            @NotNull ClassDescriptor containingDeclaration,
             @NotNull MethodVisitor mv,
             @NotNull KotlinTypeMapper typeMapper
     ) {
         mv.visitCode();
 
-        Type fieldOwnerType = typeMapper.mapClass(inlineClass);
+        Type fieldOwnerType = typeMapper.mapClass(containingDeclaration);
         Method erasedMethodImpl = typeMapper.mapAsmMethod(functionDescriptor.getOriginal(), OwnerKind.ERASED_INLINE_CLASS);
 
-        InlineClassRepresentation<SimpleType> representation = inlineClass.getInlineClassRepresentation();
-        assert representation != null : "Not an inline class: " + inlineClass;
+        ValueParameterDescriptor valueRepresentation = InlineClassesUtilsKt.underlyingRepresentation(containingDeclaration);
+        if (valueRepresentation == null) return;
+
+        Type fieldType = typeMapper.mapType(valueRepresentation);
 
         generateDelegateToStaticErasedVersion(
-                mv, erasedMethodImpl, fieldOwnerType,
-                representation.getUnderlyingPropertyName().asString(),
-                typeMapper.mapType(representation.getUnderlyingType())
+                mv, erasedMethodImpl,
+                fieldOwnerType, valueRepresentation.getName().asString(), fieldType
         );
 
         endVisit(mv, null, origin.getElement());
@@ -481,7 +481,8 @@ public class FunctionCodegen {
         }
 
         if (!functionDescriptor.isExternal()) {
-            generateMethodBody(mv, functionDescriptor, methodContext, jvmSignature, strategy, memberCodegen, state.getJvmDefaultMode());
+            generateMethodBody(mv, functionDescriptor, methodContext, jvmSignature, strategy, memberCodegen, state.getJvmDefaultMode(),
+                               state.getLanguageVersionSettings().supportsFeature(LanguageFeature.ReleaseCoroutines));
         }
         else if (staticInCompanionObject) {
             // native @JvmStatic foo() in companion object should delegate to the static native function moved to the outer class
@@ -582,7 +583,8 @@ public class FunctionCodegen {
             @NotNull JvmMethodSignature signature,
             @NotNull FunctionGenerationStrategy strategy,
             @NotNull MemberCodegen<?> parentCodegen,
-            @NotNull JvmDefaultMode jvmDefaultMode
+            @NotNull JvmDefaultMode jvmDefaultMode,
+            boolean isReleaseCoroutines
     ) {
         mv.visitCode();
 
@@ -592,7 +594,8 @@ public class FunctionCodegen {
         KotlinTypeMapper typeMapper = parentCodegen.typeMapper;
         if (BuiltinSpecialBridgesUtil.shouldHaveTypeSafeBarrier(functionDescriptor, typeMapper::mapAsmMethod)) {
             generateTypeCheckBarrierIfNeeded(
-                    new InstructionAdapter(mv), functionDescriptor, signature.getReturnType(), null, typeMapper);
+                    new InstructionAdapter(mv), functionDescriptor, signature.getReturnType(), null, typeMapper,
+                    isReleaseCoroutines);
         }
 
         Label methodEntry = null;
@@ -1427,7 +1430,8 @@ public class FunctionCodegen {
         MemberCodegen.markLineNumberForDescriptor(owner.getThisDescriptor(), iv);
 
         if (delegateTo.getArgumentTypes().length > 0 && isSpecialBridge) {
-            generateTypeCheckBarrierIfNeeded(iv, descriptor, bridge.getReturnType(), delegateTo.getArgumentTypes(), typeMapper);
+            generateTypeCheckBarrierIfNeeded(iv, descriptor, bridge.getReturnType(), delegateTo.getArgumentTypes(), typeMapper,
+                                             state.getLanguageVersionSettings().supportsFeature(LanguageFeature.ReleaseCoroutines));
         }
 
         iv.load(0, OBJECT_TYPE);
@@ -1473,7 +1477,8 @@ public class FunctionCodegen {
             @NotNull FunctionDescriptor descriptor,
             @NotNull Type returnType,
             @Nullable Type[] delegateParameterTypes,
-            @NotNull KotlinTypeMapper typeMapper
+            @NotNull KotlinTypeMapper typeMapper,
+            boolean isReleaseCoroutines
     ) {
         BuiltinMethodsWithSpecialGenericSignature.TypeSafeBarrierDescription typeSafeBarrierDescription =
                 BuiltinMethodsWithSpecialGenericSignature.getDefaultValueForOverriddenBuiltinFunction(descriptor);
@@ -1507,7 +1512,7 @@ public class FunctionCodegen {
                 } else {
                     targetBoxedType = boxType(delegateParameterTypes[i]);
                 }
-                CodegenUtilKt.generateIsCheck(iv, kotlinType, targetBoxedType);
+                CodegenUtilKt.generateIsCheck(iv, kotlinType, targetBoxedType, isReleaseCoroutines);
                 iv.ifeq(defaultBranch);
             }
         }

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

@@ -55,7 +55,6 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.ImplicitReceiver;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.kotlin.serialization.DescriptorSerializer;
 import org.jetbrains.kotlin.types.KotlinType;
-import org.jetbrains.kotlin.types.SimpleType;
 import org.jetbrains.org.objectweb.asm.FieldVisitor;
 import org.jetbrains.org.objectweb.asm.MethodVisitor;
 import org.jetbrains.org.objectweb.asm.Type;
@@ -275,25 +274,26 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
     @Override
     protected void generateUnboxMethodForInlineClass() {
         if (!(myClass instanceof KtClass)) return;
-        InlineClassRepresentation<SimpleType> inlineClassRepresentation = descriptor.getInlineClassRepresentation();
-        if (inlineClassRepresentation == null) return;
+        if (!InlineClassesUtilsKt.isInlineClass(descriptor)) return;
 
         Type ownerType = typeMapper.mapClass(descriptor);
-        Type valueType = typeMapper.mapType(inlineClassRepresentation.getUnderlyingType());
+        ValueParameterDescriptor inlinedValue = InlineClassesUtilsKt.underlyingRepresentation(this.descriptor);
+        if (inlinedValue == null) return;
+
+        Type valueType = typeMapper.mapType(inlinedValue.getType());
         SimpleFunctionDescriptor functionDescriptor = InlineClassDescriptorResolver.createUnboxFunctionDescriptor(this.descriptor);
+        assert functionDescriptor != null : "FunctionDescriptor for unbox method should be not null during codegen";
 
         functionCodegen.generateMethod(
                 JvmDeclarationOriginKt.UnboxMethodOfInlineClass(functionDescriptor), functionDescriptor,
                 new FunctionGenerationStrategy.CodegenBased(state) {
                     @Override
-                    public void doGenerateBody(@NotNull ExpressionCodegen codegen, @NotNull JvmMethodSignature signature) {
+                    public void doGenerateBody(
+                            @NotNull ExpressionCodegen codegen, @NotNull JvmMethodSignature signature
+                    ) {
                         InstructionAdapter iv = codegen.v;
                         iv.load(0, OBJECT_TYPE);
-                        iv.getfield(
-                                ownerType.getInternalName(),
-                                inlineClassRepresentation.getUnderlyingPropertyName().asString(),
-                                valueType.getDescriptor()
-                        );
+                        iv.getfield(ownerType.getInternalName(), inlinedValue.getName().asString(), valueType.getDescriptor());
                         iv.areturn(valueType);
                     }
                 }

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

@@ -5,12 +5,13 @@
 
 package org.jetbrains.kotlin.codegen
 
-import org.jetbrains.kotlin.builtins.StandardNames.COROUTINES_JVM_INTERNAL_PACKAGE_FQ_NAME
 import org.jetbrains.kotlin.builtins.createFunctionType
+import org.jetbrains.kotlin.codegen.coroutines.coroutinesJvmInternalPackageFqName
 import org.jetbrains.kotlin.codegen.coroutines.getOrCreateJvmSuspendFunctionView
 import org.jetbrains.kotlin.codegen.coroutines.isSuspendLambdaOrLocalFunction
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
+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
@@ -32,7 +33,8 @@ class JvmRuntimeTypes(
     private val generateOptimizedCallableReferenceSuperClasses: Boolean
 ) {
     private val kotlinJvmInternalPackage = MutablePackageFragmentDescriptor(module, FqName("kotlin.jvm.internal"))
-    private val kotlinCoroutinesJvmInternalPackage = MutablePackageFragmentDescriptor(module, COROUTINES_JVM_INTERNAL_PACKAGE_FQ_NAME)
+    private val kotlinCoroutinesJvmInternalPackage =
+        MutablePackageFragmentDescriptor(module, languageVersionSettings.coroutinesJvmInternalPackageFqName())
 
     private fun internal(className: String, packageFragment: PackageFragmentDescriptor = kotlinJvmInternalPackage): Lazy<ClassDescriptor> =
         lazy { createClass(packageFragment, className) }
@@ -51,16 +53,24 @@ class JvmRuntimeTypes(
     private val localVariableReference: ClassDescriptor by internal("LocalVariableReference")
     private val mutableLocalVariableReference: ClassDescriptor by internal("MutableLocalVariableReference")
 
+    private val coroutineImpl: ClassDescriptor by internal("CoroutineImpl", kotlinCoroutinesJvmInternalPackage)
     private val continuationImpl: ClassDescriptor by coroutinesInternal("ContinuationImpl")
     private val restrictedContinuationImpl: ClassDescriptor by coroutinesInternal("RestrictedContinuationImpl")
     private val suspendLambda: ClassDescriptor by coroutinesInternal("SuspendLambda")
     private val restrictedSuspendLambda: ClassDescriptor by coroutinesInternal("RestrictedSuspendLambda")
 
     private val suspendFunctionInterface: ClassDescriptor? by lazy {
-        createClass(kotlinCoroutinesJvmInternalPackage, "SuspendFunction", ClassKind.INTERFACE)
+        if (languageVersionSettings.isReleaseCoroutines())
+            createClass(kotlinCoroutinesJvmInternalPackage, "SuspendFunction", ClassKind.INTERFACE)
+        else null
     }
 
-    private fun createCoroutineSuperClass(className: String): ClassDescriptor = createClass(kotlinCoroutinesJvmInternalPackage, className)
+    private fun createCoroutineSuperClass(className: String): ClassDescriptor {
+        return if (languageVersionSettings.isReleaseCoroutines())
+            createClass(kotlinCoroutinesJvmInternalPackage, className)
+        else
+            coroutineImpl
+    }
 
     private val propertyReferences: List<ClassDescriptor> by propertyClasses("PropertyReference", "")
     private val mutablePropertyReferences: List<ClassDescriptor> by propertyClasses("MutablePropertyReference", "")
@@ -84,7 +94,7 @@ class JvmRuntimeTypes(
     fun getSupertypesForClosure(descriptor: FunctionDescriptor): Collection<KotlinType> {
         val actualFunctionDescriptor =
             if (descriptor.isSuspend)
-                getOrCreateJvmSuspendFunctionView(descriptor)
+                getOrCreateJvmSuspendFunctionView(descriptor, languageVersionSettings.supportsFeature(LanguageFeature.ReleaseCoroutines))
             else
                 descriptor
 
@@ -108,7 +118,7 @@ class JvmRuntimeTypes(
         if (descriptor.isSuspend) {
             return mutableListOf<KotlinType>().apply {
                 if (actualFunctionDescriptor.extensionReceiverParameter?.type
-                        ?.isRestrictsSuspensionReceiver() == true
+                        ?.isRestrictsSuspensionReceiver(languageVersionSettings) == true
                 ) {
                     if (descriptor.isSuspendLambdaOrLocalFunction()) {
                         add(restrictedSuspendLambda.defaultType)

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

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

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

@@ -35,9 +35,9 @@ import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStat
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.psi.psiUtil.PsiUtilsKt;
 import org.jetbrains.kotlin.resolve.BindingContext;
+import org.jetbrains.kotlin.resolve.checkers.ExpectedActualDeclarationChecker;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKt;
 import org.jetbrains.kotlin.resolve.lazy.descriptors.PackageDescriptorUtilKt;
-import org.jetbrains.kotlin.resolve.multiplatform.OptionalAnnotationUtil;
 import org.jetbrains.kotlin.utils.KotlinExceptionWithAttachments;
 import org.jetbrains.org.objectweb.asm.Type;
 
@@ -91,8 +91,8 @@ public class PackageCodegenImpl implements PackageCodegen {
             if (declaration instanceof KtClassOrObject) {
                 ClassDescriptor descriptor = state.getBindingContext().get(BindingContext.CLASS, declaration);
                 if (PsiUtilsKt.hasExpectModifier(declaration)) {
-                    if (descriptor != null && OptionalAnnotationUtil.shouldGenerateExpectClass(descriptor)) {
-                        assert OptionalAnnotationUtil.isOptionalAnnotationClass(descriptor) :
+                    if (descriptor != null && ExpectedActualDeclarationChecker.shouldGenerateExpectClass(descriptor)) {
+                        assert ExpectedActualDeclarationChecker.isOptionalAnnotationClass(descriptor) :
                                 "Expect class should be generated only if it's an optional annotation: " + descriptor;
                         state.getFactory().getPackagePartRegistry().getOptionalAnnotations().add(descriptor);
                     }

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

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

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

@@ -22,9 +22,7 @@ import java.lang.StringBuilder
 class StringConcatGenerator(val mode: JvmStringConcat, val mv: InstructionAdapter) {
 
     private val template = StringBuilder("")
-    private val specialSymbolsInTemplate = arrayListOf<String>()
     private val paramTypes = arrayListOf<Type>()
-    private var paramSlots = 0
     private var justFlushed = false
 
     @JvmOverloads
@@ -44,16 +42,7 @@ class StringConcatGenerator(val mode: JvmStringConcat, val mv: InstructionAdapte
         if (mode == JvmStringConcat.INDY_WITH_CONSTANTS) {
             when (stackValue) {
                 is StackValue.Constant -> {
-                    val value = stackValue.value
-                    if (value is String && (value.contains("\u0001") || value.contains("\u0002"))) {
-                        template.append("\u0002") //reference to special symbols added on next line
-                        specialSymbolsInTemplate.add(value)
-                    } else if (value is Char && (value == 1.toChar() || value == 2.toChar())) {
-                        template.append("\u0002") //reference to special symbols added on next line
-                        specialSymbolsInTemplate.add(value.toString())
-                    } else {
-                        template.append(value)
-                    }
+                    template.append(stackValue.value)
                     return
                 }
                 TRUE -> {
@@ -85,9 +74,8 @@ class StringConcatGenerator(val mode: JvmStringConcat, val mv: InstructionAdapte
         } else {
             justFlushed = false
             paramTypes.add(type)
-            paramSlots += type.size
             template.append("\u0001")
-            if (paramSlots >= 199) {
+            if (paramTypes.size == 200) {
                 // Concatenate current arguments into string
                 // because of `StringConcatFactory` limitation add use it as new argument for further processing:
                 // "The number of parameter slots in {@code concatType} is less than or equal to 200"
@@ -116,7 +104,7 @@ class StringConcatGenerator(val mode: JvmStringConcat, val mv: InstructionAdapte
                     "makeConcatWithConstants",
                     Type.getMethodDescriptor(JAVA_STRING_TYPE, *paramTypes.toTypedArray()),
                     bootstrap,
-                    arrayOf(template.toString()) + specialSymbolsInTemplate
+                    arrayOf(template.toString())
                 )
             } else {
                 val bootstrap = Handle(
@@ -134,15 +122,10 @@ class StringConcatGenerator(val mode: JvmStringConcat, val mv: InstructionAdapte
                     arrayOf()
                 )
             }
-            //clear old template
             template.clear()
-            specialSymbolsInTemplate.clear()
             paramTypes.clear()
-
-            //add just flushed string
             paramTypes.add(JAVA_STRING_TYPE)
             template.append("\u0001")
-            paramSlots = JAVA_STRING_TYPE.size
         }
     }
 
@@ -166,4 +149,4 @@ class StringConcatGenerator(val mode: JvmStringConcat, val mv: InstructionAdapte
             StringConcatGenerator(state.runtimeStringConcat, mv)
 
     }
-}
+}

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

@@ -15,7 +15,6 @@ import kotlin.Pair;
 import kotlin.collections.CollectionsKt;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.backend.common.SamTypeApproximator;
 import org.jetbrains.kotlin.builtins.FunctionTypesKt;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.builtins.ReflectionTypes;
@@ -35,10 +34,8 @@ import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor;
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil;
 import org.jetbrains.kotlin.load.java.JvmAbi;
-import org.jetbrains.kotlin.load.java.sam.JavaSingleAbstractMethodUtils;
 import org.jetbrains.kotlin.name.ClassId;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.name.SpecialNames;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.psi.stubs.KotlinFileStub;
 import org.jetbrains.kotlin.resolve.BindingContext;
@@ -93,7 +90,6 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
     private final ClassBuilderMode classBuilderMode;
     private final DelegatedPropertiesCodegenHelper delegatedPropertiesCodegenHelper;
     private final JvmDefaultMode jvmDefaultMode;
-    private final SamTypeApproximator samTypeApproximator;
 
     public CodegenAnnotatingVisitor(@NotNull GenerationState state) {
         this.bindingTrace = state.getBindingTrace();
@@ -104,8 +100,7 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         this.languageVersionSettings = state.getLanguageVersionSettings();
         this.classBuilderMode = state.getClassBuilderMode();
         this.delegatedPropertiesCodegenHelper = new DelegatedPropertiesCodegenHelper(state);
-        this.jvmDefaultMode = state.getJvmDefaultMode();
-        this.samTypeApproximator = new SamTypeApproximator(state.getModule().getBuiltIns(), state.getLanguageVersionSettings());
+        jvmDefaultMode = state.getJvmDefaultMode();
     }
 
     @NotNull
@@ -299,7 +294,7 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
 
     private String getName(ClassDescriptor classDescriptor) {
         String base = peekFromStack(nameStack);
-        Name descriptorName = SpecialNames.safeIdentifier(classDescriptor.getName());
+        Name descriptorName = safeIdentifier(classDescriptor.getName());
         if (DescriptorUtils.isTopLevelDeclaration(classDescriptor)) {
             return base.isEmpty() ? descriptorName.asString() : base + '/' + descriptorName;
         }
@@ -477,6 +472,7 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         SimpleFunctionDescriptor jvmSuspendFunctionView =
                 CoroutineCodegenUtilKt.getOrCreateJvmSuspendFunctionView(
                         functionDescriptor,
+                        languageVersionSettings.supportsFeature(LanguageFeature.ReleaseCoroutines),
                         this.bindingContext
                 );
 
@@ -713,6 +709,54 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         super.visitCallExpression(expression);
         checkSamCall(expression);
         checkCrossinlineCall(expression);
+        recordSuspendFunctionTypeWrapperForArguments(expression);
+    }
+
+    private void recordSuspendFunctionTypeWrapperForArguments(@NotNull KtCallExpression expression) {
+        ResolvedCall<?> call = CallUtilKt.getResolvedCall(expression, bindingContext);
+        if (call == null) return;
+
+        CallableDescriptor descriptor = call.getResultingDescriptor();
+        if (!CodegenUtilKt.needsExperimentalCoroutinesWrapper(descriptor)) return;
+
+        List<ResolvedValueArgument> argumentsByIndex = call.getValueArgumentsByIndex();
+        if (argumentsByIndex == null) return;
+
+        for (ValueParameterDescriptor parameter : descriptor.getValueParameters()) {
+            ResolvedValueArgument resolvedValueArgument = argumentsByIndex.get(parameter.getIndex());
+            if (!(resolvedValueArgument instanceof ExpressionValueArgument)) continue;
+            ValueArgument valueArgument = ((ExpressionValueArgument) resolvedValueArgument).getValueArgument();
+            if (valueArgument == null) continue;
+            KtExpression argumentExpression = valueArgument.getArgumentExpression();
+            if (argumentExpression == null) continue;
+
+            recordSuspendFunctionTypeWrapperForArgument(parameter, argumentExpression);
+        }
+
+        ReceiverValue receiver = call.getExtensionReceiver();
+        if (descriptor.getExtensionReceiverParameter() != null && receiver instanceof ExpressionReceiver) {
+            recordSuspendFunctionTypeWrapperForArgument(
+                    descriptor.getExtensionReceiverParameter(),
+                    ((ExpressionReceiver) receiver).getExpression()
+            );
+        }
+    }
+
+    private void recordSuspendFunctionTypeWrapperForArgument(ParameterDescriptor parameter, KtExpression argumentExpression) {
+        if (FunctionTypesKt.isSuspendFunctionTypeOrSubtype(parameter.getType())) {
+
+            // SuspendFunctionN type is mapped to is mapped to FunctionTypeN+1, but we also need to remove an argument for return type
+            // So, it could be parameter.getType().getArguments().size() + 1 - 1
+            int functionTypeArity = parameter.getType().getArguments().size();
+
+            Type functionType = Type.getObjectType(NUMBERED_FUNCTION_PREFIX + functionTypeArity);
+
+            bindingTrace.record(
+                    FUNCTION_TYPE_FOR_SUSPEND_WRAPPER,
+                    argumentExpression,
+                    functionType
+            );
+        }
     }
 
     private void checkCrossinlineCall(@NotNull KtCallExpression expression) {
@@ -811,20 +855,6 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         }
     }
 
-    @Nullable
-    private SamType createSamType(KotlinType kotlinType) {
-        if (!JavaSingleAbstractMethodUtils.isSamType(kotlinType)) return null;
-        return new SamType(kotlinType);
-    }
-
-    @Nullable
-    private SamType createSamTypeByValueParameter(ValueParameterDescriptor valueParameterDescriptor) {
-        KotlinType kotlinSamType = samTypeApproximator.getSamTypeForValueParameter(valueParameterDescriptor);
-        if (kotlinSamType == null) return null;
-        if (!JavaSingleAbstractMethodUtils.isSamType(kotlinSamType)) return null;
-        return new SamType(kotlinSamType);
-    }
-
     private void writeSamValueForValueParameters(
             @NotNull Collection<ValueParameterDescriptor> valueParametersWithSAMConversion,
             @Nullable List<ResolvedValueArgument> valueArguments
@@ -832,7 +862,7 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         if (valueArguments == null) return;
 
         for (ValueParameterDescriptor valueParameter : valueParametersWithSAMConversion) {
-            SamType samType = createSamTypeByValueParameter(valueParameter);
+            SamType samType = JvmSamTypeFactory.INSTANCE.createByValueParameter(valueParameter);
             if (samType == null) continue;
 
             ResolvedValueArgument resolvedValueArgument = valueArguments.get(valueParameter.getIndex());
@@ -844,7 +874,7 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
     }
 
     private void recordSamTypeOnArgumentExpression(ValueParameterDescriptor valueParameter, ValueArgument valueArgument) {
-        SamType samType = createSamTypeByValueParameter(valueParameter);
+        SamType samType = JvmSamTypeFactory.INSTANCE.createByValueParameter(valueParameter);
         if (samType == null) return;
 
         recordSamTypeOnArgumentExpression(samType, valueArgument);
@@ -925,7 +955,8 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         KtExpression argumentExpression = argument.getArgumentExpression();
         bindingTrace.record(SAM_CONSTRUCTOR_TO_ARGUMENT, expression, argumentExpression);
 
-        SamType samType = createSamType(callableDescriptor.getReturnType());
+        //noinspection ConstantConditions
+        SamType samType = JvmSamTypeFactory.INSTANCE.create(callableDescriptor.getReturnType());
         bindingTrace.record(SAM_VALUE, argumentExpression, samType);
     }
 
@@ -942,7 +973,7 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         FunctionDescriptor original = SamCodegenUtil.getOriginalIfSamAdapter((FunctionDescriptor) operationDescriptor);
         if (original == null) return;
 
-        SamType samType = createSamTypeByValueParameter(original.getValueParameters().get(0));
+        SamType samType = JvmSamTypeFactory.INSTANCE.createByValueParameter(original.getValueParameters().get(0));
         if (samType == null) return;
 
         IElementType token = expression.getOperationToken();
@@ -971,7 +1002,7 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         List<KtExpression> indexExpressions = expression.getIndexExpressions();
         List<ValueParameterDescriptor> parameters = original.getValueParameters();
         for (ValueParameterDescriptor valueParameter : parameters) {
-            SamType samType = createSamTypeByValueParameter(valueParameter);
+            SamType samType = JvmSamTypeFactory.INSTANCE.createByValueParameter(valueParameter);
             if (samType == null) continue;
 
             if (isSetter && valueParameter.getIndex() == parameters.size() - 1) {

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

@@ -13,13 +13,15 @@ import org.jetbrains.kotlin.codegen.binding.CodegenBinding
 import org.jetbrains.kotlin.codegen.context.CodegenContext
 import org.jetbrains.kotlin.codegen.context.FieldOwnerContext
 import org.jetbrains.kotlin.codegen.context.MultifileClassFacadeContext
-import org.jetbrains.kotlin.codegen.coroutines.CONTINUATION_ASM_TYPE
+import org.jetbrains.kotlin.codegen.coroutines.continuationAsmType
 import org.jetbrains.kotlin.codegen.coroutines.unwrapInitialDescriptorForSuspendFunction
 import org.jetbrains.kotlin.codegen.inline.NUMBERED_FUNCTION_PREFIX
 import org.jetbrains.kotlin.codegen.inline.ReificationArgument
 import org.jetbrains.kotlin.codegen.intrinsics.TypeIntrinsics
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
+import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.config.isReleaseCoroutines
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.deserialization.PLATFORM_DEPENDENT_ANNOTATION_FQ_NAME
 import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
@@ -43,6 +45,8 @@ import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.Synthetic
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodGenericSignature
 import org.jetbrains.kotlin.resolve.scopes.receivers.TransientReceiver
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedMemberDescriptor
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedMemberDescriptor.CoroutinesCompatibilityMode
 import org.jetbrains.kotlin.types.ErrorUtils
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.TypeSystemCommonBackendContext
@@ -66,7 +70,8 @@ internal val JAVA_LANG_DEPRECATED = Type.getType(Deprecated::class.java).descrip
 fun generateIsCheck(
     v: InstructionAdapter,
     kotlinType: KotlinType,
-    asmType: Type
+    asmType: Type,
+    isReleaseCoroutines: Boolean
 ) {
     if (TypeUtils.isNullableType(kotlinType)) {
         val nope = Label()
@@ -77,7 +82,7 @@ fun generateIsCheck(
 
             ifnull(nope)
 
-            TypeIntrinsics.instanceOf(this, kotlinType, asmType)
+            TypeIntrinsics.instanceOf(this, kotlinType, asmType, isReleaseCoroutines)
 
             goTo(end)
 
@@ -88,7 +93,7 @@ fun generateIsCheck(
             mark(end)
         }
     } else {
-        TypeIntrinsics.instanceOf(v, kotlinType, asmType)
+        TypeIntrinsics.instanceOf(v, kotlinType, asmType, isReleaseCoroutines)
     }
 }
 
@@ -97,6 +102,7 @@ fun generateAsCast(
     kotlinType: KotlinType,
     asmType: Type,
     isSafe: Boolean,
+    languageVersionSettings: LanguageVersionSettings,
     unifiedNullChecks: Boolean,
 ) {
     if (!isSafe) {
@@ -106,7 +112,7 @@ fun generateAsCast(
     } else {
         with(v) {
             dup()
-            TypeIntrinsics.instanceOf(v, kotlinType, asmType)
+            TypeIntrinsics.instanceOf(v, kotlinType, asmType, languageVersionSettings.isReleaseCoroutines())
             val ok = Label()
             ifne(ok)
             pop()
@@ -387,12 +393,13 @@ fun TypeSystemCommonBackendContext.extractReificationArgument(initialType: Kotli
     while (type.isArrayOrNullableArray()) {
         arrayDepth++
         val argument = type.getArgument(0)
-        if (argument.isStarProjection()) return null
-        type = argument.getType()
+        type =
+            if (argument.isStarProjection()) nullableAnyType()
+            else argument.getType()
     }
 
     val typeParameter = type.typeConstructor().getTypeParameterClassifier() ?: return null
-    if (!typeParameter.isReified()) return null
+
     return Pair(typeParameter, ReificationArgument(typeParameter.getName().asString(), isNullable, arrayDepth))
 }
 
@@ -438,10 +445,14 @@ fun KotlinType.isInlineClassTypeWithPrimitiveEquality(): Boolean {
     return false
 }
 
+fun CallableDescriptor.needsExperimentalCoroutinesWrapper() =
+    (this as? DeserializedMemberDescriptor)?.coroutinesExperimentalCompatibilityMode == CoroutinesCompatibilityMode.NEEDS_WRAPPER
+
 fun recordCallLabelForLambdaArgument(declaration: KtFunctionLiteral, bindingTrace: BindingTrace) {
     val labelName = getCallLabelForLambdaArgument(declaration, bindingTrace.bindingContext) ?: return
     val functionDescriptor = bindingTrace[BindingContext.FUNCTION, declaration] ?: return
     bindingTrace.record(CodegenBinding.CALL_LABEL_FOR_LAMBDA_ARGUMENT, functionDescriptor, labelName)
+
 }
 
 fun getCallLabelForLambdaArgument(declaration: KtFunctionLiteral, bindingContext: BindingContext): String? {
@@ -637,7 +648,7 @@ private fun generateLambdaForRunSuspend(
         }
 
         visitVarInsn(ALOAD, 1)
-        val continuationInternalName = CONTINUATION_ASM_TYPE.internalName
+        val continuationInternalName = state.languageVersionSettings.continuationAsmType().internalName
 
         visitTypeInsn(
             CHECKCAST,

compiler/backend/src/org/jetbrains/kotlin/codegen/context/InlineLambdaContext.kt

@@ -6,9 +6,9 @@
 package org.jetbrains.kotlin.codegen.context
 
 import org.jetbrains.kotlin.backend.common.isBuiltInSuspendCoroutineUninterceptedOrReturn
-import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.codegen.OwnerKind
 import org.jetbrains.kotlin.codegen.binding.MutableClosure
+import org.jetbrains.kotlin.config.coroutinesPackageFqName
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor
 import org.jetbrains.kotlin.descriptors.isTopLevelInPackage
@@ -17,26 +17,25 @@ import org.jetbrains.kotlin.resolve.calls.callUtil.getParentResolvedCall
 import org.jetbrains.kotlin.resolve.source.getPsi
 
 class InlineLambdaContext(
-    functionDescriptor: FunctionDescriptor,
-    contextKind: OwnerKind,
-    parentContext: CodegenContext<*>,
-    closure: MutableClosure?,
-    val isCrossInline: Boolean,
-    private val isPropertyReference: Boolean
+        functionDescriptor: FunctionDescriptor,
+        contextKind: OwnerKind,
+        parentContext: CodegenContext<*>,
+        closure: MutableClosure?,
+        val isCrossInline: Boolean,
+        private val isPropertyReference: Boolean
 ) : MethodContext(functionDescriptor, contextKind, parentContext, closure, false) {
 
     override fun getFirstCrossInlineOrNonInlineContext(): CodegenContext<*> {
         if (isCrossInline && !isSuspendIntrinsicParameter()) return this
 
-        val parent = if (isPropertyReference) parentContext as? AnonymousClassContext else {
-            parentContext as? ClosureContext
-        } ?: throw AssertionError(
-            "Parent of inlining lambda body should be " +
-                    "${if (isPropertyReference) "ClosureContext" else "AnonymousClassContext"}, but: $parentContext"
-        )
+        val parent = if (isPropertyReference) parentContext as? AnonymousClassContext else  { parentContext as? ClosureContext } ?:
+                     throw AssertionError(
+                             "Parent of inlining lambda body should be " +
+                             "${if (isPropertyReference) "ClosureContext" else "AnonymousClassContext"}, but: $parentContext"
+                     )
 
-        val grandParent =
-            parent.parentContext ?: throw AssertionError("Parent context of lambda class context should exist: $contextDescriptor")
+        val grandParent = parent.parentContext ?:
+                          throw AssertionError("Parent context of lambda class context should exist: $contextDescriptor")
         return grandParent.firstCrossInlineOrNonInlineContext
     }
 
@@ -45,7 +44,7 @@ class InlineLambdaContext(
         if (contextDescriptor !is AnonymousFunctionDescriptor) return false
         val resolvedCall = (contextDescriptor.source.getPsi() as? KtElement).getParentResolvedCall(state.bindingContext) ?: return false
         val descriptor = resolvedCall.resultingDescriptor as? FunctionDescriptor ?: return false
-        return descriptor.isBuiltInSuspendCoroutineUninterceptedOrReturn()
-                || descriptor.isTopLevelInPackage("suspendCoroutine", StandardNames.COROUTINES_PACKAGE_FQ_NAME.asString())
+        return descriptor.isBuiltInSuspendCoroutineUninterceptedOrReturn(state.languageVersionSettings)
+                || descriptor.isTopLevelInPackage("suspendCoroutine", state.languageVersionSettings.coroutinesPackageFqName().asString())
     }
 }

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

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.codegen.coroutines
 
-import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.codegen.optimization.boxing.isPrimitiveBoxing
 import org.jetbrains.kotlin.codegen.optimization.common.asSequence
 import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
@@ -16,9 +15,10 @@ import org.jetbrains.kotlin.utils.sure
 import org.jetbrains.org.objectweb.asm.Opcodes
 import org.jetbrains.org.objectweb.asm.tree.MethodInsnNode
 import org.jetbrains.org.objectweb.asm.tree.MethodNode
+import java.util.*
 
 private val BOXING_CLASS_INTERNAL_NAME =
-    StandardNames.COROUTINES_JVM_INTERNAL_PACKAGE_FQ_NAME.child(Name.identifier("Boxing")).topLevelClassInternalName()
+    RELEASE_COROUTINES_VERSION_SETTINGS.coroutinesJvmInternalPackageFqName().child(Name.identifier("Boxing")).topLevelClassInternalName()
 
 @OptIn(ExperimentalStdlibApi::class)
 object ChangeBoxingMethodTransformer : MethodTransformer() {

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

@@ -7,8 +7,9 @@ package org.jetbrains.kotlin.codegen.coroutines
 
 import com.intellij.util.ArrayUtil
 import org.jetbrains.kotlin.backend.common.CodegenUtil
-import org.jetbrains.kotlin.builtins.StandardNames
+import org.jetbrains.kotlin.builtins.isSuspendFunctionTypeOrSubtype
 import org.jetbrains.kotlin.codegen.*
+import org.jetbrains.kotlin.codegen.binding.CalculatedClosure
 import org.jetbrains.kotlin.codegen.binding.CodegenBinding
 import org.jetbrains.kotlin.codegen.binding.CodegenBinding.CAPTURES_CROSSINLINE_LAMBDA
 import org.jetbrains.kotlin.codegen.binding.CodegenBinding.CLOSURE
@@ -18,6 +19,8 @@ import org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings.METHO
 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
@@ -40,6 +43,7 @@ import org.jetbrains.kotlin.resolve.jvm.diagnostics.OtherOrigin
 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.sure
 import org.jetbrains.org.objectweb.asm.Label
 import org.jetbrains.org.objectweb.asm.MethodVisitor
@@ -54,7 +58,7 @@ abstract class AbstractCoroutineCodegen(
     element: KtElement,
     closureContext: ClosureContext,
     classBuilder: ClassBuilder,
-    private val userDataForInvokeSuspend: Map<out CallableDescriptor.UserDataKey<*>, *>? = null
+    private val userDataForDoResume: Map<out CallableDescriptor.UserDataKey<*>, *>? = null
 ) : ClosureCodegen(
     outerExpressionCodegen.state,
     element, null, closureContext, null,
@@ -65,10 +69,17 @@ abstract class AbstractCoroutineCodegen(
     protected val languageVersionSettings = outerExpressionCodegen.state.languageVersionSettings
 
     protected val methodToImplement =
-        createImplMethod(
-            INVOKE_SUSPEND_METHOD_NAME,
-            SUSPEND_CALL_RESULT_NAME to classDescriptor.module.getResult(classDescriptor.builtIns.anyType)
-        )
+        if (languageVersionSettings.isReleaseCoroutines())
+            createImplMethod(
+                INVOKE_SUSPEND_METHOD_NAME,
+                SUSPEND_CALL_RESULT_NAME to classDescriptor.module.getResult(classDescriptor.builtIns.anyType)
+            )
+        else
+            createImplMethod(
+                DO_RESUME_METHOD_NAME,
+                "data" to classDescriptor.builtIns.nullableAnyType,
+                "throwable" to classDescriptor.builtIns.throwable.defaultType.makeNullable()
+            )
 
     private fun createImplMethod(name: String, vararg parameters: Pair<String, KotlinType>) =
         SimpleFunctionDescriptorImpl.create(
@@ -85,7 +96,7 @@ abstract class AbstractCoroutineCodegen(
                 builtIns.nullableAnyType,
                 Modality.FINAL,
                 DescriptorVisibilities.PUBLIC,
-                userDataForInvokeSuspend
+                userDataForDoResume
             )
         }
 
@@ -100,7 +111,7 @@ abstract class AbstractCoroutineCodegen(
 
     override fun generateConstructor(): Method {
         val args = calculateConstructorParameters(typeMapper, languageVersionSettings, closure, asmType)
-        val argTypes = args.map { it.fieldType }.plus(CONTINUATION_ASM_TYPE).toTypedArray()
+        val argTypes = args.map { it.fieldType }.plus(languageVersionSettings.continuationAsmType()).toTypedArray()
 
         val constructor = Method("<init>", Type.VOID_TYPE, argTypes)
         val mv = v.newMethod(
@@ -115,17 +126,18 @@ abstract class AbstractCoroutineCodegen(
             iv.generateClosureFieldsInitializationFromParameters(closure, args)
 
             iv.load(0, AsmTypes.OBJECT_TYPE)
-            if (passArityToSuperClass) {
-                iv.iconst(funDescriptor.arity)
+            val hasArityParameter = !languageVersionSettings.isReleaseCoroutines() || passArityToSuperClass
+            if (hasArityParameter) {
+                iv.iconst(if (passArityToSuperClass) funDescriptor.arity else 0)
             }
 
             iv.load(argTypes.map { it.size }.sum(), AsmTypes.OBJECT_TYPE)
 
             val parameters =
-                if (passArityToSuperClass)
-                    listOf(Type.INT_TYPE, CONTINUATION_ASM_TYPE)
+                if (hasArityParameter)
+                    listOf(Type.INT_TYPE, languageVersionSettings.continuationAsmType())
                 else
-                    listOf(CONTINUATION_ASM_TYPE)
+                    listOf(languageVersionSettings.continuationAsmType())
 
             val superClassConstructorDescriptor = Type.getMethodDescriptor(
                 Type.VOID_TYPE,
@@ -138,7 +150,9 @@ abstract class AbstractCoroutineCodegen(
             FunctionCodegen.endVisit(iv, "constructor", element)
         }
 
-        v.newField(JvmDeclarationOrigin.NO_ORIGIN, AsmUtil.NO_FLAG_PACKAGE_PRIVATE, "label", "I", null, null)
+        if (languageVersionSettings.isReleaseCoroutines()) {
+            v.newField(JvmDeclarationOrigin.NO_ORIGIN, AsmUtil.NO_FLAG_PACKAGE_PRIVATE, "label", "I", null, null)
+        }
 
         return constructor
     }
@@ -155,7 +169,7 @@ class CoroutineCodegenForLambda private constructor(
     private val forInline: Boolean
 ) : AbstractCoroutineCodegen(
     outerExpressionCodegen, element, closureContext, classBuilder,
-    userDataForInvokeSuspend = mapOf(INITIAL_SUSPEND_DESCRIPTOR_FOR_INVOKE_SUSPEND to originalSuspendFunctionDescriptor)
+    userDataForDoResume = mapOf(INITIAL_SUSPEND_DESCRIPTOR_FOR_DO_RESUME to originalSuspendFunctionDescriptor)
 ) {
     private val builtIns = funDescriptor.builtIns
 
@@ -203,7 +217,8 @@ class CoroutineCodegenForLambda private constructor(
             funDescriptor.typeParameters,
             funDescriptor.valueParameters,
             funDescriptor.module.getContinuationOfTypeOrAny(
-                builtIns.unitType
+                builtIns.unitType,
+                state.languageVersionSettings.supportsFeature(LanguageFeature.ReleaseCoroutines)
             ),
             funDescriptor.modality,
             DescriptorVisibilities.PUBLIC
@@ -218,11 +233,14 @@ class CoroutineCodegenForLambda private constructor(
             "too many arguments of create to have an erased signature: $argumentsNum: $typedCreate"
         }
         return typedCreate.module.resolveClassByFqName(
-            StandardNames.COROUTINES_JVM_INTERNAL_PACKAGE_FQ_NAME.child(
-                Name.identifier("BaseContinuationImpl")
+            languageVersionSettings.coroutinesJvmInternalPackageFqName().child(
+                if (languageVersionSettings.isReleaseCoroutines())
+                    Name.identifier("BaseContinuationImpl")
+                else
+                    Name.identifier("CoroutineImpl")
             ),
             NoLookupLocation.FROM_BACKEND
-        ).sure { "BaseContinuationImpl is not found" }.defaultType.memberScope
+        ).sure { "BaseContinuationImpl or CoroutineImpl is not found" }.defaultType.memberScope
             .getContributedFunctions(typedCreate.name, NoLookupLocation.FROM_BACKEND)
             .find { it.valueParameters.size == argumentsNum }
             .sure { "erased parent of $typedCreate is not found" }
@@ -349,7 +367,7 @@ class CoroutineCodegenForLambda private constructor(
             v.thisName,
             typeMapper.mapFunctionName(createCoroutineDescriptor, null),
             Type.getMethodDescriptor(
-                CONTINUATION_ASM_TYPE,
+                languageVersionSettings.continuationAsmType(),
                 *createArgumentTypes.toTypedArray()
             ),
             false
@@ -357,7 +375,11 @@ class CoroutineCodegenForLambda private constructor(
         checkcast(Type.getObjectType(v.thisName))
 
         // .doResume(Unit)
-        invokeInvokeSuspendWithUnit(v.thisName)
+        if (languageVersionSettings.isReleaseCoroutines()) {
+            invokeInvokeSuspendWithUnit(v.thisName)
+        } else {
+            invokeDoResumeWithUnit(v.thisName)
+        }
         areturn(AsmTypes.OBJECT_TYPE)
     }
 
@@ -520,14 +542,15 @@ class CoroutineCodegenForLambda private constructor(
                 override fun wrapMethodVisitor(mv: MethodVisitor, access: Int, name: String, desc: String): MethodVisitor {
                     val stateMachineBuilder = CoroutineTransformerMethodVisitor(
                         mv, access, name, desc, null, null,
-                        containingClassInternalName = v.thisName,
                         obtainClassBuilderForCoroutineState = { v },
-                        isForNamedFunction = false,
-                        shouldPreserveClassInitialization = constructorCallNormalizationMode.shouldPreserveClassInitialization,
-                        disableTailCallOptimizationForFunctionReturningUnit = false,
                         reportSuspensionPointInsideMonitor = { reportSuspensionPointInsideMonitor(element, state, it) },
                         lineNumber = CodegenUtil.getLineNumberForElement(element, false) ?: 0,
                         sourceFile = element.containingKtFile.name,
+                        shouldPreserveClassInitialization = constructorCallNormalizationMode.shouldPreserveClassInitialization,
+                        containingClassInternalName = v.thisName,
+                        isForNamedFunction = false,
+                        languageVersionSettings = languageVersionSettings,
+                        disableTailCallOptimizationForFunctionReturningUnit = false,
                         useOldSpilledVarTypeAnalysis = state.configuration.getBoolean(JVMConfigurationKeys.USE_OLD_SPILLED_VAR_TYPE_ANALYSIS),
                         initialVarsCountByType = varsCountByType
                     )
@@ -578,6 +601,21 @@ class CoroutineCodegenForLambda private constructor(
     }
 }
 
+fun isCapturedSuspendLambda(closure: CalculatedClosure, name: String, bindingContext: BindingContext): Boolean {
+    for ((param, value) in closure.captureVariables) {
+        if (param !is ValueParameterDescriptor) continue
+        if (value.fieldName != name) continue
+        return param.type.isSuspendFunctionTypeOrSubtype
+    }
+    val classDescriptor = closure.capturedOuterClassDescriptor ?: return false
+    return isCapturedSuspendLambda(classDescriptor, name, bindingContext)
+}
+
+fun isCapturedSuspendLambda(classDescriptor: ClassDescriptor, name: String, bindingContext: BindingContext): Boolean {
+    val closure = bindingContext[CLOSURE, classDescriptor] ?: return false
+    return isCapturedSuspendLambda(closure, name, bindingContext)
+}
+
 private class AddEndLabelMethodVisitor(
     delegate: MethodVisitor,
     access: Int,
@@ -604,7 +642,7 @@ class CoroutineCodegenForNamedFunction private constructor(
     private val labelFieldStackValue by lazy {
         StackValue.field(
             FieldInfo.createForHiddenField(
-                Type.getObjectType(v.thisName),
+                computeLabelOwner(languageVersionSettings, v.thisName),
                 Type.INT_TYPE,
                 COROUTINE_LABEL_FIELD_NAME
             ),
@@ -626,25 +664,44 @@ class CoroutineCodegenForNamedFunction private constructor(
     }
 
     override fun generateClosureBody() {
-        generateInvokeSuspend()
+        generateResumeImpl()
+
+        if (!languageVersionSettings.isReleaseCoroutines()) {
+            generateGetLabelMethod()
+            generateSetLabelMethod()
+        }
 
         v.newField(
             JvmDeclarationOrigin.NO_ORIGIN, Opcodes.ACC_SYNTHETIC or AsmUtil.NO_FLAG_PACKAGE_PRIVATE,
-            CONTINUATION_RESULT_FIELD_NAME, AsmTypes.OBJECT_TYPE.descriptor, null, null
+            languageVersionSettings.dataFieldName(), AsmTypes.OBJECT_TYPE.descriptor, null, null
         )
+
+        if (!languageVersionSettings.isReleaseCoroutines()) {
+            v.newField(
+                JvmDeclarationOrigin.NO_ORIGIN, Opcodes.ACC_SYNTHETIC or AsmUtil.NO_FLAG_PACKAGE_PRIVATE,
+                EXCEPTION_FIELD_NAME, AsmTypes.JAVA_THROWABLE_TYPE.descriptor, null, null
+            )
+        }
     }
 
-    private fun generateInvokeSuspend() {
+    private fun generateResumeImpl() {
         functionCodegen.generateMethod(
             OtherOrigin(element),
             methodToImplement,
             object : FunctionGenerationStrategy.CodegenBased(state) {
                 override fun doGenerateBody(codegen: ExpressionCodegen, signature: JvmMethodSignature) {
                     StackValue.field(
-                        AsmTypes.OBJECT_TYPE, Type.getObjectType(v.thisName), CONTINUATION_RESULT_FIELD_NAME, false,
+                        AsmTypes.OBJECT_TYPE, Type.getObjectType(v.thisName), languageVersionSettings.dataFieldName(), false,
                         StackValue.LOCAL_0
                     ).store(StackValue.local(1, AsmTypes.OBJECT_TYPE), codegen.v)
 
+                    if (!languageVersionSettings.isReleaseCoroutines()) {
+                        StackValue.field(
+                            AsmTypes.JAVA_THROWABLE_TYPE, Type.getObjectType(v.thisName), EXCEPTION_FIELD_NAME, false,
+                            StackValue.LOCAL_0
+                        ).store(StackValue.local(2, AsmTypes.JAVA_THROWABLE_TYPE), codegen.v)
+                    }
+
                     labelFieldStackValue.store(
                         StackValue.operation(Type.INT_TYPE) {
                             labelFieldStackValue.put(Type.INT_TYPE, it)
@@ -696,7 +753,7 @@ class CoroutineCodegenForNamedFunction private constructor(
                         with(codegen.v) {
                             // We need to box the returned inline class in resume path.
                             // But first, check for COROUTINE_SUSPENDED, since the function can return it
-                            generateCoroutineSuspendedCheck()
+                            generateCoroutineSuspendedCheck(languageVersionSettings)
                             // Now we box the inline class
                             StackValue.coerce(AsmTypes.OBJECT_TYPE, typeMapper.mapType(inlineClassToBoxInInvokeSuspend), this)
                             StackValue.boxInlineClass(inlineClassToBoxInInvokeSuspend, this, typeMapper)

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

@@ -9,10 +9,15 @@ import org.jetbrains.kotlin.codegen.*
 import org.jetbrains.kotlin.codegen.inline.*
 import org.jetbrains.kotlin.codegen.optimization.common.*
 import org.jetbrains.kotlin.codegen.optimization.fixStack.FixStackMethodTransformer
+import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.config.isReleaseCoroutines
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
 import org.jetbrains.kotlin.utils.sure
-import org.jetbrains.org.objectweb.asm.*
+import org.jetbrains.org.objectweb.asm.Label
+import org.jetbrains.org.objectweb.asm.MethodVisitor
+import org.jetbrains.org.objectweb.asm.Opcodes
+import org.jetbrains.org.objectweb.asm.Type
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
 import org.jetbrains.org.objectweb.asm.tree.*
 import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
@@ -44,6 +49,7 @@ class CoroutineTransformerMethodVisitor(
     obtainClassBuilderForCoroutineState: () -> ClassBuilder,
     private val isForNamedFunction: Boolean,
     private val shouldPreserveClassInitialization: Boolean,
+    private val languageVersionSettings: LanguageVersionSettings,
     // Since tail-call optimization of functions with Unit return type relies on ability of call-site to recognize them,
     // in order to ignore return value and push Unit, when we cannot ensure this ability, for example, when the function overrides function,
     // returning Any, we need to disable tail-call optimization for these functions.
@@ -67,6 +73,7 @@ class CoroutineTransformerMethodVisitor(
 
     private var continuationIndex = if (isForNamedFunction) -1 else 0
     private var dataIndex = if (isForNamedFunction) -1 else 1
+    private var exceptionIndex = if (isForNamedFunction || languageVersionSettings.isReleaseCoroutines()) -1 else 2
 
     override fun performTransformations(methodNode: MethodNode) {
         removeFakeContinuationConstructorCall(methodNode)
@@ -82,7 +89,9 @@ class CoroutineTransformerMethodVisitor(
         val suspensionPoints = collectSuspensionPoints(methodNode)
         RedundantLocalsEliminationMethodTransformer(suspensionPoints)
             .transform(containingClassInternalName, methodNode)
-        ChangeBoxingMethodTransformer.transform(containingClassInternalName, methodNode)
+        if (languageVersionSettings.isReleaseCoroutines()) {
+            ChangeBoxingMethodTransformer.transform(containingClassInternalName, methodNode)
+        }
         updateMaxStack(methodNode)
 
         checkForSuspensionPointInsideMonitor(methodNode, suspensionPoints)
@@ -96,6 +105,7 @@ class CoroutineTransformerMethodVisitor(
             }
 
             val examiner = MethodNodeExaminer(
+                languageVersionSettings,
                 containingClassInternalName,
                 methodNode,
                 suspensionPoints,
@@ -109,6 +119,9 @@ class CoroutineTransformerMethodVisitor(
             }
 
             dataIndex = methodNode.maxLocals++
+            if (!languageVersionSettings.isReleaseCoroutines()) {
+                exceptionIndex = methodNode.maxLocals++
+            }
             continuationIndex = methodNode.maxLocals++
 
             prepareMethodNodePreludeForNamedFunction(methodNode)
@@ -123,6 +136,8 @@ class CoroutineTransformerMethodVisitor(
 
         UninitializedStoresProcessor(methodNode, shouldPreserveClassInitialization).run()
 
+        updateLvtAccordingToLiveness(methodNode, isForNamedFunction)
+
         val spilledToVariableMapping = spillVariables(suspensionPoints, methodNode)
 
         val suspendMarkerVarIndex = methodNode.maxLocals++
@@ -145,7 +160,7 @@ class CoroutineTransformerMethodVisitor(
             insertBefore(
                 actualCoroutineStart,
                 insnListOf(
-                    *withInstructionAdapter { loadCoroutineSuspendedMarker() }.toArray(),
+                    *withInstructionAdapter { loadCoroutineSuspendedMarker(languageVersionSettings) }.toArray(),
                     tableSwitchLabel,
                     // Allow debugger to stop on enter into suspend function
                     LineNumberNode(lineNumber, tableSwitchLabel),
@@ -163,7 +178,7 @@ class CoroutineTransformerMethodVisitor(
             )
 
             insert(firstStateLabel, withInstructionAdapter {
-                generateResumeWithExceptionCheck(dataIndex)
+                generateResumeWithExceptionCheck(languageVersionSettings.isReleaseCoroutines(), dataIndex, exceptionIndex)
             })
             insert(last, defaultLabel)
 
@@ -179,9 +194,9 @@ class CoroutineTransformerMethodVisitor(
         dropUnboxInlineClassMarkers(methodNode, suspensionPoints)
         methodNode.removeEmptyCatchBlocks()
 
-        updateLvtAccordingToLiveness(methodNode, isForNamedFunction, stateLabels)
-
-        writeDebugMetadata(methodNode, suspensionPointLineNumbers, spilledToVariableMapping)
+        if (languageVersionSettings.isReleaseCoroutines()) {
+            writeDebugMetadata(methodNode, suspensionPointLineNumbers, spilledToVariableMapping)
+        }
     }
 
     // When suspension point is inlined, it is in range of fake inliner variables.
@@ -248,7 +263,7 @@ class CoroutineTransformerMethodVisitor(
         methodNode.localVariables.add(
             LocalVariableNode(
                 SUSPEND_FUNCTION_COMPLETION_PARAMETER_NAME,
-                CONTINUATION_ASM_TYPE.descriptor,
+                languageVersionSettings.continuationAsmType().descriptor,
                 null,
                 startLabel,
                 endLabel,
@@ -387,7 +402,7 @@ class CoroutineTransformerMethodVisitor(
         methodNode.instructions.add(withInstructionAdapter { mark(endLabel) })
         methodNode.visitLocalVariable(
             CONTINUATION_VARIABLE_NAME,
-            CONTINUATION_ASM_TYPE.descriptor,
+            languageVersionSettings.continuationAsmType().descriptor,
             null,
             startLabel,
             endLabel,
@@ -415,17 +430,33 @@ class CoroutineTransformerMethodVisitor(
     }
 
     private fun InstructionAdapter.getLabel() {
-        getfield(
-            Type.getObjectType(classBuilderForCoroutineState.thisName).internalName,
-            COROUTINE_LABEL_FIELD_NAME, Type.INT_TYPE.descriptor
-        )
+        if (isForNamedFunction && !languageVersionSettings.isReleaseCoroutines())
+            invokevirtual(
+                classBuilderForCoroutineState.thisName,
+                "getLabel",
+                Type.getMethodDescriptor(Type.INT_TYPE),
+                false
+            )
+        else
+            getfield(
+                computeLabelOwner(languageVersionSettings, classBuilderForCoroutineState.thisName).internalName,
+                COROUTINE_LABEL_FIELD_NAME, Type.INT_TYPE.descriptor
+            )
     }
 
     private fun InstructionAdapter.setLabel() {
-        putfield(
-            Type.getObjectType(classBuilderForCoroutineState.thisName).internalName,
-            COROUTINE_LABEL_FIELD_NAME, Type.INT_TYPE.descriptor
-        )
+        if (isForNamedFunction && !languageVersionSettings.isReleaseCoroutines())
+            invokevirtual(
+                classBuilderForCoroutineState.thisName,
+                "setLabel",
+                Type.getMethodDescriptor(Type.VOID_TYPE, Type.INT_TYPE),
+                false
+            )
+        else
+            putfield(
+                computeLabelOwner(languageVersionSettings, classBuilderForCoroutineState.thisName).internalName,
+                COROUTINE_LABEL_FIELD_NAME, Type.INT_TYPE.descriptor
+            )
     }
 
     private fun updateMaxStack(methodNode: MethodNode) {
@@ -503,7 +534,8 @@ class CoroutineTransformerMethodVisitor(
                 needDispatchReceiver,
                 internalNameForDispatchReceiver,
                 containingClassInternalName,
-                classBuilderForCoroutineState
+                classBuilderForCoroutineState,
+                languageVersionSettings
             )
 
             visitVarInsn(Opcodes.ASTORE, continuationIndex)
@@ -511,13 +543,19 @@ class CoroutineTransformerMethodVisitor(
             visitLabel(afterCoroutineStateCreated)
 
             visitVarInsn(Opcodes.ALOAD, continuationIndex)
-            getfield(classBuilderForCoroutineState.thisName, CONTINUATION_RESULT_FIELD_NAME, AsmTypes.OBJECT_TYPE.descriptor)
+            getfield(classBuilderForCoroutineState.thisName, languageVersionSettings.dataFieldName(), AsmTypes.OBJECT_TYPE.descriptor)
             visitVarInsn(Opcodes.ASTORE, dataIndex)
 
             val resultStartLabel = Label()
             visitLabel(resultStartLabel)
 
             addContinuationAndResultToLvt(methodNode, afterCoroutineStateCreated, resultStartLabel)
+
+            if (!languageVersionSettings.isReleaseCoroutines()) {
+                visitVarInsn(Opcodes.ALOAD, continuationIndex)
+                getfield(classBuilderForCoroutineState.thisName, EXCEPTION_FIELD_NAME, AsmTypes.JAVA_THROWABLE_TYPE.descriptor)
+                visitVarInsn(Opcodes.ASTORE, exceptionIndex)
+            }
         })
     }
 
@@ -612,7 +650,7 @@ class CoroutineTransformerMethodVisitor(
 
         val livenessFrames = analyzeLiveness(methodNode)
 
-        // References shall be cleaned up after unspill (during spill in next suspension point) to prevent memory leaks,
+        // 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>>()
@@ -654,7 +692,7 @@ class CoroutineTransformerMethodVisitor(
             // k + 1 - data
             // k + 2 - exception
             for (slot in 0 until localsCount) {
-                if (slot == continuationIndex || slot == dataIndex) continue
+                if (slot == continuationIndex || slot == dataIndex || slot == exceptionIndex) continue
                 val value = frame.getLocal(slot)
                 if (value.type == null || !livenessFrame.isAlive(slot)) continue
 
@@ -721,75 +759,9 @@ class CoroutineTransformerMethodVisitor(
             referencesToCleanBySuspensionPointIndex += currentSpilledReferencesCount to predSpilledReferencesCount
         }
 
-        // Calculate debug metadata mapping before modifying method node to make it easier to locate
-        // locals alive across suspension points.
-
-        fun calculateSpilledVariableAndField(
-            suspension: SuspensionPoint,
-            slot: Int,
-            spillableVariable: SpillableVariable?
-        ): SpilledVariableAndField? {
-            if (spillableVariable == null) return null
-            val name = localVariableName(methodNode, slot, suspension.suspensionCallBegin.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
-        }
-
         // Mutate method node
 
         fun generateSpillAndUnspill(suspension: SuspensionPoint, slot: Int, spillableVariable: SpillableVariable?) {
-            fun splitLvtRecord(local: LocalVariableNode?, localRestart: LabelNode) {
-                // Split the local variable range for the local so that it is visible until the next state label, but is
-                // not visible until it has been unspilled from the continuation on the reentry path.
-                if (local != null) {
-                    val previousEnd = local.end
-                    local.end = suspension.stateLabel
-                    // Add the local back, but end it at the next state label.
-                    methodNode.localVariables.add(local)
-                    // Add a new entry that starts after the local variable is restored from the continuation.
-                    methodNode.localVariables.add(
-                        LocalVariableNode(
-                            local.name,
-                            local.desc,
-                            local.signature,
-                            localRestart,
-                            previousEnd,
-                            local.index
-                        )
-                    )
-                }
-            }
-
-            // Find and remove the local variable node, if any, in the local variable table corresponding to the slot that is spilled.
-            var local: LocalVariableNode? = null
-            val iterator = methodNode.localVariables.listIterator()
-            while (iterator.hasNext()) {
-                val node = iterator.next()
-                if (node.index == slot &&
-                    methodNode.instructions.indexOf(node.start) <= methodNode.instructions.indexOf(suspension.suspensionCallBegin) &&
-                    methodNode.instructions.indexOf(node.end) > methodNode.instructions.indexOf(suspension.tryCatchBlockEndLabelAfterSuspensionCall)
-                ) {
-                    local = node
-                    iterator.remove()
-                    break
-                }
-            }
-
             if (spillableVariable == null) {
                 with(instructions) {
                     insert(suspension.tryCatchBlockEndLabelAfterSuspensionCall, withInstructionAdapter {
@@ -797,12 +769,9 @@ class CoroutineTransformerMethodVisitor(
                         store(slot, AsmTypes.OBJECT_TYPE)
                     })
                 }
-                val newStart = suspension.tryCatchBlocksContinuationLabel.findNextOrNull { it is LabelNode } as? LabelNode ?: return
-                splitLvtRecord(local, newStart)
                 return
             }
 
-            val localRestart = LabelNode().linkWithLabel()
             with(instructions) {
                 // store variable before suspension call
                 insertBefore(suspension.suspensionCallBegin, withInstructionAdapter {
@@ -826,13 +795,8 @@ class CoroutineTransformerMethodVisitor(
                     )
                     StackValue.coerce(spillableVariable.normalizedType, spillableVariable.type, this)
                     store(slot, spillableVariable.type)
-                    if (local != null) {
-                        visitLabel(localRestart.label)
-                    }
                 })
             }
-
-            splitLvtRecord(local, localRestart)
         }
 
         fun cleanUpField(suspension: SuspensionPoint, fieldIndex: Int) {
@@ -875,6 +839,33 @@ class CoroutineTransformerMethodVisitor(
             }
         }
 
+        // 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
     }
 
@@ -910,6 +901,7 @@ class CoroutineTransformerMethodVisitor(
         suspendMarkerVarIndex: Int,
         suspendPointLineNumber: LineNumberNode?
     ): LabelNode {
+        val stateLabel = LabelNode().linkWithLabel()
         val continuationLabelAfterLoadedResult = LabelNode()
         val suspendElementLineNumber = lineNumber
         var nextLineNumberNode = nextDefinitelyHitLineNumber(suspension)
@@ -937,7 +929,7 @@ class CoroutineTransformerMethodVisitor(
                 load(suspendMarkerVarIndex, AsmTypes.OBJECT_TYPE)
                 areturn(AsmTypes.OBJECT_TYPE)
                 // Mark place for continuation
-                visitLabel(suspension.stateLabel.label)
+                visitLabel(stateLabel.label)
             })
 
             // After suspension point there is always three nodes: L1, NOP, L2
@@ -954,7 +946,7 @@ class CoroutineTransformerMethodVisitor(
 
             insert(possibleTryCatchBlockStart, withInstructionAdapter {
                 nop()
-                generateResumeWithExceptionCheck(dataIndex)
+                generateResumeWithExceptionCheck(languageVersionSettings.isReleaseCoroutines(), dataIndex, exceptionIndex)
 
                 // Load continuation argument just like suspending function returns it
                 load(dataIndex, AsmTypes.OBJECT_TYPE)
@@ -993,7 +985,7 @@ class CoroutineTransformerMethodVisitor(
             }
         }
 
-        return suspension.stateLabel
+        return stateLabel
     }
 
     // Find the next line number instruction that is defintely hit. That is, a line number
@@ -1080,7 +1072,8 @@ internal fun InstructionAdapter.generateContinuationConstructorCall(
     needDispatchReceiver: Boolean,
     internalNameForDispatchReceiver: String?,
     containingClassInternalName: String,
-    classBuilderForCoroutineState: ClassBuilder
+    classBuilderForCoroutineState: ClassBuilder,
+    languageVersionSettings: LanguageVersionSettings
 ) {
     anew(objectTypeForState)
     dup()
@@ -1089,7 +1082,8 @@ internal fun InstructionAdapter.generateContinuationConstructorCall(
         getParameterTypesIndicesForCoroutineConstructor(
             methodNode.desc,
             methodNode.access,
-            needDispatchReceiver, internalNameForDispatchReceiver ?: containingClassInternalName
+            needDispatchReceiver, internalNameForDispatchReceiver ?: containingClassInternalName,
+            languageVersionSettings
         )
     for ((type, index) in parameterTypesAndIndices) {
         load(index, type)
@@ -1109,11 +1103,22 @@ internal fun InstructionAdapter.generateContinuationConstructorCall(
     )
 }
 
-private fun InstructionAdapter.generateResumeWithExceptionCheck(dataIndex: Int) {
+private fun InstructionAdapter.generateResumeWithExceptionCheck(isReleaseCoroutines: Boolean, dataIndex: Int, exceptionIndex: Int) {
     // Check if resumeWithException has been called
 
-    load(dataIndex, AsmTypes.OBJECT_TYPE)
-    invokestatic("kotlin/ResultKt", "throwOnFailure", "(Ljava/lang/Object;)V", false)
+    if (isReleaseCoroutines) {
+        load(dataIndex, AsmTypes.OBJECT_TYPE)
+        invokestatic("kotlin/ResultKt", "throwOnFailure", "(Ljava/lang/Object;)V", false)
+    } else {
+        load(exceptionIndex, AsmTypes.OBJECT_TYPE)
+        dup()
+        val noExceptionLabel = Label()
+        ifnull(noExceptionLabel)
+        athrow()
+
+        mark(noExceptionLabel)
+        pop()
+    }
 }
 
 private fun Type.fieldNameForVar(index: Int) = descriptor.first() + "$" + index
@@ -1149,7 +1154,6 @@ internal class SuspensionPoint(
 ) {
     lateinit var tryCatchBlocksContinuationLabel: LabelNode
 
-    val stateLabel = LabelNode().linkWithLabel()
     val unboxInlineClassInstructions: List<AbstractInsnNode> = findUnboxInlineClassInstructions()
 
     private fun findUnboxInlineClassInstructions(): List<AbstractInsnNode> {
@@ -1184,15 +1188,16 @@ private fun getParameterTypesIndicesForCoroutineConstructor(
     desc: String,
     containingFunctionAccess: Int,
     needDispatchReceiver: Boolean,
-    thisName: String
+    thisName: String,
+    languageVersionSettings: LanguageVersionSettings
 ): Collection<Pair<Type, Int>> {
     return mutableListOf<Pair<Type, Int>>().apply {
         if (needDispatchReceiver) {
             add(Type.getObjectType(thisName) to 0)
         }
         val continuationIndex =
-            getAllParameterTypes(desc, !isStatic(containingFunctionAccess), thisName).dropLast(1).sumOf(Type::getSize)
-        add(CONTINUATION_ASM_TYPE to continuationIndex)
+            getAllParameterTypes(desc, !isStatic(containingFunctionAccess), thisName).dropLast(1).map(Type::getSize).sum()
+        add(languageVersionSettings.continuationAsmType() to continuationIndex)
     }
 }
 
@@ -1208,16 +1213,13 @@ internal fun replaceFakeContinuationsWithRealOnes(methodNode: MethodNode, contin
     }
 }
 
-private fun MethodNode.nodeTextWithLiveness(liveness: List<VariableLivenessFrame>): String =
-    liveness.zip(this.instructions.asSequence().toList()).joinToString("\n") { (a, b) -> "$a|${b.insnText}" }
-
 /* We do not want to spill dead variables, thus, we shrink its LVT record to region, where the variable is alive,
  * so, the variable will not be visible in debugger. User can still prolong life span of the variable by using it.
  *
  * 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, suspensionPoints: List<LabelNode>) {
+private fun updateLvtAccordingToLiveness(method: MethodNode, isForNamedFunction: Boolean) {
     val liveness = analyzeLiveness(method)
 
     fun List<LocalVariableNode>.findRecord(insnIndex: Int, variableIndex: Int): LocalVariableNode? {
@@ -1233,27 +1235,35 @@ private fun updateLvtAccordingToLiveness(method: MethodNode, isForNamedFunction:
     fun isAlive(insnIndex: Int, variableIndex: Int): Boolean =
         liveness[insnIndex].isAlive(variableIndex)
 
-    fun nextLabel(node: AbstractInsnNode?): LabelNode? {
-        var current = node
-        while (current != null) {
-            if (current is LabelNode) return current
-            current = current.next
-        }
-        return null
+    fun nextSuspensionPointEndLabel(insn: AbstractInsnNode): LabelNode {
+        val suspensionPoint =
+            InsnSequence(insn, method.instructions.last).firstOrNull { isAfterSuspendMarker(it) } ?: method.instructions.last
+        return suspensionPoint as? LabelNode ?: suspensionPoint.findNextOrNull { it is LabelNode } as LabelNode
+    }
+
+    fun nextSuspensionPointStartLabel(insn: AbstractInsnNode): LabelNode {
+        val suspensionPoint =
+            InsnSequence(insn, method.instructions.last).firstOrNull { isBeforeSuspendMarker(it) } ?: method.instructions.last
+        return suspensionPoint as? LabelNode ?: suspensionPoint.findPreviousOrNull { it is LabelNode } as LabelNode
     }
 
     fun min(a: LabelNode, b: LabelNode): LabelNode =
         if (method.instructions.indexOf(a) < method.instructions.indexOf(b)) a else b
 
+    fun max(a: LabelNode, b: LabelNode): LabelNode =
+        if (method.instructions.indexOf(a) < method.instructions.indexOf(b)) b else a
+
+    fun containsSuspensionPoint(a: LabelNode, b: LabelNode): Boolean =
+        InsnSequence(min(a, b), max(a, b)).none { isBeforeSuspendMarker(it) }
+
     val oldLvt = arrayListOf<LocalVariableNode>()
     for (record in method.localVariables) {
         oldLvt += record
     }
     method.localVariables.clear()
-
-    val oldLvtNodeToLatestNewLvtNode = mutableMapOf<LocalVariableNode, LocalVariableNode>()
     // Skip `this` for suspend lambda
     val start = if (isForNamedFunction) 0 else 1
+    val oldLvtNodeToLatestNewLvtNode = mutableMapOf<LocalVariableNode, LocalVariableNode>()
     for (variableIndex in start until method.maxLocals) {
         if (oldLvt.none { it.index == variableIndex }) continue
         var startLabel: LabelNode? = null
@@ -1265,51 +1275,36 @@ private fun updateLvtAccordingToLiveness(method: MethodNode, isForNamedFunction:
             if (isAlive(insnIndex, variableIndex) && !isAlive(insnIndex + 1, variableIndex)) {
                 // No variable in LVT -> do not add one
                 val lvtRecord = oldLvt.findRecord(insnIndex, variableIndex) ?: continue
-                if (lvtRecord.name == CONTINUATION_VARIABLE_NAME || lvtRecord.name == SUSPEND_CALL_RESULT_NAME) continue
-                // End the local when it is no longer live. Since it is not live, we will not spill and unspill it across
-                // suspension points. It is tempting to keep it alive until the next suspension point to leave it visible in
-                // the debugger for as long as possible. However, in the case of loops, the resumption after suspension can
-                // have a backwards edge targeting instruction between the point of death and the next suspension point.
-                //
-                // For example, code such as the following:
-                //
-                //    listOf<String>.forEach {
-                //       yield(it)
-                //    }
-                //
-                // Generates code of this form with a back edge after resumption that will lead to invalid locals tables
-                // if the local range is extended to the next suspension point.
-                //
-                //        iterator = iterable.iterator()
-                //    L1: (iterable dies here)
-                //        load iterator.next if there
-                //        yield suspension point
-                //
-                //    L2: (resumption point)
-                //        restore live variables (not including iterable)
-                //        goto L1 (iterator not restored here, so we cannot not have iterator live at L1)
-                val endLabel = nextLabel(insn.next)?.let { min(lvtRecord.end, it) } ?: lvtRecord.end
+                if (lvtRecord.name == CONTINUATION_VARIABLE_NAME) continue
+                // Extend lvt record to the next suspension point
+                val endLabel = min(lvtRecord.end, nextSuspensionPointEndLabel(insn))
                 // startLabel can be null in case of parameters
                 @Suppress("NAME_SHADOWING") val startLabel = startLabel ?: lvtRecord.start
-
                 // Attempt to extend existing local variable node corresponding to the record in
-                // the original local variable table, if there is no back-edge
-                val latest = oldLvtNodeToLatestNewLvtNode[lvtRecord]
-                // if we can extend the previous range to where the local variable dies, we do not need a
-                // new entry, we know we cannot extend it to the lvt.endOffset, if we could we would have
-                // done so when we added it below.
-                val extended = latest?.extendRecordIfPossible(method, suspensionPoints, lvtRecord.end) ?: false
-                if (!extended) {
-                    val new = LocalVariableNode(lvtRecord.name, lvtRecord.desc, lvtRecord.signature, startLabel, endLabel, lvtRecord.index)
-                    oldLvtNodeToLatestNewLvtNode[lvtRecord] = new
-                    method.localVariables.add(new)
-                    // see if we can extend it all the way to the old end
-                    new.extendRecordIfPossible(method, suspensionPoints, lvtRecord.end)
+                // the original local variable table.
+                val recordToExtend: LocalVariableNode? = oldLvtNodeToLatestNewLvtNode[lvtRecord]
+                if (recordToExtend != null && containsSuspensionPoint(recordToExtend.end, startLabel)) {
+                    recordToExtend.end = endLabel
+                } else {
+                    val node = LocalVariableNode(lvtRecord.name, lvtRecord.desc, lvtRecord.signature, startLabel, endLabel, lvtRecord.index)
+                    if (lvtRecord !in oldLvtNodeToLatestNewLvtNode) {
+                        method.localVariables.add(node)
+                    }
+                    oldLvtNodeToLatestNewLvtNode[lvtRecord] = node
                 }
             }
         }
     }
 
+    val deadVariables = arrayListOf<Int>()
+    outer@for (variableIndex in start until method.maxLocals) {
+        if (oldLvt.none { it.index == variableIndex }) continue
+        for (insnIndex in 0 until (method.instructions.size() - 1)) {
+            if (isAlive(insnIndex, variableIndex)) continue@outer
+        }
+        deadVariables += variableIndex
+    }
+
     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
@@ -1325,37 +1320,19 @@ private fun updateLvtAccordingToLiveness(method: MethodNode, isForNamedFunction:
             method.localVariables.add(variable)
             continue
         }
+
+        // Shrink LVT records of dead variables to the next suspension point
+        if (variable.index in deadVariables) {
+            method.localVariables.add(
+                LocalVariableNode(
+                    variable.name,
+                    variable.desc,
+                    variable.signature,
+                    variable.start,
+                    min(variable.end, nextSuspensionPointStartLabel(variable.start)),
+                    variable.index
+                )
+            )
+        }
     }
 }
-
-/* We cannot extend a record if there is STORE instruction or a back-edge.
- * STORE instructions can signify a unspilling operation, in which case, the variable will become visible before it unspilled,
- * back-edges occur in loops.
- *
- * @return true if the range has been extended
- */
-private fun LocalVariableNode.extendRecordIfPossible(
-    method: MethodNode,
-    suspensionPoints: List<LabelNode>,
-    endLabel: LabelNode
-): Boolean {
-    val nextSuspensionPointLabel = suspensionPoints.find { it in InsnSequence(end, endLabel) } ?: endLabel
-
-    var current: AbstractInsnNode? = end
-    while (current != null && current != nextSuspensionPointLabel) {
-        if (current is JumpInsnNode) {
-            if (method.instructions.indexOf(current.label) < method.instructions.indexOf(current)) {
-                return false
-            }
-        }
-        // TODO: HACK
-        // TODO: Find correct label, which is OK to be used as end label.
-        if (current.opcode == Opcodes.ARETURN && nextSuspensionPointLabel != endLabel) return false
-        if (current.isStoreOperation() && (current as VarInsnNode).`var` == index) {
-            return false
-        }
-        current = current.next
-    }
-    end = nextSuspensionPointLabel
-    return true
-}

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

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.codegen.coroutines
 
 import org.jetbrains.kotlin.codegen.optimization.boxing.isUnitInstance
-import org.jetbrains.kotlin.codegen.optimization.common.FastMethodAnalyzer
+import org.jetbrains.kotlin.codegen.optimization.common.MethodAnalyzer
 import org.jetbrains.kotlin.codegen.optimization.common.asSequence
 import org.jetbrains.kotlin.codegen.optimization.common.removeAll
 import org.jetbrains.kotlin.codegen.optimization.fixStack.top
@@ -85,7 +85,7 @@ private class UnitSourceInterpreter(private val localVariables: Set<Int>) : Basi
     }
 
     fun run(internalClassName: String, methodNode: MethodNode): Array<Frame<BasicValue>?> {
-        val frames = FastMethodAnalyzer<BasicValue>(internalClassName, methodNode, this).analyze()
+        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) {

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

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

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

@@ -88,17 +88,18 @@ class SuspendFunctionGenerationStrategy(
         return CoroutineTransformerMethodVisitor(
             mv, access, name, desc, null, null, containingClassInternalName, this::classBuilderForCoroutineState,
             isForNamedFunction = true,
-            shouldPreserveClassInitialization = constructorCallNormalizationMode.shouldPreserveClassInitialization,
-            disableTailCallOptimizationForFunctionReturningUnit = originalSuspendDescriptor.returnType?.isUnit() == true &&
-                    originalSuspendDescriptor.overriddenDescriptors.isNotEmpty() &&
-                    !originalSuspendDescriptor.allOverriddenFunctionsReturnUnit(),
             reportSuspensionPointInsideMonitor = { reportSuspensionPointInsideMonitor(declaration, state, it) },
             lineNumber = CodegenUtil.getLineNumberForElement(declaration, false) ?: 0,
             sourceFile = declaration.containingKtFile.name,
+            shouldPreserveClassInitialization = constructorCallNormalizationMode.shouldPreserveClassInitialization,
             needDispatchReceiver = originalSuspendDescriptor.dispatchReceiverParameter != null,
             internalNameForDispatchReceiver = (originalSuspendDescriptor.containingDeclaration as? ClassDescriptor)?.let {
                 if (it.isInlineClass()) state.typeMapper.mapType(it).internalName else null
             } ?: containingClassInternalNameOrNull(),
+            languageVersionSettings = languageVersionSettings,
+            disableTailCallOptimizationForFunctionReturningUnit = originalSuspendDescriptor.returnType?.isUnit() == true &&
+                    originalSuspendDescriptor.overriddenDescriptors.isNotEmpty() &&
+                    !originalSuspendDescriptor.allOverriddenFunctionsReturnUnit(),
             useOldSpilledVarTypeAnalysis = state.configuration.getBoolean(JVMConfigurationKeys.USE_OLD_SPILLED_VAR_TYPE_ANALYSIS)
         )
     }
@@ -154,7 +155,8 @@ class SuspendFunctionGenerationStrategy(
                     needDispatchReceiver,
                     internalNameForDispatchReceiver,
                     containingClassInternalName,
-                    classBuilderForCoroutineState
+                    classBuilderForCoroutineState,
+                    languageVersionSettings
                 )
                 addFakeContinuationConstructorCallMarker(this, false)
                 pop() // Otherwise stack-transformation breaks

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

@@ -12,6 +12,7 @@ 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
@@ -26,6 +27,7 @@ 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>,
@@ -39,6 +41,7 @@ internal class MethodNodeExaminer(
     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) {
@@ -51,8 +54,10 @@ internal class MethodNodeExaminer(
             for (pop in popsBeforeUnitInstances) {
                 val units = pop.meaningfulSuccessors()
                 val allUnitsAreSafe = units.all { unit ->
-                    // check they have only returns among successors
-                    unit.meaningfulSuccessors().all { it.opcode == Opcodes.ARETURN }
+                    // 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
@@ -71,22 +76,35 @@ internal class MethodNodeExaminer(
     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 controlFlowGraph.getSuccessorsIndices(insn)) {
+                for (succIndex in insn.getIndices()) {
                     dfs(methodNode.instructions[succIndex])
                 }
             }
         }
-        for (succIndex in controlFlowGraph.getSuccessorsIndices(this)) {
+
+        for (succIndex in getIndices()) {
             dfs(methodNode.instructions[succIndex])
         }
-        visited.filter { it.isMeaningful() }
+        return visited.filter { it.isMeaningful() }
     }
 
     fun replacePopsBeforeSafeUnitInstancesWithCoroutineSuspendedChecks() {
@@ -98,7 +116,7 @@ internal class MethodNodeExaminer(
                 val label = Label()
                 methodNode.instructions.insertBefore(pop, withInstructionAdapter {
                     dup()
-                    loadCoroutineSuspendedMarker()
+                    loadCoroutineSuspendedMarker(languageVersionSettings)
                     ifacmpne(label)
                     areturn(AsmTypes.OBJECT_TYPE)
                     mark(label)
@@ -141,8 +159,8 @@ internal class MethodNodeExaminer(
      * @return indices of safely reachable returns for each instruction in the method node
      */
     private fun findSafelyReachableReturns(): Array<Set<Int>?> {
-        val insns = methodNode.instructions.toArray()
-        val reachableReturnsIndices = Array(insns.size) init@{ index ->
+        val insns = methodNode.instructions
+        val reachableReturnsIndices = Array(insns.size()) init@{ index ->
             val insn = insns[index]
 
             if (insn.opcode == Opcodes.ARETURN && !insn.isAreturnAfterSafeUnitInstance()) {
@@ -164,7 +182,7 @@ internal class MethodNodeExaminer(
         var changed: Boolean
         do {
             changed = false
-            for (index in insns.indices.reversed()) {
+            for (index in 0 until insns.size()) {
                 if (insns[index].opcode == Opcodes.ARETURN) continue
 
                 @Suppress("RemoveExplicitTypeArguments")