fixup: stdlib

Motivation is to make directory moving more likely atomic
Relates to KT-39016

.bunch

@@ -1,7 +1,4 @@
-201
 202
-203_202
-193
-as40_193
-as41
-as42_as41
+201
+as41_201
+as42

.gitignore

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

.idea/codeStyles/Project.xml

@@ -101,4 +101,4 @@
       <option name="ALIGN_MULTILINE_PARAMETERS_IN_CALLS" value="true" />
     </codeStyleSettings>
   </code_scheme>
-</component>
+</component>

.idea/dictionaries/dmitriy_dolovov.xml

@@ -10,6 +10,7 @@
       <w>commonizers</w>
       <w>commonizes</w>
       <w>commonizing</w>
+      <w>interop</w>
       <w>jetbrains</w>
       <w>konan</w>
       <w>kotlinx</w>

.idea/dictionaries/svyatoslav_kuzmich.xml

@@ -0,0 +1,27 @@
+<component name="ProjectDictionaryState">
+  <dictionary name="svyatoslav.kuzmich">
+    <words>
+      <w>anyfunc</w>
+      <w>copysign</w>
+      <w>eqref</w>
+      <w>exnref</w>
+      <w>externref</w>
+      <w>funcref</w>
+      <w>jetbrains</w>
+      <w>kotlinx</w>
+      <w>ktor</w>
+      <w>optref</w>
+      <w>popcnt</w>
+      <w>rotl</w>
+      <w>rotr</w>
+      <w>simd</w>
+      <w>sqrt</w>
+      <w>testsuite</w>
+      <w>uninstantiable</w>
+      <w>unlinkable</w>
+      <w>vtable</w>
+      <w>wabt</w>
+      <w>xopt</w>
+    </words>
+  </dictionary>
+</component>

.idea/dictionaries/yan.xml

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

.idea/inspectionProfiles/idea_default.xml

@@ -453,4 +453,4 @@
       <option name="ignoreNonEmtpyLoops" value="false" />
     </inspection_tool>
   </profile>
-</component>
+</component>

.idea/runConfigurations/Generate_Compiler_Tests.xml

@@ -10,7 +10,7 @@
       </option>
       <option name="taskNames">
         <list>
-          <option value=":compiler:generateTests" />
+          <option value=":compiler:tests-for-compiler-generator:generateTests" />
           <option value=":compiler:tests-java8:generateTests" />
           <option value=":compiler:tests-against-klib:generateTests" />
           <option value=":js:js.tests:generateTests" />
@@ -22,4 +22,4 @@
     <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
     <method />
   </configuration>
-</component>
+</component>

.idea/runConfigurations/Generate_FIR_Checker_Components_and_FIR_IDE_Diagnostics.xml

@@ -0,0 +1,24 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Generate FIR Checker Components and FIR/IDE Diagnostics" type="GradleRunConfiguration" factoryName="Gradle">
+    <ExternalSystemSettings>
+      <option name="executionName" />
+      <option name="externalProjectPath" value="$PROJECT_DIR$" />
+      <option name="externalSystemIdString" value="GRADLE" />
+      <option name="scriptParameters" value="" />
+      <option name="taskDescriptions">
+        <list />
+      </option>
+      <option name="taskNames">
+        <list>
+          <option value=":compiler:fir:checkers:generateCheckersComponents" />
+          <option value=":idea:idea-frontend-fir:generateCode" />
+        </list>
+      </option>
+      <option name="vmOptions" value="" />
+    </ExternalSystemSettings>
+    <ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
+    <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
+    <DebugAllEnabled>false</DebugAllEnabled>
+    <method v="2" />
+  </configuration>
+</component>

ReadMe.md

@@ -2,10 +2,14 @@
 [![TeamCity (simple build status)](https://img.shields.io/teamcity/http/teamcity.jetbrains.com/s/Kotlin_KotlinPublic_Compiler.svg)](https://teamcity.jetbrains.com/buildConfiguration/Kotlin_KotlinPublic_Compiler?branch=%3Cdefault%3E&buildTypeTab=overview&mode=builds)
 [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin/kotlin-maven-plugin.svg)](https://search.maven.org/#search%7Cga%7C1%7Cg%3A%22org.jetbrains.kotlin%22)
 [![GitHub license](https://img.shields.io/badge/license-Apache%20License%202.0-blue.svg?style=flat)](https://www.apache.org/licenses/LICENSE-2.0)
+[![Revved up by Gradle Enterprise](https://img.shields.io/badge/Revved%20up%20by-Gradle%20Enterprise-06A0CE?logo=Gradle&labelColor=02303A)](https://ge.jetbrains.com/scans?search.rootProjectNames=Kotlin)
 
 # Kotlin Programming Language
 
-Welcome to [Kotlin](https://kotlinlang.org/)! Some handy links:
+Welcome to [Kotlin](https://kotlinlang.org/)!   
+It is an open-source, statically typed programming language supported and developed by [JetBrains](https://www.jetbrains.com/) and open-source contributors.
+
+Some handy links:
 
  * [Kotlin Site](https://kotlinlang.org/)
  * [Getting Started Guide](https://kotlinlang.org/docs/tutorials/getting-started.html)
@@ -14,10 +18,21 @@ Welcome to [Kotlin](https://kotlinlang.org/)! Some handy links:
  * [Issue Tracker](https://youtrack.jetbrains.com/issues/KT)
  * [Forum](https://discuss.kotlinlang.org/)
  * [Kotlin Blog](https://blog.jetbrains.com/kotlin/)
+ * [Subscribe to Kotlin YouTube channel](https://www.youtube.com/channel/UCP7uiEZIqci43m22KDl0sNw)
  * [Follow Kotlin on Twitter](https://twitter.com/kotlin)
  * [Public Slack channel](https://slack.kotlinlang.org/)
  * [TeamCity CI build](https://teamcity.jetbrains.com/project.html?tab=projectOverview&projectId=Kotlin)
 
+## Kotlin Multiplatform capabilities
+
+Support for multiplatform programming is one of Kotlin’s key benefits. It reduces time spent writing and maintaining the same code for [different platforms](https://kotlinlang.org/docs/reference/mpp-supported-platforms.html) while retaining the flexibility and benefits of native programming.
+
+ * [Kotlin Multiplatform Mobile](https://kotlinlang.org/lp/mobile/) for sharing code between Android and iOS
+ * [Getting Started with Kotlin Multiplatform Mobile Guide](https://kotlinlang.org/docs/mobile/create-first-app.html)
+ * [Kotlin Multiplatform Benefits](https://kotlinlang.org/docs/reference/multiplatform.html)
+ * [Share code on all platforms](https://kotlinlang.org/docs/reference/mpp-share-on-platforms.html#share-code-on-all-platforms)
+ * [Share code on similar platforms](https://kotlinlang.org/docs/reference/mpp-share-on-platforms.html#share-code-on-similar-platforms)
+
 ## Editing Kotlin
 
  * [Kotlin IntelliJ IDEA Plugin](https://kotlinlang.org/docs/tutorials/getting-started.html)
@@ -44,8 +59,8 @@ You also can use [Gradle properties](https://docs.gradle.org/current/userguide/b
 Note: The JDK 6 for MacOS is not available on Oracle's site. You can install it by
 
 ```bash
-$ brew tap caskroom/versions
-$ brew cask install java6
+$ brew tap homebrew/cask-versions
+$ brew install --cask java6
 ```
 
 On Windows you might need to add long paths setting to the repo:
@@ -94,13 +109,13 @@ Refer to [libraries/ReadMe.md](libraries/ReadMe.md) for details.
 
 ### Building for different versions of IntelliJ IDEA and Android Studio
 
-Kotlin plugin is intended to work with several recent versions of IntelliJ IDEA and Android Studio. Each platform is allowed to have a different set of features and might provide a slightly different API. Instead of using several parallel Git branches, project stores everything in a single branch, but files may have counterparts with version extensions (\*.as32, \*.172, \*.181). The primary file is expected to be replaced with its counterpart when targeting non-default platform.
+Kotlin plugin is intended to work with several recent versions of IntelliJ IDEA and Android Studio. Each platform is allowed to have a different set of features and might provide a slightly different API. Instead of using several parallel Git branches, the project stores everything in a single branch, but files may have counterparts with version extensions (\*.as32, \*.172, \*.181). The primary file is expected to be replaced with its counterpart when targeting a non-default platform.
 
-More detailed description of this scheme can be found at https://github.com/JetBrains/bunches/blob/master/ReadMe.md.
+A More detailed description of this scheme can be found at https://github.com/JetBrains/bunches/blob/master/ReadMe.md.
 
 Usually, there's no need to care about multiple platforms as all features are enabled everywhere by default. Additional counterparts should be created if there's an expected difference in behavior or an incompatible API usage is required **and** there's no reasonable workaround to save source compatibility. Kotlin plugin contains a pre-commit check that shows a warning if a file has been updated without its counterparts.
 
-Development for some particular platform is possible after 'switching' that can be done with [Bunch Tool](https://github.com/JetBrains/bunches/releases) from the command line.
+Development for some particular platform is possible after 'switching' that can be done with the [Bunch Tool](https://github.com/JetBrains/bunches/releases) from the command line.
 
 ```sh
 cd kotlin-project-dir

ant/src/org/jetbrains/kotlin/ant/Kotlin2JvmTask.kt

@@ -16,18 +16,24 @@
 
 package org.jetbrains.kotlin.ant
 
-import org.apache.tools.ant.types.Path
-import org.apache.tools.ant.types.Reference
+import org.apache.tools.ant.BuildException
+import org.apache.tools.ant.taskdefs.Execute
+import org.apache.tools.ant.taskdefs.Redirector
+import org.apache.tools.ant.types.*
 import java.io.File.pathSeparator
+import java.io.File.separator
 
 class Kotlin2JvmTask : KotlinCompilerBaseTask() {
     override val compilerFqName = "org.jetbrains.kotlin.cli.jvm.K2JVMCompiler"
 
-    var includeRuntime: Boolean = true
+    var includeRuntime: Boolean = false
     var moduleName: String? = null
 
     var noReflect: Boolean = false
 
+    private val cmdl = CommandlineJava()
+    var fork: Boolean = false
+
     private var compileClasspath: Path? = null
 
     fun setClasspath(classpath: Path) {
@@ -73,4 +79,47 @@ class Kotlin2JvmTask : KotlinCompilerBaseTask() {
         if (noReflect) args.add("-no-reflect")
         if (includeRuntime) args.add("-include-runtime")
     }
+
+    override fun execute() {
+        if (!fork)
+            super.execute()
+        else {
+            exec()
+        }
+    }
+
+    private fun exec() {
+        val javaHome = System.getProperty("java.home")
+        val javaBin = javaHome + separator + "bin" + separator + "java"
+        val redirector = Redirector(this)
+
+        fillArguments()
+
+        val command = ArrayList<String>()
+        command.add(javaBin)
+        command.addAll(cmdl.vmCommand.arguments) // jvm args
+        command.add("-Dorg.jetbrains.kotlin.cliMessageRenderer=FullPath") // same MessageRenderer as non-forking mode
+        command.add("-cp")
+        command.add(KotlinAntTaskUtil.compilerJar.canonicalPath)
+        command.add(compilerFqName)
+        command.addAll(args) // compiler args
+
+        // streamHandler: used to handle the input and output streams of the subprocess.
+        // watchdog: a watchdog for the subprocess or <code>null</code> to disable a timeout for the subprocess.
+        // TODO: support timeout for the subprocess
+        val exe = Execute(redirector.createHandler(), null)
+        exe.setAntRun(getProject())
+        exe.commandline = command.toTypedArray()
+        log("Executing command: ${command.joinToString(" ")}", LogLevel.DEBUG.level)
+        log("Compiling ${src!!.list().toList()} => [${output!!.canonicalPath}]")
+        val exitCode = exe.execute()
+        redirector.complete()
+        if (failOnError && exitCode != 0) {
+            throw BuildException("Compile failed; see the compiler error output for details.")
+        }
+    }
+
+    fun createJvmarg(): Commandline.Argument {
+        return cmdl.createVmArgument()
+    }
 }

ant/src/org/jetbrains/kotlin/ant/KotlinCompilerBaseTask.kt

@@ -80,7 +80,7 @@ abstract class KotlinCompilerBaseTask : Task() {
         fillSpecificArguments()
     }
 
-    final override fun execute() {
+    override fun execute() {
         fillArguments()
 
         val compilerClass = KotlinAntTaskUtil.getOrCreateClassLoader().loadClass(compilerFqName)

benchmarks/build.gradle.kts

@@ -40,9 +40,7 @@ dependencies {
     compile(project(":compiler:cli"))
     compile(intellijCoreDep()) { includeJars("intellij-core") }
     compile(jpsStandalone()) { includeJars("jps-model") }
-    Platform[192].orHigher {
-        compile(intellijPluginDep("java"))
-    }
+    compile(intellijPluginDep("java"))
     compile(intellijDep()) { includeIntellijCoreJarDependencies(project) }
     compile("org.jetbrains.kotlinx:kotlinx.benchmark.runtime-jvm:$benchmarks_version")
 }

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

@@ -152,7 +152,7 @@ abstract class AbstractSimpleFileBenchmark {
             .uniteWith(TopDownAnalyzerFacadeForJVM.AllJavaSourcesInProjectScope(env.project))
         val session = createSession(env, scope)
         val firProvider = session.firProvider as FirProviderImpl
-        val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider, stubMode = false)
+        val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider)
 
         val totalTransformer = FirTotalResolveProcessor(session)
         val firFile = builder.buildFirFile(file).also(firProvider::recordFile)

build-common/build.gradle.kts

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

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

@@ -17,9 +17,6 @@ interface BuildMetaInfo {
     val compilerBuildVersion: String
     val languageVersionString: String
     val apiVersionString: String
-    val coroutinesEnable: Boolean
-    val coroutinesWarn: Boolean
-    val coroutinesError: Boolean
     val multiplatformEnable: Boolean
     val metadataVersionMajor: Int
     val metadataVersionMinor: Int
@@ -35,9 +32,6 @@ abstract class BuildMetaInfoFactory<T : BuildMetaInfo>(private val metaInfoClass
         compilerBuildVersion: String,
         languageVersionString: String,
         apiVersionString: String,
-        coroutinesEnable: Boolean,
-        coroutinesWarn: Boolean,
-        coroutinesError: Boolean,
         multiplatformEnable: Boolean,
         ownVersion: Int,
         coroutinesVersion: Int,
@@ -53,9 +47,6 @@ abstract class BuildMetaInfoFactory<T : BuildMetaInfo>(private val metaInfoClass
             compilerBuildVersion = KotlinCompilerVersion.VERSION,
             languageVersionString = languageVersion.versionString,
             apiVersionString = args.apiVersion ?: languageVersion.versionString,
-            coroutinesEnable = args.coroutinesState == CommonCompilerArguments.ENABLE,
-            coroutinesWarn = args.coroutinesState == CommonCompilerArguments.WARN,
-            coroutinesError = args.coroutinesState == CommonCompilerArguments.ERROR,
             multiplatformEnable = args.multiPlatform,
             ownVersion = OWN_VERSION,
             coroutinesVersion = COROUTINES_VERSION,

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

@@ -15,9 +15,6 @@ data class CommonBuildMetaInfo(
     override val compilerBuildVersion: String,
     override val languageVersionString: String,
     override val apiVersionString: String,
-    override val coroutinesEnable: Boolean,
-    override val coroutinesWarn: Boolean,
-    override val coroutinesError: Boolean,
     override val multiplatformEnable: Boolean,
     override val metadataVersionMajor: Int,
     override val metadataVersionMinor: Int,
@@ -32,9 +29,6 @@ data class CommonBuildMetaInfo(
             compilerBuildVersion: String,
             languageVersionString: String,
             apiVersionString: String,
-            coroutinesEnable: Boolean,
-            coroutinesWarn: Boolean,
-            coroutinesError: Boolean,
             multiplatformEnable: Boolean,
             ownVersion: Int,
             coroutinesVersion: Int,
@@ -47,9 +41,6 @@ data class CommonBuildMetaInfo(
                 compilerBuildVersion = compilerBuildVersion,
                 languageVersionString = languageVersionString,
                 apiVersionString = apiVersionString,
-                coroutinesEnable = coroutinesEnable,
-                coroutinesWarn = coroutinesWarn,
-                coroutinesError = coroutinesError,
                 multiplatformEnable = multiplatformEnable,
                 metadataVersionMajor = metadataVersion.major,
                 metadataVersionMinor = metadataVersion.minor,

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

@@ -0,0 +1,12 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.build
+
+import java.io.Serializable
+
+enum class ExecutionStrategy : Serializable {
+    DAEMON, IN_PROCESS, OUT_OF_PROCESS
+}

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

@@ -15,9 +15,6 @@ data class JsBuildMetaInfo(
     override val compilerBuildVersion: String,
     override val languageVersionString: String,
     override val apiVersionString: String,
-    override val coroutinesEnable: Boolean,
-    override val coroutinesWarn: Boolean,
-    override val coroutinesError: Boolean,
     override val multiplatformEnable: Boolean,
     override val metadataVersionMajor: Int,
     override val metadataVersionMinor: Int,
@@ -32,9 +29,6 @@ data class JsBuildMetaInfo(
             compilerBuildVersion: String,
             languageVersionString: String,
             apiVersionString: String,
-            coroutinesEnable: Boolean,
-            coroutinesWarn: Boolean,
-            coroutinesError: Boolean,
             multiplatformEnable: Boolean,
             ownVersion: Int,
             coroutinesVersion: Int,
@@ -47,9 +41,6 @@ data class JsBuildMetaInfo(
                 compilerBuildVersion = compilerBuildVersion,
                 languageVersionString = languageVersionString,
                 apiVersionString = apiVersionString,
-                coroutinesEnable = coroutinesEnable,
-                coroutinesWarn = coroutinesWarn,
-                coroutinesError = coroutinesError,
                 multiplatformEnable = multiplatformEnable,
                 metadataVersionMajor = metadataVersion.major,
                 metadataVersionMinor = metadataVersion.minor,

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

@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.build
 
-import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmBytecodeBinaryVersion
 import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmMetadataVersion
 
 /**
@@ -27,9 +26,6 @@ data class JvmBuildMetaInfo(
     override val compilerBuildVersion: String,
     override val languageVersionString: String,
     override val apiVersionString: String,
-    override val coroutinesEnable: Boolean,
-    override val coroutinesWarn: Boolean,
-    override val coroutinesError: Boolean,
     override val multiplatformEnable: Boolean,
     override val metadataVersionMajor: Int,
     override val metadataVersionMinor: Int,
@@ -47,9 +43,6 @@ data class JvmBuildMetaInfo(
             compilerBuildVersion: String,
             languageVersionString: String,
             apiVersionString: String,
-            coroutinesEnable: Boolean,
-            coroutinesWarn: Boolean,
-            coroutinesError: Boolean,
             multiplatformEnable: Boolean,
             ownVersion: Int,
             coroutinesVersion: Int,
@@ -62,9 +55,6 @@ data class JvmBuildMetaInfo(
                 compilerBuildVersion = compilerBuildVersion,
                 languageVersionString = languageVersionString,
                 apiVersionString = apiVersionString,
-                coroutinesEnable = coroutinesEnable,
-                coroutinesWarn = coroutinesWarn,
-                coroutinesError = coroutinesError,
                 multiplatformEnable = multiplatformEnable,
                 metadataVersionMajor = metadataVersion.major,
                 metadataVersionMinor = metadataVersion.minor,

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

@@ -0,0 +1,31 @@
+/*
+ * 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.build
+
+/**
+ * Bytecode version was in the Kotlin metadata ([Metadata.bytecodeVersion]) since 1.0, but it was never used meaningfully in the compiler,
+ * outside of one very special case regarding experimental coroutines, which is now obsolete. It is still used in incremental compilation
+ * caches though. We should probably just pretend that the bytecode version of any Kotlin file from now on is equal to the latest observed
+ * bytecode version, `1.0.3` (see [INSTANCE]).
+ */
+class JvmBytecodeBinaryVersion(vararg numbers: Int) {
+    val major: Int = numbers.getOrNull(0) ?: -1
+    val minor: Int = numbers.getOrNull(1) ?: -1
+    val patch: Int = numbers.getOrNull(2) ?: -1
+
+    override fun toString(): String = buildString {
+        append(major)
+        if (minor != -1) {
+            append(".$minor")
+            if (patch != -1) append(".$patch")
+        }
+    }
+
+    companion object {
+        @JvmField
+        val INSTANCE = JvmBytecodeBinaryVersion(1, 0, 3)
+    }
+}

build-common/src/org/jetbrains/kotlin/build/report/BuildReporter.kt

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.build.report
+
+import org.jetbrains.kotlin.build.report.metrics.BuildMetricsReporter
+import org.jetbrains.kotlin.build.report.metrics.RemoteBuildMetricsReporter
+
+open class BuildReporter(
+    protected open val icReporter: ICReporter,
+    protected open val buildMetricsReporter: BuildMetricsReporter
+) : ICReporter by icReporter, BuildMetricsReporter by buildMetricsReporter
+
+class RemoteBuildReporter(
+    override val icReporter: RemoteICReporter,
+    override val buildMetricsReporter: RemoteBuildMetricsReporter
+) : BuildReporter(icReporter, buildMetricsReporter), RemoteReporter {
+    override fun flush() {
+        icReporter.flush()
+        buildMetricsReporter.flush()
+    }
+}

build-common/src/org/jetbrains/kotlin/build/report/ICReporter.kt

@@ -3,7 +3,7 @@
  * 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
+package org.jetbrains.kotlin.build.report
 
 import org.jetbrains.kotlin.cli.common.ExitCode
 import java.io.File
@@ -17,3 +17,5 @@ interface ICReporter {
     fun reportMarkDirtyMember(affectedFiles: Iterable<File>, scope: String, name: String)
     fun reportMarkDirty(affectedFiles: Iterable<File>, reason: String)
 }
+
+

build-common/src/org/jetbrains/kotlin/build/report/ICReporterBase.kt

@@ -1,9 +1,9 @@
 /*
- * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
-package org.jetbrains.kotlin.incremental
+package org.jetbrains.kotlin.build.report
 
 import java.io.File
 

build-common/src/org/jetbrains/kotlin/build/report/RemoteICReporter.kt

@@ -0,0 +1,9 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.build.report
+
+interface RemoteICReporter : ICReporter,
+    RemoteReporter

build-common/src/org/jetbrains/kotlin/build/report/RemoteReporter.kt

@@ -0,0 +1,11 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.build.report
+
+interface RemoteReporter {
+    fun flush()
+}
+

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

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.build.report.metrics
+
+import java.io.Serializable
+
+enum class BuildAttributeKind : Serializable {
+    REBUILD_REASON;
+
+    companion object {
+        const val serialVersionUID = 0L
+    }
+}
+
+enum class BuildAttribute(val kind: BuildAttributeKind) : Serializable {
+    NO_BUILD_HISTORY(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),
+    JAVA_CHANGE_UNEXPECTED_PSI(BuildAttributeKind.REBUILD_REASON),
+    JAVA_CHANGE_UNKNOWN_QUALIFIER(BuildAttributeKind.REBUILD_REASON),
+    DEP_CHANGE_REMOVED_ENTRY(BuildAttributeKind.REBUILD_REASON),
+    DEP_CHANGE_HISTORY_IS_NOT_FOUND(BuildAttributeKind.REBUILD_REASON),
+    DEP_CHANGE_HISTORY_CANNOT_BE_READ(BuildAttributeKind.REBUILD_REASON),
+    DEP_CHANGE_HISTORY_NO_KNOWN_BUILDS(BuildAttributeKind.REBUILD_REASON),
+    DEP_CHANGE_NON_INCREMENTAL_BUILD_IN_DEP(BuildAttributeKind.REBUILD_REASON),
+    IN_PROCESS_EXECUTION(BuildAttributeKind.REBUILD_REASON),
+    OUT_OF_PROCESS_EXECUTION(BuildAttributeKind.REBUILD_REASON),
+    IC_IS_NOT_ENABLED(BuildAttributeKind.REBUILD_REASON);
+
+    companion object {
+        const val serialVersionUID = 0L
+    }
+}

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

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.build.report.metrics
+
+import java.io.Serializable
+import java.util.*
+
+class BuildAttributes : Serializable {
+    private val myAttributes =
+        EnumMap<BuildAttribute, Int>(
+            BuildAttribute::class.java
+        )
+
+    fun add(attr: BuildAttribute, count: Int = 1) {
+        myAttributes[attr] = myAttributes.getOrDefault(attr, 0) + count
+    }
+
+    fun addAll(other: BuildAttributes) {
+        other.myAttributes.forEach { (attr, n) -> add(attr, n) }
+    }
+
+    fun asMap(): Map<BuildAttribute, Int> = myAttributes
+
+    companion object {
+        const val serialVersionUID = 0L
+    }
+}

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

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.build.report.metrics
+
+import java.io.Serializable
+
+data class BuildMetrics(
+    val buildTimes: BuildTimes = BuildTimes(),
+    val buildAttributes: BuildAttributes = BuildAttributes()
+) : Serializable {
+    fun addAll(other: BuildMetrics) {
+        buildTimes.addAll(other.buildTimes)
+        buildAttributes.addAll(other.buildAttributes)
+    }
+
+    companion object {
+        const val serialVersionUID = 0L
+    }
+}

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

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.build.report.metrics
+
+interface BuildMetricsReporter {
+    fun startMeasure(metric: BuildTime, startNs: Long)
+    fun endMeasure(metric: BuildTime, endNs: Long)
+
+    fun addAttribute(attribute: BuildAttribute)
+
+    fun getMetrics(): BuildMetrics
+    fun addMetrics(metrics: BuildMetrics?)
+}
+
+inline fun <T> BuildMetricsReporter.measure(metric: BuildTime, fn: () -> T): T {
+    val start = System.nanoTime()
+    startMeasure(metric, start)
+
+    try {
+        return fn()
+    } finally {
+        val end = System.nanoTime()
+        endMeasure(metric, end)
+    }
+}

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

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.build.report.metrics
+
+import java.util.*
+
+class BuildMetricsReporterImpl : BuildMetricsReporter {
+    private val myBuildTimeStartNs: EnumMap<BuildTime, Long> =
+        EnumMap(
+            BuildTime::class.java
+        )
+    private val myBuildTimes = BuildTimes()
+    private val myBuildAttributes = BuildAttributes()
+
+    override fun startMeasure(metric: BuildTime, startNs: Long) {
+        if (metric in myBuildTimeStartNs) {
+            error("$metric was restarted before it finished")
+        }
+        myBuildTimeStartNs[metric] = startNs
+    }
+
+    override fun endMeasure(metric: BuildTime, endNs: Long) {
+        val startNs = myBuildTimeStartNs.remove(metric) ?: error("$metric finished before it started")
+        val durationNs = endNs - startNs
+        myBuildTimes.add(metric, durationNs)
+    }
+
+    override fun addAttribute(attribute: BuildAttribute) {
+        myBuildAttributes.add(attribute)
+    }
+
+    override fun getMetrics(): BuildMetrics =
+        BuildMetrics(
+            buildTimes = myBuildTimes,
+            buildAttributes = myBuildAttributes
+        )
+
+    override fun addMetrics(metrics: BuildMetrics?) {
+        if (metrics == null) return
+
+        myBuildAttributes.addAll(metrics.buildAttributes)
+        myBuildTimes.addAll(metrics.buildTimes)
+    }
+}

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

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.build.report.metrics
+
+import java.io.Serializable
+
+@Suppress("Reformat")
+enum class BuildTime(val parent: BuildTime? = null) : Serializable {
+    GRADLE_TASK,
+        CLEAR_OUTPUT(GRADLE_TASK),
+        BACKUP_OUTPUT(GRADLE_TASK),
+        RESTORE_OUTPUT_FROM_BACKUP(GRADLE_TASK),
+        CONNECT_TO_DAEMON(GRADLE_TASK),
+        CLEAR_JAR_CACHE(GRADLE_TASK),
+        RUN_COMPILER(GRADLE_TASK),
+            NON_INCREMENTAL_COMPILATION_IN_PROCESS(RUN_COMPILER),
+            NON_INCREMENTAL_COMPILATION_OUT_OF_PROCESS(RUN_COMPILER),
+            NON_INCREMENTAL_COMPILATION_DAEMON(RUN_COMPILER),
+            INCREMENTAL_COMPILATION(RUN_COMPILER),
+                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),
+                        IC_ANALYZE_HISTORY_FILES(IC_ANALYZE_CHANGES_IN_DEPENDENCIES),
+                    IC_ANALYZE_CHANGES_IN_JAVA_SOURCES(IC_CALCULATE_INITIAL_DIRTY_SET),
+                    IC_ANALYZE_CHANGES_IN_ANDROID_LAYOUTS(IC_CALCULATE_INITIAL_DIRTY_SET),
+                    IC_DETECT_REMOVED_CLASSES(IC_CALCULATE_INITIAL_DIRTY_SET),
+                CLEAR_OUTPUT_ON_REBUILD(INCREMENTAL_COMPILATION),
+                IC_UPDATE_CACHES(INCREMENTAL_COMPILATION),
+                INCREMENTAL_ITERATION(INCREMENTAL_COMPILATION),
+                NON_INCREMENTAL_ITERATION(INCREMENTAL_COMPILATION),
+                IC_WRITE_HISTORY_FILE(INCREMENTAL_COMPILATION);
+
+    companion object {
+        const val serialVersionUID = 0L
+
+        val children by lazy {
+            values().filter { it.parent != null }.groupBy { it.parent }
+        }
+    }
+}

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

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.build.report.metrics
+
+import java.io.Serializable
+import java.util.*
+
+class BuildTimes : Serializable {
+    private val myBuildTimes = EnumMap<BuildTime, Long>(BuildTime::class.java)
+
+    fun addAll(other: BuildTimes) {
+        for ((bt, timeNs) in other.myBuildTimes) {
+            add(bt, timeNs)
+        }
+    }
+
+    fun add(buildTime: BuildTime, timeNs: Long) {
+        myBuildTimes[buildTime] = myBuildTimes.getOrDefault(buildTime, 0) + timeNs
+    }
+
+    fun asMap(): Map<BuildTime, Long> = myBuildTimes
+
+    companion object {
+        const val serialVersionUID = 0L
+    }
+}

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

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.build.report.metrics
+
+object DoNothingBuildMetricsReporter : BuildMetricsReporter {
+    override fun startMeasure(metric: BuildTime, startNs: Long) {
+    }
+
+    override fun endMeasure(metric: BuildTime, endNs: Long) {
+    }
+
+    override fun addAttribute(attribute: BuildAttribute) {
+    }
+
+    override fun getMetrics(): BuildMetrics =
+        BuildMetrics(
+            BuildTimes(),
+            BuildAttributes()
+        )
+
+    override fun addMetrics(metrics: BuildMetrics?) {}
+}

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

@@ -0,0 +1,11 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.build.report.metrics
+
+import org.jetbrains.kotlin.build.report.RemoteReporter
+
+interface RemoteBuildMetricsReporter : BuildMetricsReporter,
+    RemoteReporter

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

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.incremental
 import com.intellij.util.io.EnumeratorStringDescriptor
 import org.jetbrains.kotlin.incremental.storage.*
 import org.jetbrains.kotlin.metadata.ProtoBuf
+import org.jetbrains.kotlin.metadata.deserialization.Flags
 import org.jetbrains.kotlin.metadata.deserialization.NameResolver
 import org.jetbrains.kotlin.metadata.deserialization.TypeTable
 import org.jetbrains.kotlin.metadata.deserialization.supertypes
@@ -34,12 +35,15 @@ interface IncrementalCacheCommon {
     val thisWithDependentCaches: Iterable<AbstractIncrementalCache<*>>
     fun classesFqNamesBySources(files: Iterable<File>): Collection<FqName>
     fun getSubtypesOf(className: FqName): Sequence<FqName>
+    fun getSupertypesOf(className: FqName): Sequence<FqName>
     fun getSourceFileIfClass(fqName: FqName): File?
     fun markDirty(removedAndCompiledSources: Collection<File>)
     fun clearCacheForRemovedClasses(changesCollector: ChangesCollector)
     fun getComplementaryFilesRecursive(dirtyFiles: Collection<File>): Collection<File>
     fun updateComplementaryFiles(dirtyFiles: Collection<File>, expectActualTracker: ExpectActualTrackerImpl)
     fun dump(): String
+
+    fun isSealed(className: FqName): Boolean?
 }
 
 /**
@@ -50,6 +54,7 @@ abstract class AbstractIncrementalCache<ClassName>(
     protected val pathConverter: FileToPathConverter
 ) : BasicMapsOwner(workingDir), IncrementalCacheCommon {
     companion object {
+        private val CLASS_ATTRIBUTES = "class-attributes"
         private val SUBTYPES = "subtypes"
         private val SUPERTYPES = "supertypes"
         private val CLASS_FQ_NAME_TO_SOURCE = "class-fq-name-to-source"
@@ -71,6 +76,7 @@ abstract class AbstractIncrementalCache<ClassName>(
         result
     }
 
+    internal val classAttributesMap = registerMap(ClassAttributesMap(CLASS_ATTRIBUTES.storageFile))
     private val subtypesMap = registerMap(SubtypesMap(SUBTYPES.storageFile))
     private val supertypesMap = registerMap(SupertypesMap(SUPERTYPES.storageFile))
     protected val classFqNameToSourceMap = registerMap(ClassFqNameToSourceMap(CLASS_FQ_NAME_TO_SOURCE.storageFile, pathConverter))
@@ -90,6 +96,14 @@ abstract class AbstractIncrementalCache<ClassName>(
     override fun getSubtypesOf(className: FqName): Sequence<FqName> =
         subtypesMap[className].asSequence()
 
+    override fun getSupertypesOf(className: FqName): Sequence<FqName> {
+        return supertypesMap[className].asSequence()
+    }
+
+    override fun isSealed(className: FqName): Boolean? {
+        return classAttributesMap[className]?.isSealed
+    }
+
     override fun getSourceFileIfClass(fqName: FqName): File? =
         classFqNameToSourceMap[fqName]
 
@@ -118,6 +132,7 @@ abstract class AbstractIncrementalCache<ClassName>(
 
         supertypesMap[child] = parents
         classFqNameToSourceMap[child] = srcFile
+        classAttributesMap[child] = ICClassesAttributes(ProtoBuf.Modality.SEALED == Flags.MODALITY.get(proto.flags))
     }
 
     protected fun removeAllFromClassStorage(removedClasses: Collection<FqName>, changesCollector: ChangesCollector) {
@@ -152,14 +167,17 @@ abstract class AbstractIncrementalCache<ClassName>(
             }
         }
 
-        removedFqNames.forEach { classFqNameToSourceMap.remove(it) }
+        removedFqNames.forEach {
+            classFqNameToSourceMap.remove(it)
+            classAttributesMap.remove(it)
+        }
     }
 
     protected class ClassFqNameToSourceMap(
         storageFile: File,
         private val pathConverter: FileToPathConverter
-    ) :
-        BasicStringMap<String>(storageFile, EnumeratorStringDescriptor(), PathStringDescriptor) {
+    ) : BasicStringMap<String>(storageFile, EnumeratorStringDescriptor(), PathStringDescriptor) {
+
         operator fun set(fqName: FqName, sourceFile: File) {
             storage[fqName.asString()] = pathConverter.toPath(sourceFile)
         }

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

@@ -19,12 +19,14 @@ package org.jetbrains.kotlin.incremental
 import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.metadata.deserialization.Flags
 import org.jetbrains.kotlin.metadata.deserialization.NameResolver
+import org.jetbrains.kotlin.metadata.deserialization.supertypes
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.protobuf.MessageLite
 import org.jetbrains.kotlin.serialization.deserialization.getClassId
 
 class ChangesCollector {
     private val removedMembers = hashMapOf<FqName, MutableSet<String>>()
+    private val changedParents = hashMapOf<FqName, MutableSet<FqName>>()
     private val changedMembers = hashMapOf<FqName, MutableSet<String>>()
     private val areSubclassesAffected = hashMapOf<FqName, Boolean>()
 
@@ -47,6 +49,10 @@ class ChangesCollector {
             changes.add(ChangeInfo.SignatureChanged(fqName, areSubclassesAffected))
         }
 
+        for ((fqName, changedParents) in changedParents) {
+            changes.add(ChangeInfo.ParentsChanged(fqName, changedParents))
+        }
+
         return changes
     }
 
@@ -79,12 +85,12 @@ class ChangesCollector {
         }
 
         if (oldData == null) {
-            newData!!.collectAll(isRemoved = false, collectAllMembersForNewClass = collectAllMembersForNewClass)
+            newData!!.collectAll(isRemoved = false, isAdded = true, collectAllMembersForNewClass = collectAllMembersForNewClass)
             return
         }
 
         if (newData == null) {
-            oldData.collectAll(isRemoved = true)
+            oldData.collectAll(isRemoved = true, isAdded = false)
             return
         }
 
@@ -98,6 +104,7 @@ class ChangesCollector {
                             collectSignature(oldData, diff.areSubclassesAffected)
                         }
                         collectChangedMembers(fqName, diff.changedMembersNames)
+                        addChangedParents(fqName, diff.changedSupertypes)
                     }
                     is PackagePartProtoData -> {
                         collectSignature(oldData, areSubclassesAffected = true)
@@ -121,10 +128,11 @@ class ChangesCollector {
     private fun <T> T.getNonPrivateNames(nameResolver: NameResolver, vararg members: T.() -> List<MessageLite>): Set<String> =
             members.flatMap { this.it().filterNot { it.isPrivate }.names(nameResolver) }.toSet()
 
-    private fun ProtoData.collectAll(isRemoved: Boolean, collectAllMembersForNewClass: Boolean = false) =
+    //TODO remember all sealed parent classes
+    private fun ProtoData.collectAll(isRemoved: Boolean, isAdded: Boolean, collectAllMembersForNewClass: Boolean = false) =
         when (this) {
             is PackagePartProtoData -> collectAllFromPackage(isRemoved)
-            is ClassProtoData -> collectAllFromClass(isRemoved, collectAllMembersForNewClass)
+            is ClassProtoData -> collectAllFromClass(isRemoved, isAdded, collectAllMembersForNewClass)
         }
 
     private fun PackagePartProtoData.collectAllFromPackage(isRemoved: Boolean) {
@@ -143,7 +151,7 @@ class ChangesCollector {
         }
     }
 
-    private fun ClassProtoData.collectAllFromClass(isRemoved: Boolean, collectAllMembersForNewClass: Boolean = false) {
+    private fun ClassProtoData.collectAllFromClass(isRemoved: Boolean, isAdded: Boolean, collectAllMembersForNewClass: Boolean = false) {
         val classFqName = nameResolver.getClassId(proto.fqName).asSingleFqName()
         val kind = Flags.CLASS_KIND.get(proto.flags)
 
@@ -162,6 +170,23 @@ class ChangesCollector {
 
             collectSignature(classFqName, areSubclassesAffected = true)
         }
+
+        if (isRemoved || isAdded) {
+            collectChangedParents(classFqName, proto.supertypeList)
+        }
+    }
+
+    private fun addChangedParents(fqName: FqName, parents: Collection<FqName>) {
+        if (parents.isNotEmpty()) {
+            changedParents.getOrPut(fqName) { HashSet() }.addAll(parents)
+        }
+    }
+
+    private fun ClassProtoData.collectChangedParents(fqName: FqName, parents: Collection<ProtoBuf.Type>) {
+        val changedParentsFqNames = parents.map { type ->
+            nameResolver.getClassId(type.className).asSingleFqName()
+        }
+        addChangedParents(fqName, changedParentsFqNames)
     }
 
     private fun ClassProtoData.getNonPrivateMemberNames(): Set<String> {

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

@@ -32,6 +32,7 @@ import org.jetbrains.kotlin.name.parentOrNull
 import org.jetbrains.kotlin.serialization.SerializerExtensionProtocol
 import org.jetbrains.kotlin.serialization.deserialization.getClassId
 import org.jetbrains.kotlin.serialization.js.JsSerializerProtocol
+import org.jetbrains.kotlin.util.capitalizeDecapitalize.capitalizeAsciiOnly
 import java.io.DataInput
 import java.io.DataOutput
 import java.io.File
@@ -326,7 +327,7 @@ private class ProtoDataProvider(private val serializerProtocol: SerializerExtens
         proto.`package`.apply {
             val packageNameId = getExtensionOrNull(serializerProtocol.packageFqName)
             val packageFqName = packageNameId?.let { FqName(nameResolver.getPackageFqName(it)) } ?: FqName.ROOT
-            val packagePartClassId = ClassId(packageFqName, Name.identifier(sourceFile.nameWithoutExtension.capitalize() + "Kt"))
+            val packagePartClassId = ClassId(packageFqName, Name.identifier(sourceFile.nameWithoutExtension.capitalizeAsciiOnly() + "Kt"))
             classes[packagePartClassId] = PackagePartProtoData(this, nameResolver, packageFqName)
         }
 
@@ -347,7 +348,7 @@ fun getProtoData(sourceFile: File, metadata: ByteArray): Map<ClassId, ProtoData>
 
     proto.`package`.apply {
         val packageFqName = getExtensionOrNull(JsProtoBuf.packageFqName)?.let(nameResolver::getPackageFqName)?.let(::FqName) ?: FqName.ROOT
-        val packagePartClassId = ClassId(packageFqName, Name.identifier(sourceFile.nameWithoutExtension.capitalize() + "Kt"))
+        val packagePartClassId = ClassId(packageFqName, Name.identifier(sourceFile.nameWithoutExtension.capitalizeAsciiOnly() + "Kt"))
         classes[packagePartClassId] = PackagePartProtoData(this, nameResolver, packageFqName)
     }
 
@@ -412,4 +413,4 @@ private class PackageMetadataMap(storageFile: File) : BasicStringMap<ByteArray>(
     operator fun get(packageName: String) = storage[packageName]
 
     override fun dumpValue(value: ByteArray): String = "Package metadata: ${value.md5()}"
-}
+}

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

@@ -94,6 +94,10 @@ open class IncrementalJvmCache(
     fun sourcesByInternalName(internalName: String): Collection<File> =
         internalNameToSource[internalName]
 
+    fun getAllPartsOfMultifileFacade(facade: JvmClassName): Collection<String>? {
+        return multifileFacadeToParts[facade]
+    }
+
     fun isMultifileFacade(className: JvmClassName): Boolean =
         className in multifileFacadeToParts
 
@@ -145,6 +149,7 @@ open class IncrementalJvmCache(
                 }
                 protoMap.remove(className, changesCollector)
                 classFqNameToSourceMap.remove(className.fqNameForClassNameWithoutDollars)
+                classAttributesMap.remove(className.fqNameForClassNameWithoutDollars)
                 internalNameToSource.remove(className.internalName)
 
                 // TODO NO_CHANGES? (delegates only)
@@ -271,6 +276,7 @@ open class IncrementalJvmCache(
 
     private inner class ProtoMap(storageFile: File) : BasicStringMap<ProtoMapValue>(storageFile, ProtoMapValueExternalizer) {
 
+        @Synchronized
         fun process(kotlinClass: LocalFileKotlinClass, changesCollector: ChangesCollector) {
             return put(kotlinClass, changesCollector)
         }
@@ -282,10 +288,12 @@ open class IncrementalJvmCache(
         // from files compiled during last round.
         // However there is no need to compare old and new data in this case
         // (also that would fail with exception).
+        @Synchronized
         fun storeModuleMapping(className: JvmClassName, bytes: ByteArray) {
             storage[className.internalName] = ProtoMapValue(isPackageFacade = false, bytes = bytes, strings = emptyArray())
         }
 
+        @Synchronized
         private fun put(kotlinClass: LocalFileKotlinClass, changesCollector: ChangesCollector) {
             val header = kotlinClass.classHeader
 
@@ -308,6 +316,7 @@ open class IncrementalJvmCache(
         operator fun get(className: JvmClassName): ProtoMapValue? =
             storage[className.internalName]
 
+        @Synchronized
         fun remove(className: JvmClassName, changesCollector: ChangesCollector) {
             val key = className.internalName
             val oldValue = storage[key] ?: return
@@ -324,6 +333,8 @@ open class IncrementalJvmCache(
 
     private inner class JavaSourcesProtoMap(storageFile: File) :
         BasicStringMap<SerializedJavaClass>(storageFile, JavaClassProtoMapValueExternalizer) {
+
+        @Synchronized
         fun process(jvmClassName: JvmClassName, newData: SerializedJavaClass, changesCollector: ChangesCollector) {
             val key = jvmClassName.internalName
             val oldData = storage[key]
@@ -335,6 +346,7 @@ open class IncrementalJvmCache(
             )
         }
 
+        @Synchronized
         fun remove(className: JvmClassName, changesCollector: ChangesCollector) {
             val key = className.internalName
             val oldValue = storage[key] ?: return
@@ -374,6 +386,7 @@ open class IncrementalJvmCache(
         operator fun contains(className: JvmClassName): Boolean =
             className.internalName in storage
 
+        @Synchronized
         fun process(kotlinClass: LocalFileKotlinClass, changesCollector: ChangesCollector) {
             val key = kotlinClass.className.internalName
             val oldMap = storage[key] ?: emptyMap()
@@ -390,6 +403,7 @@ open class IncrementalJvmCache(
             }
         }
 
+        @Synchronized
         fun remove(className: JvmClassName) {
             storage.remove(className.internalName)
         }
@@ -415,6 +429,8 @@ open class IncrementalJvmCache(
 
     private inner class MultifileClassFacadeMap(storageFile: File) :
         BasicStringMap<Collection<String>>(storageFile, StringCollectionExternalizer) {
+
+        @Synchronized
         operator fun set(className: JvmClassName, partNames: Collection<String>) {
             storage[className.internalName] = partNames
         }
@@ -425,6 +441,7 @@ open class IncrementalJvmCache(
         operator fun contains(className: JvmClassName): Boolean =
             className.internalName in storage
 
+        @Synchronized
         fun remove(className: JvmClassName) {
             storage.remove(className.internalName)
         }
@@ -434,6 +451,8 @@ open class IncrementalJvmCache(
 
     private inner class MultifileClassPartMap(storageFile: File) :
         BasicStringMap<String>(storageFile, EnumeratorStringDescriptor.INSTANCE) {
+
+        @Synchronized
         fun set(partName: String, facadeName: String) {
             storage[partName] = facadeName
         }
@@ -441,6 +460,7 @@ open class IncrementalJvmCache(
         fun get(partName: JvmClassName): String? =
             storage[partName.internalName]
 
+        @Synchronized
         fun remove(className: JvmClassName) {
             storage.remove(className.internalName)
         }
@@ -522,6 +542,7 @@ open class IncrementalJvmCache(
             return result
         }
 
+        @Synchronized
         fun process(kotlinClass: LocalFileKotlinClass, changesCollector: ChangesCollector) {
             val key = kotlinClass.className.internalName
             val oldMap = storage[key] ?: emptyMap()
@@ -547,6 +568,7 @@ open class IncrementalJvmCache(
         private fun functionNameBySignature(signature: String): String =
             signature.substringBefore("(")
 
+        @Synchronized
         fun remove(className: JvmClassName) {
             storage.remove(className.internalName)
         }
@@ -568,6 +590,7 @@ sealed class ChangeInfo(val fqName: FqName) {
 
     class SignatureChanged(fqName: FqName, val areSubclassesAffected: Boolean) : ChangeInfo(fqName)
 
+    class ParentsChanged(fqName: FqName, val parentsChanged: Collection<FqName>) : ChangeInfo(fqName)
 
     protected open fun toStringProperties(): String = "fqName = $fqName"
 

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

@@ -21,6 +21,7 @@ data class IncrementalModuleEntry(
 
 class IncrementalModuleInfo(
     val projectRoot: File,
+    val rootProjectBuildDir: File,
     val dirToModule: Map<File, IncrementalModuleEntry>,
     val nameToModules: Map<String, Set<IncrementalModuleEntry>>,
     val jarToClassListFile: Map<File, File>,
@@ -28,6 +29,6 @@ class IncrementalModuleInfo(
     val jarToModule: Map<File, IncrementalModuleEntry>
 ) : Serializable {
     companion object {
-        private const val serialVersionUID = 0L
+        private const val serialVersionUID = 1L
     }
 }

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

@@ -17,19 +17,18 @@
 package org.jetbrains.kotlin.incremental
 
 import com.intellij.util.containers.MultiMap
-import com.intellij.util.containers.StringInterner
 import org.jetbrains.annotations.TestOnly
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.incremental.components.Position
 import org.jetbrains.kotlin.incremental.components.ScopeKind
 import org.jetbrains.kotlin.incremental.storage.*
 import org.jetbrains.kotlin.utils.Printer
+import org.jetbrains.kotlin.utils.createStringInterner
 import org.jetbrains.kotlin.utils.keysToMap
 import java.io.File
 import java.io.IOException
 import java.util.*
 
-
 open class LookupStorage(
     targetDataDir: File,
     pathConverter: FileToPathConverter
@@ -212,8 +211,8 @@ open class LookupStorage(
 
 class LookupTrackerImpl(private val delegate: LookupTracker) : LookupTracker {
     val lookups = MultiMap.createSet<LookupSymbol, String>()
-    val pathInterner = StringInterner()
-    private val interner = StringInterner()
+    val pathInterner = createStringInterner()
+    private val interner = createStringInterner()
 
     override val requiresPosition: Boolean
         get() = delegate.requiresPosition

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

@@ -20,6 +20,7 @@ import org.jetbrains.kotlin.build.GeneratedFile
 import org.jetbrains.kotlin.build.GeneratedJvmClass
 import org.jetbrains.kotlin.build.JvmSourceRoot
 import org.jetbrains.kotlin.build.isModuleMappingFile
+import org.jetbrains.kotlin.build.report.ICReporter
 import org.jetbrains.kotlin.config.Services
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache
@@ -31,6 +32,7 @@ import org.jetbrains.kotlin.progress.CompilationCanceledStatus
 import org.jetbrains.kotlin.resolve.sam.SAM_LOOKUP_NAME
 import org.jetbrains.kotlin.utils.addToStdlib.flattenTo
 import java.io.File
+import java.nio.file.Files
 import java.util.*
 import kotlin.collections.HashSet
 import kotlin.collections.LinkedHashSet
@@ -66,7 +68,7 @@ fun makeModuleFile(
         friendDirs
     )
 
-    val scriptFile = File.createTempFile("kjps", sanitizeJavaIdentifier(name) + ".script.xml")
+    val scriptFile = Files.createTempFile("kjps", sanitizeJavaIdentifier(name) + ".script.xml").toFile()
     scriptFile.writeText(builder.asText().toString())
     return scriptFile
 }
@@ -134,7 +136,8 @@ fun LookupStorage.update(
 
 data class DirtyData(
     val dirtyLookupSymbols: Collection<LookupSymbol> = emptyList(),
-    val dirtyClassesFqNames: Collection<FqName> = emptyList()
+    val dirtyClassesFqNames: Collection<FqName> = emptyList(),
+    val dirtyClassesFqNamesForceRecompile: Collection<FqName> = emptyList()
 )
 
 fun ChangesCollector.getDirtyData(
@@ -144,6 +147,9 @@ fun ChangesCollector.getDirtyData(
     val dirtyLookupSymbols = HashSet<LookupSymbol>()
     val dirtyClassesFqNames = HashSet<FqName>()
 
+    val sealedParents = HashMap<FqName, MutableSet<FqName>>()
+    val notSealedParents = HashSet<FqName>()
+
     for (change in changes()) {
         reporter.reportVerbose { "Process $change" }
 
@@ -168,10 +174,35 @@ fun ChangesCollector.getDirtyData(
             }
 
             fqNames.mapTo(dirtyLookupSymbols) { LookupSymbol(SAM_LOOKUP_NAME.asString(), it.asString()) }
+        } else if (change is ChangeInfo.ParentsChanged) {
+            fun FqName.isSealed(): Boolean {
+                if (notSealedParents.contains(this)) return false
+                if (sealedParents.containsKey(this)) return true
+                return isSealed(this, caches).also { sealed ->
+                    if (sealed) {
+                        sealedParents[this] = HashSet()
+                    } else {
+                        notSealedParents.add(this)
+                    }
+                }
+            }
+            change.parentsChanged.forEach { parent ->
+                if (parent.isSealed()) {
+                    sealedParents.getOrPut(parent) { HashSet() }.add(change.fqName)
+                }
+            }
         }
     }
 
-    return DirtyData(dirtyLookupSymbols, dirtyClassesFqNames)
+    val forceRecompile = HashSet<FqName>().apply {
+        addAll(sealedParents.keys)
+        //we should recompile all inheritors with parent sealed class: add known subtypes
+        addAll(sealedParents.keys.flatMap { withSubtypes(it, caches) })
+        //we should recompile all inheritors with parent sealed class: add new subtypes
+        addAll(sealedParents.values.flatten())
+    }
+
+    return DirtyData(dirtyLookupSymbols, dirtyClassesFqNames, forceRecompile)
 }
 
 fun mapLookupSymbolsToFiles(
@@ -215,6 +246,11 @@ fun mapClassesFqNamesToFiles(
     return fqNameToAffectedFiles.values.flattenTo(HashSet())
 }
 
+fun isSealed(
+    fqName: FqName,
+    caches: Iterable<IncrementalCacheCommon>
+): Boolean = caches.any { it.isSealed(fqName) ?: false }
+
 fun withSubtypes(
     typeFqName: FqName,
     caches: Iterable<IncrementalCacheCommon>

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

@@ -28,12 +28,14 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.protobuf.MessageLite
 import org.jetbrains.kotlin.serialization.deserialization.ProtoEnumFlags
 import org.jetbrains.kotlin.serialization.deserialization.descriptorVisibility
+import org.jetbrains.kotlin.serialization.deserialization.getClassId
 import java.util.*
 
 data class Difference(
     val isClassAffected: Boolean = false,
     val areSubclassesAffected: Boolean = false,
-    val changedMembersNames: Set<String> = emptySet()
+    val changedMembersNames: Set<String> = emptySet(),
+    val changedSupertypes: Set<FqName> = emptySet()
 )
 
 sealed class ProtoData
@@ -187,6 +189,7 @@ class DifferenceCalculatorForClass(
 
         var isClassAffected = false
         var areSubclassesAffected = false
+        val changedSupertypes = HashSet<FqName>()
         val names = hashSetOf<String>()
         val classIsSealed = newProto.isSealed && oldProto.isSealed
 
@@ -247,12 +250,21 @@ class DifferenceCalculatorForClass(
                 ProtoBufClassKind.FLAGS,
                 ProtoBufClassKind.FQ_NAME,
                 ProtoBufClassKind.TYPE_PARAMETER_LIST,
-                ProtoBufClassKind.SUPERTYPE_LIST,
-                ProtoBufClassKind.SUPERTYPE_ID_LIST,
                 ProtoBufClassKind.JS_EXT_CLASS_ANNOTATION_LIST -> {
                     isClassAffected = true
                     areSubclassesAffected = true
                 }
+
+                ProtoBufClassKind.SUPERTYPE_LIST,
+                ProtoBufClassKind.SUPERTYPE_ID_LIST -> {
+                    isClassAffected = true
+                    areSubclassesAffected = true
+
+                    val oldSupertypes = oldProto.supertypeList.map { oldNameResolver.getClassId(it.className).asSingleFqName() }
+                    val newSupertypes = newProto.supertypeList.map { newNameResolver.getClassId(it.className).asSingleFqName() }
+                    val changed = (oldSupertypes union newSupertypes) subtract (oldSupertypes intersect newSupertypes)
+                    changedSupertypes.addAll(changed)
+                }
                 ProtoBufClassKind.JVM_EXT_CLASS_MODULE_NAME,
                 ProtoBufClassKind.JS_EXT_CLASS_CONTAINING_FILE_ID -> {
                     // TODO
@@ -281,7 +293,7 @@ class DifferenceCalculatorForClass(
             }
         }
 
-        return Difference(isClassAffected, areSubclassesAffected, names)
+        return Difference(isClassAffected, areSubclassesAffected, names, changedSupertypes)
     }
 }
 

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

@@ -30,6 +30,7 @@ open class BasicMapsOwner(val cachesDir: File) {
     protected val String.storageFile: File
         get() = File(cachesDir, this + "." + CACHE_EXTENSION)
 
+    @Synchronized
     protected fun <K, V, M : BasicMap<K, V>> registerMap(map: M): M {
         maps.add(map)
         return map
@@ -47,6 +48,7 @@ open class BasicMapsOwner(val cachesDir: File) {
         forEachMapSafe("flush") { it.flush(memoryCachesOnly) }
     }
 
+    @Synchronized
     private fun forEachMapSafe(actionName: String, action: (BasicMap<*, *>) -> Unit) {
         val actionExceptions = LinkedHashMap<String, Exception>()
         maps.forEach {
@@ -66,5 +68,6 @@ open class BasicMapsOwner(val cachesDir: File) {
     }
 
     @TestOnly
+    @Synchronized
     fun dump(): String = maps.joinToString("\n\n") { it.dump() }
 }

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

@@ -17,9 +17,11 @@
 package org.jetbrains.kotlin.incremental.storage
 
 import com.intellij.util.io.DataExternalizer
+import com.intellij.util.io.IOUtil
 import com.intellij.util.io.KeyDescriptor
 import com.intellij.util.io.PersistentHashMap
 import java.io.File
+import java.io.IOException
 
 
 /**
@@ -30,7 +32,6 @@ class CachingLazyStorage<K, V>(
     private val keyDescriptor: KeyDescriptor<K>,
     private val valueExternalizer: DataExternalizer<V>
 ) : LazyStorage<K, V> {
-    @Volatile
     private var storage: PersistentHashMap<K, V>? = null
 
     @Synchronized
@@ -80,8 +81,10 @@ class CachingLazyStorage<K, V>(
         try {
             storage?.close()
         } finally {
-            PersistentHashMap.deleteFilesStartingWith(storageFile)
             storage = null
+            if (!IOUtil.deleteAllFilesStartingWith(storageFile)) {
+                throw IOException("Could not delete internal storage: ${storageFile.absolutePath}")
+            }
         }
     }
 

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

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.incremental.storage
+
+import com.intellij.util.io.DataExternalizer
+import org.jetbrains.kotlin.name.FqName
+import java.io.DataInput
+import java.io.DataOutput
+import java.io.File
+
+internal data class ICClassesAttributes(val isSealed: Boolean)
+
+internal object ICClassesAttributesExternalizer : DataExternalizer<ICClassesAttributes> {
+    override fun read(input: DataInput): ICClassesAttributes {
+        return ICClassesAttributes(input.readBoolean())
+    }
+
+    override fun save(output: DataOutput, value: ICClassesAttributes) {
+        output.writeBoolean(value.isSealed)
+    }
+}
+
+internal open class ClassAttributesMap(
+    storageFile: File
+) : BasicStringMap<ICClassesAttributes>(storageFile, ICClassesAttributesExternalizer) {
+    override fun dumpValue(value: ICClassesAttributes): String = value.toString()
+
+    operator fun set(key: FqName, value: ICClassesAttributes) {
+        storage[key.asString()] = value
+    }
+
+    operator fun get(key: FqName): ICClassesAttributes? = storage[key.asString()]
+
+    fun remove(key: FqName) {
+        storage.remove(key.asString())
+    }
+}

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

@@ -20,18 +20,18 @@ import org.jetbrains.kotlin.incremental.dumpCollection
 import org.jetbrains.kotlin.name.FqName
 import java.io.File
 
-internal open class ClassOneToManyMap(
-        storageFile: File
-) : BasicStringMap<Collection<String>>(storageFile, StringCollectionExternalizer) {
+internal open class ClassOneToManyMap(storageFile: File) : BasicStringMap<Collection<String>>(storageFile, StringCollectionExternalizer) {
     override fun dumpValue(value: Collection<String>): String = value.dumpCollection()
 
+    @Synchronized
     fun add(key: FqName, value: FqName) {
         storage.append(key.asString(), listOf(value.asString()))
     }
 
     operator fun get(key: FqName): Collection<FqName> =
-            storage[key.asString()]?.map(::FqName) ?: setOf()
+        storage[key.asString()]?.map(::FqName) ?: setOf()
 
+    @Synchronized
     operator fun set(key: FqName, values: Collection<FqName>) {
         if (values.isEmpty()) {
             remove(key)
@@ -41,10 +41,14 @@ internal open class ClassOneToManyMap(
         storage[key.asString()] = values.map(FqName::asString)
     }
 
+    @Synchronized
     fun remove(key: FqName) {
         storage.remove(key.asString())
     }
 
+    // Access to caches could be done from multiple threads (e.g. JPS worker and RMI). The underlying collection is already synchronized,
+    // thus we need synchronization of this method and all modification methods.
+    @Synchronized
     fun removeValues(key: FqName, removed: Set<FqName>) {
         val notRemoved = this[key].filter { it !in removed }
         this[key] = notRemoved

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

@@ -25,8 +25,7 @@ internal class DirtyClassesJvmNameMap(storageFile: File) : AbstractDirtyClassesM
 internal class DirtyClassesFqNameMap(storageFile: File) : AbstractDirtyClassesMap<FqName>(FqNameTransformer, storageFile)
 
 internal abstract class AbstractDirtyClassesMap<Name>(
-        private val nameTransformer: NameTransformer<Name>,
-        storageFile: File
+    private val nameTransformer: NameTransformer<Name>, storageFile: File
 ) : BasicStringMap<Boolean>(storageFile, BooleanDataDescriptor.INSTANCE) {
     fun markDirty(className: Name) {
         storage[nameTransformer.asString(className)] = true
@@ -37,10 +36,10 @@ internal abstract class AbstractDirtyClassesMap<Name>(
     }
 
     fun getDirtyOutputClasses(): Collection<Name> =
-            storage.keys.map { nameTransformer.asName(it) }
+        storage.keys.map { nameTransformer.asName(it) }
 
     fun isDirty(className: Name): Boolean =
-            storage.contains(nameTransformer.asString(className))
+        storage.contains(nameTransformer.asString(className))
 
     override fun dumpValue(value: Boolean) = ""
 }

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

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.incremental.storage
+
+import java.io.File
+
+open class IncrementalFileToPathConverter(val rootProjectDir: File?) : FileToPathConverter {
+    //project root dir
+    private val projectDirPath = rootProjectDir?.normalize()?.absolutePath
+
+    override fun toPath(file: File): String {
+        val path = file.normalize().absolutePath
+        return when {
+            projectDirPath == null || !path.startsWith(projectDirPath) -> path
+            else -> PROJECT_DIR_PLACEHOLDER + path.substring(projectDirPath.length)
+        }
+    }
+
+    override fun toFile(path: String): File =
+        when {
+            rootProjectDir != null && path.startsWith(PROJECT_DIR_PLACEHOLDER) -> rootProjectDir.resolve(path.substring(PATH_PREFIX.length))
+            else -> File(path)
+        }
+
+    private companion object {
+        private const val PROJECT_DIR_PLACEHOLDER = "${'$'}PROJECT_DIR$"
+        //use only for prefix length because it OS dependent
+        private const val PATH_PREFIX = "$PROJECT_DIR_PLACEHOLDER/"
+
+    }
+}

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

@@ -17,9 +17,11 @@
 package org.jetbrains.kotlin.incremental.storage
 
 import com.intellij.util.io.DataExternalizer
+import com.intellij.util.io.IOUtil
 import com.intellij.util.io.KeyDescriptor
 import com.intellij.util.io.PersistentHashMap
 import java.io.File
+import java.io.IOException
 
 
 class NonCachingLazyStorage<K, V>(
@@ -27,7 +29,6 @@ class NonCachingLazyStorage<K, V>(
     private val keyDescriptor: KeyDescriptor<K>,
     private val valueExternalizer: DataExternalizer<V>
 ) : LazyStorage<K, V> {
-    @Volatile
     private var storage: PersistentHashMap<K, V>? = null
 
     @Synchronized
@@ -76,11 +77,12 @@ class NonCachingLazyStorage<K, V>(
     override fun clean() {
         try {
             storage?.close()
-        } catch (ignored: Throwable) {
+        } finally {
+            storage = null
+            if (!IOUtil.deleteAllFilesStartingWith(storageFile)) {
+                throw IOException("Could not delete internal storage: ${storageFile.absolutePath}")
+            }
         }
-
-        PersistentHashMap.deleteFilesStartingWith(storageFile)
-        storage = null
     }
 
     @Synchronized

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

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

build-common/test/org/jetbrains/kotlin/build/BuildMetaInfoTest.kt

@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.build
 
 import junit.framework.TestCase
-import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments
 import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
 import org.junit.Assert.assertNotEquals
 import org.junit.Test
@@ -34,10 +33,7 @@ class BuildMetaInfoTest : TestCase() {
             "bytecodeVersionMinor",
             "bytecodeVersionPatch",
             "compilerBuildVersion",
-            "coroutinesEnable",
-            "coroutinesError",
             "coroutinesVersion",
-            "coroutinesWarn",
             "isEAP",
             "languageVersionString",
             "metadataVersionMajor",
@@ -71,14 +67,12 @@ class BuildMetaInfoTest : TestCase() {
     @Test
     fun testJvmEquals() {
         val args1 = K2JVMCompilerArguments()
-        args1.coroutinesState = CommonCompilerArguments.ENABLE
         val info1 = JvmBuildMetaInfo.create(args1)
 
         val args2 = K2JVMCompilerArguments()
-        args2.coroutinesState = CommonCompilerArguments.WARN
         val info2 = JvmBuildMetaInfo.create(args2)
 
-        assertNotEquals(info1, info2)
-        assertEquals(info1, info2.copy(coroutinesEnable = true, coroutinesWarn = false))
+        assertEquals(info1, info2)
+        assertEquals(info1, info2.copy())
     }
 }

build-common/test/org/jetbrains/kotlin/incremental/storage/IncrementalFileToPathConverterTest.kt

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.incremental.storage
+
+import org.jetbrains.kotlin.TestWithWorkingDir
+import org.junit.Test
+import java.io.File
+
+internal class IncrementalFileToPathConverterTest : TestWithWorkingDir() {
+    val separator: String = File.separator
+
+    @Test
+    fun testPathTransform() {
+        val relativeFilePath = "testFile.txt"
+        val transformedPath = testPathTransformation(workingDir.resolve("testDir"), relativeFilePath)
+
+        assertEquals("${'$'}PROJECT_DIR${'$'}$separator$relativeFilePath", transformedPath)
+    }
+
+    @Test
+    fun testComplicatedProjectRootPath() {
+        val relativeFilePath = "testFile.txt"
+        val transformedPath = testPathTransformation(workingDir.resolve("first$separator..${separator}testDir"), relativeFilePath)
+
+        assertEquals("${'$'}PROJECT_DIR${'$'}$separator$relativeFilePath", transformedPath)
+    }
+
+    @Test
+    fun testInccorectProjectRootPath() {
+        val relativeFilePath = "testFile.txt"
+        val transformedPath = testPathTransformation(workingDir.resolve("testDir$separator"), relativeFilePath)
+
+        assertEquals("${'$'}PROJECT_DIR${'$'}$separator$relativeFilePath", transformedPath)
+    }
+
+    @Test
+    fun testFileOutOfProject() {
+        val relativeFilePath = "..${separator}testFile.txt"
+        val transformedPath = testPathTransformation(workingDir.resolve("testDir"), relativeFilePath)
+
+        assertEquals("${workingDir.absolutePath}${separator}testFile.txt", transformedPath)
+    }
+
+    @Test
+    fun testFileWithExtraSlash() {
+        val relativeFilePath = "testFile.txt$separator"
+        val transformedPath = testPathTransformation(workingDir.resolve("testDir"), relativeFilePath)
+
+        assertEquals("${'$'}PROJECT_DIR${'$'}${separator}testFile.txt", transformedPath)
+    }
+
+    private fun testPathTransformation(projectRoot: File, relativeFilePath: String): String {
+        val pathConverter = IncrementalFileToPathConverter(projectRoot)
+        val testFile = projectRoot.resolve(relativeFilePath)
+        val transformedPath = pathConverter.toPath(testFile)
+        assertEquals(testFile.normalize().absolutePath, pathConverter.toFile(transformedPath).normalize().absolutePath)
+        return transformedPath
+    }
+}

build-common/test/org/jetbrains/kotlin/incremental/testingUtils/BuildLogFinder.kt

@@ -22,12 +22,12 @@ data class BuildLogFinder(
     private val isDataContainerBuildLogEnabled: Boolean = false,
     private val isGradleEnabled: Boolean = false,
     private val isJsEnabled: Boolean = false,
-    private val isJsIrEnabled: Boolean = false, // TODO rename as it is used for metadata-only test
-    private val isScopeExpansionEnabled: Boolean = false
+    private val isScopeExpansionEnabled: Boolean = false,
+    private val isKlibEnabled: Boolean = false
 ) {
     companion object {
         private const val JS_LOG = "js-build.log"
-        private const val JS_IR_LOG = "js-ir-build.log"
+        private const val KLIB_LOG = "klib-build.log"
         private const val SCOPE_EXPANDING_LOG = "build-with-scope-expansion.log"
         private const val GRADLE_LOG = "gradle-build.log"
         private const val DATA_CONTAINER_LOG = "data-container-version-build.log"
@@ -43,7 +43,7 @@ data class BuildLogFinder(
         val files = names.filter { File(dir, it).isFile }.toSet()
         val matchedName = when {
             isScopeExpansionEnabled && SCOPE_EXPANDING_LOG in files -> SCOPE_EXPANDING_LOG
-            isJsIrEnabled && JS_IR_LOG in files -> JS_IR_LOG
+            isKlibEnabled && KLIB_LOG in files -> KLIB_LOG
             isJsEnabled && JS_LOG in files -> JS_LOG
             isGradleEnabled && GRADLE_LOG in files -> GRADLE_LOG
             isJsEnabled && JS_JPS_LOG in files -> JS_JPS_LOG

build-common/test/org/jetbrains/kotlin/incremental/testingUtils/classFilesComparison.kt

@@ -151,29 +151,35 @@ private fun classFileToString(classFile: File): String {
     val traceVisitor = TraceClassVisitor(PrintWriter(out))
     ClassReader(classFile.readBytes()).accept(traceVisitor, 0)
 
-    val classHeader = LocalFileKotlinClass.create(classFile)?.classHeader
+    val classHeader = LocalFileKotlinClass.create(classFile)?.classHeader ?: return ""
+    if (!classHeader.metadataVersion.isCompatible()) {
+        error("Incompatible class ($classHeader): $classFile")
+    }
 
-    val annotationDataEncoded = classHeader?.data
-    if (annotationDataEncoded != null) {
-        ByteArrayInputStream(BitEncoding.decodeBytes(annotationDataEncoded)).use {
-            input ->
+    when (classHeader.kind) {
+        KotlinClassHeader.Kind.FILE_FACADE, KotlinClassHeader.Kind.CLASS, KotlinClassHeader.Kind.MULTIFILE_CLASS_PART -> {
+            ByteArrayInputStream(BitEncoding.decodeBytes(classHeader.data!!)).use { input ->
+                out.write("\n------ string table types proto -----\n${DebugJvmProtoBuf.StringTableTypes.parseDelimitedFrom(input)}")
 
-            out.write("\n------ string table types proto -----\n${DebugJvmProtoBuf.StringTableTypes.parseDelimitedFrom(input)}")
-
-            if (!classHeader.metadataVersion.isCompatible()) {
-                error("Incompatible class ($classHeader): $classFile")
-            }
-
-            when (classHeader.kind) {
-                KotlinClassHeader.Kind.FILE_FACADE ->
-                    out.write("\n------ file facade proto -----\n${DebugProtoBuf.Package.parseFrom(input, getExtensionRegistry())}")
-                KotlinClassHeader.Kind.CLASS ->
-                    out.write("\n------ class proto -----\n${DebugProtoBuf.Class.parseFrom(input, getExtensionRegistry())}")
-                KotlinClassHeader.Kind.MULTIFILE_CLASS_PART ->
-                    out.write("\n------ multi-file part proto -----\n${DebugProtoBuf.Package.parseFrom(input, getExtensionRegistry())}")
-                else -> throw IllegalStateException()
+                when (classHeader.kind) {
+                    KotlinClassHeader.Kind.FILE_FACADE ->
+                        out.write("\n------ file facade proto -----\n${DebugProtoBuf.Package.parseFrom(input, getExtensionRegistry())}")
+                    KotlinClassHeader.Kind.CLASS ->
+                        out.write("\n------ class proto -----\n${DebugProtoBuf.Class.parseFrom(input, getExtensionRegistry())}")
+                    KotlinClassHeader.Kind.MULTIFILE_CLASS_PART ->
+                        out.write("\n------ multi-file part proto -----\n${DebugProtoBuf.Package.parseFrom(input, getExtensionRegistry())}")
+                    else -> error(classHeader.kind)
+                }
             }
         }
+        KotlinClassHeader.Kind.MULTIFILE_CLASS -> {
+            out.write("\n------ multi-file facade data -----\n")
+            out.write(classHeader.data!!.joinToString("\n"))
+        }
+        KotlinClassHeader.Kind.SYNTHETIC_CLASS -> {
+            // Synthetic class has no metadata, thus there can be no differences in it.
+        }
+        KotlinClassHeader.Kind.UNKNOWN -> error("Should not meet unknown classes here: $classFile")
     }
 
     return out.toString()

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

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

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

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

build.gradle.kts

@@ -7,7 +7,7 @@ import proguard.gradle.ProGuardTask
 buildscript {
     val cacheRedirectorEnabled = findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() == true
 
-    kotlinBootstrapFrom(BootstrapOption.BintrayBootstrap(kotlinBuildProperties.kotlinBootstrapVersion!!, cacheRedirectorEnabled))
+    kotlinBootstrapFrom(BootstrapOption.SpaceBootstrap(kotlinBuildProperties.kotlinBootstrapVersion!!, cacheRedirectorEnabled))
 
     repositories {
         bootstrapKotlinRepo?.let(::maven)
@@ -27,9 +27,11 @@ buildscript {
     dependencies {
         bootstrapCompilerClasspath(kotlin("compiler-embeddable", bootstrapKotlinVersion))
 
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.19")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.21")
         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")
     }
 }
 
@@ -50,7 +52,6 @@ pill {
     excludedDirs(
         "out",
         "buildSrc/build",
-        "buildSrc/prepare-deps/android-dx/build",
         "buildSrc/prepare-deps/intellij-sdk/build"
     )
 }
@@ -72,7 +73,7 @@ val kotlinVersion by extra(
         } ?: buildNumber
 )
 
-val kotlinLanguageVersion by extra("1.4")
+val kotlinLanguageVersion by extra("1.5")
 
 allprojects {
     group = "org.jetbrains.kotlin"
@@ -129,6 +130,7 @@ 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) {
@@ -164,20 +166,18 @@ extra["versions.jansi"] = "1.16"
 extra["versions.jline"] = "3.3.1"
 extra["versions.junit"] = "4.12"
 extra["versions.javaslang"] = "2.0.6"
-extra["versions.ant"] = "1.8.2"
+extra["versions.ant"] = "1.10.7"
 extra["versions.android"] = "2.3.1"
-val coroutinesVersion = if (Platform[192].orHigher()) "1.3.7" else "1.1.1"
-extra["versions.kotlinx-coroutines-core"] = coroutinesVersion
-extra["versions.kotlinx-coroutines-jdk8"] = coroutinesVersion
+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.ant-launcher"] = "1.8.0"
 extra["versions.robolectric"] = "4.0"
 extra["versions.org.springframework"] = "4.2.0.RELEASE"
 extra["versions.jflex"] = "1.7.0"
 extra["versions.markdown"] = "0.1.25"
 extra["versions.trove4j"] = "1.0.20181211"
-extra["versions.completion-ranking-kotlin"] = "0.1.2"
+extra["versions.completion-ranking-kotlin"] = "0.1.3"
 extra["versions.r8"] = "2.0.88"
 val immutablesVersion = "0.3.1"
 extra["versions.kotlinx-collections-immutable"] = immutablesVersion
@@ -187,13 +187,14 @@ extra["versions.kotlinx-collections-immutable-jvm"] = immutablesVersion
 extra["versions.ktor-network"] = "1.0.1"
 
 if (!project.hasProperty("versions.kotlin-native")) {
-    extra["versions.kotlin-native"] = "1.4.20-dev-16314"
+    extra["versions.kotlin-native"] = "1.5-dev-17775"
 }
 
 val intellijUltimateEnabled by extra(project.kotlinBuildProperties.intellijUltimateEnabled)
 val effectSystemEnabled by extra(project.getBooleanProperty("kotlin.compiler.effectSystemEnabled") ?: false)
 val newInferenceEnabled by extra(project.getBooleanProperty("kotlin.compiler.newInferenceEnabled") ?: false)
-val useJvmIrBackend by extra(project.getBooleanProperty("kotlin.build.useIR") ?: false)
+val useJvmIrBackend by extra(project.kotlinBuildProperties.useIR)
+val useJvmFir by extra(project.kotlinBuildProperties.useFir)
 
 val intellijSeparateSdks = project.getBooleanProperty("intellijSeparateSdks") ?: false
 
@@ -229,6 +230,7 @@ extra["compilerModules"] = arrayOf(
     ":compiler:frontend",
     ":compiler:frontend.common",
     ":compiler:frontend.java",
+    ":compiler:frontend:cfg",
     ":compiler:cli-common",
     ":compiler:ir.tree",
     ":compiler:ir.tree.impl",
@@ -271,6 +273,7 @@ extra["compilerModules"] = arrayOf(
     ":core:deserialization.common.jvm",
     ":core:compiler.common",
     ":core:compiler.common.jvm",
+    ":compiler:backend.common.jvm",
     ":core:descriptors",
     ":core:descriptors.jvm",
     ":core:descriptors.runtime",
@@ -290,7 +293,9 @@ extra["compilerModules"] = arrayOf(
     ":compiler:fir:jvm",
     ":compiler:fir:checkers",
     ":compiler:fir:entrypoint",
-    ":compiler:fir:analysis-tests"
+    ":compiler:fir:analysis-tests",
+    ":compiler:fir:analysis-tests:legacy-fir-tests",
+    ":wasm:wasm.ir"
 )
 
 extra["compilerModulesForJps"] = listOf(
@@ -316,12 +321,24 @@ extra["compilerModulesForJps"] = listOf(
     ":compiler:compiler.version"
 )
 
+// TODO: fix remaining warnings and remove this property.
+extra["tasksWithWarnings"] = listOf(
+    ":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
+
 val coreLibProjects = listOfNotNull(
     ":kotlin-stdlib",
     ":kotlin-stdlib-common",
     ":kotlin-stdlib-js",
     ":kotlin-stdlib-jdk7",
     ":kotlin-stdlib-jdk8",
+    ":kotlin-test",
     ":kotlin-test:kotlin-test-annotations-common",
     ":kotlin-test:kotlin-test-common",
     ":kotlin-test:kotlin-test-jvm",
@@ -329,8 +346,7 @@ val coreLibProjects = listOfNotNull(
     ":kotlin-test:kotlin-test-junit5",
     ":kotlin-test:kotlin-test-testng",
     ":kotlin-test:kotlin-test-js".takeIf { !kotlinBuildProperties.isInJpsBuildIdeaSync },
-    ":kotlin-reflect",
-    ":kotlin-coroutines-experimental-compat"
+    ":kotlin-reflect"
 )
 
 val gradlePluginProjects = listOf(
@@ -339,7 +355,8 @@ val gradlePluginProjects = listOf(
     ":kotlin-allopen",
     ":kotlin-annotation-processing-gradle",
     ":kotlin-noarg",
-    ":kotlin-sam-with-receiver"
+    ":kotlin-sam-with-receiver",
+    ":kotlin-parcelize-compiler"
 )
 
 apply {
@@ -403,8 +420,7 @@ allprojects {
         jcenter()
         maven(protobufRepo)
         maven(intellijRepo)
-        maven("https://dl.bintray.com/kotlin/ktor")
-        maven("https://kotlin.bintray.com/kotlin-dependencies")
+        maven("https://maven.pkg.jetbrains.space/kotlin/p/kotlin/kotlin-dependencies")
         maven("https://jetbrains.bintray.com/intellij-third-party-dependencies")
         maven("https://dl.google.com/dl/android/maven2")
         bootstrapKotlinRepo?.let(::maven)
@@ -441,6 +457,26 @@ allprojects {
             if (useJvmIrBackend) {
                 useIR = true
             }
+
+            if (useJvmFir) {
+                freeCompilerArgs += "-Xuse-fir"
+                freeCompilerArgs += "-Xabi-stability=stable"
+            }
+        }
+    }
+
+    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
+                    }
+                }
+            }
         }
     }
 
@@ -462,17 +498,7 @@ allprojects {
     }
 
     tasks.withType<Test> {
-        outputs.doNotCacheIf("https://youtrack.jetbrains.com/issue/KT-37089") { true }
-    }
-
-    tasks.withType<SourceTask>().configureEach {
-        doFirst {
-            source.visit {
-                if (file.isDirectory && file.listFiles()?.isEmpty() == true) {
-                    logger.warn("Empty source directories may cause build cache misses: " + file.absolutePath)
-                }
-            }
-        }
+        outputs.doNotCacheIf("https://youtrack.jetbrains.com/issue/KTI-112") { true }
     }
 
     normalization {
@@ -534,16 +560,33 @@ allprojects {
     }
 }
 
+gradle.buildFinished {
+    val taskGraph = gradle?.taskGraph
+    if (taskGraph != null) {
+        taskGraph.allTasks
+                .filterIsInstance<SourceTask>()
+                .filter { it.didWork }
+                .forEach {
+                    it.source.visit {
+                        if (file.isDirectory && file.listFiles()?.isEmpty() == true) {
+                            logger.warn("Empty source directories may cause build cache misses: " + file.absolutePath)
+                        }
+                    }
+                }
+    }
+}
+
 gradle.taskGraph.whenReady {
     fun Boolean.toOnOff(): String = if (this) "on" else "off"
     val profile = if (isTeamcityBuild) "CI" else "Local"
 
     val proguardMessage = "proguard is ${kotlinBuildProperties.proguard.toOnOff()}"
     val jarCompressionMessage = "jar compression is ${kotlinBuildProperties.jarCompression.toOnOff()}"
-                val profileMessage = "$profile build profile is active ($proguardMessage, $jarCompressionMessage). " +
-            "Use -Pteamcity=<true|false> to reproduce CI/local build"
 
-    logger.warn("\n\n$profileMessage")
+    logger.warn(
+        "$profile build profile is active ($proguardMessage, $jarCompressionMessage). " +
+                "Use -Pteamcity=<true|false> to reproduce CI/local build"
+    )
 
     allTasks.filterIsInstance<org.gradle.jvm.tasks.Jar>().forEach { task ->
         task.entryCompression = if (kotlinBuildProperties.jarCompression)
@@ -558,7 +601,7 @@ val dist = tasks.register("dist") {
 }
 
 val syncMutedTests = tasks.register("syncMutedTests") {
-    dependsOn(":compiler:tests-mutes:run")
+    dependsOn(":compiler:tests-mutes:tc-integration:run")
 }
 
 val copyCompilerToIdeaPlugin by task<Copy> {
@@ -588,7 +631,10 @@ tasks {
 
     listOf("clean", "assemble", "install").forEach { taskName ->
         register("coreLibs${taskName.capitalize()}") {
-            coreLibProjects.forEach { projectName -> dependsOn("$projectName:$taskName") }
+            for (projectName in coreLibProjects) {
+                if (projectName.startsWith(":kotlin-test:") && taskName == "install") continue
+                dependsOn("$projectName:$taskName")
+            }
         }
     }
 
@@ -619,6 +665,7 @@ tasks {
         dependsOn("dist")
         dependsOn(
             ":compiler:test",
+            ":compiler:tests-common-new:test",
             ":compiler:container:test",
             ":compiler:tests-java8:test",
             ":compiler:tests-spec:test",
@@ -640,8 +687,11 @@ tasks {
     }
 
     register("wasmCompilerTest") {
-//  TODO: fix once
-//        dependsOn(":js:js.tests:wasmTest")
+        dependsOn(":js:js.tests:wasmTest")
+        // Windows WABT release requires Visual C++ Redistributable
+        if (!kotlinBuildProperties.isTeamcityBuild || !org.gradle.internal.os.OperatingSystem.current().isWindows) {
+            dependsOn(":wasm:wasm.ir:test")
+        }
     }
 
     register("nativeCompilerTest") {
@@ -652,6 +702,7 @@ tasks {
         dependsOn(":compiler:fir:raw-fir:psi2fir:test")
         dependsOn(":compiler:fir:raw-fir:light-tree2fir:test")
         dependsOn(":compiler:fir:analysis-tests:test")
+        dependsOn(":compiler:fir:analysis-tests:legacy-fir-tests:test")
         dependsOn(":compiler:fir:fir2ir:test")
     }
 
@@ -661,6 +712,7 @@ tasks {
             ":compiler:fir:raw-fir:psi2fir:test",
             ":compiler:fir:raw-fir:light-tree2fir:test",
             ":compiler:fir:analysis-tests:test",
+            ":compiler:fir:analysis-tests:legacy-fir-tests:test",
             ":compiler:fir:fir2ir:test",
             ":plugins:fir:fir-plugin-prototype:test"
         )
@@ -696,7 +748,6 @@ tasks {
     }
 
     register("miscCompilerTest") {
-        dependsOn("wasmCompilerTest")
         dependsOn("nativeCompilerTest")
         dependsOn("firCompilerTest")
 
@@ -704,14 +755,18 @@ tasks {
         dependsOn("scriptingTest")
         dependsOn(":kotlin-build-common:test")
         dependsOn(":compiler:incremental-compilation-impl:test")
+        dependsOn(":compiler:incremental-compilation-impl:testJvmICWithJdk11")
         dependsOn(":core:descriptors.runtime:test")
 
         dependsOn("jvmCompilerIntegrationTest")
+
+        dependsOn(":plugins:parcelize:parcelize-compiler:test")
     }
 
     register("toolsTest") {
         dependsOn(":tools:kotlinp:test")
         dependsOn(":native:kotlin-klib-commonizer:test")
+        dependsOn(":native:kotlin-klib-commonizer-api:test")
     }
 
     register("examplesTest") {
@@ -758,7 +813,6 @@ tasks {
 
     if (Ide.IJ()) {
         register("idea-new-project-wizard-tests") {
-            dependsOn("dist")
             dependsOn(
                 ":libraries:tools:new-project-wizard:test",
                 ":libraries:tools:new-project-wizard:new-project-wizard-cli:test",
@@ -768,18 +822,38 @@ tasks {
     }
 
     register("idea-plugin-performance-tests") {
-        dependsOn("dist")
         dependsOn(
-            ":idea:performanceTests:performanceTest"
+            "dist",
+            ":idea:performanceTests:performanceTest",
+            ":idea:performanceTests:aggregateResults"
         )
     }
 
+    register("idea-fir-plugin-performance-tests") {
+        dependsOn("dist")
+        dependsOn(
+            ":idea:idea-fir-performance-tests:ideaFirPerformanceTest"
+        )
+    }
+
+    register("idea-fir-plugin-tests") {
+        dependsOn("dist")
+        dependsOn(
+            ":idea:idea-fir:test",
+            ":idea:idea-frontend-api:test",
+            ":idea:idea-frontend-fir:test",
+            ":idea:idea-frontend-fir:idea-fir-low-level-api:test"
+        )
+    }
+
+
     register("android-ide-tests") {
         dependsOn("dist")
         dependsOn(
             ":plugins:android-extensions-ide:test",
             ":idea:idea-android:test",
-            ":kotlin-annotation-processing:test"
+            ":kotlin-annotation-processing:test",
+            ":plugins:parcelize:parcelize-ide:test"
         )
     }
 
@@ -811,12 +885,24 @@ tasks {
             ":generators:test"
         )
         if (Ide.IJ()) {
-            dependsOn("idea-new-project-wizard-tests")
+            dependsOn(
+                ":libraries:tools:new-project-wizard:test",
+                ":libraries:tools:new-project-wizard:new-project-wizard-cli:test",
+                ":idea:idea-new-project-wizard:test" // Temporary here. Remove after enabling builds for ideaIntegrationsTests
+            )
+        }
+    }
+
+    register("ideaIntegrationsTests") {
+        if (Ide.IJ()) {
+            dependsOn(":idea:idea-new-project-wizard:test")
         }
     }
 
     register("kaptIdeTest") {
         dependsOn(":kotlin-annotation-processing:test")
+        dependsOn(":kotlin-annotation-processing-base:test")
+        dependsOn(":kotlin-annotation-processing-cli:test")
     }
 
     register("gradleIdeTest") {
@@ -831,10 +917,11 @@ tasks {
             ":idea:idea-gradle:test",
             ":idea:test",
             ":compiler:test",
+            ":compiler:container:test",
             ":js:js.tests:test"
         )
-        if (Ide.IJ193.orHigher())
-            dependsOn(":kotlin-gradle-plugin-integration-tests:test")
+
+        dependsOn(":kotlin-gradle-plugin-integration-tests:test")
         if (Ide.AS40.orHigher())
             dependsOn(":kotlin-ultimate:ide:android-studio-native:test")
 
@@ -859,21 +946,26 @@ tasks {
         }
     }
 
+    register("publishGradlePluginArtifacts") {
+        idePluginDependency {
+            dependsOnKotlinGradlePluginPublish()
+        }
+    }
+
     register("publishIdeArtifacts") {
         idePluginDependency {
             dependsOn(
                 ":prepare:ide-plugin-dependencies:android-extensions-compiler-plugin-for-ide:publish",
                 ":prepare:ide-plugin-dependencies:allopen-compiler-plugin-for-ide:publish",
-                ":prepare:ide-plugin-dependencies:allopen-compiler-plugin-tests-for-ide:publish",
                 ":prepare:ide-plugin-dependencies:incremental-compilation-impl-tests-for-ide:publish",
                 ":prepare:ide-plugin-dependencies:kotlin-build-common-tests-for-ide:publish",
                 ":prepare:ide-plugin-dependencies:kotlin-compiler-for-ide:publish",
-                ":prepare:ide-plugin-dependencies:kotlin-dist-for-ide:publish",
                 ":prepare:ide-plugin-dependencies:kotlin-gradle-statistics-for-ide:publish",
                 ":prepare:ide-plugin-dependencies:kotlinx-serialization-compiler-plugin-for-ide:publish",
                 ":prepare:ide-plugin-dependencies:noarg-compiler-plugin-for-ide:publish",
                 ":prepare:ide-plugin-dependencies:sam-with-receiver-compiler-plugin-for-ide:publish",
                 ":prepare:ide-plugin-dependencies:compiler-components-for-jps:publish",
+                ":prepare:ide-plugin-dependencies:parcelize-compiler-plugin-for-ide:publish",
                 ":kotlin-script-runtime:publish",
                 ":kotlin-script-util:publish",
                 ":kotlin-scripting-common:publish",
@@ -886,9 +978,7 @@ tasks {
                 ":kotlin-stdlib-jdk7:publish",
                 ":kotlin-stdlib-jdk8:publish",
                 ":kotlin-reflect:publish",
-                ":kotlin-main-kts:publish",
-                ":kotlin-stdlib-js:publish",
-                ":kotlin-test:kotlin-test-js:publish"
+                ":kotlin-main-kts:publish"
             )
         }
     }
@@ -955,7 +1045,7 @@ val zipPlugin by task<Zip> {
     setExecutablePermissions()
 
     doLast {
-        logger.lifecycle("Plugin artifacts packed to $archiveFile")
+        logger.lifecycle("Plugin artifacts packed to ${archiveFile.get()}")
     }
 }
 

buildSrc/build.gradle.kts

@@ -1,3 +1,5 @@
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
 extra["versions.native-platform"] = "0.14"
 
 buildscript {
@@ -5,15 +7,15 @@ buildscript {
     val cacheRedirectorEnabled = findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() == true
 
     extra["defaultSnapshotVersion"] = kotlinBuildProperties.defaultSnapshotVersion
-    kotlinBootstrapFrom(BootstrapOption.BintrayBootstrap(kotlinBuildProperties.kotlinBootstrapVersion!!, cacheRedirectorEnabled))
+    kotlinBootstrapFrom(BootstrapOption.SpaceBootstrap(kotlinBuildProperties.kotlinBootstrapVersion!!, cacheRedirectorEnabled))
 
     repositories {
         if (cacheRedirectorEnabled) {
             maven("https://cache-redirector.jetbrains.com/jcenter.bintray.com")
-            maven("https://cache-redirector.jetbrains.com/kotlin.bintray.com/kotlin-dependencies")
+            maven("https://cache-redirector.jetbrains.com/maven.pkg.jetbrains.space/kotlin/p/kotlin/kotlin-dependencies")
         } else {
             jcenter()
-            maven("https://kotlin.bintray.com/kotlin-dependencies")
+            maven("https://maven.pkg.jetbrains.space/kotlin/p/kotlin/kotlin-dependencies")
         }
 
         project.bootstrapKotlinRepo?.let {
@@ -22,7 +24,7 @@ buildscript {
     }
 
     dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.19")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.21")
         classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${project.bootstrapKotlinVersion}")
         classpath("org.jetbrains.kotlin:kotlin-sam-with-receiver:${project.bootstrapKotlinVersion}")
     }
@@ -79,14 +81,12 @@ extra["intellijReleaseType"] = when {
     else -> "releases"
 }
 
-extra["versions.androidDxSources"] = "5.0.0_r2"
-
 extra["customDepsOrg"] = "kotlin.build"
 
 repositories {
     jcenter()
     maven("https://jetbrains.bintray.com/intellij-third-party-dependencies/")
-    maven("https://kotlin.bintray.com/kotlin-dependencies")
+    maven("https://maven.pkg.jetbrains.space/kotlin/p/kotlin/kotlin-dependencies")
     gradlePluginPortal()
 
     extra["bootstrapKotlinRepo"]?.let {
@@ -97,8 +97,8 @@ repositories {
 dependencies {
     implementation(kotlin("stdlib", embeddedKotlinVersion))
     implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:${project.bootstrapKotlinVersion}")
-    implementation("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.19")
-    implementation("com.gradle.publish:plugin-publish-plugin:0.11.0")
+    implementation("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.21")
+    implementation("com.gradle.publish:plugin-publish-plugin:0.12.0")
 
     implementation("net.rubygrapefruit:native-platform:${property("versions.native-platform")}")
     implementation("net.rubygrapefruit:native-platform-windows-amd64:${property("versions.native-platform")}")
@@ -112,6 +112,7 @@ dependencies {
     implementation("gradle.plugin.org.jetbrains.gradle.plugin.idea-ext:gradle-idea-ext:0.5")
 
     implementation("org.gradle:test-retry-gradle-plugin:1.1.9")
+    implementation("com.gradle.enterprise:test-distribution-gradle-plugin:1.2.1")
 }
 
 samWithReceiver {
@@ -126,6 +127,12 @@ java {
     targetCompatibility = JavaVersion.VERSION_1_8
 }
 
+tasks.withType<KotlinCompile>().configureEach {
+    kotlinOptions.freeCompilerArgs += listOf(
+        "-Xopt-in=kotlin.RequiresOptIn", "-Xskip-runtime-version-check", "-Xsuppress-version-warnings"
+    )
+}
+
 tasks["build"].dependsOn(":prepare-deps:build")
 
 allprojects {

buildSrc/prepare-deps/build.gradle.kts

@@ -255,9 +255,8 @@ fun buildIvyRepositoryTask(
         inputs.files(configuration)
 
         outputs.upToDateWhen {
-            configuration.resolvedConfiguration.resolvedArtifacts.single()
-                .moduleDirectory()
-                .exists()
+            val repoMarker = configuration.resolvedConfiguration.resolvedArtifacts.single().moduleDirectory().resolve(".marker")
+            repoMarker.exists()
         }
 
         doFirst {
@@ -266,8 +265,9 @@ fun buildIvyRepositoryTask(
 
             artifact.storeDirectory().cleanStore()
 
-            if (moduleDirectory.exists()) {
-                logger.info("Path ${moduleDirectory.absolutePath} already exists, skipping unpacking.")
+            val repoMarker = File(moduleDirectory, ".marker")
+            if (repoMarker.exists()) {
+                logger.info("Path ${repoMarker.absolutePath} already exists, skipping unpacking.")
                 return@doFirst
             }
 
@@ -326,6 +326,8 @@ fun buildIvyRepositoryTask(
                             )
                         }
                 }
+
+                repoMarker.createNewFile()
             }
         }
     }

buildSrc/settings.gradle

@@ -14,13 +14,13 @@ pluginManagement {
 buildscript {
     repositories {
         if (cacheRedirectorEnabled == 'true') {
-            maven { url "https://cache-redirector.jetbrains.com/kotlin.bintray.com/kotlin-dependencies" }
+            maven { url "https://cache-redirector.jetbrains.com/maven.pkg.jetbrains.space/kotlin/p/kotlin/kotlin-dependencies" }
         } else {
-            maven { url "https://kotlin.bintray.com/kotlin-dependencies" }
+            maven { url "https://maven.pkg.jetbrains.space/kotlin/p/kotlin/kotlin-dependencies" }
         }
     }
     dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.19")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.21")
     }
 }
 
@@ -46,12 +46,12 @@ if (target_AppCode_Clion) {
 } else if (target_AndroidStudio) {
     logger.info("Including modules for AS (mobile plugin) in buildSrc/settings.gradle")
 
-    include ":prepare-deps:cocoa-common-binaries"
+    include ":prepare-deps:appcode-binaries"
     include ":prepare-deps:lldb-framework"
     include ":prepare-deps:lldb-frontend"
 
-    project(":prepare-deps:cocoa-common-binaries").projectDir =
-            file("${buildProperties.propertiesProvider.rootProjectDir}/kotlin-ultimate/buildSrc/prepare-deps/cocoa-common-binaries")
+    project(":prepare-deps:appcode-binaries").projectDir =
+            file("${buildProperties.propertiesProvider.rootProjectDir}/kotlin-ultimate/buildSrc/prepare-deps/appcode-binaries")
     project(":prepare-deps:lldb-framework").projectDir =
             file("${buildProperties.propertiesProvider.rootProjectDir}/kotlin-ultimate/buildSrc/prepare-deps/lldb-framework")
     project(":prepare-deps:lldb-frontend").projectDir =
@@ -69,4 +69,4 @@ if (target_AppCode_Clion) {
 
 } else {
     logger.info("Not including extra modules in buildSrc/settings.gradle")
-}
+}

buildSrc/src/main/kotlin/BuildPropertiesExt.kt

@@ -18,3 +18,5 @@ val KotlinBuildProperties.proguard: Boolean get() = postProcessing && getBoolean
 val KotlinBuildProperties.jarCompression: Boolean get() = getBoolean("kotlin.build.jar.compression", isTeamcityBuild)
 
 val KotlinBuildProperties.ignoreTestFailures: Boolean get() = getBoolean("ignoreTestFailures", isTeamcityBuild)
+
+val KotlinBuildProperties.disableWerror: Boolean get() = getBoolean("kotlin.build.disable.werror", false)

buildSrc/src/main/kotlin/CommonUtil.kt

@@ -54,11 +54,12 @@ var Project.javaHome: String?
         extra["javaHome"] = v
     }
 
-fun Project.generator(fqName: String, sourceSet: SourceSet? = null) = smartJavaExec {
+fun Project.generator(fqName: String, sourceSet: SourceSet? = null, configure: JavaExec.() -> Unit = {}) = smartJavaExec {
     classpath = (sourceSet ?: testSourceSet).runtimeClasspath
     mainClass.set(fqName)
     workingDir = rootDir
     systemProperty("line.separator", "\n")
+    configure()
 }
 
 fun Project.getBooleanProperty(name: String): Boolean? = this.findProperty(name)?.let {

buildSrc/src/main/kotlin/IdeCompatibilityDsl.kt

@@ -54,7 +54,7 @@ enum class Ide(val platform: Platform) : CompatibilityPredicate {
     AS36(Platform.P192),
     AS40(Platform.P193),
     AS41(Platform.P201),
-    AS42(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/artifacts.kt

@@ -71,18 +71,6 @@ fun Project.noDefaultJar() {
     }
 }
 
-fun <T : Task> Project.runtimeJarArtifactBy(
-    task: TaskProvider<T>,
-    artifactRef: Any,
-    body: ConfigurablePublishArtifact.() -> Unit = {}
-) {
-    addArtifact("archives", task, artifactRef, body)
-    addArtifact("runtimeJar", task, artifactRef, body)
-    configurations.findByName("runtime")?.let {
-        addArtifact(it.name, task, artifactRef, body)
-    }
-}
-
 fun Project.runtimeJar(body: Jar.() -> Unit = {}): TaskProvider<Jar> = runtimeJar(getOrCreateTask("jar", body)) { }
 
 fun <T : Jar> Project.runtimeJar(task: TaskProvider<T>, body: T.() -> Unit = {}): TaskProvider<T> {
@@ -103,7 +91,11 @@ fun <T : Jar> Project.runtimeJar(task: TaskProvider<T>, body: T.() -> Unit = {})
         body()
     }
 
-    project.runtimeJarArtifactBy(task, task)
+    project.addArtifact("archives", task, task)
+    project.addArtifact("runtimeJar", task, task)
+    project.configurations.findByName("runtime")?.let {
+        project.addArtifact(it.name, task, task)
+    }
 
     val runtimeJar = configurations.maybeCreate("runtimeJar").apply {
         isCanBeConsumed = true

buildSrc/src/main/kotlin/dependencies.kt

@@ -9,10 +9,13 @@
 
 import org.gradle.api.GradleException
 import org.gradle.api.Project
+import org.gradle.api.artifacts.Dependency
+import org.gradle.api.artifacts.ExternalModuleDependency
 import org.gradle.api.artifacts.ProjectDependency
 import org.gradle.api.artifacts.dsl.DependencyHandler
 import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.FileCollection
+import org.gradle.kotlin.dsl.accessors.runtime.addDependencyTo
 import org.gradle.kotlin.dsl.extra
 import org.gradle.kotlin.dsl.project
 import java.io.File
@@ -112,6 +115,50 @@ 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")
 
+fun Project.testApiJUnit5(
+    vintageEngine: Boolean = false,
+    runner: Boolean = false,
+    suiteApi: Boolean = false
+) {
+    with(dependencies) {
+        val platformVersion = commonVer("org.junit", "junit-bom")
+        testApi(platform("org.junit:junit-bom:$platformVersion"))
+        testApi("org.junit.jupiter:junit-jupiter")
+        if (vintageEngine) {
+            testApi("org.junit.vintage:junit-vintage-engine:$platformVersion")
+        }
+        val componentsVersion = commonVer("org.junit.platform", "")
+
+        val components = mutableListOf(
+            "org.junit.platform:junit-platform-commons",
+            "org.junit.platform:junit-platform-launcher"
+        )
+        if (runner) {
+            components += "org.junit.platform:junit-platform-runner"
+        }
+        if (suiteApi) {
+            components += "org.junit.platform:junit-platform-suite-api"
+        }
+
+        for (component in components) {
+            testApi("$component:$componentsVersion")
+        }
+
+        addDependencyTo<ExternalModuleDependency>(this, "testImplementation", intellijDep()) {
+            // This dependency is needed only for FileComparisonFailure
+            includeJars("idea_rt", rootProject = rootProject)
+            isTransitive = false
+        }
+
+        // This is needed only for using FileComparisonFailure, which relies on JUnit 3 classes
+        add("testRuntimeOnly", commonDep("junit:junit"))
+    }
+}
+
+private fun DependencyHandler.testApi(dependencyNotation: Any) {
+    add("testApi", dependencyNotation)
+}
+
 val Project.protobufVersion: String get() = findProperty("versions.protobuf") as String
 
 val Project.protobufRepo: String

buildSrc/src/main/kotlin/embeddable.kt

@@ -5,10 +5,13 @@ import org.gradle.api.Project
 import org.gradle.api.file.DuplicatesStrategy
 import org.gradle.api.tasks.TaskProvider
 import org.gradle.jvm.tasks.Jar
-import org.gradle.kotlin.dsl.*
+import org.gradle.kotlin.dsl.named
+import org.gradle.kotlin.dsl.project
+import org.gradle.kotlin.dsl.provideDelegate
+import org.gradle.kotlin.dsl.register
 import java.io.File
 
-val kotlinEmbeddableRootPackage = "org.jetbrains.kotlin"
+const val kotlinEmbeddableRootPackage = "org.jetbrains.kotlin"
 
 val packagesToRelocate =
     listOf(
@@ -31,21 +34,23 @@ val packagesToRelocate =
 // But due to the shadow plugin bug (https://github.com/johnrengelman/shadow/issues/262) it is not possible to use
 // packagesToRelocate list to for the include list. Therefore the exclude list has to be created.
 val packagesToExcludeFromDummy =
-        listOf("org/jetbrains/kotlin/**",
-               "org/intellij/lang/annotations/**",
-               "org/jetbrains/jps/**",
-               "META-INF/**",
-               "com/sun/jna/**",
-               "com/thoughtworks/xstream/**",
-               "javaslang/**",
-               "*.proto",
-               "messages/**",
-               "net/sf/cglib/**",
-               "one/util/streamex/**",
-               "org/iq80/snappy/**",
-               "org/jline/**",
-               "org/xmlpull/**",
-               "*.txt")
+    listOf(
+        "org/jetbrains/kotlin/**",
+        "org/intellij/lang/annotations/**",
+        "org/jetbrains/jps/**",
+        "META-INF/**",
+        "com/sun/jna/**",
+        "com/thoughtworks/xstream/**",
+        "javaslang/**",
+        "*.proto",
+        "messages/**",
+        "net/sf/cglib/**",
+        "one/util/streamex/**",
+        "org/iq80/snappy/**",
+        "org/jline/**",
+        "org/xmlpull/**",
+        "*.txt"
+    )
 
 private fun ShadowJar.configureEmbeddableCompilerRelocation(withJavaxInject: Boolean = true) {
     relocate("com.google.protobuf", "org.jetbrains.kotlin.protobuf")
@@ -67,8 +72,8 @@ private fun Project.compilerShadowJar(taskName: String, body: ShadowJar.() -> Un
     dependencies.add(compilerJar.name, dependencies.project(":kotlin-compiler", configuration = "runtimeJar"))
 
     return tasks.register<ShadowJar>(taskName) {
-        destinationDir = File(buildDir, "libs")
-        setDuplicatesStrategy(DuplicatesStrategy.EXCLUDE)
+        destinationDirectory.set(project.file(File(buildDir, "libs")))
+        duplicatesStrategy = DuplicatesStrategy.EXCLUDE
         from(compilerJar)
         body()
     }
@@ -107,8 +112,8 @@ fun Project.embeddableCompilerDummyForDependenciesRewriting(
     )
 
     return tasks.register<ShadowJar>(taskName) {
-        destinationDir = File(buildDir, "libs")
-        setDuplicatesStrategy(DuplicatesStrategy.EXCLUDE)
+        destinationDirectory.set(project.file(File(buildDir, "libs")))
+        duplicatesStrategy = DuplicatesStrategy.EXCLUDE
         from(compilerDummyJar)
         configureEmbeddableCompilerRelocation(withJavaxInject = false)
         body()
@@ -119,7 +124,7 @@ fun Project.rewriteDepsToShadedJar(
     originalJarTask: TaskProvider<out Jar>, shadowJarTask: TaskProvider<out Jar>, body: Jar.() -> Unit = {}
 ): TaskProvider<out Jar> {
     originalJarTask.configure {
-        classifier = "original"
+        archiveClassifier.set("original")
     }
 
     val compilerDummyJarFile by lazy { configurations.getAt("compilerDummyJar").singleFile }
@@ -132,7 +137,7 @@ fun Project.rewriteDepsToShadedJar(
         // which leads to the content of that JAR being excluded as well:
         exclude { it.file == compilerDummyJarFile }
 
-        classifier = ""
+        archiveClassifier.set("original")
         body()
     }
     return shadowJarTask

buildSrc/src/main/kotlin/jdksFinder.kt

@@ -10,12 +10,12 @@ 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);
+    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"))
+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)
 
@@ -101,8 +101,12 @@ fun MutableCollection<JdkId>.discoverJdks(project: Project) {
     }
 }
 
-private val macOsJavaHomeOutRegexes = listOf(Regex("""\s+(\S+),\s+(\S+):\s+".*?"\s+(.+)"""),
-                                             Regex("""\s+(\S+)\s+\((.*?)\):\s+(.+)"""))
+private val macOsJavaHomeOutRegexes =
+    listOf(
+        Regex("""\s+(\S+),\s+(\S+):\s+".*?"\s+(.+)"""),
+        Regex("""\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)

buildSrc/src/main/kotlin/localDependencies.kt

@@ -76,8 +76,6 @@ fun Project.jpsStandalone() = "kotlin.build:jps-standalone:${rootProject.extra["
 
 fun Project.nodeJSPlugin() = "kotlin.build:NodeJS:${rootProject.extra["versions.idea.NodeJS"]}"
 
-fun Project.androidDxJar() = "org.jetbrains.kotlin:android-dx:${rootProject.extra["versions.androidBuildTools"]}"
-
 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"]}"
@@ -132,12 +130,10 @@ object IntellijRootUtils {
     }
 }
 
-fun ModuleDependency.includeIntellijCoreJarDependencies(project: Project) =
-    includeJars(*(project.rootProject.extra["IntellijCoreDependencies"] as List<String>).toTypedArray(), rootProject = project.rootProject)
-
-fun ModuleDependency.includeIntellijCoreJarDependencies(project: Project, jarsFilterPredicate: (String) -> Boolean) =
+@Suppress("UNCHECKED_CAST")
+fun ModuleDependency.includeIntellijCoreJarDependencies(project: Project, jarsFilterPredicate: (String) -> Boolean = { true }): Unit =
     includeJars(
-        *(project.rootProject.extra["IntellijCoreDependencies"] as List<String>).filter { jarsFilterPredicate(it) }.toTypedArray(),
+        *(project.rootProject.extra["IntellijCoreDependencies"] as List<String>).filter(jarsFilterPredicate).toTypedArray(),
         rootProject = project.rootProject
     )
 

buildSrc/src/main/kotlin/pluginMarkers.kt

@@ -18,8 +18,12 @@ import java.util.*
 
 internal const val PLUGIN_MARKER_SUFFIX = ".gradle.plugin"
 
-@UseExperimental(ExperimentalStdlibApi::class)
+@OptIn(ExperimentalStdlibApi::class)
 fun Project.publishPluginMarkers(withEmptyJars: Boolean = true) {
+
+    fun Project.isSonatypePublish(): Boolean =
+        hasProperty("isSonatypePublish") && property("isSonatypePublish") as Boolean
+
     val pluginDevelopment = extensions.getByType<PluginBundleExtension>()
     val publishingExtension = extensions.getByType<PublishingExtension>()
     val mainPublication = publishingExtension.publications[KotlinBuildPublishingPlugin.PUBLICATION_NAME] as MavenPublication
@@ -32,7 +36,12 @@ fun Project.publishPluginMarkers(withEmptyJars: Boolean = true) {
 
         tasks.named<PublishToMavenRepository>(
             "publish${markerPublication.name.capitalize(Locale.ROOT)}PublicationTo${KotlinBuildPublishingPlugin.REPOSITORY_NAME}Repository"
-        ).configureRepository()
+        ).apply {
+            configureRepository()
+            configure {
+                onlyIf { !isSonatypePublish() }
+            }
+        }
     }
 }
 

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

@@ -41,7 +41,7 @@ open class DexMethodCount : DefaultTask() {
         dependsOn(jar)
     }
 
-    @Internal // plain output properties are not supported, mark as internal to suppress warning from validateTaskProperties
+    @Internal // plain output properties are not supported, mark as internal to suppress warning from validatePlugins
     lateinit var counts: Counts
 
     @get:OutputFile

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * 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.
  */
 
@@ -8,7 +8,6 @@ package plugins
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.attributes.Usage
-import org.gradle.api.component.AdhocComponentWithVariants
 import org.gradle.api.component.SoftwareComponentFactory
 import org.gradle.api.plugins.JavaBasePlugin
 import org.gradle.api.publish.PublishingExtension
@@ -17,13 +16,12 @@ import org.gradle.api.publish.maven.plugins.MavenPublishPlugin
 import org.gradle.api.publish.maven.tasks.PublishToMavenRepository
 import org.gradle.api.tasks.TaskProvider
 import org.gradle.kotlin.dsl.*
+import org.gradle.plugins.signing.Sign
 import org.gradle.plugins.signing.SigningExtension
 import org.gradle.plugins.signing.SigningPlugin
-import java.net.URI
 import java.util.*
 import javax.inject.Inject
 
-
 class KotlinBuildPublishingPlugin @Inject constructor(
     private val componentFactory: SoftwareComponentFactory
 ) : Plugin<Project> {
@@ -47,7 +45,7 @@ class KotlinBuildPublishingPlugin @Inject constructor(
             }
         }
 
-        val kotlinLibraryComponent = componentFactory.adhoc(ADHOC_COMPONENT_NAME) as AdhocComponentWithVariants
+        val kotlinLibraryComponent = componentFactory.adhoc(ADHOC_COMPONENT_NAME)
         components.add(kotlinLibraryComponent)
         kotlinLibraryComponent.addVariantsFromConfiguration(publishedCompile) { mapToMavenScope("compile") }
         kotlinLibraryComponent.addVariantsFromConfiguration(publishedRuntime) { mapToMavenScope("runtime") }
@@ -73,56 +71,11 @@ class KotlinBuildPublishingPlugin @Inject constructor(
                 create<MavenPublication>(PUBLICATION_NAME) {
                     from(kotlinLibraryComponent)
 
-                    pom {
-                        packaging = "jar"
-                        name.set(humanReadableName(project))
-                        description.set(project.description ?: humanReadableName(project))
-                        url.set("https://kotlinlang.org/")
-                        licenses {
-                            license {
-                                name.set("The Apache License, Version 2.0")
-                                url.set("http://www.apache.org/licenses/LICENSE-2.0.txt")
-                            }
-                        }
-                        scm {
-                            url.set("https://github.com/JetBrains/kotlin")
-                            connection.set("scm:git:https://github.com/JetBrains/kotlin.git")
-                            developerConnection.set("scm:git:https://github.com/JetBrains/kotlin.git")
-                        }
-                        developers {
-                            developer {
-                                name.set("Kotlin Team")
-                                organization.set("JetBrains")
-                                organizationUrl.set("https://www.jetbrains.com")
-                            }
-                        }
-                    }
-                }
-            }
-
-            repositories {
-                maven {
-                    name = REPOSITORY_NAME
-                    url = file("${project.rootDir}/build/repo").toURI()
+                    configureKotlinPomAttributes(project)
                 }
             }
         }
-
-        configure<SigningExtension> {
-            setRequired(provider {
-                project.findProperty("signingRequired")?.toString()?.toBoolean()
-                    ?: project.property("isSonatypeRelease") as Boolean
-            })
-
-            sign(extensions.getByType<PublishingExtension>().publications[PUBLICATION_NAME])
-        }
-
-        tasks.register("install") {
-            dependsOn(tasks.named("publishToMavenLocal"))
-        }
-
-        tasks.named<PublishToMavenRepository>("publish${PUBLICATION_NAME}PublicationTo${REPOSITORY_NAME}Repository")
-            .configureRepository()
+        configureDefaultPublishing()
     }
 
     companion object {
@@ -133,13 +86,84 @@ class KotlinBuildPublishingPlugin @Inject constructor(
         const val COMPILE_CONFIGURATION = "publishedCompile"
         const val RUNTIME_CONFIGURATION = "publishedRuntime"
 
-        @UseExperimental(ExperimentalStdlibApi::class)
-        fun humanReadableName(project: Project) =
-            project.name.split("-").joinToString(separator = " ") { it.capitalize(Locale.ROOT) }
     }
 }
 
-fun TaskProvider<PublishToMavenRepository>.configureRepository() = configure {
+@OptIn(ExperimentalStdlibApi::class)
+private fun humanReadableName(name: String) =
+    name.split("-").joinToString(separator = " ") { it.capitalize(Locale.ROOT) }
+
+fun MavenPublication.configureKotlinPomAttributes(project: Project, explicitDescription: String? = null) {
+    val publication = this
+    pom {
+        packaging = "jar"
+        name.set(humanReadableName(publication.artifactId))
+        description.set(explicitDescription ?: project.description ?: humanReadableName(publication.artifactId))
+        url.set("https://kotlinlang.org/")
+        licenses {
+            license {
+                name.set("The Apache License, Version 2.0")
+                url.set("http://www.apache.org/licenses/LICENSE-2.0.txt")
+            }
+        }
+        scm {
+            url.set("https://github.com/JetBrains/kotlin")
+            connection.set("scm:git:https://github.com/JetBrains/kotlin.git")
+            developerConnection.set("scm:git:https://github.com/JetBrains/kotlin.git")
+        }
+        developers {
+            developer {
+                name.set("Kotlin Team")
+                organization.set("JetBrains")
+                organizationUrl.set("https://www.jetbrains.com")
+            }
+        }
+    }
+}
+
+
+fun Project.configureDefaultPublishing() {
+    configure<PublishingExtension> {
+        repositories {
+            maven {
+                name = KotlinBuildPublishingPlugin.REPOSITORY_NAME
+                url = file("${project.rootDir}/build/repo").toURI()
+            }
+        }
+    }
+
+    configureSigning()
+
+    tasks.register("install") {
+        dependsOn(tasks.named("publishToMavenLocal"))
+    }
+
+    tasks.withType<PublishToMavenRepository>()
+        .matching { it.name.endsWith("PublicationTo${KotlinBuildPublishingPlugin.REPOSITORY_NAME}Repository") }
+        .all { configureRepository() }
+}
+
+private fun Project.configureSigning() {
+    val signingRequired = provider {
+        project.findProperty("signingRequired")?.toString()?.toBoolean()
+            ?: project.property("isSonatypeRelease") as Boolean
+    }
+
+    configure<SigningExtension> {
+        setRequired(signingRequired)
+        sign(extensions.getByType<PublishingExtension>().publications) // all publications
+        useGpgCmd()
+    }
+
+    tasks.withType<Sign>().configureEach {
+        setOnlyIf { signingRequired.get() }
+    }
+}
+
+fun TaskProvider<PublishToMavenRepository>.configureRepository() =
+    configure { configureRepository() }
+
+private fun PublishToMavenRepository.configureRepository() {
     dependsOn(project.rootProject.tasks.named("preparePublication"))
     doFirst {
         val preparePublication = project.rootProject.tasks.named("preparePublication").get()
@@ -157,4 +181,4 @@ fun TaskProvider<PublishToMavenRepository>.configureRepository() = configure {
             }
         }
     }
-}
+}

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

@@ -1,3 +1,4 @@
+@file:Suppress("DEPRECATION")
 package plugins
 
 import org.codehaus.groovy.runtime.InvokerHelper
@@ -16,10 +17,8 @@ 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> {
 

buildSrc/src/main/kotlin/sourceSets.kt

@@ -30,6 +30,7 @@ val SourceSet.projectDefault: Project.() -> Unit
             }
             "test" -> {
                 java.srcDirs("test", "tests")
+                this@projectDefault.resources.srcDir("testResources")
             }
         }
     }

buildSrc/src/main/kotlin/tasks.kt

@@ -1,17 +1,6 @@
 /*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * 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.
  */
 
 
@@ -31,50 +20,65 @@ import java.lang.Character.isUpperCase
 import java.nio.file.Files
 import java.nio.file.Path
 
-fun Task.dependsOnKotlinPluginInstall() {
-    dependsOn(
-        ":kotlin-allopen:install",
-        ":kotlin-noarg:install",
-        ":kotlin-sam-with-receiver:install",
-        ":kotlin-android-extensions:install",
-        ":kotlin-build-common:install",
-        ":kotlin-compiler-embeddable:install",
-        ":native:kotlin-native-utils:install",
-        ":kotlin-util-klib:install",
-        ":kotlin-util-io:install",
-        ":kotlin-compiler-runner:install",
-        ":kotlin-daemon-embeddable:install",
-        ":kotlin-daemon-client:install",
-        ":kotlin-gradle-plugin-api:install",
-        ":kotlin-gradle-plugin:install",
-        ":kotlin-gradle-plugin-model:install",
-        ":kotlin-reflect:install",
-        ":kotlin-annotation-processing-gradle:install",
-        ":kotlin-test:kotlin-test-common:install",
-        ":kotlin-test:kotlin-test-annotations-common:install",
-        ":kotlin-test:kotlin-test-jvm:install",
-        ":kotlin-test:kotlin-test-js:install",
-        ":kotlin-test:kotlin-test-junit:install",
-        ":kotlin-gradle-subplugin-example:install",
-        ":kotlin-stdlib-common:install",
-        ":kotlin-stdlib:install",
-        ":kotlin-stdlib-jdk8:install",
-        ":kotlin-stdlib-js:install",
-        ":examples:annotation-processor-example:install",
-        ":kotlin-script-runtime:install",
-        ":kotlin-scripting-common:install",
-        ":kotlin-scripting-jvm:install",
-        ":kotlin-scripting-compiler-embeddable:install",
-        ":kotlin-scripting-compiler-impl-embeddable:install",
-        ":kotlin-test-js-runner:install",
-        ":native:kotlin-klib-commonizer-embeddable:install"
-    )
+val kotlinGradlePluginAndItsRequired = arrayOf(
+    ":kotlin-allopen",
+    ":kotlin-noarg",
+    ":kotlin-sam-with-receiver",
+    ":kotlin-android-extensions",
+    ":kotlin-parcelize-compiler",
+    ":kotlin-build-common",
+    ":kotlin-compiler-embeddable",
+    ":native:kotlin-native-utils",
+    ":kotlin-util-klib",
+    ":kotlin-util-io",
+    ":kotlin-compiler-runner",
+    ":kotlin-daemon-embeddable",
+    ":kotlin-daemon-client",
+    ":kotlin-gradle-plugin-api",
+    ":kotlin-gradle-plugin",
+    ":kotlin-gradle-plugin-model",
+    ":kotlin-reflect",
+    ":kotlin-annotation-processing-gradle",
+    ":kotlin-test",
+    ":kotlin-gradle-subplugin-example",
+    ":kotlin-stdlib-common",
+    ":kotlin-stdlib",
+    ":kotlin-stdlib-jdk8",
+    ":kotlin-stdlib-js",
+    ":examples:annotation-processor-example",
+    ":kotlin-script-runtime",
+    ":kotlin-scripting-common",
+    ":kotlin-scripting-jvm",
+    ":kotlin-scripting-compiler-embeddable",
+    ":kotlin-scripting-compiler-impl-embeddable",
+    ":kotlin-test-js-runner",
+    ":native:kotlin-klib-commonizer-embeddable",
+    ":native:kotlin-klib-commonizer-api"
+)
+
+fun Task.dependsOnKotlinGradlePluginInstall() {
+    kotlinGradlePluginAndItsRequired.forEach {
+        dependsOn("${it}:install")
+    }
 }
 
+fun Task.dependsOnKotlinGradlePluginPublish() {
+    kotlinGradlePluginAndItsRequired.forEach {
+        project.rootProject.tasks.findByPath("${it}:publish")?.let { task ->
+            dependsOn(task)
+        }
+    }
+}
+
+/**
+ * @param parallel is redundant if @param jUnit5Enabled is true, because
+ *   JUnit5 supports parallel test execution by itself, without gradle help
+ */
 fun Project.projectTest(
     taskName: String = "test",
     parallel: Boolean = false,
     shortenTempRootName: Boolean = false,
+    jUnit5Enabled: Boolean = false,
     body: Test.() -> Unit = {}
 ): TaskProvider<Test> = getOrCreateTask(taskName) {
     doFirst {
@@ -108,12 +112,29 @@ fun Project.projectTest(
                 }
             }
 
-            include {
-                val path = it.path
-                if (it.isDirectory) {
+            val parentNames = if (jUnit5Enabled) {
+                /*
+                 * If we run test from inner test class with junit 5 we need
+                 *   to include all containing classes of our class
+                 */
+                val nestedNames = classFileNameWithoutExtension.split("$")
+                mutableListOf(nestedNames.first()).also {
+                    for (s in nestedNames.subList(1, nestedNames.size)) {
+                        it += "${it.last()}\$$s"
+                    }
+                }
+            } else emptyList()
+
+            include { treeElement ->
+                val path = treeElement.path
+                if (treeElement.isDirectory) {
                     classFileNameWithoutExtension.startsWith(path)
                 } else {
-                    path == classFileName || (path.endsWith(".class") && path.startsWith("$classFileNameWithoutExtension$"))
+                    if (jUnit5Enabled) {
+                        path == classFileName || (path.endsWith(".class") && parentNames.any { path.startsWith(it) })
+                    } else {
+                        path == classFileName || (path.endsWith(".class") && path.startsWith("$classFileNameWithoutExtension$"))
+                    }
                 }
             }
         }
@@ -153,7 +174,7 @@ fun Project.projectTest(
 
     var subProjectTempRoot: Path? = null
     doFirst {
-        val teamcity = rootProject.findProperty("teamcity") as? Map<Any?, *>
+        val teamcity = rootProject.findProperty("teamcity") as? Map<*, *>
         val systemTempRoot =
             // TC by default doesn't switch `teamcity.build.tempDir` to 'java.io.tmpdir' so it could cause to wasted disk space
             // Should be fixed soon on Teamcity side
@@ -176,10 +197,10 @@ fun Project.projectTest(
         }
     }
 
-    if (parallel) {
+    if (parallel && !jUnit5Enabled) {
         maxParallelForks =
             project.findProperty("kotlin.test.maxParallelForks")?.toString()?.toInt()
-                ?: Math.max(Runtime.getRuntime().availableProcessors() / if (kotlinBuildProperties.isTeamcityBuild) 2 else 4, 1)
+                ?: (Runtime.getRuntime().availableProcessors() / if (kotlinBuildProperties.isTeamcityBuild) 2 else 4).coerceAtLeast(1)
     }
     body()
 }

buildSrc/src/main/kotlin/testDistribution.kt

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+import com.gradle.enterprise.gradleplugin.testdistribution.TestDistributionExtension
+import org.gradle.api.tasks.testing.Test
+import org.gradle.internal.os.OperatingSystem
+
+
+fun Test.configureTestDistribution(configure: TestDistributionExtension.() -> Unit = {}) {
+    val isTeamcityBuild = project.kotlinBuildProperties.isTeamcityBuild
+    val testDistributionEnabled = project.findProperty("kotlin.build.test.distribution.enabled")?.toString()?.toBoolean()
+        ?: isTeamcityBuild
+
+    useJUnitPlatform()
+    extensions.configure(TestDistributionExtension::class.java) {
+        enabled.set(testDistributionEnabled)
+        maxRemoteExecutors.set(20)
+        if (isTeamcityBuild) {
+            requirements.set(setOf("os=${OperatingSystem.current().familyName}"))
+        } else {
+            maxLocalExecutors.set(0)
+        }
+        configure()
+    }
+}
+
+fun Test.isTestDistributionEnabled(): Boolean =
+    extensions.findByType(TestDistributionExtension::class.java)?.enabled?.orNull ?: false

compiler/android-tests/android-module/build.gradle

@@ -1,14 +1,11 @@
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
-ext {
-    isD8Enabled = project.findProperty('android.enableD8').toBoolean()
-}
 buildscript {
     repositories {
         google()
         jcenter()
     }
     dependencies {        
-        classpath 'com.android.tools.build:gradle:3.5.3'
+        classpath 'com.android.tools.build:gradle:4.1.2'
     }
 }
 apply plugin: 'com.android.application'
@@ -20,7 +17,7 @@ repositories {
 
 android {
     compileSdkVersion 26
-    buildToolsVersion "28.0.3"
+    buildToolsVersion "29.0.3"
 
     defaultConfig {
         applicationId "org.jetbrains.kotlin.android.tests"
@@ -40,14 +37,6 @@ android {
 
     packagingOptions { exclude 'META-INF/build.txt' }
 
-    //TODO run under java 6, cause there is error on implicit 'stream' import in 'asWithMutable' test
-    lintOptions {
-        abortOnError false
-    }
-
-    compileOptions {
-        incremental = false
-    }
 
     dexOptions {
         dexInProcess false
@@ -60,11 +49,9 @@ android {
         resultsDir = "build/test/results"
     }
 
-    if (isD8Enabled) {
-        compileOptions {
-            sourceCompatibility = 1.8
-            targetCompatibility = 1.8
-        }
+    compileOptions {
+        sourceCompatibility = 1.8
+        targetCompatibility = 1.8
     }
 
     flavorDimensions "box"
@@ -86,15 +73,20 @@ android {
             dimension "box"
         }
 
+        common_ir0 {
+            dimension "box"
+        }
 
-        if (isD8Enabled) {
-            jvm80 {
-                dimension "box"
-            }
+        common_ir1 {
+            dimension "box"
+        }
 
-            reflectjvm80 {
-                dimension "box"
-            }
+        common_ir2 {
+            dimension "box"
+        }
+
+        reflect_ir0 {
+            dimension "box"
         }
     }
 

compiler/android-tests/android-module/gradle.properties

@@ -1,3 +1,2 @@
 #don't try to download android specific tools within gradle: licence acceptance will be required
-android.builder.sdkDownload=false
-android.enableD8=true
+android.builder.sdkDownload=false

compiler/android-tests/build.gradle.kts

@@ -6,25 +6,27 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:util"))
-    compile(project(":compiler:cli"))
-    compile(project(":compiler:frontend"))
-    compile(project(":compiler:backend"))
-    compile(kotlinStdlib())
-    compile(project(":kotlin-reflect"))
-    compile(projectTests(":compiler:tests-common"))
-    compile(commonDep("junit:junit"))
-
-    Platform[193].orLower {
-        compileOnly(intellijDep()) { includeJars("openapi") }
-    }
-
-    testCompile(project(":compiler:incremental-compilation-impl"))
     testCompile(project(":core:descriptors"))
     testCompile(project(":core:descriptors.jvm"))
+    testCompile(project(":compiler:util"))
+    testCompile(project(":compiler:cli"))
+    testCompile(project(":compiler:frontend"))
+    testCompile(project(":compiler:backend"))
+    testCompile(project(":compiler:incremental-compilation-impl"))
     testCompile(project(":compiler:frontend.java"))
+
+    testCompile(kotlinStdlib())
+    testCompile(project(":kotlin-reflect"))
+    testCompile(projectTests(":compiler:tests-common"))
+    testCompile(commonDep("junit:junit"))
+    testApi(projectTests(":compiler:test-infrastructure"))
+    testApi(projectTests(":compiler:test-infrastructure-utils"))
+    testApi(projectTests(":compiler:tests-compiler-utils"))
+    testApi(projectTests(":compiler:tests-common-new"))
+
     testCompile(projectTests(":jps-plugin"))
     testCompile(commonDep("junit:junit"))
+
     Platform[193].orLower {
         testCompile(intellijDep()) { includeJars("openapi", rootProject = rootProject) }
     }
@@ -36,15 +38,15 @@ dependencies {
     Platform[201].orLower {
         testCompile(intellijDep()) { includeJars("groovy-all", rootProject = rootProject) }
     }
-    Platform[192].orHigher {
-        testCompile(intellijPluginDep("java")) { includeJars("jps-builders") }
-    }
+    testCompile(intellijPluginDep("java")) { includeJars("jps-builders") }
     testCompile(jpsStandalone()) { includeJars("jps-model") }
     testCompile(jpsBuildTest())
+
+    testCompile("org.junit.platform:junit-platform-launcher:${commonVer("org.junit.platform", "")}")
 }
 
 sourceSets {
-    "main" { projectDefault() }
+    "main" { }
     "test" { projectDefault() }
 }
 

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

@@ -1,62 +0,0 @@
-/*
- * Copyright 2010-2015 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.android.tests;
-
-import org.jetbrains.kotlin.jps.build.BaseKotlinJpsBuildTestCase;
-import org.junit.Ignore;
-
-import java.io.File;
-import java.io.IOException;
-
-@Ignore
-public class AndroidJpsBuildTestCase extends BaseKotlinJpsBuildTestCase {
-    private static final String PROJECT_NAME = "android-module";
-    private static final String SDK_NAME = "Android_SDK";
-
-    private final File workDir = new File(AndroidRunner.getPathManager().getTmpFolder());
-
-    public void doTest() {
-        initProject();
-        rebuildAllModules();
-        buildAllModules().assertSuccessful();
-    }
-
-    @Override
-    protected String getProjectName() {
-        return "android-module";
-    }
-
-    @Override
-    protected void runTest() {
-        doTest();
-    }
-
-    @Override
-    public String getName() {
-        return "AndroidJpsTest";
-    }
-
-    @Override
-    protected File doGetProjectDir() throws IOException {
-        return workDir;
-    }
-
-    private void initProject() {
-        addJdk(SDK_NAME, AndroidRunner.getPathManager().getPlatformFolderInAndroidSdk() + "/android.jar");
-        loadProject(workDir.getAbsolutePath() + File.separator + PROJECT_NAME + ".ipr");
-    }
-}

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

@@ -25,7 +25,7 @@ import org.junit.runners.AllTests;
 
 import java.io.File;
 
-//@RunWith(AllTests.class)
+@RunWith(AllTests.class)
 public class AndroidRunner {
 
     private static PathManager pathManager;
@@ -46,12 +46,8 @@ public class AndroidRunner {
 
         CodegenTestsOnAndroidGenerator.generate(pathManager);
 
-        System.out.println("Run tests on android...");
-        TestSuite suite = CodegenTestsOnAndroidRunner.runTestsInEmulator(pathManager);
-        //AndroidJpsBuildTestCase indirectly depends on UsefulTestCase which compiled against java 8
-        //TODO: Need add separate run configuration for AndroidJpsBuildTestCase
-        //suite.addTest(new AndroidJpsBuildTestCase());
-        return suite;
+        System.out.println("Run tests on Android...");
+        return CodegenTestsOnAndroidRunner.runTestsInEmulator(pathManager);
     }
 
     public void tearDown() throws Exception {

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

@@ -20,7 +20,9 @@ import com.intellij.openapi.util.Ref
 import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.test.KotlinBaseTest
+import org.jetbrains.kotlin.test.model.TestModule
+import org.jetbrains.kotlin.test.services.TestServices
+import org.jetbrains.kotlin.test.services.sourceFileProvider
 import java.io.File
 import java.util.regex.Pattern
 
@@ -34,28 +36,24 @@ private data class OldPackageAndNew(val oldFqName: FqName, val newFqName: FqName
 
 internal fun patchFilesAndAddTest(
     testFile: File,
-    testFiles: List<KotlinBaseTest.TestFile>,
+    module: TestModule,
+    services: TestServices,
     filesHolder: CodegenTestsOnAndroidGenerator.FilesWriter
-): FqName? {
-    if (testFiles.any { it.name.endsWith(".java") }) {
-        //TODO support java files
-        return null
-    }
-    val ktFiles = testFiles.filter { it.name.endsWith(".kt") }
-    if (ktFiles.isEmpty()) return null
-
+): FqName {
     val newPackagePrefix = testFile.path.replace("\\\\|-|\\.|/".toRegex(), "_")
     val oldPackage = Ref<FqName>()
     val isJvmName = Ref<Boolean>(false)
+    val testFiles = module.files
     val isSingle = testFiles.size == 1
     val resultFiles = testFiles.map {
         val fileName = if (isSingle) it.name else testFile.name.substringBeforeLast(".kt") + "/" + it.name
+        val content = services.sourceFileProvider.getContentOfSourceFile(it)
         TestClassInfo(
             fileName,
-            changePackage(newPackagePrefix, it.content, oldPackage, isJvmName),
+            changePackage(newPackagePrefix, content, oldPackage, isJvmName),
             oldPackage.get(),
             isJvmName.get(),
-            getGeneratedClassName(File(fileName), it.content, newPackagePrefix, oldPackage.get())
+            getGeneratedClassName(File(fileName), content, newPackagePrefix, oldPackage.get())
         )
     }
     val packages =

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

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.android.tests
 
-import com.intellij.openapi.Disposable
 import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.util.SystemInfo
 import com.intellij.openapi.util.io.FileUtil
@@ -13,20 +12,34 @@ import com.intellij.openapi.util.io.FileUtilRt
 import org.jetbrains.kotlin.cli.common.output.writeAllTo
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.codegen.CodegenTestCase
 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.*
 import org.jetbrains.kotlin.idea.KotlinFileType
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.psi.KtFile
 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.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
+import org.jetbrains.kotlin.test.services.sourceProviders.CoroutineHelpersSourceFilesProvider
+import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.junit.Assert
 import java.io.File
 import java.io.FileWriter
 import java.io.IOException
+import kotlin.io.path.ExperimentalPathApi
+import kotlin.io.path.Path
+import kotlin.io.path.createTempDirectory
 import kotlin.test.assertTrue
 
 data class ConfigurationKey(val kind: ConfigurationKind, val jdkKind: TestJdkKind, val configuration: String)
@@ -41,17 +54,18 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
     //keep it globally to avoid test grouping on TC
     private val generatedTestNames = hashSetOf<String>()
 
-    private val COMMON = FlavorConfig("common", 3);
-    private val REFLECT = FlavorConfig("reflect", 1);
-    private val JVM8 = FlavorConfig("jvm8", 1);
-    private val JVM8REFLECT = FlavorConfig("reflectjvm8", 1);
+    private val COMMON = FlavorConfig(TargetBackend.ANDROID,"common", 3)
+    private val REFLECT = FlavorConfig(TargetBackend.ANDROID, "reflect", 1)
 
-    class FlavorConfig(private val prefix: String, val limit: Int) {
+    private val COMMON_IR = FlavorConfig(TargetBackend.ANDROID_IR, "common_ir", 3)
+    private val REFLECT_IR = FlavorConfig(TargetBackend.ANDROID_IR,"reflect_ir", 1)
+
+    class FlavorConfig(private val backend: TargetBackend, private val prefix: String, val limit: Int) {
 
         private var writtenFilesCount = 0
 
         fun printStatistics() {
-            println("FlavorTestCompiler: $prefix, generated file count: $writtenFilesCount")
+            println("FlavorTestCompiler for $backend: $prefix, generated file count: $writtenFilesCount")
         }
 
         fun getFlavorForNewFiles(newFilesCount: Int): String {
@@ -97,7 +111,7 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
                 it.setExecutable(true)
             }
         }
-        File("./gradlew.bat").copyTo(File(projectRoot, "gradlew.bat"));
+        File("./gradlew.bat").copyTo(File(projectRoot, "gradlew.bat"))
         val file = File(target, "gradle-wrapper.properties")
         file.readLines().map {
             when {
@@ -134,27 +148,47 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
     private fun generateTestsAndFlavourSuites() {
         println("Generating test files...")
 
-        generateTestMethodsForDirectories(File("compiler/testData/codegen/box"), File("compiler/testData/codegen/boxInline"))
+        val folders = arrayOf(
+            File("compiler/testData/codegen/box"),
+            File("compiler/testData/codegen/boxInline")
+        )
+
+        generateTestMethodsForDirectories(
+            TargetBackend.ANDROID,
+            COMMON,
+            REFLECT,
+            *folders
+        )
+
+        generateTestMethodsForDirectories(
+            TargetBackend.ANDROID_IR,
+            COMMON_IR,
+            REFLECT_IR,
+            *folders
+        )
 
         pendingUnitTestGenerators.values.forEach { it.generate() }
     }
 
-    private fun generateTestMethodsForDirectories(vararg dirs: File) {
+    private fun generateTestMethodsForDirectories(
+        backend: TargetBackend,
+        commonFlavor: FlavorConfig,
+        reflectionFlavor: FlavorConfig,
+        vararg dirs: File
+    ) {
         val holders = mutableMapOf<ConfigurationKey, FilesWriter>()
 
         for (dir in dirs) {
             val files = dir.listFiles() ?: error("Folder with testData is empty: ${dir.absolutePath}")
-            processFiles(files, holders)
+            processFiles(files, holders, backend, commonFlavor, reflectionFlavor)
         }
 
         holders.values.forEach {
             it.writeFilesOnDisk()
         }
 
-        COMMON.printStatistics()
-        REFLECT.printStatistics()
-        JVM8.printStatistics()
-        JVM8REFLECT.printStatistics()
+        commonFlavor.printStatistics()
+        reflectionFlavor.printStatistics()
     }
 
     internal inner class FilesWriter(
@@ -238,10 +272,14 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
         }
     }
 
+    @OptIn(TestInfrastructureInternals::class)
     @Throws(IOException::class)
     private fun processFiles(
         files: Array<File>,
-        holders: MutableMap<ConfigurationKey, FilesWriter>
+        holders: MutableMap<ConfigurationKey, FilesWriter>,
+        backend: TargetBackend,
+        commmonFlavor: FlavorConfig,
+        reflectionFlavor: FlavorConfig
     ) {
         holders.values.forEach {
             it.writeFilesOnDiskIfNeeded()
@@ -251,7 +289,7 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
             if (file.isDirectory) {
                 val listFiles = file.listFiles()
                 if (listFiles != null) {
-                    processFiles(listFiles, holders)
+                    processFiles(listFiles, holders, backend, commmonFlavor, reflectionFlavor)
                 }
             } else if (FileUtilRt.getExtension(file.name) != KotlinFileType.EXTENSION) {
                 // skip non kotlin files
@@ -260,14 +298,13 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
                     continue
                 }
 
-                if (!InTextDirectivesUtils.isPassingTarget(TargetBackend.JVM, file) ||
+                if (!InTextDirectivesUtils.isPassingTarget(backend.compatibleWith, file) ||
                     InTextDirectivesUtils.isIgnoredTarget(TargetBackend.ANDROID, file)
                 ) {
                     continue
                 }
 
-                val fullFileText =
-                    FileUtil.loadFile(file, true).replace("COROUTINES_PACKAGE", "kotlin.coroutines")
+                val fullFileText = FileUtil.loadFile(file, true)
 
                 if (fullFileText.contains("// WITH_COROUTINES")) {
                     if (fullFileText.contains("kotlin.coroutines.experimental")) continue
@@ -277,48 +314,106 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
                 //TODO support JvmPackageName
                 if (fullFileText.contains("@file:JvmPackageName(")) continue
                 // TODO: Support jvm assertions
-                if (fullFileText.contains("// KOTLIN_CONFIGURATION_FLAGS: ASSERTIONS_MODE=jvm")) continue
+                if (fullFileText.contains("// ASSERTIONS_MODE: jvm")) continue
+                if (fullFileText.contains("// MODULE: ")) continue
                 val targets = InTextDirectivesUtils.findLinesWithPrefixesRemoved(fullFileText, "// JVM_TARGET:")
-                    .also { it.remove(JvmTarget.JVM_1_6.description) }
 
-                val isJvm8Target =
-                    if (targets.isEmpty()) false
-                    else if (targets.contains(JvmTarget.JVM_1_8.description) && targets.size == 1) true
-                    else continue //TODO: support other targets on Android
+                val isAtLeastJvm8Target = !targets.contains(JvmTarget.JVM_1_6.description)
+
+                if (isAtLeastJvm8Target && fullFileText.contains("@Target(AnnotationTarget.TYPE)")) {
+                    //TODO: type annotations supported on sdk 26 emulator
+                    continue
+                }
 
                 // TODO: support SKIP_JDK6 on new platforms
                 if (fullFileText.contains("// SKIP_JDK6")) continue
 
                 if (hasBoxMethod(fullFileText)) {
-                    val testFiles = createTestFiles(file, fullFileText)
-                    val kind = KotlinBaseTest.extractConfigurationKind(testFiles)
-                    val jdkKind = KotlinBaseTest.getTestJdkKind(testFiles)
+                    val testConfiguration = createTestConfiguration(file, backend)
+                    val services = testConfiguration.testServices
+
+                    val moduleStructure = try {
+                        testConfiguration.moduleStructureExtractor.splitTestDataByModules(
+                            file.path,
+                            testConfiguration.directives,
+                        ).also {
+                            services.register(TestModuleStructure::class, it)
+                        }
+                    } catch (e: ExceptionFromModuleStructureTransformer) {
+                        continue
+                    }
+                    val module = moduleStructure.modules.singleOrNull() ?: continue
+                    if (module.files.any { it.isJavaFile || it.isKtsFile }) continue
+                    if (module.files.isEmpty()) continue
+                    services.registerDependencyProvider(DependencyProviderImpl(services, moduleStructure.modules))
+
                     val keyConfiguration = CompilerConfiguration()
-                    KotlinBaseTest.updateConfigurationByDirectivesInTestFiles(testFiles, keyConfiguration)
+                    val configuratorForFlags = JvmEnvironmentConfigurator(services)
+                    with(configuratorForFlags) {
+                        val extractor = DirectiveToConfigurationKeyExtractor()
+                        extractor.provideConfigurationKeys()
+                        extractor.configure(keyConfiguration, module.directives)
+                    }
+                    val kind = configuratorForFlags.extractConfigurationKind(module.directives)
+                    val jdkKind = configuratorForFlags.extractJdkKind(module.directives)
+
+                    keyConfiguration.languageVersionSettings = module.languageVersionSettings
 
                     val key = ConfigurationKey(kind, jdkKind, keyConfiguration.toString())
-                    val compiler = if (isJvm8Target) {
-                        if (kind.withReflection) JVM8REFLECT else JVM8
-                    } else if (kind.withReflection) REFLECT else COMMON
+                    val compiler = if (kind.withReflection) reflectionFlavor else commmonFlavor
+                    val compilerConfigurationProvider = services.compilerConfigurationProvider as CompilerConfigurationProviderImpl
                     val filesHolder = holders.getOrPut(key) {
-                        FilesWriter(compiler, KotlinTestUtils.newConfiguration(kind, jdkKind, KotlinTestUtils.getAnnotationsJar()).apply {
+                        FilesWriter(compiler, compilerConfigurationProvider.createCompilerConfiguration(module)).also {
                             println("Creating new configuration by $key")
-                            KotlinBaseTest.updateConfigurationByDirectivesInTestFiles(testFiles, this)
-                        })
+                        }
                     }
 
-                    patchFilesAndAddTest(file, testFiles, filesHolder)
+                    patchFilesAndAddTest(file, module, services, filesHolder)
                 }
             }
         }
     }
 
-    private fun createTestFiles(file: File, expectedText: String): List<KotlinBaseTest.TestFile> =
-        CodegenTestCase.createTestFilesFromFile(file, expectedText, "kotlin.coroutines", false, TargetBackend.JVM)
+    private fun createTestConfiguration(testDataFile: File, backend: TargetBackend): TestConfiguration {
+        return TestConfigurationBuilder().apply {
+            configure(backend)
+            testInfo = KotlinTestInfo(
+                "org.jetbrains.kotlin.android.tests.AndroidRunner",
+                "test${testDataFile.nameWithoutExtension.capitalize()}",
+                emptySet()
+            )
+        }.build(testDataFile.path)
+    }
+
+    private fun TestConfigurationBuilder.configure(backend: TargetBackend) {
+        globalDefaults {
+            frontend = FrontendKinds.ClassicFrontend
+            targetBackend = backend
+            targetPlatform = JvmPlatforms.defaultJvmPlatform
+            dependencyKind = DependencyKind.Binary
+        }
+
+        useConfigurators(
+            ::CommonEnvironmentConfigurator,
+            ::JvmEnvironmentConfigurator
+        )
+
+        useAdditionalSourceProviders(
+            ::AdditionalDiagnosticsSourceFilesProvider,
+            ::CoroutineHelpersSourceFilesProvider,
+            ::CodegenHelpersSourceFilesProvider,
+        )
+
+        assertions = JUnit5Assertions
+        useAdditionalService<TemporaryDirectoryManager>(::TemporaryDirectoryManagerImpl)
+        useAdditionalService<BackendKindExtractor>(::BackendKindExtractorImpl)
+        useSourcePreprocessor(*AbstractKotlinCompilerTest.defaultPreprocessors.toTypedArray())
+        useDirectives(*AbstractKotlinCompilerTest.defaultDirectiveContainers.toTypedArray())
+    }
 
     companion object {
-        const val GRADLE_VERSION = "5.6.4" // update GRADLE_SHA_256 on change
-        const val GRADLE_SHA_256 = "1f3067073041bc44554d0efe5d402a33bc3d3c93cc39ab684f308586d732a80d"
+        const val GRADLE_VERSION = "6.8.1" // update GRADLE_SHA_256 on change
+        const val GRADLE_SHA_256 = "fd591a34af7385730970399f473afabdb8b28d57fd97d6625c388d090039d6fd"
         const val testClassPackage = "org.jetbrains.kotlin.android.tests"
         const val testClassName = "CodegenTestCaseOnAndroid"
         const val baseTestClassPackage = "org.jetbrains.kotlin.android.tests"
@@ -339,20 +434,21 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
 
         @Throws(IOException::class)
         internal fun writeAndroidSkdToLocalProperties(pathManager: PathManager) {
-            val sdkRoot = KotlinTestUtils.getAndroidSdkSystemIndependentPath()
+            val sdkRoot = KtTestUtil.getAndroidSdkSystemIndependentPath()
             println("Writing android sdk to local.properties: $sdkRoot")
             val file = File(pathManager.tmpFolder + "/local.properties")
             FileWriter(file).use { fw -> fw.write("sdk.dir=$sdkRoot") }
         }
 
+        @OptIn(ExperimentalPathApi::class)
         @JvmStatic
         fun main(args: Array<String>) {
-            val tmpFolder = createTempDir()
-            println("Created temporary folder for android tests: " + tmpFolder.absolutePath)
-            val rootFolder = File("")
-            val pathManager = PathManager(rootFolder.absolutePath, tmpFolder.absolutePath)
+            val tmpFolder = createTempDirectory().toAbsolutePath().toString()
+            println("Created temporary folder for android tests: $tmpFolder")
+            val rootFolder = Path("").toAbsolutePath().toString()
+            val pathManager = PathManager(rootFolder, tmpFolder)
             generate(pathManager, true)
-            println("Android test project is generated into " + tmpFolder.absolutePath + " folder")
+            println("Android test project is generated into $tmpFolder folder")
         }
     }
 }

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

@@ -55,16 +55,6 @@ class CodegenTestsOnAndroidRunner private constructor(private val pathManager: P
                 runTestsOnEmulator(gradleRunner, TestSuite("D8")).apply {
                     rootSuite.addTest(this)
                 }
-
-                renameFlavorFolder()
-                enableD8(false)
-                runTestsOnEmulator(gradleRunner, TestSuite("DX")).apply {
-                    (0 until this.countTestCases()).forEach {
-                        val testCase = testAt(it) as TestCase
-                        testCase.name += "_DX"
-                    }
-                    rootSuite.addTest(this)
-                }
             } catch (e: RuntimeException) {
                 e.printStackTrace()
                 throw e
@@ -81,25 +71,20 @@ class CodegenTestsOnAndroidRunner private constructor(private val pathManager: P
         return rootSuite
     }
 
-    private fun enableD8(enable: Boolean) {
-        val file = File(pathManager.androidTmpFolder, "gradle.properties")
-        val lines = file.readLines().map {
-            if (it.startsWith("android.enableD8=")) {
-                "android.enableD8=$enable"
-            } else it
-        }
-        file.writeText(lines.joinToString("\n"))
-    }
-
-    private fun processReport(suite: TestSuite, resultOutput: String) {
+    private fun processReport(rootSuite: TestSuite, resultOutput: String) {
         val reportFolder = File(flavorFolder())
         try {
             val folders = reportFolder.listFiles()
             assertTrue(folders != null && folders.isNotEmpty(), "No folders in ${reportFolder.path}")
+
             folders.forEach {
                 assertTrue("${it.path} is not directory") { it.isDirectory }
+                val isIr = it.name.contains("_ir")
                 val testCases = parseSingleReportInFolder(it)
-                testCases.forEach { aCase -> suite.addTest(aCase) }
+                testCases.forEach { aCase ->
+                    if (isIr) aCase.name += "_ir"
+                    rootSuite.addTest(aCase)
+                }
                 Assert.assertNotEquals("There is no test results in report", 0, testCases.size.toLong())
             }
         } catch (e: Throwable) {
@@ -107,10 +92,6 @@ class CodegenTestsOnAndroidRunner private constructor(private val pathManager: P
         }
     }
 
-    private fun renameFlavorFolder() {
-        val reportFolder = File(flavorFolder())
-        reportFolder.renameTo(File(reportFolder.parentFile, reportFolder.name + "_d8"))
-    }
 
     private fun flavorFolder() = pathManager.tmpFolder + "/build/test/results/connected/flavors"
 
@@ -139,7 +120,7 @@ class CodegenTestsOnAndroidRunner private constructor(private val pathManager: P
 
         private fun cleanAndBuildProject(gradleRunner: GradleRunner) {
             gradleRunner.clean()
-            gradleRunner.build()
+            gradleRunner.assembleAndroidTest()
         }
 
         @Throws(IOException::class, SAXException::class, ParserConfigurationException::class)
@@ -158,22 +139,14 @@ class CodegenTestsOnAndroidRunner private constructor(private val pathManager: P
 
             return (0 until testCases.length).map { i ->
                 val item = testCases.item(i) as Element
-                val failure = item.getElementsByTagName("failure")
+                val failure = item.getElementsByTagName("failure").takeIf { it.length != 0 }?.item(0)
                 val name = item.getAttribute("name")
-                val clazz = item.getAttribute("classname")
 
-                if (failure.length == 0) {
-                    object : TestCase(name) {
-                        @Throws(Throwable::class)
-                        override fun runTest() {
-
-                        }
-                    }
-                } else {
-                    object : TestCase(name) {
-                        @Throws(Throwable::class)
-                        override fun runTest() {
-                            Assert.fail(failure.item(0).textContent)
+                object : TestCase(name) {
+                    @Throws(Throwable::class)
+                    override fun runTest() {
+                        if (failure != null) {
+                            Assert.fail(failure.textContent)
                         }
                     }
                 }

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

@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.android.tests;
 
-import org.jetbrains.kotlin.test.KotlinTestUtils;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
 
 import java.io.File;
 
@@ -69,7 +69,7 @@ public class PathManager {
     }
 
     public String getAndroidSdkRoot() {
-        return KotlinTestUtils.getAndroidSdkSystemIndependentPath();
+        return KtTestUtil.getAndroidSdkSystemIndependentPath();
     }
 
     public String getAndroidModuleRoot() {

compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/emulator/Emulator.java

@@ -121,8 +121,11 @@ public class Emulator {
 
     public void startEmulator() {
         startServer();
-        System.out.println("Starting emulator...");
-        RunUtils.executeOnSeparateThread(new RunUtils.RunSettings(getStartCommand(), null, false, "START: ", true));
+        System.out.println("Starting emulator with ANDROID_HOME/ANDROID_SDK_ROOT: " + pathManager.getAndroidSdkRoot());
+        GeneralCommandLine startCommand = getStartCommand();
+        startCommand.withEnvironment("ANDROID_SDK_ROOT", pathManager.getAndroidSdkRoot());
+        startCommand.withEnvironment("ANDROID_HOME", pathManager.getAndroidSdkRoot());
+        RunUtils.executeOnSeparateThread(new RunUtils.RunSettings(startCommand, null, false, "START: ", true));
         printLog();
     }
 
@@ -144,6 +147,7 @@ public class Emulator {
         bootCheckCommand.addParameter("shell");
         bootCheckCommand.addParameter("getprop");
         bootCheckCommand.addParameter("sys.boot_completed");
+
         int counter = 0;
         RunResult execute = RunUtils.execute(bootCheckCommand);
         while (counter < 20) {

compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/gradle/GradleRunner.java

@@ -45,9 +45,9 @@ public class GradleRunner {
         OutputUtils.checkResult(result);
     }
 
-    public void build() {
+    public void assembleAndroidTest() {
         System.out.println("Building gradle project...");
-        GeneralCommandLine build = generateCommandLine("build");
+        GeneralCommandLine build = generateCommandLine("assembleAndroidTest");
         build.addParameter("--stacktrace");
         build.addParameter("--warn");
         RunResult result = RunUtils.execute(build);

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

@@ -0,0 +1,8 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.backend.common
+
+class BackendException(message: String, cause: Throwable?) : IllegalStateException(message, cause)

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

@@ -232,12 +232,13 @@ object CodegenUtil {
     }
 
     @JvmStatic
-    fun reportBackendException(exception: Throwable, phase: String, fileUrl: String?): Nothing {
+    fun reportBackendException(exception: Throwable, phase: String, location: String?, additionalMessage: String? = null): Nothing {
         // CompilationException (the only KotlinExceptionWithAttachments possible here) is already supposed
         // to have all information about the context.
         if (exception is KotlinExceptionWithAttachments) throw exception
-        throw IllegalStateException(
-            getExceptionMessage("Backend", "Exception during $phase", exception, fileUrl),
+        throw BackendException(
+            getExceptionMessage("Backend", "Exception during $phase", exception, location) +
+                    additionalMessage?.let { "\n" + it }.orEmpty(),
             exception
         )
     }

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

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

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

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

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

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

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

@@ -0,0 +1,13 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.codegen
+
+import org.jetbrains.org.objectweb.asm.Opcodes
+
+// This object should help compiling against different ASM versions in different bunch versions
+object VersionIndependentOpcodes {
+    const val ACC_RECORD = Opcodes.ACC_RECORD
+}

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

@@ -0,0 +1,13 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.codegen
+
+import org.jetbrains.org.objectweb.asm.Opcodes
+
+// This object should help compiling against different ASM versions from different bunch versions
+object VersionIndependentOpcodes {
+    const val ACC_RECORD = 0
+}