Add test for obsolete issue

The problem was fixed in d51bb2c053

 #KT-37692 Obsolete

.bunch

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

.gitattributes

@@ -1,4 +1,8 @@
 **/testData/** linguist-vendored
 *Generated.java linguist-generated=true
+* text=auto
+* eol=lf
+*.png binary
+*.jar binary
 compiler/cli/bin/* eol=lf
 compiler/cli/bin/*.bat eol=crlf

.gitignore

@@ -18,6 +18,7 @@ workspace.xml
 /jps-plugin/testData/kannotator
 /js/js.translator/testData/out/
 /js/js.translator/testData/out-min/
+/js/js.translator/testData/out-pir/
 .gradle/
 build/
 !**/src/**/build
@@ -49,10 +50,12 @@ build/
 .idea/artifacts/kotlin_main_kts_jar.xml
 .idea/artifacts/kotlin_compiler_client_embeddable_jar.xml
 .idea/artifacts/kotlin_reflect_jar.xml
+.idea/artifacts/kotlin_stdlib_js_ir_*
+.idea/artifacts/kotlin_test_js_ir_*
+.idea/artifacts/kotlin_stdlib_wasm_*
 .idea/jarRepositories.xml
 kotlin-ultimate/
 node_modules/
 .rpt2_cache/
 libraries/tools/kotlin-test-js-runner/lib/
-libraries/tools/kotlin-source-map-loader/lib/
 local.properties

.idea/dictionaries/4u7.xml

@@ -2,6 +2,8 @@
   <dictionary name="4u7">
     <words>
       <w>bintray</w>
+      <w>cacheability</w>
+      <w>cacheable</w>
       <w>cidr</w>
       <w>foldable</w>
       <w>instrumentator</w>
@@ -9,6 +11,7 @@
       <w>protobuf</w>
       <w>redirector</w>
       <w>remapper</w>
+      <w>sonatype</w>
       <w>unpresent</w>
     </words>
   </dictionary>

.idea/dictionaries/dmitriy_dolovov.xml

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

.idea/dictionaries/yan.xml

@@ -6,6 +6,7 @@
       <w>destructured</w>
       <w>hacky</w>
       <w>impls</w>
+      <w>inlined</w>
       <w>kapt</w>
       <w>kotlinc</w>
       <w>mutators</w>

.idea/misc.xml

@@ -12,14 +12,8 @@
       <item index="2" class="java.lang.String" itemvalue="org.gradle.api.tasks.options.Option" />
     </list>
   </component>
-  <component name="FacetAutodetectingManager">
-    <autodetection-disabled>
-      <facet-type id="Python">
-        <modules>
-          <module name="Jet" />
-        </modules>
-      </facet-type>
-    </autodetection-disabled>
+  <component name="FrameworkDetectionExcludesConfiguration">
+    <file type="web" url="file://$PROJECT_DIR$" />
   </component>
   <component name="IdProvider" IDEtalkID="71A301FF1940049D6D82F12C40F1E1D5" />
   <component name="JavadocGenerationManager">
@@ -30,7 +24,7 @@
     <option name="myDefaultNotNull" value="org.jetbrains.annotations.NotNull" />
     <option name="myNullables">
       <value>
-        <list size="11">
+        <list size="14">
           <item index="0" class="java.lang.String" itemvalue="org.jetbrains.annotations.Nullable" />
           <item index="1" class="java.lang.String" itemvalue="javax.annotation.Nullable" />
           <item index="2" class="java.lang.String" itemvalue="javax.annotation.CheckForNull" />
@@ -42,12 +36,15 @@
           <item index="8" class="java.lang.String" itemvalue="org.checkerframework.checker.nullness.compatqual.NullableType" />
           <item index="9" class="java.lang.String" itemvalue="androidx.annotation.RecentlyNullable" />
           <item index="10" class="java.lang.String" itemvalue="com.android.annotations.Nullable" />
+          <item index="11" class="java.lang.String" itemvalue="org.eclipse.jdt.annotation.Nullable" />
+          <item index="12" class="java.lang.String" itemvalue="io.reactivex.annotations.Nullable" />
+          <item index="13" class="java.lang.String" itemvalue="io.reactivex.rxjava3.annotations.Nullable" />
         </list>
       </value>
     </option>
     <option name="myNotNulls">
       <value>
-        <list size="11">
+        <list size="14">
           <item index="0" class="java.lang.String" itemvalue="org.jetbrains.annotations.NotNull" />
           <item index="1" class="java.lang.String" itemvalue="javax.annotation.Nonnull" />
           <item index="2" class="java.lang.String" itemvalue="javax.validation.constraints.NotNull" />
@@ -59,6 +56,9 @@
           <item index="8" class="java.lang.String" itemvalue="org.checkerframework.checker.nullness.compatqual.NonNullType" />
           <item index="9" class="java.lang.String" itemvalue="androidx.annotation.RecentlyNonNull" />
           <item index="10" class="java.lang.String" itemvalue="com.android.annotations.NonNull" />
+          <item index="11" class="java.lang.String" itemvalue="org.eclipse.jdt.annotation.NonNull" />
+          <item index="12" class="java.lang.String" itemvalue="io.reactivex.annotations.NonNull" />
+          <item index="13" class="java.lang.String" itemvalue="io.reactivex.rxjava3.annotations.NonNull" />
         </list>
       </value>
     </option>
@@ -66,7 +66,7 @@
   <component name="ProjectResources">
     <default-html-doctype>http://www.w3.org/1999/xhtml</default-html-doctype>
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="false" project-jdk-name="1.8" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
   <component name="PsiViewerSettings">

.idea/runConfigurations/Test__KMM.xml

@@ -0,0 +1,20 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Test: KMM" type="GradleRunConfiguration" factoryName="Gradle">
+    <ExternalSystemSettings>
+      <option name="executionName" />
+      <option name="externalProjectPath" value="$PROJECT_DIR$" />
+      <option name="externalSystemIdString" value="GRADLE" />
+      <option name="scriptParameters" value="" />
+      <option name="taskDescriptions">
+        <list />
+      </option>
+      <option name="taskNames">
+        <list>
+          <option value="kmmTest" />
+        </list>
+      </option>
+      <option name="vmOptions" value="" />
+    </ExternalSystemSettings>
+    <method v="2" />
+  </configuration>
+</component>

.idea/runConfigurations/Test__stdlib_js_public_kotlin_api_test__overwrite_results.xml

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

.idea/scopes/Apply_copyright.xml

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

ReadMe.md

@@ -1,5 +1,5 @@
 [![official project](https://jb.gg/badges/official.svg)](https://confluence.jetbrains.com/display/ALL/JetBrains+on+GitHub)
-[![TeamCity (simple build status)](https://img.shields.io/teamcity/http/teamcity.jetbrains.com/s/Kotlin_dev_Compiler.svg)](https://teamcity.jetbrains.com/viewType.html?buildTypeId=Kotlin_dev_Compiler&branch_Kotlin_dev=%3Cdefault%3E&tab=buildTypeStatusDiv)
+[![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)
 
@@ -37,11 +37,16 @@ In order to build Kotlin distribution you need to have:
         JDK_18="path to JDK 1.8"
         JDK_9="path to JDK 9"
 
-For local development, if you're not working on bytecode generation or the standard library, it's OK to have only JDK 1.8 and JDK 9 installed, and to point JDK_16 and JDK_17 environment variables to your JDK 1.8 installation.
+For local development, if you're not working on bytecode generation or the standard library, it's OK to have only JDK 1.8 and JDK 9 installed, and to point `JDK_16` and `JDK_17` environment variables to your JDK 1.8 installation.
 
-You also can use [Gradle properties](https://docs.gradle.org/current/userguide/build_environment.html#sec:gradle_properties_and_system_properties) to setup JDK_* variables.
+You also can use [Gradle properties](https://docs.gradle.org/current/userguide/build_environment.html#sec:gradle_configuration_properties) to setup `JDK_*` variables.
 
-> Note: The JDK 6 for MacOS is not available on Oracle's site. You can [download it here](https://support.apple.com/kb/DL1572).
+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
+```
 
 On Windows you might need to add long paths setting to the repo:
 
@@ -73,7 +78,7 @@ command line parameters on the first run:
 
 - `clean` - clean build results
 - `dist` - assembles the compiler distribution into `dist/kotlinc/` folder
-- `ideaPlugin` - assembles the Kotlin IDEA plugin distribution into `dist/artifacts/Kotlin` folder
+- `ideaPlugin` - assembles the Kotlin IDEA plugin distribution into `dist/artifacts/ideaPlugin/Kotlin/` folder
 - `install` - build and install all public artifacts into local maven repository
 - `runIde` - build IDEA plugin and run IDEA with it
 - `coreLibsTest` - build and run stdlib, reflect and kotlin-test tests
@@ -106,28 +111,39 @@ bunch switch 191
 
 Working with the Kotlin project requires at least IntelliJ IDEA 2019.1. You can download IntelliJ IDEA 2019.1 [here](https://www.jetbrains.com/idea/download).
 
-After cloning the project, to import the project in Intellij choose the project directory in the Open project dialog. Then, after project opened, Select 
-`File` -> `New...` -> `Module from Existing Sources` in the menu, and select `build.gradle.kts` file in the project's root folder.
+After cloning the project, to import the project in IntelliJ choose the project directory in the Open project dialog. Then, after project opened, select 
+`File` -> `New` -> `Module from Existing Sources...` in the menu, and select `build.gradle.kts` file in the project's root folder.
 
 In the import dialog, select `use default gradle wrapper`.
 
 To be able to run tests from IntelliJ easily, check `Delegate IDE build/run actions to Gradle` and choose `Gradle Test Runner` in the Gradle runner settings after importing the project.
 
-At this time, you can use the latest released 1.3.x version of the Kotlin plugin for working with the code. To make sure you have the latest version installed, use Tools | Kotlin | Configure Kotlin Plugin Updates and press "Check for updates now".
+At this time, you can use the latest released `1.3.x` version of the Kotlin plugin for working with the code. To make sure you have the latest version installed, use `Tools` -> `Kotlin` -> `Configure Kotlin Plugin Updates`.
 
 ### Compiling and running
 
-From this root project there are Run/Debug Configurations for running IDEA or the Compiler Tests for example; so if you want to try out the latest and greatest IDEA plugin
+From this root project there are Run/Debug Configurations for running `IDEA` or the `Generate Compiler Tests` for example; so if you want to try out the latest and greatest IDEA plugin
 
-* VCS -> Git -> Pull
-* Run the "IDEA" run configuration in the project
-* a child IntelliJ IDEA with the Kotlin plugin will then startup
+* `VCS` -> `Git` -> `Pull`
+* Run the `IDEA` run configuration in the project
+* A child IntelliJ IDEA with the Kotlin plugin will then startup
 
 ### Including into composite build
 
-To include kotlin compiler into [composite build](https://docs.gradle.org/current/userguide/composite_builds.html) you need to define `dependencySubstitution` for `kotlin-compiler` module in `settings.gradle`
+To include kotlin compiler into [composite build](https://docs.gradle.org/current/userguide/composite_builds.html) you need to define `dependencySubstitution` for `kotlin-compiler` module in `settings.gradle.kts`
 
+```Kotlin
+includeBuild("/path/to/kotlin") {
+    dependencySubstitution {
+        substitute(module("org.jetbrains.kotlin:kotlin-compiler"))
+            .with(project(":include:kotlin-compiler"))
+    }
+}
 ```
+
+or in `settings.gradle`
+
+```Groovy
 includeBuild('/path/to/kotlin') {
     dependencySubstitution {
         substitute module('org.jetbrains.kotlin:kotlin-compiler') with project(':include:kotlin-compiler')

benchmarks/build.gradle.kts

@@ -75,6 +75,21 @@ benchmark {
             include("CommonCallsBenchmark")
             //include("InferenceBaselineCallsBenchmark")
         }
+
+        register("ni") {
+            warmups = 10
+            iterations = 10
+            iterationTime = 1
+            iterationTimeUnit = "sec"
+            param("useNI", true)
+            param("isIR", false)
+            param("size", 1000)
+            include("InferenceBaselineCallsBenchmark")
+            include("InferenceExplicitArgumentsCallsBenchmark")
+            include("InferenceForInApplicableCandidate")
+            include("InferenceFromArgumentCallsBenchmark")
+            include("InferenceFromReturnTypeCallsBenchmark")
+        }
     }
     targets {
         register("main")

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

@@ -32,8 +32,8 @@ import org.jetbrains.kotlin.fir.java.FirJavaModuleBasedSession
 import org.jetbrains.kotlin.fir.java.FirLibrarySession
 import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
 import org.jetbrains.kotlin.fir.resolve.firProvider
-import org.jetbrains.kotlin.fir.resolve.impl.FirProviderImpl
-import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveTransformer
+import org.jetbrains.kotlin.fir.resolve.providers.impl.FirProviderImpl
+import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveProcessor
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.TargetPlatform
@@ -66,25 +66,25 @@ private val JDK_PATH = File("${System.getProperty("java.home")!!}/lib/rt.jar")
 private val RUNTIME_JAR = File(System.getProperty("kotlin.runtime.path") ?: "dist/kotlinc/lib/kotlin-runtime.jar")
 
 private val LANGUAGE_FEATURE_SETTINGS =
-        LanguageVersionSettingsImpl(
-                LanguageVersion.KOTLIN_1_3, ApiVersion.KOTLIN_1_3,
-                specificFeatures = mapOf(LanguageFeature.NewInference to LanguageFeature.State.ENABLED)
-        )
+    LanguageVersionSettingsImpl(
+        LanguageVersion.KOTLIN_1_3, ApiVersion.KOTLIN_1_3,
+        specificFeatures = mapOf(LanguageFeature.NewInference to LanguageFeature.State.ENABLED)
+    )
 
 private fun newConfiguration(useNewInference: Boolean): CompilerConfiguration {
     val configuration = CompilerConfiguration()
     configuration.put(CommonConfigurationKeys.MODULE_NAME, "benchmark")
-    configuration.put(CLIConfigurationKeys.INTELLIJ_PLUGIN_ROOT, "../idea/resources")
+    configuration.put(CLIConfigurationKeys.INTELLIJ_PLUGIN_ROOT, "../compiler/cli/cli-common/resources")
     configuration.addJvmClasspathRoot(JDK_PATH)
     configuration.addJvmClasspathRoot(RUNTIME_JAR)
     configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, MessageCollector.NONE)
 
     val newInferenceState = if (useNewInference) LanguageFeature.State.ENABLED else LanguageFeature.State.DISABLED
     configuration.languageVersionSettings = LanguageVersionSettingsImpl(
-            LanguageVersion.KOTLIN_1_3, ApiVersion.KOTLIN_1_3,
-            specificFeatures = mapOf(
-                    LanguageFeature.NewInference to newInferenceState
-            )
+        LanguageVersion.KOTLIN_1_3, ApiVersion.KOTLIN_1_3,
+        specificFeatures = mapOf(
+            LanguageFeature.NewInference to newInferenceState
+        )
     )
     return configuration
 }
@@ -105,21 +105,21 @@ abstract class AbstractSimpleFileBenchmark {
     fun setUp() {
         if (isIR && !useNewInference) error("Invalid configuration")
         env = KotlinCoreEnvironment.createForTests(
-                myDisposable, 
-                newConfiguration(useNewInference),
-                EnvironmentConfigFiles.JVM_CONFIG_FILES
+            myDisposable,
+            newConfiguration(useNewInference),
+            EnvironmentConfigFiles.JVM_CONFIG_FILES
         )
 
         if (isIR) {
             Extensions.getArea(env.project)
-                    .getExtensionPoint(PsiElementFinder.EP_NAME)
-                    .unregisterExtension(JavaElementFinder::class.java)
+                .getExtensionPoint(PsiElementFinder.EP_NAME)
+                .unregisterExtension(JavaElementFinder::class.java)
         }
 
         file = createFile(
-                "test.kt",
-                buildText(),
-                env.project
+            "test.kt",
+            buildText(),
+            env.project
         )
     }
 
@@ -134,22 +134,22 @@ abstract class AbstractSimpleFileBenchmark {
     private fun analyzeGreenFileFrontend(bh: Blackhole) {
         val tracker = ExceptionTracker()
         val storageManager: StorageManager =
-                LockBasedStorageManager.createWithExceptionHandling("benchmarks", tracker)
+            LockBasedStorageManager.createWithExceptionHandling("benchmarks", tracker)
 
         val context = SimpleGlobalContext(storageManager, tracker)
         val module =
-                ModuleDescriptorImpl(
-                        Name.special("<benchmark>"), storageManager,
-                        JvmBuiltIns(storageManager, JvmBuiltIns.Kind.FROM_DEPENDENCIES)
-                )
+            ModuleDescriptorImpl(
+                Name.special("<benchmark>"), storageManager,
+                JvmBuiltIns(storageManager, JvmBuiltIns.Kind.FROM_DEPENDENCIES)
+            )
         val moduleContext = context.withProject(env.project).withModule(module)
 
         val result = TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
-                moduleContext.project,
-                listOf(file),
-                NoScopeRecordCliBindingTrace(),
-                env.configuration,
-                { scope -> JvmPackagePartProvider(LANGUAGE_FEATURE_SETTINGS, scope) }
+            moduleContext.project,
+            listOf(file),
+            NoScopeRecordCliBindingTrace(),
+            env.configuration,
+            { scope -> JvmPackagePartProvider(LANGUAGE_FEATURE_SETTINGS, scope) }
         )
 
         assert(result.bindingContext.diagnostics.none { it.severity == Severity.ERROR })
@@ -159,17 +159,15 @@ abstract class AbstractSimpleFileBenchmark {
 
     private fun analyzeGreenFileIr(bh: Blackhole) {
         val scope = GlobalSearchScope.filesScope(env.project, listOf(file.virtualFile))
-                .uniteWith(TopDownAnalyzerFacadeForJVM.AllJavaSourcesInProjectScope(env.project))
+            .uniteWith(TopDownAnalyzerFacadeForJVM.AllJavaSourcesInProjectScope(env.project))
         val session = createSession(env, scope)
         val firProvider = session.firProvider as FirProviderImpl
         val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider, stubMode = false)
 
-        val totalTransformer = FirTotalResolveTransformer()
+        val totalTransformer = FirTotalResolveProcessor(session)
         val firFile = builder.buildFirFile(file).also(firProvider::recordFile)
 
-        for (transformer in totalTransformer.transformers) {
-            transformer.transformFile(firFile, null)
-        }
+        totalTransformer.process(listOf(firFile))
 
         bh.consume(firFile.hashCode())
     }
@@ -178,37 +176,37 @@ abstract class AbstractSimpleFileBenchmark {
 }
 
 fun createSession(
-        environment: KotlinCoreEnvironment,
-        sourceScope: GlobalSearchScope,
-        librariesScope: GlobalSearchScope = GlobalSearchScope.notScope(sourceScope)
+    environment: KotlinCoreEnvironment,
+    sourceScope: GlobalSearchScope,
+    librariesScope: GlobalSearchScope = GlobalSearchScope.notScope(sourceScope)
 ): FirSession {
     val moduleInfo = FirTestModuleInfo()
     val project = environment.project
     val provider = FirProjectSessionProvider(project)
-    return FirJavaModuleBasedSession(moduleInfo, provider, sourceScope).also {
+    return FirJavaModuleBasedSession.create(moduleInfo, provider, sourceScope).also {
         createSessionForDependencies(provider, moduleInfo, librariesScope, environment)
     }
 }
 
 private fun createSessionForDependencies(
-        provider: FirProjectSessionProvider,
-        moduleInfo: FirTestModuleInfo,
-        librariesScope: GlobalSearchScope,
-        environment: KotlinCoreEnvironment
+    provider: FirProjectSessionProvider,
+    moduleInfo: FirTestModuleInfo,
+    librariesScope: GlobalSearchScope,
+    environment: KotlinCoreEnvironment
 ) {
     val dependenciesInfo = FirTestModuleInfo()
     moduleInfo.dependencies.add(dependenciesInfo)
     FirLibrarySession.create(
-            dependenciesInfo, provider, librariesScope, environment.project,
-            environment.createPackagePartProvider(librariesScope)
+        dependenciesInfo, provider, librariesScope, environment.project,
+        environment.createPackagePartProvider(librariesScope)
     )
 }
 
 class FirTestModuleInfo(
-        override val name: Name = Name.identifier("TestModule"),
-        val dependencies: MutableList<ModuleInfo> = mutableListOf(),
-        override val platform: TargetPlatform = JvmPlatforms.unspecifiedJvmPlatform,
-        override val analyzerServices: PlatformDependentAnalyzerServices = JvmPlatformAnalyzerServices
+    override val name: Name = Name.identifier("TestModule"),
+    val dependencies: MutableList<ModuleInfo> = mutableListOf(),
+    override val platform: TargetPlatform = JvmPlatforms.unspecifiedJvmPlatform,
+    override val analyzerServices: PlatformDependentAnalyzerServices = JvmPlatformAnalyzerServices
 ) : ModuleInfo {
     override fun dependencies(): List<ModuleInfo> = dependencies
 }

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

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

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

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.benchmarks
+
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+import java.util.concurrent.TimeUnit
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Benchmark)
+open class PlusAssignOperatorDesugaringBenchmark : AbstractInferenceBenchmark() {
+    @Param("9", "10", "11", "12", "13", "14")
+    private var size: Int = 0
+
+    @Benchmark
+    fun benchmark(bh: Blackhole) {
+        analyzeGreenFile(bh)
+    }
+
+    override fun buildText(): String = buildString {
+        appendLine(
+            """
+            class A {
+                operator fun <T : Number> plus(other: (Int) -> T): A = this
+                operator fun <T : CharSequence> plusAssign(other: (String) -> T) {}
+            }
+        """.trimIndent()
+        )
+        appendLine("fun test() {")
+        appendLine("var a = A()")
+        for (i in 1..size) {
+            appendLine("a += {")
+        }
+        for (i in 1..size) {
+            appendLine(
+                """
+                it.inc()
+                1
+                }
+            """.trimIndent()
+            )
+        }
+        appendLine()
+    }
+}

build-common/build.gradle.kts

@@ -1,4 +1,3 @@
-
 description = "Kotlin Build Common"
 
 plugins {
@@ -12,7 +11,7 @@ dependencies {
     compileOnly(project(":compiler:cli-common"))
     compileOnly(project(":compiler:frontend.java"))
     compileOnly(project(":js:js.serializer"))
-    compileOnly(project(":js:js.frontend"))
+    compileOnly(project(":js:js.config"))
     compileOnly(project(":kotlin-util-klib-metadata"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
     compileOnly(intellijDep()) { includeJars("asm-all", "trove4j", "util", rootProject = rootProject) }
@@ -23,8 +22,9 @@ dependencies {
     testCompile(commonDep("junit:junit"))
     testCompile(protobufFull())
     testCompile(kotlinStdlib())
-    testCompileOnly(intellijDep()) { includeJars("openapi") }
-
+    Platform[193].orLower {
+        testCompileOnly(intellijDep()) { includeJars("openapi", rootProject = rootProject) }
+    }
     testRuntime(project(":kotlin-reflect"))
 }
 

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

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

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

@@ -128,8 +128,8 @@ open class IncrementalJsCache(
         }
 
         for ((srcFile, irData) in incrementalResults.irFileData) {
-            val (fileData, symbols, types, strings, declarations, bodies, fqn) = irData
-            irTranslationResults.put(srcFile, fileData, symbols, types, strings, declarations, bodies, fqn)
+            val (fileData, types, signatures, strings, declarations, bodies, fqn) = irData
+            irTranslationResults.put(srcFile, fileData, types, signatures, strings, declarations, bodies, fqn)
         }
     }
 
@@ -240,8 +240,8 @@ private class TranslationResultMap(
 private object IrTranslationResultValueExternalizer : DataExternalizer<IrTranslationResultValue> {
     override fun save(output: DataOutput, value: IrTranslationResultValue) {
         output.writeArray(value.fileData)
-        output.writeArray(value.symbols)
         output.writeArray(value.types)
+        output.writeArray(value.signatures)
         output.writeArray(value.strings)
         output.writeArray(value.declarations)
         output.writeArray(value.bodies)
@@ -262,14 +262,14 @@ private object IrTranslationResultValueExternalizer : DataExternalizer<IrTransla
 
     override fun read(input: DataInput): IrTranslationResultValue {
         val fileData = input.readArray()
-        val symbols = input.readArray()
         val types = input.readArray()
+        val signatures = input.readArray()
         val strings = input.readArray()
         val declarations = input.readArray()
         val bodies = input.readArray()
         val fqn = input.readArray()
 
-        return IrTranslationResultValue(fileData, symbols, types, strings, declarations, bodies, fqn)
+        return IrTranslationResultValue(fileData, types, signatures, strings, declarations, bodies, fqn)
     }
 }
 
@@ -280,8 +280,8 @@ private class IrTranslationResultMap(
     BasicStringMap<IrTranslationResultValue>(storageFile, IrTranslationResultValueExternalizer) {
     override fun dumpValue(value: IrTranslationResultValue): String =
         "Filedata: ${value.fileData.md5()}, " +
-                "Symbols: ${value.symbols.md5()}, " +
                 "Types: ${value.types.md5()}, " +
+                "Signatures: ${value.signatures.md5()}, " +
                 "Strings: ${value.strings.md5()}, " +
                 "Declarations: ${value.declarations.md5()}, " +
                 "Bodies: ${value.bodies.md5()}"
@@ -289,15 +289,15 @@ private class IrTranslationResultMap(
     fun put(
         sourceFile: File,
         newFiledata: ByteArray,
-        newSymbols: ByteArray,
         newTypes: ByteArray,
+        newSignatures: ByteArray,
         newStrings: ByteArray,
         newDeclarations: ByteArray,
         newBodies: ByteArray,
         fqn: ByteArray
     ) {
         storage[pathConverter.toPath(sourceFile)] =
-            IrTranslationResultValue(newFiledata, newSymbols, newTypes, newStrings, newDeclarations, newBodies, fqn)
+            IrTranslationResultValue(newFiledata, newTypes, newSignatures, newStrings, newDeclarations, newBodies, fqn)
     }
 
     operator fun get(sourceFile: File): IrTranslationResultValue? =

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

@@ -33,6 +33,7 @@ import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmProtoBufUtil
 import org.jetbrains.kotlin.metadata.jvm.deserialization.ModuleMapping
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.resolve.jvm.AsmTypes
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName
 import org.jetbrains.org.objectweb.asm.*
 import java.io.File
@@ -476,8 +477,21 @@ open class IncrementalJvmCache(
             if (inlineFunctions.isEmpty()) return emptyMap()
 
             val result = HashMap<String, Long>()
-
+            var dummyVersion: Int = -1
             ClassReader(bytes).accept(object : ClassVisitor(Opcodes.API_VERSION) {
+
+                override fun visit(
+                    version: Int,
+                    access: Int,
+                    name: String?,
+                    signature: String?,
+                    superName: String?,
+                    interfaces: Array<out String>?
+                ) {
+                    super.visit(version, access, name, signature, superName, interfaces)
+                    dummyVersion = version
+                }
+
                 override fun visitMethod(
                     access: Int,
                     name: String,
@@ -485,7 +499,8 @@ open class IncrementalJvmCache(
                     signature: String?,
                     exceptions: Array<out String>?
                 ): MethodVisitor? {
-                    val dummyClassWriter = ClassWriter(Opcodes.API_VERSION)
+                    val dummyClassWriter = ClassWriter(0)
+                    dummyClassWriter.visit(dummyVersion, 0, "dummy", null, AsmTypes.OBJECT_TYPE.internalName, null)
 
                     return object : MethodVisitor(Opcodes.API_VERSION, dummyClassWriter.visitMethod(0, name, desc, null, exceptions)) {
                         override fun visitEnd() {
@@ -493,6 +508,7 @@ open class IncrementalJvmCache(
                             if (jvmName !in inlineFunctions) return
 
                             val dummyBytes = dummyClassWriter.toByteArray()!!
+
                             val hash = dummyBytes.md5()
                             result[jvmName] = hash
                         }

build-common/src/org/jetbrains/kotlin/incremental/JavaClassesTrackerImpl.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-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

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

@@ -206,6 +206,11 @@ open class ProtoCompareGenerated(
             if (!checkStringEquals(old.getExtension(JvmProtoBuf.anonymousObjectOriginName), new.getExtension(JvmProtoBuf.anonymousObjectOriginName))) return false
         }
 
+        if (old.hasExtension(JvmProtoBuf.jvmClassFlags) != new.hasExtension(JvmProtoBuf.jvmClassFlags)) return false
+        if (old.hasExtension(JvmProtoBuf.jvmClassFlags)) {
+            if (old.getExtension(JvmProtoBuf.jvmClassFlags) != new.getExtension(JvmProtoBuf.jvmClassFlags)) return false
+        }
+
         if (old.getExtensionCount(JsProtoBuf.classAnnotation) != new.getExtensionCount(JsProtoBuf.classAnnotation)) {
             return false
         }
@@ -264,6 +269,7 @@ open class ProtoCompareGenerated(
         JVM_EXT_CLASS_MODULE_NAME,
         JVM_EXT_CLASS_LOCAL_VARIABLE_LIST,
         JVM_EXT_ANONYMOUS_OBJECT_ORIGIN_NAME,
+        JVM_EXT_JVM_CLASS_FLAGS,
         JS_EXT_CLASS_ANNOTATION_LIST,
         JS_EXT_CLASS_CONTAINING_FILE_ID,
         JAVA_EXT_IS_PACKAGE_PRIVATE_CLASS,
@@ -332,6 +338,11 @@ open class ProtoCompareGenerated(
             if (!checkStringEquals(old.getExtension(JvmProtoBuf.anonymousObjectOriginName), new.getExtension(JvmProtoBuf.anonymousObjectOriginName))) result.add(ProtoBufClassKind.JVM_EXT_ANONYMOUS_OBJECT_ORIGIN_NAME)
         }
 
+        if (old.hasExtension(JvmProtoBuf.jvmClassFlags) != new.hasExtension(JvmProtoBuf.jvmClassFlags)) result.add(ProtoBufClassKind.JVM_EXT_JVM_CLASS_FLAGS)
+        if (old.hasExtension(JvmProtoBuf.jvmClassFlags)) {
+            if (old.getExtension(JvmProtoBuf.jvmClassFlags) != new.getExtension(JvmProtoBuf.jvmClassFlags)) result.add(ProtoBufClassKind.JVM_EXT_JVM_CLASS_FLAGS)
+        }
+
         if (old.getExtensionCount(JsProtoBuf.classAnnotation) != new.getExtensionCount(JsProtoBuf.classAnnotation)) {
             result.add(ProtoBufClassKind.JS_EXT_CLASS_ANNOTATION_LIST)
         }
@@ -1735,6 +1746,10 @@ fun ProtoBuf.Class.hashCode(stringIndexes: (Int) -> Int, fqNameIndexes: (Int) ->
         hashCode = 31 * hashCode + stringIndexes(getExtension(JvmProtoBuf.anonymousObjectOriginName))
     }
 
+    if (hasExtension(JvmProtoBuf.jvmClassFlags)) {
+        hashCode = 31 * hashCode + getExtension(JvmProtoBuf.jvmClassFlags)
+    }
+
     for(i in 0..getExtensionCount(JsProtoBuf.classAnnotation) - 1) {
         hashCode = 31 * hashCode + getExtension(JsProtoBuf.classAnnotation, i).hashCode(stringIndexes, fqNameIndexes, typeById)
     }

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

@@ -28,42 +28,42 @@ import org.jetbrains.kotlin.modules.KotlinModuleXmlBuilder
 import org.jetbrains.kotlin.modules.TargetId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.progress.CompilationCanceledStatus
-import org.jetbrains.kotlin.synthetic.SAM_LOOKUP_NAME
+import org.jetbrains.kotlin.resolve.sam.SAM_LOOKUP_NAME
 import org.jetbrains.kotlin.utils.addToStdlib.flattenTo
-import org.jetbrains.kotlin.utils.keysToMap
 import java.io.File
 import java.util.*
 import kotlin.collections.HashSet
+import kotlin.collections.LinkedHashSet
 
 const val DELETE_MODULE_FILE_PROPERTY = "kotlin.delete.module.file.after.build"
 
 fun makeModuleFile(
-        name: String,
-        isTest: Boolean,
-        outputDir: File,
-        sourcesToCompile: Iterable<File>,
-        commonSources: Iterable<File>,
-        javaSourceRoots: Iterable<JvmSourceRoot>,
-        classpath: Iterable<File>,
-        friendDirs: Iterable<File>
+    name: String,
+    isTest: Boolean,
+    outputDir: File,
+    sourcesToCompile: Iterable<File>,
+    commonSources: Iterable<File>,
+    javaSourceRoots: Iterable<JvmSourceRoot>,
+    classpath: Iterable<File>,
+    friendDirs: Iterable<File>
 ): File {
     val builder = KotlinModuleXmlBuilder()
     builder.addModule(
-            name,
-            outputDir.absolutePath,
-            // important to transform file to absolute paths,
-            // otherwise compiler will use module file's parent as base path (a temporary file; see below)
-            // (see org.jetbrains.kotlin.cli.jvm.compiler.KotlinToJVMBytecodeCompiler.getAbsolutePaths)
-            sourcesToCompile.map { it.absoluteFile },
-            javaSourceRoots,
-            classpath,
-            commonSources.map { it.absoluteFile },
-            null,
-            "java-production",
-            isTest,
-            // this excludes the output directories from the class path, to be removed for true incremental compilation
-            setOf(outputDir),
-            friendDirs
+        name,
+        outputDir.absolutePath,
+        // important to transform file to absolute paths,
+        // otherwise compiler will use module file's parent as base path (a temporary file; see below)
+        // (see org.jetbrains.kotlin.cli.jvm.compiler.KotlinToJVMBytecodeCompiler.getAbsolutePaths)
+        sourcesToCompile.map { it.absoluteFile },
+        javaSourceRoots,
+        classpath,
+        commonSources.map { it.absoluteFile },
+        null,
+        "java-production",
+        isTest,
+        // this excludes the output directories from the class path, to be removed for true incremental compilation
+        setOf(outputDir),
+        friendDirs
     )
 
     val scriptFile = File.createTempFile("kjps", sanitizeJavaIdentifier(name) + ".script.xml")
@@ -84,9 +84,9 @@ private fun sanitizeJavaIdentifier(string: String) =
     }
 
 fun makeCompileServices(
-        incrementalCaches: Map<TargetId, IncrementalCache>,
-        lookupTracker: LookupTracker,
-        compilationCanceledStatus: CompilationCanceledStatus?
+    incrementalCaches: Map<TargetId, IncrementalCache>,
+    lookupTracker: LookupTracker,
+    compilationCanceledStatus: CompilationCanceledStatus?
 ): Services =
     with(Services.Builder()) {
         register(LookupTracker::class.java, lookupTracker)
@@ -106,12 +106,14 @@ fun updateIncrementalCache(
     for (generatedFile in generatedFiles) {
         when {
             generatedFile is GeneratedJvmClass -> cache.saveFileToCache(generatedFile, changesCollector)
-            generatedFile.outputFile.isModuleMappingFile() -> cache.saveModuleMappingToCache(generatedFile.sourceFiles, generatedFile.outputFile)
+            generatedFile.outputFile.isModuleMappingFile() -> cache.saveModuleMappingToCache(
+                generatedFile.sourceFiles,
+                generatedFile.outputFile
+            )
         }
     }
 
-    javaChangesTracker?.javaClassesUpdates?.forEach {
-        (source, serializedJavaClass) ->
+    javaChangesTracker?.javaClassesUpdates?.forEach { (source, serializedJavaClass) ->
         cache.saveJavaClassProto(source, serializedJavaClass, changesCollector)
     }
 
@@ -119,9 +121,9 @@ fun updateIncrementalCache(
 }
 
 fun LookupStorage.update(
-        lookupTracker: LookupTracker,
-        filesToCompile: Iterable<File>,
-        removedFiles: Iterable<File>
+    lookupTracker: LookupTracker,
+    filesToCompile: Iterable<File>,
+    removedFiles: Iterable<File>
 ) {
     if (lookupTracker !is LookupTrackerImpl) throw AssertionError("Lookup tracker is expected to be LookupTrackerImpl, got ${lookupTracker::class.java}")
 
@@ -131,8 +133,8 @@ fun LookupStorage.update(
 }
 
 data class DirtyData(
-        val dirtyLookupSymbols: Collection<LookupSymbol> = emptyList(),
-        val dirtyClassesFqNames: Collection<FqName> = emptyList()
+    val dirtyLookupSymbols: Collection<LookupSymbol> = emptyList(),
+    val dirtyClassesFqNames: Collection<FqName> = emptyList()
 )
 
 fun ChangesCollector.getDirtyData(
@@ -214,19 +216,21 @@ fun mapClassesFqNamesToFiles(
 }
 
 fun withSubtypes(
-        typeFqName: FqName,
-        caches: Iterable<IncrementalCacheCommon>
+    typeFqName: FqName,
+    caches: Iterable<IncrementalCacheCommon>
 ): Set<FqName> {
-    val types = LinkedList(listOf(typeFqName))
+    val types = LinkedHashSet(listOf(typeFqName))
     val subtypes = hashSetOf<FqName>()
 
     while (types.isNotEmpty()) {
-        val unprocessedType = types.pollFirst()
+        val iterator = types.iterator()
+        val unprocessedType = iterator.next()
+        iterator.remove()
 
         caches.asSequence()
-              .flatMap { it.getSubtypesOf(unprocessedType) }
-              .filter { it !in subtypes }
-              .forEach { types.addLast(it) }
+            .flatMap { it.getSubtypesOf(unprocessedType) }
+            .filter { it !in subtypes }
+            .forEach { types.add(it) }
 
         subtypes.add(unprocessedType)
     }

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

@@ -273,6 +273,10 @@ class DifferenceCalculatorForClass(
                     isClassAffected = true
                     areSubclassesAffected = true
                 }
+                ProtoBufClassKind.JVM_EXT_JVM_CLASS_FLAGS -> {
+                    isClassAffected = true
+                    areSubclassesAffected = true
+                }
             }
         }
 

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

@@ -1,81 +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.EnumeratorStringDescriptor
-import com.intellij.util.io.KeyDescriptor
-import org.jetbrains.annotations.TestOnly
-import org.jetbrains.kotlin.utils.Printer
-import java.io.File
-
-abstract class BasicMap<K : Comparable<K>, V>(
-        internal val storageFile: File,
-        keyDescriptor: KeyDescriptor<K>,
-        valueExternalizer: DataExternalizer<V>
-) {
-    protected val storage = LazyStorage(storageFile, keyDescriptor, valueExternalizer)
-
-    fun clean() {
-        storage.clean()
-    }
-
-    fun flush(memoryCachesOnly: Boolean) {
-        storage.flush(memoryCachesOnly)
-    }
-
-    fun close() {
-        storage.close()
-    }
-
-    @TestOnly
-    fun dump(): String {
-        return with(StringBuilder()) {
-            with(Printer(this)) {
-                println(this@BasicMap::class.java.simpleName)
-                pushIndent()
-
-                for (key in storage.keys.sorted()) {
-                    println("${dumpKey(key)} -> ${dumpValue(storage[key]!!)}")
-                }
-
-                popIndent()
-            }
-
-            this
-        }.toString()
-    }
-
-    @TestOnly
-    protected abstract fun dumpKey(key: K): String
-
-    @TestOnly
-    protected abstract fun dumpValue(value: V): String
-}
-
-abstract class BasicStringMap<V>(
-        storageFile: File,
-        keyDescriptor: KeyDescriptor<String>,
-        valueExternalizer: DataExternalizer<V>
-) : BasicMap<String, V>(storageFile, keyDescriptor, valueExternalizer) {
-    constructor(
-            storageFile: File,
-            valueExternalizer: DataExternalizer<V>
-    ) : this(storageFile, EnumeratorStringDescriptor.INSTANCE, valueExternalizer)
-
-    override fun dumpKey(key: String): String = key
-}

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

@@ -1,55 +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 org.jetbrains.kotlin.incremental.dumpCollection
-import org.jetbrains.kotlin.name.FqName
-import java.io.File
-
-internal open class ClassOneToManyMap(
-        storageFile: File
-) : BasicStringMap<Collection<String>>(storageFile, StringCollectionExternalizer) {
-    override fun dumpValue(value: Collection<String>): String = value.dumpCollection()
-
-    fun add(key: FqName, value: FqName) {
-        storage.append(key.asString(), value.asString())
-    }
-
-    operator fun get(key: FqName): Collection<FqName> =
-            storage[key.asString()]?.map(::FqName) ?: setOf()
-
-    operator fun set(key: FqName, values: Collection<FqName>) {
-        if (values.isEmpty()) {
-            remove(key)
-            return
-        }
-
-        storage[key.asString()] = values.map(FqName::asString)
-    }
-
-    fun remove(key: FqName) {
-        storage.remove(key.asString())
-    }
-
-    fun removeValues(key: FqName, removed: Set<FqName>) {
-        val notRemoved = this[key].filter { it !in removed }
-        this[key] = notRemoved
-    }
-}
-
-internal class SubtypesMap(storageFile: File) : ClassOneToManyMap(storageFile)
-internal class SupertypesMap(storageFile: File) : ClassOneToManyMap(storageFile)

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

@@ -1,122 +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.IOUtil
-import com.intellij.util.io.KeyDescriptor
-import com.intellij.util.io.PersistentHashMap
-import java.io.DataOutput
-import java.io.File
-import java.io.IOException
-
-
-/**
- * It's lazy in a sense that PersistentHashMap is created only on write
- */
-class LazyStorage<K, V>(
-        private val storageFile: File,
-        private val keyDescriptor: KeyDescriptor<K>,
-        private val valueExternalizer: DataExternalizer<V>
-) {
-    @Volatile
-    private var storage: PersistentHashMap<K, V>? = null
-
-    @Synchronized
-    private fun getStorageIfExists(): PersistentHashMap<K, V>? {
-        if (storage != null) return storage
-
-        if (storageFile.exists()) {
-            storage = createMap()
-            return storage
-        }
-
-        return null
-    }
-
-    @Synchronized
-    private fun getStorageOrCreateNew(): PersistentHashMap<K, V> {
-        if (storage == null) {
-            storage = createMap()
-        }
-
-        return storage!!
-    }
-
-    val keys: Collection<K>
-        get() = getStorageIfExists()?.allKeysWithExistingMapping ?: listOf()
-
-    operator fun contains(key: K): Boolean =
-            getStorageIfExists()?.containsMapping(key) ?: false
-
-    operator fun get(key: K): V? =
-            getStorageIfExists()?.get(key)
-
-    operator fun set(key: K, value: V) {
-        getStorageOrCreateNew().put(key, value)
-    }
-
-    fun remove(key: K) {
-        getStorageIfExists()?.remove(key)
-    }
-
-    fun append(key: K, value: String) {
-        append(key) { out -> IOUtil.writeUTF(out, value) }
-    }
-
-    fun append(key: K, value: Int) {
-        append(key) { out -> out.writeInt(value) }
-    }
-
-    @Synchronized
-    fun clean() {
-        try {
-            storage?.close()
-        }
-        catch (ignored: Throwable) {
-        }
-
-        PersistentHashMap.deleteFilesStartingWith(storageFile)
-        storage = null
-    }
-
-    @Synchronized
-    fun flush(memoryCachesOnly: Boolean) {
-        val existingStorage = storage ?: return
-
-        if (memoryCachesOnly) {
-            if (existingStorage.isDirty) {
-                existingStorage.dropMemoryCaches()
-            }
-        }
-        else {
-            existingStorage.force()
-        }
-    }
-
-    @Synchronized
-    fun close() {
-        storage?.close()
-    }
-
-    private fun createMap(): PersistentHashMap<K, V> =
-            PersistentHashMap(storageFile, keyDescriptor, valueExternalizer)
-
-    private fun append(key: K, append: (DataOutput)->Unit) {
-        getStorageOrCreateNew().appendData(key, append)
-    }
-}

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

@@ -1,42 +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 java.io.File
-
-internal class LookupMap(storage: File) : BasicMap<LookupSymbolKey, Collection<Int>>(storage, LookupSymbolKeyDescriptor, IntCollectionExternalizer) {
-    override fun dumpKey(key: LookupSymbolKey): String = key.toString()
-
-    override fun dumpValue(value: Collection<Int>): String = value.toString()
-
-    fun add(name: String, scope: String, fileId: Int) {
-        storage.append(LookupSymbolKey(name, scope), fileId)
-    }
-
-    operator fun get(key: LookupSymbolKey): Collection<Int>? = storage[key]
-
-    operator fun set(key: LookupSymbolKey, fileIds: Set<Int>) {
-        storage[key] = fileIds
-    }
-
-    fun remove(key: LookupSymbolKey) {
-        storage.remove(key)
-    }
-
-    val keys: Collection<LookupSymbolKey>
-        get() = storage.keys
-}

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

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

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

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

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

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

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

@@ -208,6 +208,65 @@ public final class DebugJvmModuleProtoBuf {
      */
     org.jetbrains.kotlin.metadata.DebugProtoBuf.AnnotationOrBuilder getAnnotationOrBuilder(
         int index);
+
+    /**
+     * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+     *
+     * <pre>
+     * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+     * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+     * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+     * it to the corresponding class with the resolution capabilities of common modules.
+     * </pre>
+     */
+    java.util.List<org.jetbrains.kotlin.metadata.DebugProtoBuf.Class> 
+        getOptionalAnnotationClassList();
+    /**
+     * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+     *
+     * <pre>
+     * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+     * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+     * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+     * it to the corresponding class with the resolution capabilities of common modules.
+     * </pre>
+     */
+    org.jetbrains.kotlin.metadata.DebugProtoBuf.Class getOptionalAnnotationClass(int index);
+    /**
+     * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+     *
+     * <pre>
+     * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+     * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+     * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+     * it to the corresponding class with the resolution capabilities of common modules.
+     * </pre>
+     */
+    int getOptionalAnnotationClassCount();
+    /**
+     * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+     *
+     * <pre>
+     * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+     * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+     * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+     * it to the corresponding class with the resolution capabilities of common modules.
+     * </pre>
+     */
+    java.util.List<? extends org.jetbrains.kotlin.metadata.DebugProtoBuf.ClassOrBuilder> 
+        getOptionalAnnotationClassOrBuilderList();
+    /**
+     * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+     *
+     * <pre>
+     * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+     * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+     * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+     * it to the corresponding class with the resolution capabilities of common modules.
+     * </pre>
+     */
+    org.jetbrains.kotlin.metadata.DebugProtoBuf.ClassOrBuilder getOptionalAnnotationClassOrBuilder(
+        int index);
   }
   /**
    * Protobuf type {@code org.jetbrains.kotlin.metadata.jvm.Module}
@@ -320,6 +379,14 @@ public final class DebugJvmModuleProtoBuf {
               annotation_.add(input.readMessage(org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation.PARSER, extensionRegistry));
               break;
             }
+            case 130: {
+              if (!((mutable_bitField0_ & 0x00000040) == 0x00000040)) {
+                optionalAnnotationClass_ = new java.util.ArrayList<org.jetbrains.kotlin.metadata.DebugProtoBuf.Class>();
+                mutable_bitField0_ |= 0x00000040;
+              }
+              optionalAnnotationClass_.add(input.readMessage(org.jetbrains.kotlin.metadata.DebugProtoBuf.Class.PARSER, extensionRegistry));
+              break;
+            }
           }
         }
       } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
@@ -340,6 +407,9 @@ public final class DebugJvmModuleProtoBuf {
         if (((mutable_bitField0_ & 0x00000020) == 0x00000020)) {
           annotation_ = java.util.Collections.unmodifiableList(annotation_);
         }
+        if (((mutable_bitField0_ & 0x00000040) == 0x00000040)) {
+          optionalAnnotationClass_ = java.util.Collections.unmodifiableList(optionalAnnotationClass_);
+        }
         this.unknownFields = unknownFields.build();
         makeExtensionsImmutable();
       }
@@ -628,6 +698,76 @@ public final class DebugJvmModuleProtoBuf {
       return annotation_.get(index);
     }
 
+    public static final int OPTIONAL_ANNOTATION_CLASS_FIELD_NUMBER = 16;
+    private java.util.List<org.jetbrains.kotlin.metadata.DebugProtoBuf.Class> optionalAnnotationClass_;
+    /**
+     * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+     *
+     * <pre>
+     * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+     * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+     * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+     * it to the corresponding class with the resolution capabilities of common modules.
+     * </pre>
+     */
+    public java.util.List<org.jetbrains.kotlin.metadata.DebugProtoBuf.Class> getOptionalAnnotationClassList() {
+      return optionalAnnotationClass_;
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+     *
+     * <pre>
+     * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+     * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+     * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+     * it to the corresponding class with the resolution capabilities of common modules.
+     * </pre>
+     */
+    public java.util.List<? extends org.jetbrains.kotlin.metadata.DebugProtoBuf.ClassOrBuilder> 
+        getOptionalAnnotationClassOrBuilderList() {
+      return optionalAnnotationClass_;
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+     *
+     * <pre>
+     * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+     * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+     * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+     * it to the corresponding class with the resolution capabilities of common modules.
+     * </pre>
+     */
+    public int getOptionalAnnotationClassCount() {
+      return optionalAnnotationClass_.size();
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+     *
+     * <pre>
+     * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+     * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+     * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+     * it to the corresponding class with the resolution capabilities of common modules.
+     * </pre>
+     */
+    public org.jetbrains.kotlin.metadata.DebugProtoBuf.Class getOptionalAnnotationClass(int index) {
+      return optionalAnnotationClass_.get(index);
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+     *
+     * <pre>
+     * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+     * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+     * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+     * it to the corresponding class with the resolution capabilities of common modules.
+     * </pre>
+     */
+    public org.jetbrains.kotlin.metadata.DebugProtoBuf.ClassOrBuilder getOptionalAnnotationClassOrBuilder(
+        int index) {
+      return optionalAnnotationClass_.get(index);
+    }
+
     private void initFields() {
       packageParts_ = java.util.Collections.emptyList();
       metadataParts_ = java.util.Collections.emptyList();
@@ -635,6 +775,7 @@ public final class DebugJvmModuleProtoBuf {
       stringTable_ = org.jetbrains.kotlin.metadata.DebugProtoBuf.StringTable.getDefaultInstance();
       qualifiedNameTable_ = org.jetbrains.kotlin.metadata.DebugProtoBuf.QualifiedNameTable.getDefaultInstance();
       annotation_ = java.util.Collections.emptyList();
+      optionalAnnotationClass_ = java.util.Collections.emptyList();
     }
     private byte memoizedIsInitialized = -1;
     public final boolean isInitialized() {
@@ -666,6 +807,12 @@ public final class DebugJvmModuleProtoBuf {
           return false;
         }
       }
+      for (int i = 0; i < getOptionalAnnotationClassCount(); i++) {
+        if (!getOptionalAnnotationClass(i).isInitialized()) {
+          memoizedIsInitialized = 0;
+          return false;
+        }
+      }
       memoizedIsInitialized = 1;
       return true;
     }
@@ -691,6 +838,9 @@ public final class DebugJvmModuleProtoBuf {
       for (int i = 0; i < annotation_.size(); i++) {
         output.writeMessage(6, annotation_.get(i));
       }
+      for (int i = 0; i < optionalAnnotationClass_.size(); i++) {
+        output.writeMessage(16, optionalAnnotationClass_.get(i));
+      }
       getUnknownFields().writeTo(output);
     }
 
@@ -729,6 +879,10 @@ public final class DebugJvmModuleProtoBuf {
         size += org.jetbrains.kotlin.protobuf.CodedOutputStream
           .computeMessageSize(6, annotation_.get(i));
       }
+      for (int i = 0; i < optionalAnnotationClass_.size(); i++) {
+        size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+          .computeMessageSize(16, optionalAnnotationClass_.get(i));
+      }
       size += getUnknownFields().getSerializedSize();
       memoizedSerializedSize = size;
       return size;
@@ -843,6 +997,7 @@ public final class DebugJvmModuleProtoBuf {
           getStringTableFieldBuilder();
           getQualifiedNameTableFieldBuilder();
           getAnnotationFieldBuilder();
+          getOptionalAnnotationClassFieldBuilder();
         }
       }
       private static Builder create() {
@@ -883,6 +1038,12 @@ public final class DebugJvmModuleProtoBuf {
         } else {
           annotationBuilder_.clear();
         }
+        if (optionalAnnotationClassBuilder_ == null) {
+          optionalAnnotationClass_ = java.util.Collections.emptyList();
+          bitField0_ = (bitField0_ & ~0x00000040);
+        } else {
+          optionalAnnotationClassBuilder_.clear();
+        }
         return this;
       }
 
@@ -959,6 +1120,15 @@ public final class DebugJvmModuleProtoBuf {
         } else {
           result.annotation_ = annotationBuilder_.build();
         }
+        if (optionalAnnotationClassBuilder_ == null) {
+          if (((bitField0_ & 0x00000040) == 0x00000040)) {
+            optionalAnnotationClass_ = java.util.Collections.unmodifiableList(optionalAnnotationClass_);
+            bitField0_ = (bitField0_ & ~0x00000040);
+          }
+          result.optionalAnnotationClass_ = optionalAnnotationClass_;
+        } else {
+          result.optionalAnnotationClass_ = optionalAnnotationClassBuilder_.build();
+        }
         result.bitField0_ = to_bitField0_;
         onBuilt();
         return result;
@@ -1069,6 +1239,32 @@ public final class DebugJvmModuleProtoBuf {
             }
           }
         }
+        if (optionalAnnotationClassBuilder_ == null) {
+          if (!other.optionalAnnotationClass_.isEmpty()) {
+            if (optionalAnnotationClass_.isEmpty()) {
+              optionalAnnotationClass_ = other.optionalAnnotationClass_;
+              bitField0_ = (bitField0_ & ~0x00000040);
+            } else {
+              ensureOptionalAnnotationClassIsMutable();
+              optionalAnnotationClass_.addAll(other.optionalAnnotationClass_);
+            }
+            onChanged();
+          }
+        } else {
+          if (!other.optionalAnnotationClass_.isEmpty()) {
+            if (optionalAnnotationClassBuilder_.isEmpty()) {
+              optionalAnnotationClassBuilder_.dispose();
+              optionalAnnotationClassBuilder_ = null;
+              optionalAnnotationClass_ = other.optionalAnnotationClass_;
+              bitField0_ = (bitField0_ & ~0x00000040);
+              optionalAnnotationClassBuilder_ = 
+                org.jetbrains.kotlin.protobuf.GeneratedMessage.alwaysUseFieldBuilders ?
+                   getOptionalAnnotationClassFieldBuilder() : null;
+            } else {
+              optionalAnnotationClassBuilder_.addAllMessages(other.optionalAnnotationClass_);
+            }
+          }
+        }
         this.mergeUnknownFields(other.getUnknownFields());
         return this;
       }
@@ -1098,6 +1294,12 @@ public final class DebugJvmModuleProtoBuf {
             return false;
           }
         }
+        for (int i = 0; i < getOptionalAnnotationClassCount(); i++) {
+          if (!getOptionalAnnotationClass(i).isInitialized()) {
+            
+            return false;
+          }
+        }
         return true;
       }
 
@@ -2426,6 +2628,372 @@ public final class DebugJvmModuleProtoBuf {
         return annotationBuilder_;
       }
 
+      private java.util.List<org.jetbrains.kotlin.metadata.DebugProtoBuf.Class> optionalAnnotationClass_ =
+        java.util.Collections.emptyList();
+      private void ensureOptionalAnnotationClassIsMutable() {
+        if (!((bitField0_ & 0x00000040) == 0x00000040)) {
+          optionalAnnotationClass_ = new java.util.ArrayList<org.jetbrains.kotlin.metadata.DebugProtoBuf.Class>(optionalAnnotationClass_);
+          bitField0_ |= 0x00000040;
+         }
+      }
+
+      private org.jetbrains.kotlin.protobuf.RepeatedFieldBuilder<
+          org.jetbrains.kotlin.metadata.DebugProtoBuf.Class, org.jetbrains.kotlin.metadata.DebugProtoBuf.Class.Builder, org.jetbrains.kotlin.metadata.DebugProtoBuf.ClassOrBuilder> optionalAnnotationClassBuilder_;
+
+      /**
+       * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+       *
+       * <pre>
+       * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+       * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+       * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+       * it to the corresponding class with the resolution capabilities of common modules.
+       * </pre>
+       */
+      public java.util.List<org.jetbrains.kotlin.metadata.DebugProtoBuf.Class> getOptionalAnnotationClassList() {
+        if (optionalAnnotationClassBuilder_ == null) {
+          return java.util.Collections.unmodifiableList(optionalAnnotationClass_);
+        } else {
+          return optionalAnnotationClassBuilder_.getMessageList();
+        }
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+       *
+       * <pre>
+       * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+       * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+       * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+       * it to the corresponding class with the resolution capabilities of common modules.
+       * </pre>
+       */
+      public int getOptionalAnnotationClassCount() {
+        if (optionalAnnotationClassBuilder_ == null) {
+          return optionalAnnotationClass_.size();
+        } else {
+          return optionalAnnotationClassBuilder_.getCount();
+        }
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+       *
+       * <pre>
+       * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+       * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+       * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+       * it to the corresponding class with the resolution capabilities of common modules.
+       * </pre>
+       */
+      public org.jetbrains.kotlin.metadata.DebugProtoBuf.Class getOptionalAnnotationClass(int index) {
+        if (optionalAnnotationClassBuilder_ == null) {
+          return optionalAnnotationClass_.get(index);
+        } else {
+          return optionalAnnotationClassBuilder_.getMessage(index);
+        }
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+       *
+       * <pre>
+       * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+       * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+       * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+       * it to the corresponding class with the resolution capabilities of common modules.
+       * </pre>
+       */
+      public Builder setOptionalAnnotationClass(
+          int index, org.jetbrains.kotlin.metadata.DebugProtoBuf.Class value) {
+        if (optionalAnnotationClassBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          ensureOptionalAnnotationClassIsMutable();
+          optionalAnnotationClass_.set(index, value);
+          onChanged();
+        } else {
+          optionalAnnotationClassBuilder_.setMessage(index, value);
+        }
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+       *
+       * <pre>
+       * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+       * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+       * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+       * it to the corresponding class with the resolution capabilities of common modules.
+       * </pre>
+       */
+      public Builder setOptionalAnnotationClass(
+          int index, org.jetbrains.kotlin.metadata.DebugProtoBuf.Class.Builder builderForValue) {
+        if (optionalAnnotationClassBuilder_ == null) {
+          ensureOptionalAnnotationClassIsMutable();
+          optionalAnnotationClass_.set(index, builderForValue.build());
+          onChanged();
+        } else {
+          optionalAnnotationClassBuilder_.setMessage(index, builderForValue.build());
+        }
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+       *
+       * <pre>
+       * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+       * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+       * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+       * it to the corresponding class with the resolution capabilities of common modules.
+       * </pre>
+       */
+      public Builder addOptionalAnnotationClass(org.jetbrains.kotlin.metadata.DebugProtoBuf.Class value) {
+        if (optionalAnnotationClassBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          ensureOptionalAnnotationClassIsMutable();
+          optionalAnnotationClass_.add(value);
+          onChanged();
+        } else {
+          optionalAnnotationClassBuilder_.addMessage(value);
+        }
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+       *
+       * <pre>
+       * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+       * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+       * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+       * it to the corresponding class with the resolution capabilities of common modules.
+       * </pre>
+       */
+      public Builder addOptionalAnnotationClass(
+          int index, org.jetbrains.kotlin.metadata.DebugProtoBuf.Class value) {
+        if (optionalAnnotationClassBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          ensureOptionalAnnotationClassIsMutable();
+          optionalAnnotationClass_.add(index, value);
+          onChanged();
+        } else {
+          optionalAnnotationClassBuilder_.addMessage(index, value);
+        }
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+       *
+       * <pre>
+       * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+       * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+       * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+       * it to the corresponding class with the resolution capabilities of common modules.
+       * </pre>
+       */
+      public Builder addOptionalAnnotationClass(
+          org.jetbrains.kotlin.metadata.DebugProtoBuf.Class.Builder builderForValue) {
+        if (optionalAnnotationClassBuilder_ == null) {
+          ensureOptionalAnnotationClassIsMutable();
+          optionalAnnotationClass_.add(builderForValue.build());
+          onChanged();
+        } else {
+          optionalAnnotationClassBuilder_.addMessage(builderForValue.build());
+        }
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+       *
+       * <pre>
+       * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+       * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+       * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+       * it to the corresponding class with the resolution capabilities of common modules.
+       * </pre>
+       */
+      public Builder addOptionalAnnotationClass(
+          int index, org.jetbrains.kotlin.metadata.DebugProtoBuf.Class.Builder builderForValue) {
+        if (optionalAnnotationClassBuilder_ == null) {
+          ensureOptionalAnnotationClassIsMutable();
+          optionalAnnotationClass_.add(index, builderForValue.build());
+          onChanged();
+        } else {
+          optionalAnnotationClassBuilder_.addMessage(index, builderForValue.build());
+        }
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+       *
+       * <pre>
+       * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+       * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+       * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+       * it to the corresponding class with the resolution capabilities of common modules.
+       * </pre>
+       */
+      public Builder addAllOptionalAnnotationClass(
+          java.lang.Iterable<? extends org.jetbrains.kotlin.metadata.DebugProtoBuf.Class> values) {
+        if (optionalAnnotationClassBuilder_ == null) {
+          ensureOptionalAnnotationClassIsMutable();
+          org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll(
+              values, optionalAnnotationClass_);
+          onChanged();
+        } else {
+          optionalAnnotationClassBuilder_.addAllMessages(values);
+        }
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+       *
+       * <pre>
+       * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+       * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+       * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+       * it to the corresponding class with the resolution capabilities of common modules.
+       * </pre>
+       */
+      public Builder clearOptionalAnnotationClass() {
+        if (optionalAnnotationClassBuilder_ == null) {
+          optionalAnnotationClass_ = java.util.Collections.emptyList();
+          bitField0_ = (bitField0_ & ~0x00000040);
+          onChanged();
+        } else {
+          optionalAnnotationClassBuilder_.clear();
+        }
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+       *
+       * <pre>
+       * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+       * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+       * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+       * it to the corresponding class with the resolution capabilities of common modules.
+       * </pre>
+       */
+      public Builder removeOptionalAnnotationClass(int index) {
+        if (optionalAnnotationClassBuilder_ == null) {
+          ensureOptionalAnnotationClassIsMutable();
+          optionalAnnotationClass_.remove(index);
+          onChanged();
+        } else {
+          optionalAnnotationClassBuilder_.remove(index);
+        }
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+       *
+       * <pre>
+       * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+       * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+       * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+       * it to the corresponding class with the resolution capabilities of common modules.
+       * </pre>
+       */
+      public org.jetbrains.kotlin.metadata.DebugProtoBuf.Class.Builder getOptionalAnnotationClassBuilder(
+          int index) {
+        return getOptionalAnnotationClassFieldBuilder().getBuilder(index);
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+       *
+       * <pre>
+       * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+       * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+       * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+       * it to the corresponding class with the resolution capabilities of common modules.
+       * </pre>
+       */
+      public org.jetbrains.kotlin.metadata.DebugProtoBuf.ClassOrBuilder getOptionalAnnotationClassOrBuilder(
+          int index) {
+        if (optionalAnnotationClassBuilder_ == null) {
+          return optionalAnnotationClass_.get(index);  } else {
+          return optionalAnnotationClassBuilder_.getMessageOrBuilder(index);
+        }
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+       *
+       * <pre>
+       * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+       * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+       * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+       * it to the corresponding class with the resolution capabilities of common modules.
+       * </pre>
+       */
+      public java.util.List<? extends org.jetbrains.kotlin.metadata.DebugProtoBuf.ClassOrBuilder> 
+           getOptionalAnnotationClassOrBuilderList() {
+        if (optionalAnnotationClassBuilder_ != null) {
+          return optionalAnnotationClassBuilder_.getMessageOrBuilderList();
+        } else {
+          return java.util.Collections.unmodifiableList(optionalAnnotationClass_);
+        }
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+       *
+       * <pre>
+       * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+       * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+       * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+       * it to the corresponding class with the resolution capabilities of common modules.
+       * </pre>
+       */
+      public org.jetbrains.kotlin.metadata.DebugProtoBuf.Class.Builder addOptionalAnnotationClassBuilder() {
+        return getOptionalAnnotationClassFieldBuilder().addBuilder(
+            org.jetbrains.kotlin.metadata.DebugProtoBuf.Class.getDefaultInstance());
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+       *
+       * <pre>
+       * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+       * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+       * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+       * it to the corresponding class with the resolution capabilities of common modules.
+       * </pre>
+       */
+      public org.jetbrains.kotlin.metadata.DebugProtoBuf.Class.Builder addOptionalAnnotationClassBuilder(
+          int index) {
+        return getOptionalAnnotationClassFieldBuilder().addBuilder(
+            index, org.jetbrains.kotlin.metadata.DebugProtoBuf.Class.getDefaultInstance());
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.metadata.Class optional_annotation_class = 16;</code>
+       *
+       * <pre>
+       * &#64;OptionalExpectation-annotated annotation classes in this module. This list is only used in the compiler frontend when compiling
+       * a second-tier multiplatform module against a multiplatform module which uses optional annotations, not actualized on the JVM.
+       * This is not needed in the IDE because optional annotations can only be used in common modules, where the IDE plugin resolves
+       * it to the corresponding class with the resolution capabilities of common modules.
+       * </pre>
+       */
+      public java.util.List<org.jetbrains.kotlin.metadata.DebugProtoBuf.Class.Builder> 
+           getOptionalAnnotationClassBuilderList() {
+        return getOptionalAnnotationClassFieldBuilder().getBuilderList();
+      }
+      private org.jetbrains.kotlin.protobuf.RepeatedFieldBuilder<
+          org.jetbrains.kotlin.metadata.DebugProtoBuf.Class, org.jetbrains.kotlin.metadata.DebugProtoBuf.Class.Builder, org.jetbrains.kotlin.metadata.DebugProtoBuf.ClassOrBuilder> 
+          getOptionalAnnotationClassFieldBuilder() {
+        if (optionalAnnotationClassBuilder_ == null) {
+          optionalAnnotationClassBuilder_ = new org.jetbrains.kotlin.protobuf.RepeatedFieldBuilder<
+              org.jetbrains.kotlin.metadata.DebugProtoBuf.Class, org.jetbrains.kotlin.metadata.DebugProtoBuf.Class.Builder, org.jetbrains.kotlin.metadata.DebugProtoBuf.ClassOrBuilder>(
+                  optionalAnnotationClass_,
+                  ((bitField0_ & 0x00000040) == 0x00000040),
+                  getParentForChildren(),
+                  isClean());
+          optionalAnnotationClass_ = null;
+        }
+        return optionalAnnotationClassBuilder_;
+      }
+
       // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.metadata.jvm.Module)
     }
 
@@ -4644,7 +5212,7 @@ public final class DebugJvmModuleProtoBuf {
       "\n,core/metadata.jvm/src/jvm_module.debug" +
       ".proto\022!org.jetbrains.kotlin.metadata.jv" +
       "m\032&core/metadata/src/metadata.debug.prot" +
-      "o\"\205\003\n\006Module\022F\n\rpackage_parts\030\001 \003(\0132/.or" +
+      "o\"\316\003\n\006Module\022F\n\rpackage_parts\030\001 \003(\0132/.or" +
       "g.jetbrains.kotlin.metadata.jvm.PackageP" +
       "arts\022G\n\016metadata_parts\030\002 \003(\0132/.org.jetbr" +
       "ains.kotlin.metadata.jvm.PackageParts\022\030\n" +
@@ -4653,16 +5221,18 @@ public final class DebugJvmModuleProtoBuf {
       "ringTable\022O\n\024qualified_name_table\030\005 \001(\0132",
       "1.org.jetbrains.kotlin.metadata.Qualifie" +
       "dNameTable\022=\n\nannotation\030\006 \003(\0132).org.jet" +
-      "brains.kotlin.metadata.Annotation\"\276\002\n\014Pa" +
-      "ckageParts\022\027\n\017package_fq_name\030\001 \002(\t\022\030\n\020s" +
-      "hort_class_name\030\002 \003(\t\022*\n\036multifile_facad" +
-      "e_short_name_id\030\003 \003(\005B\002\020\001\022#\n\033multifile_f" +
-      "acade_short_name\030\004 \003(\t\022.\n&class_with_jvm" +
-      "_package_name_short_name\030\005 \003(\t\022F\n:class_" +
-      "with_jvm_package_name_multifile_facade_s" +
-      "hort_name_id\030\007 \003(\005B\002\020\001\0222\n&class_with_jvm",
-      "_package_name_package_id\030\006 \003(\005B\002\020\001B\030B\026De" +
-      "bugJvmModuleProtoBuf"
+      "brains.kotlin.metadata.Annotation\022G\n\031opt" +
+      "ional_annotation_class\030\020 \003(\0132$.org.jetbr" +
+      "ains.kotlin.metadata.Class\"\276\002\n\014PackagePa" +
+      "rts\022\027\n\017package_fq_name\030\001 \002(\t\022\030\n\020short_cl" +
+      "ass_name\030\002 \003(\t\022*\n\036multifile_facade_short" +
+      "_name_id\030\003 \003(\005B\002\020\001\022#\n\033multifile_facade_s" +
+      "hort_name\030\004 \003(\t\022.\n&class_with_jvm_packag" +
+      "e_name_short_name\030\005 \003(\t\022F\n:class_with_jv",
+      "m_package_name_multifile_facade_short_na" +
+      "me_id\030\007 \003(\005B\002\020\001\0222\n&class_with_jvm_packag" +
+      "e_name_package_id\030\006 \003(\005B\002\020\001B\030B\026DebugJvmM" +
+      "oduleProtoBuf"
     };
     org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
         new org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
@@ -4682,7 +5252,7 @@ public final class DebugJvmModuleProtoBuf {
     internal_static_org_jetbrains_kotlin_metadata_jvm_Module_fieldAccessorTable = new
       org.jetbrains.kotlin.protobuf.GeneratedMessage.FieldAccessorTable(
         internal_static_org_jetbrains_kotlin_metadata_jvm_Module_descriptor,
-        new java.lang.String[] { "PackageParts", "MetadataParts", "JvmPackageName", "StringTable", "QualifiedNameTable", "Annotation", });
+        new java.lang.String[] { "PackageParts", "MetadataParts", "JvmPackageName", "StringTable", "QualifiedNameTable", "Annotation", "OptionalAnnotationClass", });
     internal_static_org_jetbrains_kotlin_metadata_jvm_PackageParts_descriptor =
       getDescriptor().getMessageTypes().get(1);
     internal_static_org_jetbrains_kotlin_metadata_jvm_PackageParts_fieldAccessorTable = new

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

@@ -18,6 +18,7 @@ public final class DebugJvmProtoBuf {
     registry.add(org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.classModuleName);
     registry.add(org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.classLocalVariable);
     registry.add(org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.anonymousObjectOriginName);
+    registry.add(org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.jvmClassFlags);
     registry.add(org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.packageModuleName);
     registry.add(org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.packageLocalVariable);
   }
@@ -4650,6 +4651,21 @@ public final class DebugJvmProtoBuf {
           .newFileScopedGeneratedExtension(
         java.lang.Integer.class,
         null);
+  public static final int JVM_CLASS_FLAGS_FIELD_NUMBER = 104;
+  /**
+   * <code>extend .org.jetbrains.kotlin.metadata.Class { ... }</code>
+   *
+   * <pre>
+   * isFunctionBodyInInterface: 0 if actual body generated in DefaultImpl, 1 - otherwise (in interface default method)
+   * </pre>
+   */
+  public static final
+    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.kotlin.metadata.DebugProtoBuf.Class,
+      java.lang.Integer> jvmClassFlags = org.jetbrains.kotlin.protobuf.GeneratedMessage
+          .newFileScopedGeneratedExtension(
+        java.lang.Integer.class,
+        null);
   public static final int PACKAGE_MODULE_NAME_FIELD_NUMBER = 101;
   /**
    * <code>extend .org.jetbrains.kotlin.metadata.Package { ... }</code>
@@ -4758,12 +4774,13 @@ public final class DebugJvmProtoBuf {
       "\'.org.jetbrains.kotlin.metadata.Property",
       ":P\n\034anonymous_object_origin_name\022$.org.j" +
       "etbrains.kotlin.metadata.Class\030g \001(\005B\004\230\265" +
-      "\030\001:I\n\023package_module_name\022&.org.jetbrain" +
-      "s.kotlin.metadata.Package\030e \001(\005B\004\230\265\030\001:o\n" +
-      "\026package_local_variable\022&.org.jetbrains." +
-      "kotlin.metadata.Package\030f \003(\0132\'.org.jetb" +
-      "rains.kotlin.metadata.PropertyB\022B\020DebugJ" +
-      "vmProtoBuf"
+      "\030\001:@\n\017jvm_class_flags\022$.org.jetbrains.ko" +
+      "tlin.metadata.Class\030h \001(\005:\0010:I\n\023package_" +
+      "module_name\022&.org.jetbrains.kotlin.metad" +
+      "ata.Package\030e \001(\005B\004\230\265\030\001:o\n\026package_local" +
+      "_variable\022&.org.jetbrains.kotlin.metadat" +
+      "a.Package\030f \003(\0132\'.org.jetbrains.kotlin.m" +
+      "etadata.PropertyB\022B\020DebugJvmProtoBuf"
     };
     org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
         new org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
@@ -4820,8 +4837,9 @@ public final class DebugJvmProtoBuf {
     classModuleName.internalInit(descriptor.getExtensions().get(8));
     classLocalVariable.internalInit(descriptor.getExtensions().get(9));
     anonymousObjectOriginName.internalInit(descriptor.getExtensions().get(10));
-    packageModuleName.internalInit(descriptor.getExtensions().get(11));
-    packageLocalVariable.internalInit(descriptor.getExtensions().get(12));
+    jvmClassFlags.internalInit(descriptor.getExtensions().get(11));
+    packageModuleName.internalInit(descriptor.getExtensions().get(12));
+    packageLocalVariable.internalInit(descriptor.getExtensions().get(13));
     org.jetbrains.kotlin.protobuf.ExtensionRegistry registry =
         org.jetbrains.kotlin.protobuf.ExtensionRegistry.newInstance();
     registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.stringIdInTable);

build.gradle.kts

@@ -1,14 +1,13 @@
 import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+import org.gradle.crypto.checksum.Checksum
 import org.gradle.plugins.ide.idea.model.IdeaModel
-import org.jetbrains.kotlin.gradle.tasks.AbstractKotlinCompile
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import proguard.gradle.ProGuardTask
 
 buildscript {
-    extra["defaultSnapshotVersion"] = "1.4-SNAPSHOT"
     val cacheRedirectorEnabled = findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() == true
 
-    kotlinBootstrapFrom(BootstrapOption.BintrayBootstrap("1.4.0-dev-1075", cacheRedirectorEnabled))
+    kotlinBootstrapFrom(BootstrapOption.BintrayBootstrap(kotlinBuildProperties.kotlinBootstrapVersion!!, cacheRedirectorEnabled))
 
     repositories {
         bootstrapKotlinRepo?.let(::maven)
@@ -28,9 +27,8 @@ buildscript {
     dependencies {
         bootstrapCompilerClasspath(kotlin("compiler-embeddable", bootstrapKotlinVersion))
 
-        classpath("com.gradle.publish:plugin-publish-plugin:0.9.7")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.17")
         classpath(kotlin("gradle-plugin", bootstrapKotlinVersion))
-        classpath("net.sf.proguard:proguard-gradle:6.1.0")
         classpath("org.jetbrains.dokka:dokka-gradle-plugin:0.9.17")
     }
 }
@@ -40,9 +38,12 @@ if (kotlinBuildProperties.buildScanServer != null) {
 }
 
 plugins {
+    base
     idea
     id("jps-compatible")
     id("org.jetbrains.gradle.plugin.idea-ext")
+    id("org.gradle.crypto.checksum") version "1.2.0"
+    signing
 }
 
 pill {
@@ -55,9 +56,6 @@ pill {
 }
 
 val isTeamcityBuild = project.kotlinBuildProperties.isTeamcityBuild
-val includeStdlibJsIr by extra(
-    findProperty("include.stdlib.js.ir")?.let { it.toString().toBoolean() } ?: isTeamcityBuild
-)
 
 val configuredJdks: List<JdkId> =
     getConfiguredJdks().also {
@@ -68,7 +66,11 @@ val configuredJdks: List<JdkId> =
 
 val defaultSnapshotVersion: String by extra
 val buildNumber by extra(findProperty("build.number")?.toString() ?: defaultSnapshotVersion)
-val kotlinVersion by extra(findProperty("deployVersion")?.toString() ?: buildNumber)
+val kotlinVersion by extra(
+        findProperty("deployVersion")?.toString()?.let { deploySnapshotStr ->
+            if (deploySnapshotStr != "default.snapshot") deploySnapshotStr else defaultSnapshotVersion
+        } ?: buildNumber
+)
 
 val kotlinLanguageVersion by extra("1.4")
 
@@ -148,6 +150,9 @@ rootProject.apply {
     from(rootProject.file("gradle/report.gradle.kts"))
     from(rootProject.file("gradle/javaInstrumentation.gradle.kts"))
     from(rootProject.file("gradle/jps.gradle.kts"))
+    from(rootProject.file("gradle/checkArtifacts.gradle.kts"))
+    from(rootProject.file("gradle/checkCacheability.gradle.kts"))
+    from(rootProject.file("gradle/retryPublishing.gradle.kts"))
 }
 
 IdeVersionConfigurator.setCurrentIde(project)
@@ -161,25 +166,28 @@ extra["versions.junit"] = "4.12"
 extra["versions.javaslang"] = "2.0.6"
 extra["versions.ant"] = "1.8.2"
 extra["versions.android"] = "2.3.1"
-val coroutinesVersion = if (Platform[192].orHigher()) "1.2.1" else "1.1.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.json"] = "20160807"
 extra["versions.native-platform"] = "0.14"
 extra["versions.ant-launcher"] = "1.8.0"
-extra["versions.robolectric"] = "3.1"
+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.0.2"
+extra["versions.completion-ranking-kotlin"] = "0.1.2"
 extra["versions.r8"] = "1.5.70"
+val immutablesVersion = "0.3.1"
+extra["versions.kotlinx-collections-immutable"] = immutablesVersion
+extra["versions.kotlinx-collections-immutable-jvm"] = immutablesVersion
 
 // NOTE: please, also change KTOR_NAME in pathUtil.kt and all versions in corresponding jar names in daemon tests.
 extra["versions.ktor-network"] = "1.0.1"
 
 if (!project.hasProperty("versions.kotlin-native")) {
-    extra["versions.kotlin-native"] = "1.4-dev-14287"
+    extra["versions.kotlin-native"] = "1.4-M3-dev-15627"
 }
 
 val intellijUltimateEnabled by extra(project.kotlinBuildProperties.intellijUltimateEnabled)
@@ -192,20 +200,25 @@ extra["intellijSeparateSdks"] = intellijSeparateSdks
 
 extra["IntellijCoreDependencies"] =
     listOf(
-        if (Platform[191].orHigher()) "asm-all-7.0.1" else "asm-all",
+        when {
+            Platform[202].orHigher() -> "asm-all-8.0.1"
+            else -> "asm-all-7.0.1"
+        },
         "guava",
         "jdom",
         "jna",
         "log4j",
-        "picocontainer",
+        if (Platform[201].orHigher()) null else "picocontainer",
         "snappy-in-java",
         "streamex",
         "trove4j"
-    )
+    ).filterNotNull()
 
 
 extra["compilerModules"] = arrayOf(
     ":compiler:util",
+    ":compiler:config",
+    ":compiler:config.jvm",
     ":compiler:container",
     ":compiler:resolution",
     ":compiler:serialization",
@@ -223,6 +236,7 @@ extra["compilerModules"] = arrayOf(
     ":compiler:ir.serialization.common",
     ":compiler:ir.serialization.js",
     ":compiler:ir.serialization.jvm",
+    ":compiler:ir.interpreter",
     ":kotlin-util-io",
     ":kotlin-util-klib",
     ":kotlin-util-klib-metadata",
@@ -230,16 +244,20 @@ extra["compilerModules"] = arrayOf(
     ":compiler:backend",
     ":compiler:plugin-api",
     ":compiler:light-classes",
+    ":compiler:javac-wrapper",
     ":compiler:cli",
     ":compiler:cli-js",
     ":compiler:incremental-compilation-impl",
+    ":compiler:compiler.version",
     ":js:js.ast",
     ":js:js.serializer",
     ":js:js.parser",
+    ":js:js.config",
     ":js:js.frontend",
     ":js:js.translator",
     ":js:js.dce",
     ":native:frontend.native",
+    ":native:kotlin-native-utils",
     ":compiler",
     ":kotlin-build-common",
     ":core:metadata",
@@ -252,23 +270,48 @@ extra["compilerModules"] = arrayOf(
     ":core:type-system",
     ":compiler:fir:cones",
     ":compiler:fir:resolve",
+    ":compiler:fir:fir-serialization",
     ":compiler:fir:tree",
-    ":compiler:fir:psi2fir",
-    ":compiler:fir:lightTree",
+    ":compiler:fir:raw-fir:fir-common",
+    ":compiler:fir:raw-fir:psi2fir",
+    ":compiler:fir:raw-fir:light-tree2fir",
     ":compiler:fir:fir2ir",
+    ":compiler:fir:fir2ir:jvm-backend",
     ":compiler:fir:java",
-    ":compiler:fir:jvm"
+    ":compiler:fir:jvm",
+    ":compiler:fir:checkers",
+    ":compiler:fir:analysis-tests"
+)
+
+extra["compilerModulesForJps"] = listOf(
+    ":core:type-system",
+    ":kotlin-build-common",
+    ":kotlin-util-io",
+    ":kotlin-util-klib",
+    ":kotlin-util-klib-metadata",
+    ":compiler:cli-common",
+    ":kotlin-compiler-runner",
+    ":daemon-common",
+    ":daemon-common-new",
+    ":core:descriptors",
+    ":core:descriptors.jvm",
+    ":idea:idea-jps-common",
+    ":kotlin-preloader",
+    ":compiler:util",
+    ":compiler:config",
+    ":compiler:config.jvm",
+    ":js:js.config",
+    ":core:util.runtime",
+    ":compiler:compiler.version"
 )
 
 val coreLibProjects = listOfNotNull(
     ":kotlin-stdlib",
     ":kotlin-stdlib-common",
     ":kotlin-stdlib-js",
-    // Exclude JS IR from core libs because it depends on local compiler build, which
-    // in turn depends on local JVM stdlib. It slows down library testing.
-    ":kotlin-stdlib-js-ir".takeIf { includeStdlibJsIr },
     ":kotlin-stdlib-jdk7",
     ":kotlin-stdlib-jdk8",
+    ":kotlin-test:kotlin-test-annotations-common",
     ":kotlin-test:kotlin-test-common",
     ":kotlin-test:kotlin-test-jvm",
     ":kotlin-test:kotlin-test-junit",
@@ -281,14 +324,10 @@ val coreLibProjects = listOfNotNull(
 
 val gradlePluginProjects = listOf(
     ":kotlin-gradle-plugin",
-    ":kotlin-gradle-plugin:plugin-marker",
     ":kotlin-gradle-plugin-api",
-//        ":kotlin-gradle-plugin-integration-tests",  // TODO: build fails
     ":kotlin-allopen",
-    ":kotlin-allopen:plugin-marker",
     ":kotlin-annotation-processing-gradle",
     ":kotlin-noarg",
-    ":kotlin-noarg:plugin-marker",
     ":kotlin-sam-with-receiver"
 )
 
@@ -314,11 +353,27 @@ fun Task.listConfigurationContents(configName: String) {
 
 val defaultJvmTarget = "1.8"
 val defaultJavaHome = jdkPath(defaultJvmTarget)
-val ignoreTestFailures by extra(project.findProperty("ignoreTestFailures")?.toString()?.toBoolean() ?: project.hasProperty("teamcity"))
+val ignoreTestFailures by extra(project.kotlinBuildProperties.ignoreTestFailures)
 
 allprojects {
 
-    configurations.maybeCreate("embedded")
+    configurations.maybeCreate("embedded").apply {
+        isCanBeConsumed = false
+        isCanBeResolved = true
+        attributes {
+            attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_RUNTIME))
+            attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objects.named(LibraryElements.JAR))
+        }
+    }
+
+    configurations.maybeCreate("embeddedElements").apply {
+        extendsFrom(configurations["embedded"])
+        isCanBeConsumed = true
+        isCanBeResolved = false
+        attributes {
+            attribute(Usage.USAGE_ATTRIBUTE, objects.named("embedded-java-runtime"))
+        }
+    }
 
     jvmTarget = defaultJvmTarget
     javaHome = defaultJavaHome
@@ -342,15 +397,17 @@ allprojects {
         maven("https://jetbrains.bintray.com/intellij-third-party-dependencies")
         maven("https://dl.google.com/dl/android/maven2")
         bootstrapKotlinRepo?.let(::maven)
-        internalKotlinRepo?.let(::maven)
+        internalBootstrapRepo?.let(::maven)
     }
 
     configureJvmProject(javaHome!!, jvmTarget!!)
 
     val commonCompilerArgs = listOfNotNull(
-        "-Xuse-experimental=kotlin.Experimental",
+        "-Xopt-in=kotlin.RequiresOptIn",
         "-Xread-deserialized-contracts",
         "-Xjvm-default=compatibility",
+        "-Xno-optimized-callable-references",
+        "-Xno-kotlin-nothing-value-exception",
         "-progressive".takeIf { hasProperty("test.progressive.mode") }
     )
 
@@ -385,12 +442,27 @@ allprojects {
         isReproducibleFileOrder = true
     }
 
+    tasks.withType<Test> {
+        outputs.doNotCacheIf("https://youtrack.jetbrains.com/issue/KT-37089") { true }
+    }
+
+    normalization {
+        runtimeClasspath {
+            ignore("META-INF/MANIFEST.MF")
+            ignore("META-INF/compiler.version")
+            ignore("META-INF/plugin.xml")
+        }
+    }
+
     tasks {
         register("listArchives") { listConfigurationContents("archives") }
 
         register("listRuntimeJar") { listConfigurationContents("runtimeJar") }
 
         register("listDistJar") { listConfigurationContents("distJar") }
+
+        // Aggregate task for build related checks
+        register("checkBuild")
     }
 
     afterEvaluate {
@@ -427,25 +499,17 @@ allprojects {
                 ?.exclude("org.jetbrains.kotlin", "kotlin-scripting-compiler-embeddable")
         }
 
-        // Aggregate task for build related checks
-        tasks.register("checkBuild")
-        
         apply(from = "$rootDir/gradle/cacheRedirector.gradle.kts")
     }
 }
 
 gradle.taskGraph.whenReady {
-    if (isTeamcityBuild) {
-        logger.warn("CI build profile is active (IC is off, proguard is on). Use -Pteamcity=false to reproduce local build")
-        for (task in allTasks) {
-            when (task) {
-                is AbstractKotlinCompile<*> -> task.incremental = false
-                is JavaCompile -> task.options.isIncremental = false
-            }
-        }
-    } else {
-        logger.warn("Local build profile is active (IC is on, proguard is off). Use -Pteamcity=true to reproduce TC build")
-    }
+    fun Boolean.toOnOff(): String = if (this) "on" else "off"
+    val profile = if (isTeamcityBuild) "CI" else "Local"
+
+    logger.warn("$profile build profile is active (proguard is ${kotlinBuildProperties.proguard.toOnOff()}" +
+                            ", jar compression is ${kotlinBuildProperties.jarCompression.toOnOff()})." +
+                            " Use -Pteamcity=<true|false> to reproduce CI/local build")
 
     allTasks.filterIsInstance<org.gradle.jvm.tasks.Jar>().forEach { task ->
         task.entryCompression = if (kotlinBuildProperties.jarCompression)
@@ -459,6 +523,10 @@ val dist = tasks.register("dist") {
     dependsOn(":kotlin-compiler:dist")
 }
 
+val syncMutedTests = tasks.register("syncMutedTests") {
+    dependsOn(":compiler:tests-mutes:run")
+}
+
 val copyCompilerToIdeaPlugin by task<Copy> {
     dependsOn(dist)
     into(ideaPluginDir)
@@ -471,7 +539,7 @@ val ideaPlugin by task<Task> {
 }
 
 tasks {
-    register("clean") {
+    named("clean") {
         doLast {
             delete("$buildDir/repo")
             delete(distDir)
@@ -484,7 +552,7 @@ tasks {
         }
     }
 
-    listOf("clean", "assemble", "install", "dist").forEach { taskName ->
+    listOf("clean", "assemble", "install").forEach { taskName ->
         register("coreLibs${taskName.capitalize()}") {
             coreLibProjects.forEach { projectName -> dependsOn("$projectName:$taskName") }
         }
@@ -493,6 +561,8 @@ tasks {
     register("coreLibsTest") {
         (coreLibProjects + listOf(
             ":kotlin-stdlib:samples",
+            ":kotlin-stdlib-js-ir",
+            ":kotlin-test:kotlin-test-js-ir".takeIf { !kotlinBuildProperties.isInJpsBuildIdeaSync },
             ":kotlin-test:kotlin-test-js:kotlin-test-js-it".takeIf { !kotlinBuildProperties.isInJpsBuildIdeaSync },
             ":kotlinx-metadata-jvm",
             ":tools:binary-compatibility-validator"
@@ -517,7 +587,7 @@ tasks {
             ":compiler:test",
             ":compiler:container:test",
             ":compiler:tests-java8:test",
-            ":compiler:tests-spec:remoteRunTests",
+            ":compiler:tests-spec:test",
             ":compiler:tests-against-klib:test"
         )
         dependsOn(":plugins:jvm-abi-gen:test")
@@ -536,16 +606,32 @@ tasks {
     }
 
     register("wasmCompilerTest") {
-        dependsOn(":js:js.tests:wasmTest")
+//  TODO: fix once
+//        dependsOn(":js:js.tests:wasmTest")
+    }
+
+    register("nativeCompilerTest") {
+        dependsOn(":native:kotlin-native-utils:test")
     }
 
     register("firCompilerTest") {
-        dependsOn(":compiler:fir:psi2fir:test")
-        dependsOn(":compiler:fir:resolve:test")
+        dependsOn(":compiler:fir:raw-fir:psi2fir:test")
+        dependsOn(":compiler:fir:raw-fir:light-tree2fir:test")
+        dependsOn(":compiler:fir:analysis-tests:test")
         dependsOn(":compiler:fir:fir2ir:test")
-        dependsOn(":compiler:fir:lightTree:test")
     }
-    
+
+    register("firAllTest") {
+        dependsOn(
+            ":dist",
+            ":compiler:fir:raw-fir:psi2fir:test",
+            ":compiler:fir:raw-fir:light-tree2fir:test",
+            ":compiler:fir:analysis-tests:test",
+            ":compiler:fir:fir2ir:test",
+            ":plugins:fir:fir-plugin-prototype:test"
+        )
+    }
+
     register("compilerFrontendVisualizerTest") {
         dependsOn("compiler:visualizer:test")
     }
@@ -553,7 +639,7 @@ tasks {
     register("scriptingTest") {
         dependsOn("dist")
         dependsOn(":kotlin-script-util:test")
-        dependsOn(":kotlin-scripting-compiler:test")
+        dependsOn(":kotlin-scripting-compiler-embeddable:test")
         dependsOn(":kotlin-scripting-common:test")
         dependsOn(":kotlin-scripting-jvm:test")
         dependsOn(":kotlin-scripting-jvm-host-test:test")
@@ -564,14 +650,23 @@ tasks {
 //        dependsOn(":kotlin-scripting-jvm-host-test:embeddableTest")
         dependsOn(":kotlin-scripting-jsr223-test:embeddableTest")
         dependsOn(":kotlin-main-kts-test:test")
+        dependsOn(":kotlin-scripting-ide-services-test:test")
+        dependsOn(":kotlin-scripting-ide-services-test:embeddableTest")
+        dependsOn(":kotlin-scripting-js-test:test")
     }
 
     register("compilerTest") {
         dependsOn("jvmCompilerTest")
         dependsOn("jsCompilerTest")
+        dependsOn("miscCompilerTest")
+    }
+
+    register("miscCompilerTest") {
         dependsOn("wasmCompilerTest")
+        dependsOn("nativeCompilerTest")
         dependsOn("firCompilerTest")
 
+        dependsOn(":kotlin-daemon-tests:test")
         dependsOn("scriptingTest")
         dependsOn(":kotlin-build-common:test")
         dependsOn(":compiler:incremental-compilation-impl:test")
@@ -582,6 +677,7 @@ tasks {
 
     register("toolsTest") {
         dependsOn(":tools:kotlinp:test")
+        dependsOn(":native:kotlin-klib-commonizer:test")
     }
 
     register("examplesTest") {
@@ -612,13 +708,6 @@ tasks {
         dependsOn(":jps-plugin:test")
     }
 
-    register("konan-tests") {
-        dependsOn("dist")
-        dependsOn(
-            ":native:kotlin-native-commonizer:test"
-        )
-    }
-
     register("idea-plugin-main-tests") {
         dependsOn("dist")
         dependsOn(":idea:test")
@@ -640,20 +729,32 @@ tasks {
         )
     }
 
-    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"
-        )
+    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",
+                ":idea:idea-new-project-wizard:test"
+            )
+        }
     }
 
     register("idea-plugin-tests") {
         dependsOn("dist")
         dependsOn(
             "idea-plugin-main-tests",
-            "idea-plugin-additional-tests",
-            "idea-new-project-wizard-tests"
+            "idea-plugin-additional-tests"
+        )
+        if (Ide.IJ()) {
+            dependsOn("idea-new-project-wizard-tests")
+        }
+    }
+
+    register("idea-plugin-performance-tests") {
+        dependsOn("dist")
+        dependsOn(
+            ":idea:performanceTests:performanceTest"
         )
     }
 
@@ -670,7 +771,6 @@ tasks {
         dependsOn("dist")
         dependsOn(
             ":kotlin-annotation-processing:test",
-            ":kotlin-source-sections-compiler-plugin:test",
             ":kotlin-allopen-compiler-plugin:test",
             ":kotlin-noarg-compiler-plugin:test",
             ":kotlin-sam-with-receiver-compiler-plugin:test",
@@ -687,13 +787,60 @@ tasks {
         dependsOn(
             "idea-plugin-tests",
             "jps-tests",
-            "konan-tests",
             "plugins-tests",
             "android-ide-tests",
             ":generators:test"
         )
     }
 
+    register("publishIdeArtifacts") {
+        idePluginDependency {
+            dependsOn(
+                ":prepare:ide-plugin-dependencies:android-extensions-compiler-plugin-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:allopen-compiler-plugin-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:allopen-compiler-plugin-tests-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:incremental-compilation-impl-tests-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:kotlin-build-common-tests-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:kotlin-compiler-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:kotlin-dist-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:kotlin-gradle-statistics-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:kotlinx-serialization-compiler-plugin-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:noarg-compiler-plugin-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:sam-with-receiver-compiler-plugin-for-ide:publish",
+                ":prepare:ide-plugin-dependencies:compiler-components-for-jps:publish",
+                ":kotlin-script-runtime:publish",
+                ":kotlin-script-util:publish",
+                ":kotlin-scripting-common:publish",
+                ":kotlin-scripting-jvm:publish",
+                ":kotlin-scripting-compiler:publish",
+                ":kotlin-scripting-compiler-impl:publish",
+                ":kotlin-android-extensions-runtime:publish",
+                ":kotlin-stdlib-common:publish",
+                ":kotlin-stdlib:publish",
+                ":kotlin-stdlib-jdk7:publish",
+                ":kotlin-stdlib-jdk8:publish",
+                ":kotlin-reflect:publish",
+                ":kotlin-main-kts:publish",
+                ":kotlin-stdlib-js:publish",
+                ":kotlin-test:kotlin-test-js:publish"
+            )
+        }
+    }
+
+    register("kmmTest", AggregateTest::class) {
+        dependsOn(
+            ":idea:idea-gradle:test",
+            ":idea:test",
+            ":compiler:test",
+            ":js:js.tests:test"
+        )
+        if (Ide.IJ193.orHigher())
+            dependsOn(":kotlin-gradle-plugin-integration-tests:test")
+        if (Ide.AS40.orHigher())
+            dependsOn(":kotlin-ultimate:ide:android-studio-native:test")
+
+        testPatternFile = file("tests/mpp/kmm-patterns.csv")
+    }
 
     register("test") {
         doLast {
@@ -701,9 +848,17 @@ tasks {
         }
     }
 
-    register("check") {
+    named("check") {
         dependsOn("test")
     }
+
+    named("checkBuild") {
+        if (kotlinBuildProperties.isTeamcityBuild) {
+            doFirst {
+                println("##teamcity[setParameter name='bootstrap.kotlin.version' value='$bootstrapKotlinVersion']")
+            }
+        }
+    }
 }
 
 fun CopySpec.setExecutablePermissions() {
@@ -713,15 +868,15 @@ fun CopySpec.setExecutablePermissions() {
 
 val zipCompiler by task<Zip> {
     dependsOn(dist)
-    destinationDir = file(distDir)
-    archiveName = "kotlin-compiler-$kotlinVersion.zip"
+    destinationDirectory.set(file(distDir))
+    archiveFileName.set("kotlin-compiler-$kotlinVersion.zip")
 
     from(distKotlinHomeDir)
     into("kotlinc")
     setExecutablePermissions()
 
     doLast {
-        logger.lifecycle("Compiler artifacts packed to $archivePath")
+        logger.lifecycle("Compiler artifacts packed to ${archiveFile.get().asFile.absolutePath}")
     }
 }
 
@@ -730,6 +885,7 @@ val zipStdlibTests by task<Zip> {
     archiveFileName.set("kotlin-stdlib-tests.zip")
     from("libraries/stdlib/common/test") { into("common") }
     from("libraries/stdlib/test") { into("test") }
+    from("libraries/kotlin.test/common/src/test/kotlin") { into("kotlin-test") }
     doLast {
         logger.lifecycle("Stdlib tests are packed to ${archiveFile.get()}")
     }
@@ -758,21 +914,45 @@ val zipPlugin by task<Zip> {
     }
     val destPath = project.findProperty("pluginZipPath") as String?
     val dest = File(destPath ?: "$buildDir/kotlin-plugin.zip")
-    destinationDir = dest.parentFile
-    archiveName = dest.name
-    doFirst {
-        if (destPath == null) throw GradleException("Specify target zip path with 'pluginZipPath' property")
-    }
+    destinationDirectory.set(dest.parentFile)
+    archiveFileName.set(dest.name)
 
     from(src)
     into("Kotlin")
     setExecutablePermissions()
 
     doLast {
-        logger.lifecycle("Plugin artifacts packed to $archivePath")
+        logger.lifecycle("Plugin artifacts packed to $archiveFile")
     }
 }
 
+fun Project.secureZipTask(zipTask: TaskProvider<Zip>): RegisteringDomainObjectDelegateProviderWithAction<out TaskContainer, Task> {
+    val checkSumTask = tasks.register("${zipTask.name}Checksum", Checksum::class) {
+        dependsOn(zipTask)
+        val compilerFile = zipTask.get().outputs.files.singleFile
+        files = files(compilerFile)
+        outputDir = compilerFile.parentFile
+        algorithm = Checksum.Algorithm.SHA256
+    }
+
+    val signTask = tasks.register("${zipTask.name}Sign", Sign::class) {
+        description = "Signs the archive produced by the '" + zipTask.name + "' task."
+        sign(zipTask.get())
+    }
+
+    return tasks.registering {
+        dependsOn(checkSumTask)
+        dependsOn(signTask)
+    }
+}
+
+signing {
+    useGpgCmd()
+}
+
+val zipCompilerWithSignature by secureZipTask(zipCompiler)
+val zipPluginWithSignature by secureZipTask(zipPlugin)
+
 configure<IdeaModel> {
     module {
         excludeDirs = files(
@@ -900,3 +1080,15 @@ val Jar.outputFile: File
 
 val Project.sourceSetsOrNull: SourceSetContainer?
     get() = convention.findPlugin(JavaPluginConvention::class.java)?.sourceSets
+
+val disableVerificationTasks = System.getProperty("disable.verification.tasks") == "true"
+if (disableVerificationTasks) {
+    gradle.taskGraph.whenReady {
+        allTasks.forEach {
+            if (it is VerificationTask) {
+                logger.info("DISABLED: '$it'")
+                it.enabled = false
+            }
+        }
+    }
+}

buildSrc/build.gradle.kts

@@ -1,11 +1,11 @@
-extra["versions.shadow"] = "5.2.0"
 extra["versions.native-platform"] = "0.14"
 
 buildscript {
+
     val cacheRedirectorEnabled = findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() == true
 
-    val buildSrcKotlinVersion: String by extra(findProperty("buildSrc.kotlin.version")?.toString() ?: embeddedKotlinVersion)
-    val buildSrcKotlinRepo: String? by extra(findProperty("buildSrc.kotlin.repo") as String?)
+    extra["defaultSnapshotVersion"] = kotlinBuildProperties.defaultSnapshotVersion
+    kotlinBootstrapFrom(BootstrapOption.BintrayBootstrap(kotlinBuildProperties.kotlinBootstrapVersion!!, cacheRedirectorEnabled))
 
     repositories {
         if (cacheRedirectorEnabled) {
@@ -16,27 +16,29 @@ buildscript {
             maven("https://kotlin.bintray.com/kotlin-dependencies")
         }
 
-        buildSrcKotlinRepo?.let {
+        project.bootstrapKotlinRepo?.let {
             maven(url = it)
         }
     }
 
     dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.8")
-        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:$buildSrcKotlinVersion")
-        classpath("org.jetbrains.kotlin:kotlin-sam-with-receiver:$buildSrcKotlinVersion")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.17")
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${project.bootstrapKotlinVersion}")
+        classpath("org.jetbrains.kotlin:kotlin-sam-with-receiver:${project.bootstrapKotlinVersion}")
     }
 }
 
 val cacheRedirectorEnabled = findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() == true
 
-logger.info("buildSrcKotlinVersion: " + extra["buildSrcKotlinVersion"])
+logger.info("buildSrcKotlinVersion: " + extra["bootstrapKotlinVersion"])
 logger.info("buildSrc kotlin compiler version: " + org.jetbrains.kotlin.config.KotlinCompilerVersion.VERSION)
 logger.info("buildSrc stdlib version: " + KotlinVersion.CURRENT)
 
 apply {
     plugin("kotlin")
     plugin("kotlin-sam-with-receiver")
+
+    from("../gradle/checkCacheability.gradle.kts")
 }
 
 plugins {
@@ -46,10 +48,6 @@ plugins {
 
 gradlePlugin {
     plugins {
-        register("pill-configurable") {
-            id = "pill-configurable"
-            implementationClass = "org.jetbrains.kotlin.pill.PillConfigurablePlugin"
-        }
         register("jps-compatible") {
             id = "jps-compatible"
             implementationClass = "org.jetbrains.kotlin.pill.JpsCompatiblePlugin"
@@ -57,6 +55,10 @@ gradlePlugin {
     }
 }
 
+kotlinDslPluginOptions {
+    experimentalWarning.set(false)
+}
+
 fun Project.getBooleanProperty(name: String): Boolean? = this.findProperty(name)?.let {
     val v = it.toString()
     if (v.isBlank()) true
@@ -70,12 +72,12 @@ rootProject.apply {
 val isTeamcityBuild = kotlinBuildProperties.isTeamcityBuild
 val intellijUltimateEnabled by extra(kotlinBuildProperties.intellijUltimateEnabled)
 val intellijSeparateSdks by extra(project.getBooleanProperty("intellijSeparateSdks") ?: false)
-val verifyDependencyOutput by extra( getBooleanProperty("kotlin.build.dependency.output.verification") ?: isTeamcityBuild)
 
-extra["intellijReleaseType"] = if (extra["versions.intellijSdk"]?.toString()?.endsWith("SNAPSHOT") == true)
-    "snapshots"
-else
-    "releases"
+extra["intellijReleaseType"] = when {
+    extra["versions.intellijSdk"]?.toString()?.contains("-EAP-") == true -> "snapshots"
+    extra["versions.intellijSdk"]?.toString()?.endsWith("SNAPSHOT") == true -> "nightly"
+    else -> "releases"
+}
 
 extra["versions.androidDxSources"] = "5.0.0_r2"
 
@@ -87,22 +89,25 @@ repositories {
     maven("https://kotlin.bintray.com/kotlin-dependencies")
     gradlePluginPortal()
 
-    extra["buildSrcKotlinRepo"]?.let {
+    extra["bootstrapKotlinRepo"]?.let {
         maven(url = it)
     }
 }
 
 dependencies {
     implementation(kotlin("stdlib", embeddedKotlinVersion))
-    implementation("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.8")
+    implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:${project.bootstrapKotlinVersion}")
+    implementation("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.17")
+    implementation("com.gradle.publish:plugin-publish-plugin:0.11.0")
 
     implementation("net.rubygrapefruit:native-platform:${property("versions.native-platform")}")
     implementation("net.rubygrapefruit:native-platform-windows-amd64:${property("versions.native-platform")}")
     implementation("net.rubygrapefruit:native-platform-windows-i386:${property("versions.native-platform")}")
     implementation("com.jakewharton.dex:dex-method-list:3.0.0")
 
-    implementation("com.github.jengelman.gradle.plugins:shadow:${property("versions.shadow")}")
-    implementation("org.jetbrains.intellij.deps:asm-all:7.0.1")
+    implementation("com.github.jengelman.gradle.plugins:shadow:${rootProject.extra["versions.shadow"]}")
+    implementation("net.sf.proguard:proguard-gradle:6.2.2")
+    implementation("org.jetbrains.intellij.deps:asm-all:8.0.1")
 
     implementation("gradle.plugin.org.jetbrains.gradle.plugin.idea-ext:gradle-idea-ext:0.5")
 }

buildSrc/gradle.properties.as35

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

buildSrc/gradle.properties.as36

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

buildSrc/gradle.properties.as40

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

buildSrc/prepare-deps/build.gradle.kts

@@ -2,18 +2,20 @@
 
 import org.gradle.internal.os.OperatingSystem
 import java.io.Closeable
-import java.io.FileWriter
 import java.io.OutputStreamWriter
 import java.net.URI
 import java.text.SimpleDateFormat
 import java.util.*
 import javax.xml.stream.XMLOutputFactory
 
+import org.jetbrains.kotlin.gradle.tasks.internal.CleanableStore
+import java.time.Duration
+import java.time.Instant
+
 plugins {
     base
 }
 
-val verifyDependencyOutput: Boolean by rootProject.extra
 val intellijUltimateEnabled: Boolean by rootProject.extra
 val intellijReleaseType: String by rootProject.extra
 val intellijVersion = rootProject.extra["versions.intellijSdk"] as String
@@ -22,7 +24,7 @@ val androidStudioRelease = rootProject.findProperty("versions.androidStudioRelea
 val androidStudioBuild = rootProject.findProperty("versions.androidStudioBuild") as String?
 val intellijSeparateSdks: Boolean by rootProject.extra
 val installIntellijCommunity = !intellijUltimateEnabled || intellijSeparateSdks
-val installIntellijUltimate = intellijUltimateEnabled
+val installIntellijUltimate = intellijUltimateEnabled && androidStudioRelease == null
 
 val intellijVersionDelimiterIndex = intellijVersion.indexOfAny(charArrayOf('.', '-'))
 if (intellijVersionDelimiterIndex == -1) {
@@ -31,7 +33,6 @@ if (intellijVersionDelimiterIndex == -1) {
 
 val platformBaseVersion = intellijVersion.substring(0, intellijVersionDelimiterIndex)
 
-logger.info("verifyDependencyOutput: $verifyDependencyOutput")
 logger.info("intellijUltimateEnabled: $intellijUltimateEnabled")
 logger.info("intellijVersion: $intellijVersion")
 logger.info("androidStudioRelease: $androidStudioRelease")
@@ -105,7 +106,7 @@ val nodeJSPlugin by configurations.creating
 val intellijRuntimeAnnotations = "intellij-runtime-annotations"
 
 val dependenciesDir = (findProperty("kotlin.build.dependencies.dir") as String?)?.let(::File)
-    ?: rootProject.rootDir.parentFile.resolve("dependencies")
+    ?: rootProject.gradle.gradleUserHomeDir.resolve("kotlin-build-dependencies")
 
 val customDepsRepoDir = dependenciesDir.resolve("repo")
 
@@ -147,14 +148,20 @@ val makeIntellijCore = buildIvyRepositoryTask(intellijCore, customDepsOrg, custo
 val makeIntellijAnnotations by tasks.registering(Copy::class) {
     dependsOn(makeIntellijCore)
 
-    from(repoDir.resolve("intellij-core/$intellijVersion/artifacts/annotations.jar"))
+    val intellijCoreRepo = CleanableStore[repoDir.resolve("intellij-core").absolutePath][intellijVersion].use()
+    from(intellijCoreRepo.resolve("artifacts/annotations.jar"))
 
-    val targetDir = File(repoDir, "$intellijRuntimeAnnotations/$intellijVersion")
+    val annotationsStore = CleanableStore[repoDir.resolve(intellijRuntimeAnnotations).absolutePath]
+    val targetDir = annotationsStore[intellijVersion].use()
     into(targetDir)
 
     val ivyFile = File(targetDir, "$intellijRuntimeAnnotations.ivy.xml")
     outputs.files(ivyFile)
 
+    doFirst {
+        annotationsStore.cleanStore()
+    }
+
     doLast {
         writeIvyXml(
             customDepsOrg,
@@ -171,7 +178,11 @@ val makeIntellijAnnotations by tasks.registering(Copy::class) {
 
 val mergeSources by tasks.creating(Jar::class.java) {
     dependsOn(sources)
-    from(provider { sources.map(::zipTree) })
+    isPreserveFileTimestamps = false
+    isReproducibleFileOrder = true
+    if (!kotlinBuildProperties.isTeamcityBuild) {
+        from(provider { sources.map(::zipTree) })
+    }
     destinationDirectory.set(File(repoDir, sources.name))
     archiveBaseName.set("intellij")
     archiveClassifier.set("sources")
@@ -186,8 +197,8 @@ val makeIde = if (androidStudioBuild != null) {
         customDepsOrg,
         customDepsRepoDir,
         if (androidStudioOs == "mac")
-            ::skipContentsDirectory 
-        else 
+            ::skipContentsDirectory
+        else
             ::skipToplevelDirectory
     )
 } else {
@@ -205,7 +216,6 @@ val makeIde = if (androidStudioBuild != null) {
 }
 
 val buildJpsStandalone = buildIvyRepositoryTask(jpsStandalone, customDepsOrg, customDepsRepoDir, null, sourcesFile)
-val buildNodeJsPlugin = buildIvyRepositoryTask(nodeJSPlugin, customDepsOrg, customDepsRepoDir, ::skipToplevelDirectory, sourcesFile)
 
 tasks.named("build") {
     dependsOn(
@@ -215,15 +225,12 @@ tasks.named("build") {
         makeIntellijAnnotations
     )
 
-    if (installIntellijUltimate) {
-        dependsOn(buildNodeJsPlugin)
-    }
 }
 
-// Task to delete legacy repo locations
-tasks.register<Delete>("cleanLegacy") {
-    delete("$projectDir/android-dx")
-    delete("$projectDir/intellij-sdk")
+if (installIntellijUltimate) {
+    val buildNodeJsPlugin =
+        buildIvyRepositoryTask(nodeJSPlugin, customDepsOrg, customDepsRepoDir, ::skipToplevelDirectory, sourcesFile)
+    tasks.named("build") { dependsOn(buildNodeJsPlugin) }
 }
 
 tasks.named<Delete>("clean") {
@@ -236,86 +243,96 @@ fun buildIvyRepositoryTask(
     repoDirectory: File,
     pathRemap: ((String) -> String)? = null,
     sources: File? = null
-) = tasks.register("buildIvyRepositoryFor${configuration.name.capitalize()}") {
+): TaskProvider<Task> {
+    fun ResolvedArtifact.storeDirectory(): CleanableStore =
+        CleanableStore[repoDirectory.resolve("$organization/${moduleVersion.id.name}").absolutePath]
 
     fun ResolvedArtifact.moduleDirectory(): File =
-        File(repoDirectory, "$organization/${moduleVersion.id.name}/${moduleVersion.id.version}")
+        storeDirectory()[moduleVersion.id.version].use()
 
-    dependsOn(configuration)
-    inputs.files(configuration)
+    return tasks.register("buildIvyRepositoryFor${configuration.name.capitalize()}") {
+        dependsOn(configuration)
+        inputs.files(configuration)
 
-    if (verifyDependencyOutput) {
-        outputs.dir(provider {
-            configuration.resolvedConfiguration.resolvedArtifacts.single().moduleDirectory()
-        })
-    } else {
         outputs.upToDateWhen {
             configuration.resolvedConfiguration.resolvedArtifacts.single()
                 .moduleDirectory()
                 .exists()
         }
-    }
 
-    doFirst {
-        configuration.resolvedConfiguration.resolvedArtifacts.single().run {
-            val moduleDirectory = moduleDirectory()
-            val artifactsDirectory = File(moduleDirectory(), "artifacts")
+        doFirst {
+            val artifact = configuration.resolvedConfiguration.resolvedArtifacts.single()
+            val moduleDirectory = artifact.moduleDirectory()
 
-            logger.info("Unpacking ${file.name} into ${artifactsDirectory.absolutePath}")
-            copy {
-                val fileTree = when (extension) {
-                    "tar.gz" -> tarTree(file)
-                    "zip" -> zipTree(file)
-                    else -> error("Unsupported artifact extension: $extension")
-                }
+            artifact.storeDirectory().cleanStore()
 
-                from(fileTree.matching {
-                    exclude("**/plugins/Kotlin/**")
-                })
-
-                into(artifactsDirectory)
-
-                if (pathRemap != null) {
-                    eachFile {
-                        path = pathRemap(path)
-                    }
-                }
-
-                includeEmptyDirs = false
+            if (moduleDirectory.exists()) {
+                logger.info("Path ${moduleDirectory.absolutePath} already exists, skipping unpacking.")
+                return@doFirst
             }
 
-            writeIvyXml(
-                organization,
-                moduleVersion.id.name,
-                moduleVersion.id.version,
-                moduleVersion.id.name,
-                File(artifactsDirectory, "lib"),
-                File(artifactsDirectory, "lib"),
-                File(moduleDirectory, "ivy"),
-                *listOfNotNull(sources).toTypedArray()
-            )
-
-            val pluginsDirectory = File(artifactsDirectory, "plugins")
-            if (pluginsDirectory.exists()) {
-                file(File(artifactsDirectory, "plugins"))
-                    .listFiles { file: File -> file.isDirectory }
-                    .forEach {
-                        writeIvyXml(
-                            organization,
-                            it.name,
-                            moduleVersion.id.version,
-                            it.name,
-                            File(it, "lib"),
-                            File(it, "lib"),
-                            File(moduleDirectory, "ivy"),
-                            *listOfNotNull(sources).toTypedArray()
-                        )
+            with(artifact) {
+                val artifactsDirectory = File(moduleDirectory, "artifacts")
+                logger.info("Unpacking ${file.name} into ${artifactsDirectory.absolutePath}")
+                copy {
+                    val fileTree = when (extension) {
+                        "tar.gz" -> tarTree(file)
+                        "zip" -> zipTree(file)
+                        else -> error("Unsupported artifact extension: $extension")
                     }
+
+                    from(
+                        fileTree.matching {
+                            exclude("**/plugins/Kotlin/**")
+                        }
+                    )
+
+                    into(artifactsDirectory)
+
+                    if (pathRemap != null) {
+                        eachFile {
+                            path = pathRemap(path)
+                        }
+                    }
+
+                    includeEmptyDirs = false
+                }
+
+                writeIvyXml(
+                    organization,
+                    moduleVersion.id.name,
+                    moduleVersion.id.version,
+                    moduleVersion.id.name,
+                    File(artifactsDirectory, "lib"),
+                    File(artifactsDirectory, "lib"),
+                    File(moduleDirectory, "ivy"),
+                    *listOfNotNull(sources).toTypedArray()
+                )
+
+                val pluginsDirectory = File(artifactsDirectory, "plugins")
+                if (pluginsDirectory.exists()) {
+                    file(File(artifactsDirectory, "plugins"))
+                        .listFiles { file: File -> file.isDirectory }
+                        .forEach {
+                            writeIvyXml(
+                                organization,
+                                it.name,
+                                moduleVersion.id.version,
+                                it.name,
+                                File(it, "lib"),
+                                File(it, "lib"),
+                                File(moduleDirectory, "ivy"),
+                                *listOfNotNull(sources).toTypedArray()
+                            )
+                        }
+                }
             }
         }
     }
 }
 
+fun CleanableStore.cleanStore() = cleanDir(Instant.now().minus(Duration.ofDays(30)))
+
 fun writeIvyXml(
     organization: String,
     moduleName: String,
@@ -335,7 +352,7 @@ fun writeIvyXml(
 
     val ivyFile = targetDir.resolve("$fileName.ivy.xml")
     ivyFile.parentFile.mkdirs()
-    with(XMLWriter(FileWriter(ivyFile))) {
+    with(XMLWriter(ivyFile.writer())) {
         document("UTF-8", "1.0") {
             element("ivy-module") {
                 attribute("version", "2.0")
@@ -359,24 +376,24 @@ fun writeIvyXml(
                 }
 
                 element("publications") {
-                    artifactDir.listFiles()?.filter(::shouldIncludeIntellijJar)?.forEach { jarFile ->
-                        val relativeName = jarFile.toRelativeString(baseDir).removeSuffix(".jar")
-                        emptyElement("artifact") {
-                            attributes(
-                                "name" to relativeName,
-                                "type" to "jar",
-                                "ext" to "jar",
-                                "conf" to "default"
-                            )
-                        }
+                    artifactDir.listFiles()
+                        ?.filter(::shouldIncludeIntellijJar)
+                        ?.sortedBy { it.name.toLowerCase() }
+                        ?.forEach { jarFile ->
+                            val relativeName = jarFile.toRelativeString(baseDir).removeSuffix(".jar")
+                            emptyElement("artifact") {
+                                attributes(
+                                    "name" to relativeName,
+                                    "type" to "jar",
+                                    "ext" to "jar",
+                                    "conf" to "default"
+                                )
+                            }
                     }
 
                     sourcesJar.forEach { jarFile ->
                         emptyElement("artifact") {
-                            val sourcesArtifactName = jarFile.name
-                                .substringBeforeLast("-")
-                                .substringBeforeLast("-")
-
+                            val sourcesArtifactName = jarFile.name.substringBefore("-$version")
                             attributes(
                                 "name" to sourcesArtifactName,
                                 "type" to "jar",

buildSrc/settings.gradle

@@ -20,15 +20,13 @@ buildscript {
         }
     }
     dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.8")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.17")
     }
 }
 
 def buildProperties = BuildPropertiesKt.getKotlinBuildPropertiesForSettings(settings)
 def projectVersions = file("../gradle/versions.properties").text
 
-BuildCacheKt.setupBuildCache(settings)
-
 include "prepare-deps"
 
 def target_AppCode_Clion = buildProperties.includeCidrPlugins && !projectVersions.contains("versions.androidStudioRelease")
@@ -39,9 +37,12 @@ if (target_AppCode_Clion) {
     logger.info("Including modules for AC and CL in buildSrc/settings.gradle")
 
     include ":prepare-deps:kotlin-native-platform-deps"
+    include ":prepare-deps:native-debug-plugin"
 
     project(":prepare-deps:kotlin-native-platform-deps").projectDir =
             file("${buildProperties.propertiesProvider.rootProjectDir}/kotlin-ultimate/buildSrc/prepare-deps/kotlin-native-platform-deps")
+    project(":prepare-deps:native-debug-plugin").projectDir =
+            file("${buildProperties.propertiesProvider.rootProjectDir}/kotlin-ultimate/buildSrc/prepare-deps/native-debug-plugin")
 } else if (target_AndroidStudio) {
     logger.info("Including modules for AS (mobile plugin) in buildSrc/settings.gradle")
 

buildSrc/src/main/kotlin/AggregateTest.kt

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

buildSrc/src/main/kotlin/Bootstrap.kt

@@ -1,114 +0,0 @@
-@file:Suppress("unused") // usages in build scripts are not tracked properly
-
-import org.gradle.api.Project
-import org.gradle.kotlin.dsl.*
-import java.net.URI
-
-
-var Project.bootstrapKotlinVersion: String
-    get() = this.property("bootstrapKotlinVersion") as String
-    private set(value) {
-        this.extra["bootstrapKotlinVersion"] = value
-    }
-
-var Project.bootstrapKotlinRepo: String?
-    get() = this.property("bootstrapKotlinRepo") as String?
-    private set(value) {
-        this.extra["bootstrapKotlinRepo"] = value
-    }
-
-val Project.internalKotlinRepo: String?
-    get() = "https://teamcity.jetbrains.com/guestAuth/app/rest/builds/buildType:(id:Kotlin_KotlinPublic_Compiler),number:$bootstrapKotlinVersion," +
-            "branch:default:any/artifacts/content/internal/repo"
-
-fun Project.kotlinBootstrapFrom(defaultSource: BootstrapOption) {
-    val customVersion = project.findProperty("bootstrap.kotlin.version") as String?
-    val customRepo = project.findProperty("bootstrap.kotlin.repo") as String?
-    val teamCityVersion = project.findProperty("bootstrap.teamcity.kotlin.version") as String?
-    val teamCityBuild = project.findProperty("bootstrap.teamcity.build.number") as String?
-    val teamCityProject = project.findProperty("bootstrap.teamcity.project") as String?
-
-    val bootstrapSource = when {
-        project.hasProperty("bootstrap.local") -> BootstrapOption.Local(
-            project.findProperty("bootstrap.local.version") as String?,
-            project.findProperty("bootstrap.local.path") as String?
-        )
-        teamCityVersion != null -> BootstrapOption.TeamCity(
-            teamCityVersion,
-            teamCityBuild,
-            projectExtId = teamCityProject,
-            onlySuccessBootstrap = false
-        )
-        customVersion != null -> BootstrapOption.Custom(kotlinVersion = customVersion, repo = customRepo)
-        else -> defaultSource
-    }
-
-    bootstrapSource.applyToProject(project)
-    project.logger.lifecycle("Using kotlin bootstrap version $bootstrapKotlinVersion from repo $bootstrapKotlinRepo")
-}
-
-sealed class BootstrapOption {
-    abstract fun applyToProject(project: Project)
-
-    /** Manual repository and version specification.
-     *
-     *  If [repo] is not specified the default buildscript and project repositories are used
-     */
-    open class Custom(val kotlinVersion: String, val repo: String?, val cacheRedirector: Boolean = false) : BootstrapOption() {
-        override fun applyToProject(project: Project) {
-            project.bootstrapKotlinVersion = kotlinVersion
-            project.bootstrapKotlinRepo = if (cacheRedirector)
-                repo?.let { URI(it) }?.let { "https://cache-redirector.jetbrains.com/${it.host}/${it.path}" }
-            else
-                repo
-        }
-    }
-
-    /** Get bootstrap from kotlin-dev bintray repo */
-    class BintrayDev(kotlinVersion: String, cacheRedirector: Boolean = false) :
-        Custom(kotlinVersion, "https://dl.bintray.com/kotlin/kotlin-dev", cacheRedirector)
-
-    /** Get bootstrap from kotlin-bootstrap bintray repo, where bootstraps are published */
-    class BintrayBootstrap(kotlinVersion: String, cacheRedirector: Boolean = false) :
-        Custom(kotlinVersion, "https://dl.bintray.com/kotlin/kotlin-bootstrap", cacheRedirector)
-
-    /** Get bootstrap from teamcity maven artifacts of the specified build configuration
-     *
-     * [kotlinVersion] the version of maven artifacts
-     * [buildNumber] build number of a teamcity build, by default the same as [kotlinVersion],
-     * [projectExtId] extId of a teamcity build configuration, by default "Kotlin_dev_Compiler",
-     * [onlySuccessBootstrap] allow artifacts only from success builds of the default branch tagged with 'bootstrap' tag
-     */
-    class TeamCity(
-        val kotlinVersion: String,
-        val buildNumber: String? = null,
-        val projectExtId: String? = null,
-        val onlySuccessBootstrap: Boolean = true,
-        val teamcityUrl: String = "https://teamcity.jetbrains.com"
-    ) : BootstrapOption() {
-        override fun applyToProject(project: Project) {
-            val query = if (onlySuccessBootstrap) "status:SUCCESS,tag:bootstrap,pinned:true" else "branch:default:any"
-            project.bootstrapKotlinRepo = "$teamcityUrl/guestAuth/app/rest/builds/buildType:(id:${projectExtId
-                ?: "Kotlin_dev_Compiler"}),number:${buildNumber ?: kotlinVersion},$query/artifacts/content/maven/"
-            project.bootstrapKotlinVersion = kotlinVersion
-        }
-    }
-
-    /**
-     * Use previously published local artifacts from the build/repo maven repository
-     *
-     * [kotlinVersion] version of artifacts, by default the snapshot version of project is used
-     * [localPath] the path to local repository, if specified it is resolved with respect or project dir
-     */
-    class Local(val kotlinVersion: String? = null, val localPath: String? = null) : BootstrapOption() {
-        override fun applyToProject(project: Project) {
-            val repoPath = if (localPath != null)
-                project.projectDir.resolve(localPath).canonicalFile
-            else
-                project.buildDir.resolve("repo")
-
-            project.bootstrapKotlinRepo = repoPath.toURI().toString()
-            project.bootstrapKotlinVersion = kotlinVersion ?: project.property("defaultSnapshotVersion") as String
-        }
-    }
-}

buildSrc/src/main/kotlin/BuildPropertiesExt.kt

@@ -0,0 +1,20 @@
+/*
+ * 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.
+ */
+
+val KotlinBuildProperties.includeJava9: Boolean
+    get() = !isInJpsBuildIdeaSync && getBoolean("kotlin.build.java9", true)
+
+val KotlinBuildProperties.useBootstrapStdlib: Boolean
+    get() = isInJpsBuildIdeaSync || getBoolean("kotlin.build.useBootstrapStdlib", false)
+
+val KotlinBuildProperties.postProcessing: Boolean get() = isTeamcityBuild || getBoolean("kotlin.build.postprocessing", true)
+
+val KotlinBuildProperties.relocation: Boolean get() = postProcessing
+
+val KotlinBuildProperties.proguard: Boolean get() = postProcessing && getBoolean("kotlin.build.proguard", isTeamcityBuild)
+
+val KotlinBuildProperties.jarCompression: Boolean get() = getBoolean("kotlin.build.jar.compression", isTeamcityBuild)
+
+val KotlinBuildProperties.ignoreTestFailures: Boolean get() = getBoolean("ignoreTestFailures", isTeamcityBuild)

buildSrc/src/main/kotlin/CacheableProguradTask.kt

@@ -0,0 +1,385 @@
+/*
+ * 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 groovy.lang.Closure
+import org.gradle.api.file.FileCollection
+import org.gradle.api.tasks.*
+import org.gradle.internal.jvm.Jvm
+import org.gradle.internal.jvm.inspection.JvmVersionDetector
+import proguard.ClassSpecification
+import java.io.File
+import javax.inject.Inject
+
+
+@CacheableTask
+open class CacheableProguardTask @Inject constructor(
+    private val jvmVersionDetector: JvmVersionDetector
+) : proguard.gradle.ProGuardTask() {
+
+    @Internal
+    var jdkHome: File? = null
+
+    @get:Optional
+    @get:Input
+    internal val jdkMajorVersion: String?
+        get() = jdkHome?.let { jvmVersionDetector.getJavaVersion(Jvm.forHome(jdkHome)) }?.majorVersion
+
+    @CompileClasspath
+    override fun getLibraryJarFileCollection(): FileCollection = super.getLibraryJarFileCollection().filter { libraryFile ->
+        jdkHome?.let { !libraryFile.absoluteFile.startsWith(it.absoluteFile) } ?: true
+    }
+
+    @InputFiles
+    @PathSensitive(PathSensitivity.RELATIVE)
+    override fun getConfigurationFileCollection(): FileCollection = super.getConfigurationFileCollection()
+
+    @InputFiles
+    @Classpath
+    override fun getInJarFileCollection(): FileCollection = super.getInJarFileCollection()
+
+    @Optional
+    @OutputFiles
+    override fun getOutJarFileCollection(): FileCollection = super.getOutJarFileCollection()
+
+    @get:Optional
+    @get:OutputFile
+    internal val printConfigurationFile: File?
+        get() = configuration.printConfiguration?.takeIf { it.path.isNotEmpty() }
+
+    @Input
+    override fun getOutJarFilters(): MutableList<Any?> = super.getOutJarFilters()
+
+    @Input
+    override fun getInJarFilters(): MutableList<Any?> = super.getInJarFilters()
+
+    @Input
+    override fun getLibraryJarFilters(): MutableList<Any?> = super.getLibraryJarFilters()
+
+    @Internal
+    override fun getOutJarFiles(): MutableList<Any?> = super.getOutJarFiles()
+
+    @Internal
+    override fun getInJarFiles(): MutableList<Any?> = super.getInJarFiles()
+
+    @Internal
+    override fun getInJarCounts(): MutableList<Any?> = super.getInJarCounts()
+
+    @Internal
+    override fun getLibraryJarFiles(): MutableList<Any?> = super.getLibraryJarFiles()
+
+    /*
+     * Inputs properly declared these methods so we don't override them
+     *
+     * configuration(configurationFiles: Any?)
+     * libraryjars(libraryJarFiles: Any?)
+     * libraryjars(filterArgs: MutableMap<Any?, Any?>?, libraryJarFiles: Any?)
+     * injars(inJarFiles: Any?)
+     * injars(filterArgs: MutableMap<Any?, Any?>?, inJarFiles: Any?)
+     * outjars(outJarFiles: Any?)
+     * outjars(filterArgs: MutableMap<Any?, Any?>?, outJarFiles: Any?)
+     * printconfiguration()
+     * printconfiguration(printConfiguration: Any?)
+    */
+
+    override fun renamesourcefileattribute() = throw NotImplementedError()
+
+    override fun renamesourcefileattribute(newSourceFileAttribute: String?) = throw NotImplementedError()
+
+    override fun dontshrink() = throw NotImplementedError()
+
+    override fun assumenosideeffects(classSpecificationString: String?) = throw NotImplementedError()
+
+    override fun assumenosideeffects(classSpecificationArgs: MutableMap<Any?, Any?>?, classMembersClosure: Closure<*>?) = throw NotImplementedError()
+
+    override fun keepnames(classSpecificationString: String?) = throw NotImplementedError()
+
+    override fun keepnames(keepArgs: MutableMap<Any?, Any?>?, classSpecificationString: String?) = throw NotImplementedError()
+
+    override fun keepnames(keepClassSpecificationArgs: MutableMap<Any?, Any?>?) = throw NotImplementedError()
+
+    override fun keepnames(keepClassSpecificationArgs: MutableMap<Any?, Any?>?, classMembersClosure: Closure<*>?) = throw NotImplementedError()
+
+    override fun printmapping() = throw NotImplementedError()
+
+    override fun printmapping(printMapping: Any?) = throw NotImplementedError()
+
+    override fun keep(classSpecificationString: String?) = throw NotImplementedError()
+
+    override fun keep(keepArgs: MutableMap<Any?, Any?>?, classSpecificationString: String?) = throw NotImplementedError()
+
+    override fun keep(keepClassSpecificationArgs: MutableMap<Any?, Any?>?) = throw NotImplementedError()
+
+    override fun keep(keepClassSpecificationArgs: MutableMap<Any?, Any?>?, classMembersClosure: Closure<*>?) = throw NotImplementedError()
+
+    override fun keepdirectories() = throw NotImplementedError()
+
+    override fun keepdirectories(filter: String?) = throw NotImplementedError()
+
+    override fun dontpreverify() = throw NotImplementedError()
+
+    override fun dontnote() = throw NotImplementedError()
+
+    override fun dontnote(filter: String?) = throw NotImplementedError()
+
+    @Internal
+    override fun getrenamesourcefileattribute(): Any? = throw NotImplementedError()
+
+    override fun useuniqueclassmembernames() = throw NotImplementedError()
+
+    override fun overloadaggressively() = throw NotImplementedError()
+
+    @Internal
+    override fun getprintusage(): Any? = throw NotImplementedError()
+
+    @Internal
+    override fun getforceprocessing(): Any? = throw NotImplementedError()
+
+    override fun whyareyoukeeping(classSpecificationString: String?) = throw NotImplementedError()
+
+    override fun whyareyoukeeping(classSpecificationArgs: MutableMap<Any?, Any?>?) = throw NotImplementedError()
+
+    override fun whyareyoukeeping(classSpecificationArgs: MutableMap<Any?, Any?>?, classMembersClosure: Closure<*>?) = throw NotImplementedError()
+
+    override fun obfuscationdictionary(obfuscationDictionary: Any?) = throw NotImplementedError()
+
+    override fun adaptclassstrings() = throw NotImplementedError()
+
+    override fun adaptclassstrings(filter: String?) = throw NotImplementedError()
+
+    override fun applymapping(applyMapping: Any?) = throw NotImplementedError()
+
+    override fun mergeinterfacesaggressively() = throw NotImplementedError()
+
+    @Internal
+    override fun getdontwarn(): Any? = throw NotImplementedError()
+
+    override fun ignorewarnings() = throw NotImplementedError()
+
+    @Internal
+    override fun getaddconfigurationdebugging(): Any? = throw NotImplementedError()
+
+    override fun field(memberSpecificationArgs: MutableMap<Any?, Any?>?) = throw NotImplementedError()
+
+    @Internal
+    override fun getallowaccessmodification(): Any? = throw NotImplementedError()
+
+    override fun constructor(memberSpecificationArgs: MutableMap<Any?, Any?>?) = throw NotImplementedError()
+
+    override fun dontusemixedcaseclassnames() = throw NotImplementedError()
+
+    @Internal
+    override fun getignorewarnings(): Any? = throw NotImplementedError()
+
+    @Internal
+    override fun getkeepdirectories(): Any? = throw NotImplementedError()
+
+    override fun classobfuscationdictionary(classObfuscationDictionary: Any?) = throw NotImplementedError()
+
+    override fun verbose() = throw NotImplementedError()
+
+    override fun optimizations(filter: String?) = throw NotImplementedError()
+
+    @Internal
+    override fun getuseuniqueclassmembernames(): Any? = throw NotImplementedError()
+
+    @Internal
+    override fun getmicroedition(): Any? = throw NotImplementedError()
+
+    override fun assumenoescapingparameters(classSpecificationString: String?) = throw NotImplementedError()
+
+    override fun assumenoescapingparameters(classSpecificationArgs: MutableMap<Any?, Any?>?, classMembersClosure: Closure<*>?) = throw NotImplementedError()
+
+    @Internal
+    override fun getandroid(): Any? = throw NotImplementedError()
+
+    override fun keeppackagenames() = throw NotImplementedError()
+
+    override fun keeppackagenames(filter: String?) = throw NotImplementedError()
+
+    @Internal
+    override fun getoverloadaggressively(): Any? = throw NotImplementedError()
+
+    override fun skipnonpubliclibraryclasses() = throw NotImplementedError()
+
+    @Internal
+    override fun getdontusemixedcaseclassnames(): Any? = throw NotImplementedError()
+
+    @Internal
+    override fun getdontnote(): Any? = throw NotImplementedError()
+
+    override fun assumenoexternalreturnvalues(classSpecificationString: String?) = throw NotImplementedError()
+
+    override fun assumenoexternalreturnvalues(classSpecificationArgs: MutableMap<Any?, Any?>?, classMembersClosure: Closure<*>?) = throw NotImplementedError()
+
+    override fun target(targetClassVersion: String?) = throw NotImplementedError()
+
+    override fun keepattributes() = throw NotImplementedError()
+
+    override fun keepattributes(filter: String?) = throw NotImplementedError()
+
+    override fun keepclassmembernames(classSpecificationString: String?) = throw NotImplementedError()
+
+    override fun keepclassmembernames(keepArgs: MutableMap<Any?, Any?>?, classSpecificationString: String?) = throw NotImplementedError()
+
+    override fun keepclassmembernames(keepClassSpecificationArgs: MutableMap<Any?, Any?>?) = throw NotImplementedError()
+
+    override fun keepclassmembernames(keepClassSpecificationArgs: MutableMap<Any?, Any?>?, classMembersClosure: Closure<*>?) = throw NotImplementedError()
+
+    @Internal
+    override fun getdontpreverify(): Any? = throw NotImplementedError()
+
+    @Internal
+    override fun getverbose(): Any? = throw NotImplementedError()
+
+    @Internal
+    override fun getskipnonpubliclibraryclasses(): Any? = throw NotImplementedError()
+
+    @Internal
+    override fun getdontoptimize(): Any? = throw NotImplementedError()
+
+    override fun keepclasseswithmembernames(classSpecificationString: String?) = throw NotImplementedError()
+
+    override fun keepclasseswithmembernames(keepArgs: MutableMap<Any?, Any?>?, classSpecificationString: String?) = throw NotImplementedError()
+
+    override fun keepclasseswithmembernames(keepClassSpecificationArgs: MutableMap<Any?, Any?>?) = throw NotImplementedError()
+
+    override fun keepclasseswithmembernames(keepClassSpecificationArgs: MutableMap<Any?, Any?>?, classMembersClosure: Closure<*>?) = throw NotImplementedError()
+
+    override fun keepclasseswithmembers(classSpecificationString: String?) = throw NotImplementedError()
+
+    override fun keepclasseswithmembers(keepArgs: MutableMap<Any?, Any?>?, classSpecificationString: String?) = throw NotImplementedError()
+
+    override fun keepclasseswithmembers(keepClassSpecificationArgs: MutableMap<Any?, Any?>?) = throw NotImplementedError()
+
+    override fun keepclasseswithmembers(keepClassSpecificationArgs: MutableMap<Any?, Any?>?, classMembersClosure: Closure<*>?) = throw NotImplementedError()
+
+    @Internal
+    override fun getdump(): Any? = throw NotImplementedError()
+
+    override fun printseeds() = throw NotImplementedError()
+
+    override fun printseeds(printSeeds: Any?) = throw NotImplementedError()
+
+    override fun dontoptimize() = throw NotImplementedError()
+
+    override fun dontobfuscate() = throw NotImplementedError()
+
+    override fun extendClassSpecifications(
+        classSpecifications: MutableList<Any?>?,
+        classSpecification: ClassSpecification?
+    ): MutableList<Any?> = throw NotImplementedError()
+
+    override fun allowaccessmodification() = throw NotImplementedError()
+
+    @Internal
+    override fun getdontobfuscate(): Any? = throw NotImplementedError()
+
+    @Internal
+    override fun getprintmapping(): Any? = throw NotImplementedError()
+
+    override fun flattenpackagehierarchy() = throw NotImplementedError()
+
+    override fun flattenpackagehierarchy(flattenPackageHierarchy: String?) = throw NotImplementedError()
+
+    override fun android() = throw NotImplementedError()
+
+    override fun dump() = throw NotImplementedError()
+
+    override fun dump(dump: Any?) = throw NotImplementedError()
+
+    @Internal
+    override fun getdontshrink(): Any? = throw NotImplementedError()
+
+    @Internal
+    override fun getkeepattributes(): Any? = throw NotImplementedError()
+
+    override fun microedition() = throw NotImplementedError()
+
+    override fun keepparameternames() = throw NotImplementedError()
+
+    override fun addconfigurationdebugging() = throw NotImplementedError()
+
+    override fun packageobfuscationdictionary(packageObfuscationDictionary: Any?) = throw NotImplementedError()
+
+    @Internal
+    override fun getdontskipnonpubliclibraryclassmembers(): Any? = throw NotImplementedError()
+
+    override fun dontskipnonpubliclibraryclassmembers() = throw NotImplementedError()
+
+    @Internal
+    override fun getprintconfiguration(): Any? = throw NotImplementedError()
+
+    override fun forceprocessing() = throw NotImplementedError()
+
+    override fun keepclassmembers(classSpecificationString: String?) = throw NotImplementedError()
+
+    override fun keepclassmembers(keepArgs: MutableMap<Any?, Any?>?, classSpecificationString: String?) = throw NotImplementedError()
+
+    override fun keepclassmembers(keepClassSpecificationArgs: MutableMap<Any?, Any?>?) = throw NotImplementedError()
+
+    override fun keepclassmembers(keepClassSpecificationArgs: MutableMap<Any?, Any?>?, classMembersClosure: Closure<*>?) = throw NotImplementedError()
+
+    @Internal
+    override fun getmergeinterfacesaggressively(): Any? = throw NotImplementedError()
+
+    @Internal
+    override fun getConfigurationFiles(): MutableList<Any?> = throw NotImplementedError()
+
+    @Internal
+    override fun getkeeppackagenames(): Any? = throw NotImplementedError()
+
+    override fun assumevalues(classSpecificationString: String?) = throw NotImplementedError()
+
+    override fun assumevalues(classSpecificationArgs: MutableMap<Any?, Any?>?, classMembersClosure: Closure<*>?) = throw NotImplementedError()
+
+    override fun printusage() = throw NotImplementedError()
+
+    override fun printusage(printUsage: Any?) = throw NotImplementedError()
+
+    @Internal
+    override fun getprintseeds(): Any? = throw NotImplementedError()
+
+    @Internal
+    override fun getadaptresourcefilenames(): Any? = throw NotImplementedError()
+
+    override fun assumenoexternalsideeffects(classSpecificationString: String?) = throw NotImplementedError()
+
+    override fun assumenoexternalsideeffects(classSpecificationArgs: MutableMap<Any?, Any?>?, classMembersClosure: Closure<*>?) = throw NotImplementedError()
+
+    override fun dontwarn() = throw NotImplementedError()
+
+    override fun dontwarn(filter: String?) = throw NotImplementedError()
+
+    @Internal
+    override fun getrepackageclasses(): Any? = throw NotImplementedError()
+
+    @Internal
+    override fun getadaptresourcefilecontents(): Any? = throw NotImplementedError()
+
+    @Internal
+    override fun getflattenpackagehierarchy(): Any? = throw NotImplementedError()
+
+    override fun optimizationpasses(optimizationPasses: Int) = throw NotImplementedError()
+
+    override fun adaptresourcefilenames() = throw NotImplementedError()
+
+    override fun adaptresourcefilenames(filter: String?) = throw NotImplementedError()
+
+    override fun method(memberSpecificationArgs: MutableMap<Any?, Any?>?) = throw NotImplementedError()
+
+    @Internal
+    override fun getadaptclassstrings(): Any? = throw NotImplementedError()
+
+    override fun repackageclasses() = throw NotImplementedError()
+
+    override fun repackageclasses(repackageClasses: String?) = throw NotImplementedError()
+
+    @Internal
+    override fun getkeepparameternames(): Any? = throw NotImplementedError()
+
+    override fun adaptresourcefilecontents() = throw NotImplementedError()
+
+    override fun adaptresourcefilecontents(filter: String?) = throw NotImplementedError()
+}

buildSrc/src/main/kotlin/CommonUtil.kt

@@ -7,10 +7,12 @@ import org.gradle.api.Task
 import org.gradle.api.file.CopySourceSpec
 import org.gradle.api.file.SourceDirectorySet
 import org.gradle.api.plugins.JavaPluginConvention
+import org.gradle.api.tasks.JavaExec
 import org.gradle.api.tasks.SourceSet
-import org.gradle.api.tasks.SourceSetContainer
 import org.gradle.api.tasks.SourceSetOutput
+import org.gradle.api.tasks.bundling.AbstractArchiveTask
 import org.gradle.kotlin.dsl.*
+import proguard.gradle.ProGuardTask
 import java.io.File
 import java.util.concurrent.Callable
 
@@ -56,6 +58,7 @@ fun Project.generator(fqName: String, sourceSet: SourceSet? = null) = smartJavaE
     classpath = (sourceSet ?: testSourceSet).runtimeClasspath
     main = fqName
     workingDir = rootDir
+    systemProperty("line.separator", "\n")
 }
 
 fun Project.getBooleanProperty(name: String): Boolean? = this.findProperty(name)?.let {
@@ -69,3 +72,11 @@ inline fun CopySourceSpec.from(crossinline filesProvider: () -> Any?): CopySourc
 fun Project.javaPluginConvention(): JavaPluginConvention = the()
 
 fun Project.findJavaPluginConvention(): JavaPluginConvention? = convention.findByType() ?: convention.findPlugin()
+
+fun JavaExec.pathRelativeToWorkingDir(file: File): String = file.relativeTo(workingDir).invariantSeparatorsPath
+
+fun Task.singleOutputFile(): File = when (this) {
+    is AbstractArchiveTask -> archiveFile.get().asFile
+    is ProGuardTask -> project.file(outJarFiles.single()!!)
+    else -> outputs.files.singleFile
+}

buildSrc/src/main/kotlin/IdeCompatibilityDsl.kt

@@ -26,10 +26,12 @@ fun CompatibilityPredicate.or(other: CompatibilityPredicate): CompatibilityPredi
 }
 
 enum class Platform : CompatibilityPredicate {
-    P183, P191, P192, P193;
+    P183, P191, P192, P193, P201, P202;
 
     val version: Int = name.drop(1).toInt()
 
+    val displayVersion: String = "20${name.drop(1).dropLast(1)}.${name.last()}"
+
     override fun matches(ide: Ide) = ide.platform == this
 
     companion object {
@@ -44,14 +46,22 @@ enum class Ide(val platform: Platform) : CompatibilityPredicate {
     IJ191(Platform.P191),
     IJ192(Platform.P192),
     IJ193(Platform.P193),
+    IJ201(Platform.P201),
+    IJ202(Platform.P202),
 
     AS35(Platform.P183),
     AS36(Platform.P192),
-    AS40(Platform.P193);
+    AS40(Platform.P193),
+    AS41(Platform.P201);
 
     val kind = Kind.values().first { it.shortName == name.take(2) }
     val version = name.dropWhile { !it.isDigit() }.toInt()
 
+    val displayVersion: String = when (kind) {
+        Kind.IntelliJ -> "IJ${platform.displayVersion}"
+        Kind.AndroidStudio -> "Studio${name.substringAfter("AS").toCharArray().joinToString(separator = ".")}"
+    }
+
     override fun matches(ide: Ide) = ide == this
 
     enum class Kind(val shortName: String) {

buildSrc/src/main/kotlin/artifacts.kt

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

buildSrc/src/main/kotlin/dependencies.kt

@@ -2,21 +2,34 @@
 
 // usages in build scripts are not tracked properly
 
-import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 import org.gradle.api.GradleException
 import org.gradle.api.Project
 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.api.tasks.AbstractCopyTask
 import org.gradle.kotlin.dsl.extra
 import org.gradle.kotlin.dsl.project
 import java.io.File
 
-val Project.isSnapshotIntellij get() = rootProject.extra["versions.intellijSdk"].toString().endsWith("SNAPSHOT")
+private val Project.isEAPIntellij get() = rootProject.extra["versions.intellijSdk"].toString().contains("-EAP-")
+private val Project.isNightlyIntellij get() = rootProject.extra["versions.intellijSdk"].toString().endsWith("SNAPSHOT") && !isEAPIntellij
+
+val Project.intellijRepo get() =
+    when {
+        isEAPIntellij -> "https://www.jetbrains.com/intellij-repository/snapshots"
+        isNightlyIntellij -> "https://www.jetbrains.com/intellij-repository/nightly"
+        else -> "https://www.jetbrains.com/intellij-repository/releases"
+    }
+
+val Project.internalBootstrapRepo: String? get() =
+    when {
+        bootstrapKotlinRepo?.startsWith("https://buildserver.labs.intellij.net") == true ->
+            bootstrapKotlinRepo!!.replace("artifacts/content/maven", "artifacts/content/internal/repo")
+        else -> "https://teamcity.jetbrains.com/guestAuth/app/rest/builds/buildType:(id:Kotlin_KotlinPublic_Compiler),number:$bootstrapKotlinVersion," +
+                "branch:default:any/artifacts/content/internal/repo/"
+    }
 
-val Project.intellijRepo get() = "https://www.jetbrains.com/intellij-repository/" + if (isSnapshotIntellij) "snapshots" else "releases"
 
 fun Project.commonDep(coord: String): String {
     val parts = coord.split(':')
@@ -129,6 +142,12 @@ fun Project.firstFromJavaHomeThatExists(vararg paths: String, jdkHome: File = Fi
             logger.warn("Cannot find file by paths: ${paths.toList()} in $jdkHome")
     }
 
+fun Project.toolsJarApi(): Any =
+    if (kotlinBuildProperties.isInJpsBuildIdeaSync)
+        files(toolsJarFile() ?: error("tools.jar is not found!"))
+    else
+        dependencies.project(":dependencies:tools-jar-api")
+
 fun Project.toolsJar(): FileCollection = files(toolsJarFile() ?: error("tools.jar is not found!"))
 
 fun Project.toolsJarFile(jdkHome: File = File(this.property("JDK_18") as String)): File? =

buildSrc/src/main/kotlin/embeddable.kt

@@ -11,17 +11,19 @@ import java.io.File
 val kotlinEmbeddableRootPackage = "org.jetbrains.kotlin"
 
 val packagesToRelocate =
-        listOf( "com.intellij",
-                "com.google",
-                "com.sampullara",
-                "org.apache",
-                "org.jdom",
-                "org.picocontainer",
-                "org.jline",
-                "org.fusesource",
-                "kotlinx.coroutines",
-                "net.jpountz",
-                "one.util.streamex")
+    listOf(
+        "com.intellij",
+        "com.google",
+        "com.sampullara",
+        "org.apache",
+        "org.jdom",
+        "org.picocontainer",
+        "org.jline",
+        "org.fusesource",
+        "net.jpountz",
+        "one.util.streamex",
+        "kotlinx.collections.immutable"
+    )
 
 // The shaded compiler "dummy" is used to rewrite dependencies in projects that are used with the embeddable compiler
 // on the runtime and use some shaded dependencies from the compiler

buildSrc/src/main/kotlin/localDependencies.kt

@@ -24,11 +24,14 @@ import org.gradle.api.artifacts.dsl.RepositoryHandler
 import org.gradle.api.artifacts.repositories.IvyArtifactRepository
 import org.gradle.api.tasks.JavaExec
 import org.gradle.api.tasks.TaskProvider
-import org.gradle.kotlin.dsl.*
+import org.gradle.kotlin.dsl.DependencyHandlerScope
+import org.gradle.kotlin.dsl.extra
+import org.gradle.kotlin.dsl.register
 import java.io.File
 
 private fun Project.kotlinBuildLocalDependenciesDir(): File =
-    (findProperty("kotlin.build.dependencies.dir") as String?)?.let(::File) ?: project.rootDir.absoluteFile.resolve("dependencies")
+    (findProperty("kotlin.build.dependencies.dir") as String?)?.let(::File)
+        ?: rootProject.gradle.gradleUserHomeDir.resolve("kotlin-build-dependencies")
 
 private fun Project.kotlinBuildLocalRepoDir(): File = kotlinBuildLocalDependenciesDir().resolve("repo")
 
@@ -174,12 +177,17 @@ fun Project.runIdeTask(name: String, ideaPluginDir: File, ideaSandboxDir: File,
             "-Didea.debug.mode=true",
             "-Didea.system.path=$ideaSandboxDir",
             "-Didea.config.path=$ideaSandboxConfigDir",
+            "-Didea.tooling.debug=true",
             "-Dapple.laf.useScreenMenuBar=true",
             "-Dapple.awt.graphics.UseQuartz=true",
             "-Dsun.io.useCanonCaches=false",
             "-Dplugin.path=${ideaPluginDir.absolutePath}"
         )
 
+        if (Platform[201].orHigher() && !isIntellijUltimateSdkAvailable()) {
+            jvmArgs("-Didea.platform.prefix=Idea")
+        }
+
         if (rootProject.findProperty("versions.androidStudioRelease") != null) {
             jvmArgs("-Didea.platform.prefix=AndroidStudio")
         }

buildSrc/src/main/kotlin/pill/JpsCompatiblePlugin.kt

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+@file:Suppress("PackageDirectoryMismatch")
+package org.jetbrains.kotlin.pill
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+
+@Suppress("unused")
+class JpsCompatiblePlugin : Plugin<Project> {
+    override fun apply(project: Project) {
+        project.configurations.maybeCreate(EmbeddedComponents.CONFIGURATION_NAME)
+        project.extensions.create("pill", PillExtension::class.java)
+
+        // 'jpsTest' does not require the 'tests-jar' artifact
+        project.configurations.create("jpsTest")
+
+        if (project == project.rootProject) {
+            project.tasks.create("pill") {
+                dependsOn(":pill:pill-importer:pill")
+
+                if (System.getProperty("pill.android.tests", "false") == "true") {
+                    TaskUtils.useAndroidSdk(this)
+                    TaskUtils.useAndroidJar(this)
+                }
+            }
+
+            project.tasks.create("unpill") {
+                dependsOn(":pill:pill-importer:unpill")
+            }
+        }
+    }
+}

buildSrc/src/main/kotlin/pill/PillExtension.kt

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+@file:Suppress("PackageDirectoryMismatch")
+package org.jetbrains.kotlin.pill
+
+import java.io.File
+import org.gradle.api.Project
+
+open class PillExtension {
+    enum class Variant {
+        // Default variant (./gradlew pill)
+        BASE() {
+            override val includes = setOf(BASE)
+        },
+
+        // Full variant (./gradlew pill -Dpill.variant=full)
+        FULL() {
+            override val includes = setOf(BASE, FULL)
+        },
+
+        // Do not import the project to JPS model, but set some options for it
+        NONE() {
+            override val includes = emptySet<Variant>()
+        },
+
+        // 'BASE' if the "jps-compatible" plugin is applied, 'NONE' otherwise
+        DEFAULT() {
+            override val includes = emptySet<Variant>()
+        };
+
+        abstract val includes: Set<Variant>
+    }
+
+    open var variant: Variant = Variant.DEFAULT
+
+    open var excludedDirs: List<File> = emptyList()
+
+    @Suppress("unused")
+    fun Project.excludedDirs(vararg dirs: String) {
+        excludedDirs = excludedDirs + dirs.map { File(projectDir, it) }
+    }
+
+    @Suppress("unused")
+    fun serialize() = mapOf<String, Any?>(
+        "variant" to variant.name,
+        "excludedDirs" to excludedDirs
+    )
+}

buildSrc/src/main/kotlin/pill/context.kt

@@ -1,33 +0,0 @@
-@file:Suppress("PackageDirectoryMismatch")
-package org.jetbrains.kotlin.pill
-
-import org.gradle.api.artifacts.*
-import org.gradle.api.artifacts.component.*
-
-class DependencyMapper(val predicate: (ResolvedArtifact) -> Boolean, val mapping: (ResolvedArtifact) -> MappedDependency?) {
-    companion object {
-        fun forProject(path: String, mapping: (ResolvedArtifact) -> MappedDependency?): DependencyMapper {
-            return DependencyMapper(
-                predicate = { artifact ->
-                    val identifier = artifact.id.componentIdentifier as? ProjectComponentIdentifier
-                    identifier?.projectPath == path
-                },
-                mapping = mapping
-            )
-        }
-
-        fun forModule(group: String, module: String, version: String?, mapping: (ResolvedArtifact) -> MappedDependency?): DependencyMapper {
-            return DependencyMapper(
-                predicate = { artifact ->
-                    val identifier = artifact.id.componentIdentifier as? ModuleComponentIdentifier
-                    identifier?.group == group && identifier?.module == module && (version == null || identifier?.version == version)
-                },
-                mapping = mapping
-            )
-        }
-    }
-}
-
-class MappedDependency(val main: PDependency?, val deferred: List<PDependency> = emptyList())
-
-class ParserContext(val dependencyMappers: List<DependencyMapper>, val variant: PillExtension.Variant)

buildSrc/src/main/kotlin/pill/dependencies.kt

@@ -1,94 +0,0 @@
-/*
- * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-@file:Suppress("PackageDirectoryMismatch")
-package org.jetbrains.kotlin.pill
-
-import java.io.File
-import org.gradle.api.Project
-import org.gradle.api.tasks.SourceSet
-import org.gradle.api.artifacts.*
-import org.gradle.api.artifacts.component.*
-
-data class PDependencies(val main: List<PDependency>, val deferred: List<PDependency>) {
-    fun join(): List<PDependency> {
-        return main + deferred
-    }
-}
-
-fun Project.resolveDependencies(
-    configuration: Configuration,
-    forTests: Boolean,
-    dependencyMappers: List<DependencyMapper>,
-    withEmbedded: Boolean = false
-): PDependencies {
-    val dependencies = mutableListOf<PDependency>()
-    val deferred = mutableListOf<PDependency>()
-
-    nextArtifact@ for (artifact in configuration.resolvedConfiguration.resolvedArtifacts) {
-        val identifier = artifact.id.componentIdentifier
-
-        for (mapper in dependencyMappers) {
-            if (mapper.predicate(artifact)) {
-                val mapped = mapper.mapping(artifact)
-
-                if (mapped != null) {
-                    mapped.main?.let { dependencies += it }
-                    deferred += mapped.deferred
-                }
-
-                continue@nextArtifact
-            }
-        }
-
-        fun addProjectDependency(projectPath: String) {
-            val project = rootProject.findProject(projectPath) ?: error("Cannot find project $projectPath")
-
-            fun addSourceSet(name: String, suffix: String): Boolean {
-                val sourceSet = project.sourceSets?.findByName(name)?.takeIf { !it.allSource.isEmpty() } ?: return false
-                dependencies += PDependency.Module(project.pillModuleName + '.' + suffix)
-                return true
-            }
-
-            if (forTests && artifact.classifier == "tests") {
-                addSourceSet(SourceSet.TEST_SOURCE_SET_NAME, "test") || addSourceSet(SourceSet.MAIN_SOURCE_SET_NAME, "src")
-            } else {
-                addSourceSet(SourceSet.MAIN_SOURCE_SET_NAME, "src")
-            }
-
-            if (withEmbedded) {
-                val embeddedConfiguration = project.configurations.findByName(EmbeddedComponents.CONFIGURATION_NAME)
-                if (embeddedConfiguration != null) {
-                    dependencies += resolveDependencies(embeddedConfiguration, forTests, dependencyMappers, withEmbedded).join()
-                }
-            }
-        }
-
-        when (identifier) {
-            is ProjectComponentIdentifier -> addProjectDependency(identifier.projectPath)
-            is LibraryBinaryIdentifier -> addProjectDependency(identifier.projectPath)
-            is ModuleComponentIdentifier -> {
-                val file = artifact.file
-                val library = PLibrary(file.name, classes = listOf(file))
-                dependencies += PDependency.ModuleLibrary(library)
-            }
-        }
-    }
-
-    val existingFiles = mutableSetOf<File>()
-
-    for (dependency in configuration.dependencies) {
-        if (dependency !is SelfResolvingDependency) {
-            continue
-        }
-
-        val files = dependency.resolve().filter { it !in existingFiles }.takeIf { it.isNotEmpty() } ?: continue
-        existingFiles.addAll(files)
-        val library = PLibrary(dependency.name, classes = files.toList())
-        deferred += PDependency.ModuleLibrary(library)
-    }
-
-    return PDependencies(dependencies, deferred)
-}

buildSrc/src/main/kotlin/pill/extension.kt

@@ -1,39 +0,0 @@
-@file:Suppress("PackageDirectoryMismatch")
-package org.jetbrains.kotlin.pill
-
-import java.io.File
-import org.gradle.api.Project
-
-open class PillExtension {
-    enum class Variant {
-        // Default variant (./gradlew pill)
-        BASE() { override val includes = setOf(BASE) },
-
-        // Full variant (./gradlew pill -Dpill.variant=full)
-        FULL() { override val includes = setOf(BASE, FULL) },
-
-        // Do not import the project to JPS model, but set some options for it
-        NONE() { override val includes = emptySet<Variant>() },
-
-        // 'BASE' if the "jps-compatible" plugin is applied, 'NONE' otherwise
-        DEFAULT() { override val includes = emptySet<Variant>() };
-
-        abstract val includes: Set<Variant>
-    }
-
-    open var variant: Variant = Variant.DEFAULT
-
-    open var importAsLibrary: Boolean = false
-
-    open var excludedDirs: List<File> = emptyList()
-
-    fun Project.excludedDirs(vararg dirs: String) {
-        excludedDirs = excludedDirs + dirs.map { File(projectDir, it) }
-    }
-
-    open var libraryPath: File? = null
-        set(v) {
-            importAsLibrary = true
-            field = v
-        }
-}

buildSrc/src/main/kotlin/pill/kotlinPluginArtifact.kt

@@ -1,182 +0,0 @@
-@file:Suppress("PackageDirectoryMismatch")
-
-package org.jetbrains.kotlin.pill
-
-import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
-import org.gradle.api.Project
-import org.gradle.api.artifacts.Configuration
-import org.gradle.api.artifacts.ProjectDependency
-import org.gradle.api.internal.file.copy.SingleParentCopySpec
-import org.gradle.api.plugins.JavaPlugin
-import org.gradle.api.tasks.Copy
-import org.gradle.jvm.tasks.Jar
-import org.gradle.kotlin.dsl.extra
-import org.jetbrains.kotlin.pill.ArtifactElement.*
-import org.jetbrains.kotlin.pill.POrderRoot.*
-import java.io.File
-
-class PArtifact(val artifactName: String, val outputDir: File, private val contents: ArtifactElement.Root) {
-    fun render(context: PathContext) = xml("component", "name" to "ArtifactManager") {
-        xml("artifact", "name" to artifactName) {
-            xml("output-path") {
-                raw(context(outputDir))
-            }
-
-            add(contents.renderRecursively(context))
-        }
-    }
-}
-
-sealed class ArtifactElement {
-    private val myChildren = mutableListOf<ArtifactElement>()
-    val children get() = myChildren
-
-    fun add(child: ArtifactElement) {
-        myChildren += child
-    }
-
-    fun add(children: List<ArtifactElement>) {
-        myChildren += children
-    }
-
-    abstract fun render(context: PathContext): xml
-
-    fun renderRecursively(context: PathContext): xml {
-        return render(context).apply {
-            children.forEach { add(it.renderRecursively(context)) }
-        }
-    }
-
-    fun getDirectory(path: String): ArtifactElement {
-        if (path.isEmpty()) {
-            return this
-        }
-
-        var current: ArtifactElement = this
-        for (segment in path.split("/")) {
-            val existing = current.children.firstOrNull { it is Directory && it.name == segment }
-            if (existing != null) {
-                current = existing
-                continue
-            }
-
-            current = Directory(segment).also { current.add(it) }
-        }
-
-        return current
-    }
-
-    class Root : ArtifactElement() {
-        override fun render(context: PathContext) = xml("root", "id" to "root")
-    }
-
-    data class Directory(val name: String) : ArtifactElement() {
-        override fun render(context: PathContext) = xml("element", "id" to "directory", "name" to name)
-    }
-
-    data class Archive(val name: String) : ArtifactElement() {
-        override fun render(context: PathContext) = xml("element", "id" to "archive", "name" to name)
-    }
-
-    data class ModuleOutput(val moduleName: String) : ArtifactElement() {
-        override fun render(context: PathContext) = xml("element", "id" to "module-output", "name" to moduleName)
-    }
-
-    data class FileCopy(val source: File, val outputFileName: String? = null) : ArtifactElement() {
-        override fun render(context: PathContext): xml {
-            val args = mutableListOf("id" to "file-copy", "path" to context(source))
-            if (outputFileName != null) {
-                args += "output-file-name" to outputFileName
-            }
-
-            return xml("element", *args.toTypedArray())
-        }
-    }
-
-    data class DirectoryCopy(val source: File) : ArtifactElement() {
-        override fun render(context: PathContext) = xml("element", "id" to "dir-copy", "path" to context(source))
-    }
-
-    data class ProjectLibrary(val name: String) : ArtifactElement() {
-        override fun render(context: PathContext) = xml("element", "id" to "library", "level" to "project", "name" to name)
-    }
-
-    data class ExtractedDirectory(val archive: File, val pathInJar: String = "/") : ArtifactElement() {
-        override fun render(context: PathContext) =
-            xml("element", "id" to "extracted-dir", "path" to context(archive), "path-in-jar" to pathInJar)
-    }
-}
-
-fun generateKotlinPluginArtifactFile(rootProject: Project, dependencyMappers: List<DependencyMapper>): PFile {
-    val root = Root()
-
-    fun Project.getProject(name: String) = findProject(name) ?: error("Cannot find project $name")
-
-    val prepareIdeaPluginProject = rootProject.getProject(":prepare:idea-plugin")
-
-    root.add(Directory("kotlinc").apply {
-        val kotlincDirectory = rootProject.extra["distKotlinHomeDir"].toString()
-        add(DirectoryCopy(File(kotlincDirectory)))
-    })
-
-    root.add(Directory("lib").apply {
-        val librariesConfiguration = prepareIdeaPluginProject.configurations.getByName("libraries")
-        add(getArtifactElements(rootProject, librariesConfiguration, dependencyMappers, false))
-
-        add(Directory("jps").apply {
-            val prepareJpsPluginProject = rootProject.getProject(":kotlin-jps-plugin")
-            add(Archive(prepareJpsPluginProject.name + ".jar").apply {
-                val jpsPluginConfiguration = prepareIdeaPluginProject.configurations.getByName("jpsPlugin")
-                add(getArtifactElements(rootProject, jpsPluginConfiguration, dependencyMappers, true))
-            })
-        })
-
-        add(Archive("kotlin-plugin.jar").apply {
-            add(FileCopy(File(rootProject.projectDir, "resources/kotlinManifest.properties")))
-
-            val embeddedConfiguration = prepareIdeaPluginProject.configurations.getByName(EmbeddedComponents.CONFIGURATION_NAME)
-            add(getArtifactElements(rootProject, embeddedConfiguration, dependencyMappers, true))
-        })
-    })
-
-    val artifact = PArtifact("KotlinPlugin", File(rootProject.projectDir, "out/artifacts/Kotlin"), root)
-    return PFile(
-        File(rootProject.projectDir, ".idea/artifacts/${artifact.artifactName}.xml"),
-        artifact.render(ProjectContext(rootProject))
-    )
-}
-
-private fun getArtifactElements(
-    rootProject: Project,
-    configuration: Configuration,
-    dependencyMappers: List<DependencyMapper>,
-    extractDependencies: Boolean
-): List<ArtifactElement> {
-    val dependencies = rootProject.resolveDependencies(configuration, false, dependencyMappers, withEmbedded = true).join()
-
-    val artifacts = mutableListOf<ArtifactElement>()
-
-    for (dependency in dependencies) {
-        when (dependency) {
-            is PDependency.Module -> {
-                val moduleOutput = ModuleOutput(dependency.name)
-
-                if (extractDependencies) {
-                    artifacts += moduleOutput
-                } else {
-                    artifacts += Archive(dependency.name + ".jar").apply {
-                        add(moduleOutput)
-                    }
-                }
-            }
-            is PDependency.Library -> artifacts += ProjectLibrary(dependency.name)
-            is PDependency.ModuleLibrary -> {
-                val files = dependency.library.classes
-                if (extractDependencies) files.mapTo(artifacts) { ExtractedDirectory(it) }
-                else  files.mapTo(artifacts) { FileCopy(it) }
-            }
-        }
-    }
-
-    return artifacts
-}

buildSrc/src/main/kotlin/pill/parser.kt

@@ -1,420 +0,0 @@
-/*
- * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-@file:Suppress("PackageDirectoryMismatch")
-package org.jetbrains.kotlin.pill
-
-import org.gradle.api.Project
-import org.gradle.api.artifacts.*
-import org.gradle.api.tasks.*
-import org.gradle.api.plugins.JavaPlugin
-import org.gradle.api.plugins.JavaPluginConvention
-import org.gradle.kotlin.dsl.configure
-import org.gradle.plugins.ide.idea.IdeaPlugin
-import org.gradle.api.file.SourceDirectorySet
-import org.gradle.api.internal.HasConvention
-import org.gradle.api.internal.file.copy.CopySpecInternal
-import org.gradle.api.internal.file.copy.SingleParentCopySpec
-import org.gradle.language.jvm.tasks.ProcessResources
-import org.jetbrains.kotlin.pill.POrderRoot.*
-import org.jetbrains.kotlin.pill.PSourceRoot.*
-import org.jetbrains.kotlin.pill.PillExtension.*
-import java.io.File
-import java.util.LinkedList
-
-data class PProject(
-    val name: String,
-    val rootDirectory: File,
-    val modules: List<PModule>,
-    val libraries: List<PLibrary>
-)
-
-data class PModule(
-    val name: String,
-    val rootDirectory: File,
-    val moduleFile: File,
-    val contentRoots: List<PContentRoot>,
-    val orderRoots: List<POrderRoot>,
-    val moduleForProductionSources: PModule? = null
-)
-
-data class PContentRoot(
-    val path: File,
-    val forTests: Boolean,
-    val sourceRoots: List<PSourceRoot>,
-    val excludedDirectories: List<File>
-)
-
-data class PSourceRoot(
-    val path: File,
-    val kind: Kind,
-    val kotlinOptions: PSourceRootKotlinOptions?
-) {
-    enum class Kind { PRODUCTION, TEST, RESOURCES, TEST_RESOURCES }
-}
-
-data class PSourceRootKotlinOptions(
-    val noStdlib: Boolean?,
-    val noReflect: Boolean?,
-    val moduleName: String?,
-    val apiVersion: String?,
-    val languageVersion: String?,
-    val jvmTarget: String?,
-    val extraArguments: List<String>
-) {
-    fun intersect(other: PSourceRootKotlinOptions) = PSourceRootKotlinOptions(
-        if (noStdlib == other.noStdlib) noStdlib else null,
-        if (noReflect == other.noReflect) noReflect else null,
-        if (moduleName == other.moduleName) moduleName else null,
-        if (apiVersion == other.apiVersion) apiVersion else null,
-        if (languageVersion == other.languageVersion) languageVersion else null,
-        if (jvmTarget == other.jvmTarget) jvmTarget else null,
-        extraArguments.intersect(other.extraArguments).toList()
-    )
-}
-
-data class POrderRoot(
-    val dependency: PDependency,
-    val scope: Scope,
-    val isExported: Boolean = false,
-    val isProductionOnTestDependency: Boolean = false
-) {
-    enum class Scope { COMPILE, TEST, RUNTIME, PROVIDED }
-}
-
-sealed class PDependency {
-    data class Module(val name: String) : PDependency()
-    data class Library(val name: String) : PDependency()
-    data class ModuleLibrary(val library: PLibrary) : PDependency()
-}
-
-data class PLibrary(
-    val name: String,
-    val classes: List<File>,
-    val javadoc: List<File> = emptyList(),
-    val sources: List<File> = emptyList(),
-    val annotations: List<File> = emptyList(),
-    val dependencies: List<PLibrary> = emptyList(),
-    val originalName: String = name
-) {
-    fun attachSource(file: File): PLibrary {
-        return this.copy(sources = this.sources + listOf(file))
-    }
-}
-
-fun parse(project: Project, libraries: List<PLibrary>, context: ParserContext): PProject = with (context) {
-    if (project != project.rootProject) {
-        error("$project is not a root project")
-    }
-
-    fun Project.matchesSelectedVariant(): Boolean {
-        val extension = this.extensions.findByType(PillExtension::class.java) ?: return true
-        val projectVariant = extension.variant.takeUnless { it == Variant.DEFAULT } ?: Variant.BASE
-        return projectVariant in context.variant.includes
-    }
-
-    val (includedProjects, excludedProjects) = project.allprojects
-        .partition { it.plugins.hasPlugin(JpsCompatiblePlugin::class.java) && it.matchesSelectedVariant() }
-
-    val modules = includedProjects.flatMap { parseModules(it, excludedProjects) }
-
-    return PProject("Kotlin", project.projectDir, modules, libraries)
-}
-
-/*
-    Ordering here and below is significant.
-    Placing 'runtime' configuration dependencies on the top make 'idea' tests to run normally.
-    ('idea' module has 'intellij-core' as transitive dependency, and we really need to get rid of it.)
- */
-private val CONFIGURATION_MAPPING = mapOf(
-    listOf("runtimeClasspath") to Scope.RUNTIME,
-    listOf("compileClasspath", "compileOnly") to Scope.PROVIDED,
-    listOf("embedded") to Scope.COMPILE
-)
-
-private val TEST_CONFIGURATION_MAPPING = mapOf(
-    listOf("runtimeClasspath", "testRuntimeClasspath") to Scope.RUNTIME,
-    listOf("compileClasspath", "testCompileClasspath", "compileOnly", "testCompileOnly") to Scope.PROVIDED,
-    listOf("jpsTest") to Scope.TEST
-)
-
-private fun ParserContext.parseModules(project: Project, excludedProjects: List<Project>): List<PModule> {
-    val (productionContentRoots, testContentRoots) = parseContentRoots(project).partition { !it.forTests }
-
-    val modules = mutableListOf<PModule>()
-
-    fun getJavaExcludedDirs() = project.plugins.findPlugin(IdeaPlugin::class.java)
-        ?.model?.module?.excludeDirs?.toList() ?: emptyList()
-
-    fun getPillExcludedDirs() = project.extensions.getByType(PillExtension::class.java).excludedDirs
-
-    val allExcludedDirs = getPillExcludedDirs() + getJavaExcludedDirs() + project.buildDir +
-            (if (project == project.rootProject) excludedProjects.map { it.buildDir } else emptyList())
-
-    var productionSourcesModule: PModule? = null
-
-    fun getModuleFile(suffix: String = ""): File {
-        val relativePath = File(project.projectDir, project.pillModuleName + suffix + ".iml")
-            .toRelativeString(project.rootProject.projectDir)
-
-        return File(project.rootProject.projectDir, ".idea/modules/$relativePath")
-    }
-
-    for ((nameSuffix, roots) in mapOf(".src" to productionContentRoots, ".test" to testContentRoots)) {
-        if (roots.isEmpty()) {
-            continue
-        }
-
-        val mainRoot = roots.first()
-
-        var dependencies = parseDependencies(project, mainRoot.forTests)
-        if (productionContentRoots.isNotEmpty() && mainRoot.forTests) {
-            val productionModuleDependency = PDependency.Module(project.pillModuleName + ".src")
-            dependencies += POrderRoot(productionModuleDependency, Scope.COMPILE, true)
-        }
-
-        val module = PModule(
-            project.pillModuleName + nameSuffix,
-            mainRoot.path,
-            getModuleFile(nameSuffix),
-            roots,
-            dependencies,
-            productionSourcesModule
-        )
-
-        modules += module
-
-        if (!mainRoot.forTests) {
-            productionSourcesModule = module
-        }
-    }
-
-    val mainModuleFileRelativePath = when (project) {
-        project.rootProject -> File(project.rootProject.projectDir, project.rootProject.name + ".iml")
-        else -> getModuleFile()
-    }
-
-    modules += PModule(
-        project.pillModuleName,
-        project.projectDir,
-        mainModuleFileRelativePath,
-        listOf(PContentRoot(project.projectDir, false, emptyList(), allExcludedDirs)),
-        if (modules.isEmpty()) parseDependencies(project, false) else emptyList()
-    )
-
-    return modules
-}
-
-private fun parseContentRoots(project: Project): List<PContentRoot> {
-    val sourceRoots = parseSourceRoots(project).groupBy { it.kind }
-    fun getRoots(kind: PSourceRoot.Kind) = sourceRoots[kind] ?: emptyList()
-
-    val productionSourceRoots = getRoots(Kind.PRODUCTION) + getRoots(Kind.RESOURCES)
-    val testSourceRoots = getRoots(Kind.TEST) + getRoots(Kind.TEST_RESOURCES)
-
-    fun createContentRoots(sourceRoots: List<PSourceRoot>, forTests: Boolean): List<PContentRoot> {
-        return sourceRoots.map { PContentRoot(it.path, forTests, listOf(it), emptyList()) }
-    }
-
-    return createContentRoots(productionSourceRoots, forTests = false) +
-            createContentRoots(testSourceRoots, forTests = true)
-}
-
-private fun parseSourceRoots(project: Project): List<PSourceRoot> {
-    if (!project.plugins.hasPlugin(JavaPlugin::class.java)) {
-        return emptyList()
-    }
-
-    val kotlinTasksBySourceSet = project.tasks.names
-            .filter { it.startsWith("compile") && it.endsWith("Kotlin") }
-            .map { project.tasks.getByName(it) }
-            .associateBy { it.invokeInternal("getSourceSetName") }
-
-    val sourceRoots = mutableListOf<PSourceRoot>()
-
-    val sourceSets = project.sourceSets
-    if (sourceSets != null) {
-        for (sourceSet in sourceSets) {
-            val kotlinCompileTask = kotlinTasksBySourceSet[sourceSet.name]
-            val kind = if (sourceSet.isTestSourceSet) Kind.TEST else Kind.PRODUCTION
-
-            fun Any.getKotlin(): SourceDirectorySet {
-                val kotlinMethod = javaClass.getMethod("getKotlin")
-                val oldIsAccessible = kotlinMethod.isAccessible
-                try {
-                    kotlinMethod.isAccessible = true
-                    return kotlinMethod(this) as SourceDirectorySet
-                } finally {
-                    kotlinMethod.isAccessible = oldIsAccessible
-                }
-            }
-
-            val kotlinSourceDirectories = (sourceSet as HasConvention).convention
-                .plugins["kotlin"]?.getKotlin()?.srcDirs
-                ?: emptySet()
-
-            val directories = (sourceSet.java.sourceDirectories.files + kotlinSourceDirectories).toList()
-                .filter { it.exists() }
-                .takeIf { it.isNotEmpty() }
-                ?: continue
-
-            val kotlinOptions = kotlinCompileTask?.let { getKotlinOptions(it) }
-
-            for (resourceRoot in sourceSet.resources.sourceDirectories.files) {
-                if (!resourceRoot.exists() || resourceRoot in directories) {
-                    continue
-                }
-
-                val resourceRootKind = when (kind) {
-                    Kind.PRODUCTION -> Kind.RESOURCES
-                    Kind.TEST -> Kind.TEST_RESOURCES
-                    else -> error("Invalid source root kind $kind")
-                }
-
-                sourceRoots += PSourceRoot(resourceRoot, resourceRootKind, kotlinOptions)
-            }
-
-            for (directory in directories) {
-                sourceRoots += PSourceRoot(directory, kind, kotlinOptions)
-            }
-
-            for (root in parseResourceRootsProcessedByProcessResourcesTask(project, sourceSet)) {
-                if (sourceRoots.none { it.path == root.path }) {
-                    sourceRoots += root
-                }
-            }
-        }
-    }
-
-    return sourceRoots
-}
-
-private fun parseResourceRootsProcessedByProcessResourcesTask(project: Project, sourceSet: SourceSet): List<PSourceRoot> {
-    val isMainSourceSet = sourceSet.name == SourceSet.MAIN_SOURCE_SET_NAME
-
-    val resourceRootKind = if (sourceSet.isTestSourceSet) PSourceRoot.Kind.TEST_RESOURCES else PSourceRoot.Kind.RESOURCES
-    val taskNameBase = "processResources"
-    val taskName = if (isMainSourceSet) taskNameBase else sourceSet.name + taskNameBase.capitalize()
-    val task = project.tasks.findByName(taskName) as? ProcessResources ?: return emptyList()
-
-    val roots = mutableListOf<File>()
-    fun collectRoots(spec: CopySpecInternal) {
-        if (spec is SingleParentCopySpec && spec.children.none()) {
-            roots += spec.sourcePaths.map { File(project.projectDir, it.toString()) }.filter { it.exists() }
-            return
-        }
-
-        spec.children.forEach(::collectRoots)
-    }
-    collectRoots(task.rootSpec)
-
-    return roots.map { PSourceRoot(it, resourceRootKind, null) }
-}
-
-private val SourceSet.isTestSourceSet: Boolean
-    get() = name == SourceSet.TEST_SOURCE_SET_NAME
-            || name.endsWith("Test")
-            || name.endsWith("Tests")
-
-private fun getKotlinOptions(kotlinCompileTask: Any): PSourceRootKotlinOptions? {
-    val compileArguments = run {
-        val method = kotlinCompileTask::class.java.getMethod("getSerializedCompilerArguments")
-        method.isAccessible = true
-        method.invoke(kotlinCompileTask) as List<String>
-    }
-
-    fun parseBoolean(name: String) = compileArguments.contains("-$name")
-    fun parseString(name: String) = compileArguments.dropWhile { it != "-$name" }.drop(1).firstOrNull()
-
-    fun isOptionForScriptingCompilerPlugin(option: String)
-            = option.startsWith("-Xplugin=") && option.contains("kotlin-scripting-compiler")
-
-    val extraArguments = compileArguments.filter {
-        it.startsWith("-X") && !isOptionForScriptingCompilerPlugin(it)
-    }
-
-    return PSourceRootKotlinOptions(
-            parseBoolean("no-stdlib"),
-            parseBoolean("no-reflect"),
-            parseString("module-name"),
-            parseString("api-version"),
-            parseString("language-version"),
-            parseString("jvm-target"),
-            extraArguments
-    )
-}
-
-private fun Any.invokeInternal(name: String, instance: Any = this): Any? {
-    val method = javaClass.methods.single { it.name.startsWith(name) && it.parameterTypes.isEmpty() }
-
-    val oldIsAccessible = method.isAccessible
-    try {
-        method.isAccessible = true
-        return method.invoke(instance)
-    } finally {
-        method.isAccessible = oldIsAccessible
-    }
-}
-
-private fun ParserContext.parseDependencies(project: Project, forTests: Boolean): List<POrderRoot> {
-    val configurations = project.configurations
-    val configurationMapping = if (forTests) TEST_CONFIGURATION_MAPPING else CONFIGURATION_MAPPING
-
-    val mainRoots = mutableListOf<POrderRoot>()
-    val deferredRoots = mutableListOf<POrderRoot>()
-
-    for ((configurationNames, scope) in configurationMapping) {
-        for (configurationName in configurationNames) {
-            val configuration = configurations.findByName(configurationName) ?: continue
-            val (main, deferred) = project.resolveDependencies(configuration, forTests, dependencyMappers)
-            mainRoots += main.map { POrderRoot(it, scope) }
-            deferredRoots += deferred.map { POrderRoot(it, scope) }
-        }
-    }
-
-    return removeDuplicates(mainRoots + deferredRoots)
-}
-
-fun removeDuplicates(roots: List<POrderRoot>): List<POrderRoot> {
-    val dependenciesByScope = roots.groupBy { it.scope }.mapValues { it.value.mapTo(mutableSetOf()) { it.dependency } }
-    fun dependenciesFor(scope: Scope) = dependenciesByScope[scope] ?: emptySet<PDependency>()
-
-    val result = mutableSetOf<POrderRoot>()
-    for (root in roots.distinct()) {
-        val scope = root.scope
-        val dependency = root.dependency
-
-        if (root in result) {
-            continue
-        }
-
-        if ((scope == Scope.PROVIDED || scope == Scope.RUNTIME) && dependency in dependenciesFor(Scope.COMPILE)) {
-            continue
-        }
-
-        if (scope == Scope.PROVIDED && dependency in dependenciesFor(Scope.RUNTIME)) {
-            result += POrderRoot(dependency, Scope.COMPILE)
-            continue
-        }
-
-        if (scope == Scope.RUNTIME && dependency in dependenciesFor(Scope.PROVIDED)) {
-            result += POrderRoot(dependency, Scope.COMPILE)
-            continue
-        }
-
-        result += root
-    }
-
-    return result.toList()
-}
-
-val Project.pillModuleName: String
-    get() = path.removePrefix(":").replace(':', '.')
-
-val Project.sourceSets: SourceSetContainer?
-    get() {
-        val convention = project.convention.findPlugin(JavaPluginConvention::class.java) ?: return null
-        return convention.sourceSets
-    }

buildSrc/src/main/kotlin/pill/pathContext.kt

@@ -1,54 +0,0 @@
-@file:Suppress("PackageDirectoryMismatch")
-package org.jetbrains.kotlin.pill
-
-import org.gradle.api.Project
-import java.io.File
-
-private val USER_HOME_DIR_PATH = System.getProperty("user.home").withSlash()
-
-private fun replacePrefix(path: String, prefix: String, variableName: String): String {
-    if (path.startsWith(prefix)) {
-        return "$" + variableName + "$/" + path.drop(prefix.length)
-    }
-
-    return path
-}
-
-private fun simplifyUserHomeDirPath(path: String): String {
-    return replacePrefix(path, USER_HOME_DIR_PATH, "USER_HOME")
-}
-
-interface PathContext {
-    operator fun invoke(file: File): String
-
-    fun url(file: File): Pair<String, String> {
-        val path = when {
-            file.isFile && file.extension.toLowerCase() == "jar" -> "jar://" + this(file) + "!/"
-            else -> "file://" + this(file)
-        }
-
-        return Pair("url", path)
-    }
-}
-
-class ProjectContext private constructor(private val projectDir: File) : PathContext {
-    constructor(project: PProject) : this(project.rootDirectory)
-    constructor(project: Project) : this(project.projectDir)
-
-    override fun invoke(file: File): String {
-        return simplifyUserHomeDirPath(replacePrefix(file.absolutePath, projectDir.absolutePath.withSlash(), "PROJECT_DIR"))
-    }
-}
-
-class ModuleContext(val project: PProject, val module: PModule) : PathContext {
-    override fun invoke(file: File): String {
-        if (!file.startsWith(project.rootDirectory)) {
-            return simplifyUserHomeDirPath(file.absolutePath)
-        }
-
-        return "\$MODULE_DIR\$/" + file.toRelativeString(module.moduleFile.parentFile)
-    }
-}
-
-fun String.withSlash() = if (this.endsWith("/")) this else (this + "/")
-fun String.withoutSlash() = this.trimEnd('/')

buildSrc/src/main/kotlin/pill/plugin.kt

@@ -1,343 +0,0 @@
-@file:Suppress("PackageDirectoryMismatch")
-package org.jetbrains.kotlin.pill
-
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.api.plugins.BasePluginConvention
-import org.gradle.kotlin.dsl.extra
-import shadow.org.jdom2.input.SAXBuilder
-import shadow.org.jdom2.*
-import shadow.org.jdom2.output.Format
-import shadow.org.jdom2.output.XMLOutputter
-import java.io.File
-
-class PillConfigurablePlugin : Plugin<Project> {
-    override fun apply(project: Project) {
-        project.configurations.maybeCreate(EmbeddedComponents.CONFIGURATION_NAME)
-        project.extensions.create("pill", PillExtension::class.java)
-    }
-}
-
-class JpsCompatiblePlugin : Plugin<Project> {
-    companion object {
-        private fun getDependencyMappers(projectLibraries: List<PLibrary>): List<DependencyMapper> {
-            val mappersForKotlinLibrariesExeptStdlib = projectLibraries
-                .filter { it.name != "kotlin-stdlib" }
-                .map { DependencyMapper.forProject(it.originalName) { MappedDependency(PDependency.Library(it.name)) } }
-
-            val disabledModuleMappers = listOf(
-                ":kotlin-stdlib-common",
-                ":core:builtins",
-                ":kotlin-compiler",
-                ":kotlin-compiler-embeddable",
-                ":kotlin-test:kotlin-test-common",
-                ":kotlin-test:kotlin-test-annotations-common"
-            ).map { DependencyMapper.forProject(it) { null } }
-
-            return listOf(
-                DependencyMapper.forProject(":kotlin-stdlib") {
-                    MappedDependency(
-                        PDependency.Library("kotlin-stdlib"),
-                        listOf(PDependency.Library("annotations-13.0"))
-                    )
-                },
-                DependencyMapper.forProject(":kotlin-test:kotlin-test-jvm") { MappedDependency(PDependency.Library("kotlin-test-jvm")) },
-                DependencyMapper.forProject(":kotlin-reflect-api") { MappedDependency(PDependency.Library("kotlin-reflect")) }
-            ) + mappersForKotlinLibrariesExeptStdlib + disabledModuleMappers
-        }
-
-        fun getProjectLibraries(rootProject: Project): List<PLibrary> {
-            val distLibDir = File(rootProject.extra["distLibDir"].toString())
-            fun distJar(name: String) = File(rootProject.projectDir, "dist/kotlinc/lib/$name.jar")
-
-            val libraries = rootProject.allprojects
-                .mapNotNull { library ->
-                    val libraryExtension = library.extensions.findByType(PillExtension::class.java)
-                            ?.takeIf { it.importAsLibrary }
-                            ?: return@mapNotNull null
-
-                    val libraryPath = libraryExtension.libraryPath ?: distLibDir
-                    val archivesBaseName = library.convention.findPlugin(BasePluginConvention::class.java)?.archivesBaseName ?: library.name
-
-                    fun List<File>.filterExisting() = filter { it.exists() }
-
-                    PLibrary(
-                        library.name,
-                        classes = listOf(File(libraryPath, "$archivesBaseName.jar")).filterExisting(),
-                        sources = listOf(File(libraryPath, "$archivesBaseName-sources.jar")).filterExisting(),
-                        originalName = library.path
-                    )
-                }
-
-            return libraries + PLibrary("annotations-13.0", classes = listOf(distJar("annotations-13.0")))
-        }
-    }
-
-    override fun apply(project: Project) {
-        project.plugins.apply(PillConfigurablePlugin::class.java)
-        // 'jpsTest' does not require the 'tests-jar' artifact
-        project.configurations.create("jpsTest")
-
-        if (project == project.rootProject) {
-            project.tasks.create("pill") {
-                doLast { pill(project) }
-
-                if (System.getProperty("pill.android.tests", "false") == "true") {
-                    TaskUtils.useAndroidSdk(this)
-                    TaskUtils.useAndroidJar(this)
-                }
-            }
-
-            project.tasks.create("unpill") {
-                doLast { unpill(project) }
-            }
-        }
-    }
-
-    private lateinit var projectDir: File
-    private lateinit var platformVersion: String
-    private lateinit var platformBaseNumber: String
-    private lateinit var platformDir: File
-    private lateinit var intellijCoreDir: File
-    private var isAndroidStudioPlatform: Boolean = false
-
-    private fun initEnvironment(project: Project) {
-        projectDir = project.projectDir
-        platformVersion = project.extensions.extraProperties.get("versions.intellijSdk").toString()
-        platformBaseNumber = platformVersion.substringBefore(".", "").takeIf { it.isNotEmpty() }
-            ?: platformVersion.substringBefore("-", "").takeIf { it.isNotEmpty() }
-            ?: error("Invalid platform version: $platformVersion")
-        platformDir = IntellijRootUtils.getIntellijRootDir(project)
-        intellijCoreDir = File(platformDir.parentFile.parentFile.parentFile, "intellij-core")
-        isAndroidStudioPlatform = project.extensions.extraProperties.has("versions.androidStudioRelease")
-    }
-
-    private fun pill(rootProject: Project) {
-        initEnvironment(rootProject)
-
-        val variantOptionValue = System.getProperty("pill.variant", "base").toUpperCase()
-        val variant = PillExtension.Variant.values().firstOrNull { it.name == variantOptionValue }
-                ?: run {
-                    rootProject.logger.error("Invalid variant name: $variantOptionValue")
-                    return
-                }
-
-        rootProject.logger.lifecycle("Pill: Setting up project for the '${variant.name.toLowerCase()}' variant...")
-
-        if (variant == PillExtension.Variant.NONE || variant == PillExtension.Variant.DEFAULT) {
-            rootProject.logger.error("'none' and 'default' should not be passed as a Pill variant property value")
-            return
-        }
-
-        val projectLibraries = getProjectLibraries(rootProject)
-        val dependencyMappers = getDependencyMappers(projectLibraries)
-
-        val parserContext = ParserContext(dependencyMappers, variant)
-
-        val jpsProject = parse(rootProject, projectLibraries, parserContext)
-            .mapLibraries(this::attachPlatformSources, this::attachAsmSources)
-
-        val files = render(jpsProject)
-
-        removeExistingIdeaLibrariesAndModules()
-        removeJpsAndPillRunConfigurations()
-        removeAllArtifactConfigurations()
-
-        generateKotlinPluginArtifactFile(rootProject, dependencyMappers).write()
-
-        copyRunConfigurations()
-        setOptionsForDefaultJunitRunConfiguration(rootProject)
-
-        files.forEach { it.write() }
-    }
-
-    private fun unpill(project: Project) {
-        initEnvironment(project)
-
-        removeExistingIdeaLibrariesAndModules()
-        removeJpsAndPillRunConfigurations()
-        removeAllArtifactConfigurations()
-    }
-
-    private fun removeExistingIdeaLibrariesAndModules() {
-        File(projectDir, ".idea/libraries").deleteRecursively()
-        File(projectDir, ".idea/modules").deleteRecursively()
-    }
-
-    private fun removeJpsAndPillRunConfigurations() {
-        File(projectDir, ".idea/runConfigurations")
-            .walk()
-            .filter { (it.name.startsWith("JPS_") || it.name.startsWith("Pill_")) && it.extension.toLowerCase() == "xml" }
-            .forEach { it.delete() }
-    }
-
-    private fun removeAllArtifactConfigurations() {
-        File(projectDir, ".idea/artifacts")
-            .walk()
-            .filter { it.extension.toLowerCase() == "xml" }
-            .forEach { it.delete() }
-    }
-
-    private fun copyRunConfigurations() {
-        val runConfigurationsDir = File(projectDir, "buildSrc/src/main/resources/runConfigurations")
-        val targetDir = File(projectDir, ".idea/runConfigurations")
-        val platformDirProjectRelative = "\$PROJECT_DIR\$/" + platformDir.toRelativeString(projectDir)
-        val additionalIdeaArgs = if (isAndroidStudioPlatform) "-Didea.platform.prefix=AndroidStudio" else ""
-
-        targetDir.mkdirs()
-
-        fun substitute(text: String): String {
-            return text
-                .replace("\$IDEA_HOME_PATH\$", platformDirProjectRelative)
-                .replace("\$ADDITIONAL_IDEA_ARGS\$", additionalIdeaArgs)
-        }
-
-        runConfigurationsDir.listFiles()
-            .filter { it.extension == "xml" }
-            .map { it.name to substitute(it.readText()) }
-            .forEach { File(targetDir, it.first).writeText(it.second) }
-    }
-
-    /*
-        This sets a proper (project root) working directory and a "idea.home.path" property to the default JUnit configuration,
-        so one does not need to make these changes manually.
-     */
-    private fun setOptionsForDefaultJunitRunConfiguration(project: Project) {
-        val workspaceFile = File(projectDir, ".idea/workspace.xml")
-        if (!workspaceFile.exists()) {
-            project.logger.warn("${workspaceFile.name} does not exist, JUnit default run configuration was not modified")
-            return
-        }
-
-        val document = SAXBuilder().build(workspaceFile)
-        val rootElement = document.rootElement
-
-        fun Element.getOrCreateChild(name: String, vararg attributes: Pair<String, String>): Element {
-            for (child in getChildren(name)) {
-                if (attributes.all { (attribute, value) -> child.getAttributeValue(attribute) == value }) {
-                    return child
-                }
-            }
-
-            return Element(name).apply {
-                for ((attributeName, value) in attributes) {
-                    setAttribute(attributeName, value)
-                }
-
-                this@getOrCreateChild.addContent(this@apply)
-            }
-        }
-
-        val platformDirProjectRelative = "\$PROJECT_DIR\$/" + platformDir.toRelativeString(projectDir)
-
-        val runManagerComponent = rootElement.getOrCreateChild("component", "name" to "RunManager")
-
-        val junitConfiguration = runManagerComponent.getOrCreateChild(
-            "configuration",
-            "default" to "true",
-            "type" to "JUnit",
-            "factoryName" to "JUnit"
-        )
-
-        val kotlinJunitConfiguration = runManagerComponent.getOrCreateChild(
-            "configuration",
-            "default" to "true",
-            "type" to "KotlinJUnit",
-            "factoryName" to "Kotlin JUnit"
-        )
-
-        fun Element.applyJUnitTemplate() {
-            getOrCreateChild("option", "name" to "WORKING_DIRECTORY").setAttribute("value", "file://\$PROJECT_DIR\$")
-            getOrCreateChild("option", "name" to "VM_PARAMETERS").also { vmParams ->
-                var options = vmParams.getAttributeValue("value", "")
-                    .split(' ')
-                    .map { it.trim() }
-                    .filter { it.isNotEmpty() }
-
-                fun addOrReplaceOptionValue(name: String, value: Any?) {
-                    val optionsWithoutNewValue = options.filter { !it.startsWith("-D$name=") }
-                    options = if (value == null) optionsWithoutNewValue else (optionsWithoutNewValue + listOf("-D$name=$value"))
-                }
-
-                if (options.none { it == "-ea" }) {
-                    options += "-ea"
-                }
-
-                addOrReplaceOptionValue("idea.home.path", platformDirProjectRelative)
-                addOrReplaceOptionValue("ideaSdk.androidPlugin.path", platformDirProjectRelative + "/plugins/android/lib")
-                addOrReplaceOptionValue("use.jps", "true")
-                addOrReplaceOptionValue("kotlinVersion", project.rootProject.extra["kotlinVersion"].toString())
-
-                val isAndroidStudioBunch = project.findProperty("versions.androidStudioRelease") != null
-                addOrReplaceOptionValue("idea.platform.prefix", if (isAndroidStudioBunch) "AndroidStudio" else null)
-
-                val androidJarPath = project.configurations.findByName("androidJar")?.singleFile
-                val androidSdkPath = project.configurations.findByName("androidSdk")?.singleFile
-
-                if (androidJarPath != null && androidSdkPath != null) {
-                    addOrReplaceOptionValue("android.sdk", "\$PROJECT_DIR\$/" + androidSdkPath.toRelativeString(projectDir))
-                    addOrReplaceOptionValue("android.jar", "\$PROJECT_DIR\$/" + androidJarPath.toRelativeString(projectDir))
-                }
-
-                vmParams.setAttribute("value", options.joinToString(" "))
-            }
-        }
-
-        junitConfiguration.applyJUnitTemplate()
-        kotlinJunitConfiguration.applyJUnitTemplate()
-
-        val output = XMLOutputter().also {
-            it.format = Format.getPrettyFormat().apply {
-                setEscapeStrategy { Verifier.isHighSurrogate(it) || it == '"' }
-                setIndent("  ")
-                setTextMode(Format.TextMode.TRIM)
-                setOmitEncoding(false)
-                setOmitDeclaration(false)
-            }
-        }
-
-        val postProcessedXml = output.outputString(document)
-            .replace("&#x22;", "&quot;")
-            .replace("&#xA;", "&#10;")
-            .replace("&#xC;", "&#13;")
-
-        workspaceFile.writeText(postProcessedXml)
-    }
-
-    private fun attachPlatformSources(library: PLibrary): PLibrary {
-        val platformSourcesJar = File(platformDir, "../../../sources/intellij-$platformVersion-sources.jar")
-
-        if (library.classes.any { it.startsWith(platformDir) || it.startsWith(intellijCoreDir) }) {
-            return library.attachSource(platformSourcesJar)
-        }
-
-        return library
-    }
-
-    private fun attachAsmSources(library: PLibrary): PLibrary {
-        val asmSourcesJar = File(platformDir, "../asm-shaded-sources/asm-src-$platformBaseNumber.jar")
-        val asmAllJar = File(platformDir, "lib/asm-all.jar")
-
-        if (library.classes.any { it == asmAllJar }) {
-            return library.attachSource(asmSourcesJar)
-        }
-
-        return library
-    }
-
-    private fun PProject.mapLibraries(vararg mappers: (PLibrary) -> PLibrary): PProject {
-        fun mapLibrary(root: POrderRoot): POrderRoot {
-            val dependency = root.dependency
-
-            if (dependency is PDependency.ModuleLibrary) {
-                val newLibrary = mappers.fold(dependency.library) { lib, mapper -> mapper(lib) }
-                return root.copy(dependency = dependency.copy(library = newLibrary))
-            }
-
-            return root
-        }
-
-        val modules = this.modules.map { it.copy(orderRoots = it.orderRoots.map(::mapLibrary)) }
-        return this.copy(modules = modules)
-    }
-}

buildSrc/src/main/kotlin/pill/xml.kt

@@ -1,61 +0,0 @@
-@file:Suppress("PackageDirectoryMismatch")
-package org.jetbrains.kotlin.pill
-
-import shadow.org.jdom2.Document
-import shadow.org.jdom2.Element
-import shadow.org.jdom2.output.Format
-import shadow.org.jdom2.output.XMLOutputter
-
-class xml(val name: String, private vararg val args: Pair<String, Any>, block: xml.() -> Unit = {}) {
-    private companion object {
-        fun makeXml(name: String, vararg args: Pair<String, Any>, block: xml.() -> Unit = {}): xml {
-            return xml(name, *args, block = block)
-        }
-    }
-
-    private val children = mutableListOf<xml>()
-    private var value: Any? = null
-
-    init {
-        @Suppress("UNUSED_EXPRESSION")
-        block()
-    }
-
-    fun xml(name: String, vararg args: Pair<String, Any>, block: xml.() -> Unit = {}) {
-        children += makeXml(name, *args, block = block)
-    }
-
-    fun add(xml: xml) {
-        children += xml
-    }
-
-    fun raw(text: String) {
-        value = text
-    }
-
-    private fun toElement(): Element {
-        val element = Element(name)
-
-        for (arg in args) {
-            element.setAttribute(arg.first, arg.second.toString())
-        }
-
-        require(value == null || children.isEmpty())
-
-        value?.let { value ->
-            element.addContent(value.toString())
-        }
-
-        for (child in children) {
-            element.addContent(child.toElement())
-        }
-
-        return element
-    }
-
-    override fun toString(): String {
-        val document = Document().also { it.rootElement = toElement() }
-        val output = XMLOutputter().also { it.format = Format.getPrettyFormat() }
-        return output.outputString(document)
-    }
-}

buildSrc/src/main/kotlin/pluginMarkers.kt

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+import com.gradle.publish.PluginBundleExtension
+import com.gradle.publish.PluginConfig
+import org.gradle.api.Project
+import org.gradle.api.publish.PublicationContainer
+import org.gradle.api.publish.PublishingExtension
+import org.gradle.api.publish.maven.MavenPublication
+import org.gradle.api.publish.maven.tasks.PublishToMavenRepository
+import org.gradle.api.tasks.bundling.Jar
+import org.gradle.kotlin.dsl.*
+import plugins.KotlinBuildPublishingPlugin
+import plugins.configureRepository
+import java.util.*
+
+internal const val PLUGIN_MARKER_SUFFIX = ".gradle.plugin"
+
+@UseExperimental(ExperimentalStdlibApi::class)
+fun Project.publishPluginMarkers(withEmptyJars: Boolean = true) {
+    val pluginDevelopment = extensions.getByType<PluginBundleExtension>()
+    val publishingExtension = extensions.getByType<PublishingExtension>()
+    val mainPublication = publishingExtension.publications[KotlinBuildPublishingPlugin.PUBLICATION_NAME] as MavenPublication
+
+    pluginDevelopment.plugins.forEach { declaration ->
+        val markerPublication = createMavenMarkerPublication(declaration, mainPublication, publishingExtension.publications)
+        if (withEmptyJars) {
+            addEmptyJarArtifacts(markerPublication)
+        }
+
+        tasks.named<PublishToMavenRepository>(
+            "publish${markerPublication.name.capitalize(Locale.ROOT)}PublicationTo${KotlinBuildPublishingPlugin.REPOSITORY_NAME}Repository"
+        ).configureRepository()
+    }
+}
+
+fun Project.addEmptyJarArtifacts(publication: MavenPublication) {
+    val emptyJar = getOrCreateTask<Jar>("emptyJar") {
+        archiveBaseName.set("empty")
+    }
+
+    publication.artifact(emptyJar.get()) { }
+    publication.artifact(emptyJar.get()) { classifier = "sources" }
+    publication.artifact(emptyJar.get()) { classifier = "javadoc" }
+}
+
+// Based on code from `java-gradle-plugin`
+// https://github.com/gradle/gradle/blob/v6.4.0/subprojects/plugin-development/src/main/java/org/gradle/plugin/devel/plugins/MavenPluginPublishPlugin.java#L84
+private fun createMavenMarkerPublication(
+    declaration: PluginConfig,
+    coordinates: MavenPublication,
+    publications: PublicationContainer
+): MavenPublication {
+    return publications.create<MavenPublication>(declaration.name.toString() + "PluginMarkerMaven") {
+        val pluginId: String = declaration.id
+        artifactId = pluginId + PLUGIN_MARKER_SUFFIX
+        groupId = pluginId
+        pom.withXml {
+            val root = asElement()
+            val document = root.ownerDocument
+            val dependencies = root.appendChild(document.createElement("dependencies"))
+            val dependency = dependencies.appendChild(document.createElement("dependency"))
+            val groupId = dependency.appendChild(document.createElement("groupId"))
+            groupId.textContent = coordinates.groupId
+            val artifactId = dependency.appendChild(document.createElement("artifactId"))
+            artifactId.textContent = coordinates.artifactId
+            val version = dependency.appendChild(document.createElement("version"))
+            version.textContent = coordinates.version
+        }
+
+        pom.name.set(declaration.displayName)
+        pom.description.set(declaration.description)
+    }
+}

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

@@ -5,10 +5,12 @@
 
 import com.jakewharton.dex.*
 import org.gradle.api.DefaultTask
+import org.gradle.api.Project
 import org.gradle.api.tasks.*
 import org.gradle.jvm.tasks.Jar
 import java.io.File
 
+@CacheableTask
 open class DexMethodCount : DefaultTask() {
 
     data class Counts(
@@ -19,34 +21,23 @@ open class DexMethodCount : DefaultTask() {
         val byClass: Map<String, Int>
     )
 
-    init {
-        outputs.upToDateWhen { !shouldPrintTeamCityStatistics } // always execute when teamCityStatistics output is required
-    }
-
-    @InputFile
+    @Classpath
     lateinit var jarFile: File
 
-    @Input
     @Optional
+    @Input
     var ownPackages: List<String>? = null
 
-    // ##teamcity[buildStatisticValue key='DexMethodCount_${artifactOrArchiveName}' value='62362']
-    @Input
-    @Optional
-    var teamCityStatistics: Boolean? = null
-
-    private val shouldPrintTeamCityStatistics = teamCityStatistics ?: project.hasProperty("teamcity")
-
-
-    @Input
-    @Optional
+    @Internal
     var artifactName: String? = null
 
-    private val artifactOrArchiveName get() = artifactName ?: project.name
+    @get:Input
+    val artifactOrArchiveName: String
+        get() = artifactName ?: project.name
 
     fun from(jar: Jar) {
-        jarFile = jar.archivePath
-        artifactName = jar.baseName
+        jarFile = jar.archiveFile.get().asFile
+        artifactName = jar.archiveBaseName.orNull
         dependsOn(jar)
     }
 
@@ -54,16 +45,13 @@ open class DexMethodCount : DefaultTask() {
     lateinit var counts: Counts
 
     @get:OutputFile
-    val detailOutputFile: File get() = project.buildDir.resolve("$artifactOrArchiveName-method-count.txt")
+    val detailOutputFile: File
+        get() = project.buildDir.resolve("$artifactOrArchiveName-method-count.txt")
 
     @TaskAction
     fun invoke() {
         val methods = dexMethods(jarFile)
-
         val counts = methods.getCounts().also { this.counts = it }
-
-        printTotals(counts)
-        printTCStats(counts)
         outputDetails(counts)
     }
 
@@ -71,7 +59,7 @@ open class DexMethodCount : DefaultTask() {
         val byPackage = this.groupingBy { it.`package` }.eachCount()
         val byClass = this.groupingBy { it.declaringType }.eachCount()
 
-        val ownPackages = ownPackages?.map { it + '.' }
+        val ownPackages = ownPackages?.map { "$it." }
         val byOwnPackages = if (ownPackages != null) {
             this.partition { method -> ownPackages.any { method.declaringType.startsWith(it) } }.let {
                 it.first.size to it.second.size
@@ -87,26 +75,6 @@ open class DexMethodCount : DefaultTask() {
         )
     }
 
-    private fun printTotals(counts: Counts) {
-        logger.lifecycle("Artifact $artifactOrArchiveName, total methods: ${counts.total}")
-        ownPackages?.let { packages ->
-            logger.lifecycle("Artifact $artifactOrArchiveName, total methods from packages ${packages.joinToString { "$it.*" }}: ${counts.totalOwnPackages}")
-            logger.lifecycle("Artifact $artifactOrArchiveName, total methods from other packages: ${counts.totalOtherPackages}")
-        }
-    }
-
-    private fun printTCStats(counts: Counts) {
-        if (shouldPrintTeamCityStatistics) {
-            println("##teamcity[buildStatisticValue key='DexMethodCount_${artifactOrArchiveName}' value='${counts.total}']")
-            counts.totalOwnPackages?.let { value ->
-                println("##teamcity[buildStatisticValue key='DexMethodCount_${artifactOrArchiveName}_OwnPackages' value='$value']")
-            }
-            counts.totalOtherPackages?.let { value ->
-                println("##teamcity[buildStatisticValue key='DexMethodCount_${artifactOrArchiveName}_OtherPackages' value='$value']")
-            }
-        }
-    }
-
     private fun outputDetails(counts: Counts) {
         detailOutputFile.printWriter().use { writer ->
             writer.println("${counts.total.padRight()}\tTotal methods")
@@ -126,9 +94,67 @@ open class DexMethodCount : DefaultTask() {
             }
         }
     }
-
 }
 
+open class DexMethodCountStats : DefaultTask() {
+
+    @Internal
+    lateinit var from: TaskProvider<DexMethodCount>
+
+    @get:InputFile
+    internal val inputFile
+        get() = from.get().detailOutputFile
+
+    @TaskAction
+    private fun printStats() {
+        val artifactOrArchiveName = from.get().artifactOrArchiveName
+        inputFile.reader().useLines { lines ->
+            fun String.getStatValue() = substringBefore("\t").trim()
+
+            val ownPackages = from.get().ownPackages
+            val statsLineCount = if (ownPackages == null) 1 else 3
+            val stats = lines.take(statsLineCount).map { it.getStatValue() }.toList()
+
+            val total = stats[0]
+            logger.lifecycle("Artifact $artifactOrArchiveName, total methods: $total")
+
+            if (project.kotlinBuildProperties.isTeamcityBuild) {
+                println("##teamcity[buildStatisticValue key='DexMethodCount_${artifactOrArchiveName}' value='$total']")
+            }
+
+            ownPackages?.let { packages ->
+                val totalOwnPackages = stats[1]
+                val totalOtherPackages = stats[2]
+
+                logger.lifecycle("Artifact $artifactOrArchiveName, total methods from packages ${packages.joinToString { "$it.*" }}: $totalOwnPackages")
+                logger.lifecycle("Artifact $artifactOrArchiveName, total methods from other packages: $totalOtherPackages")
+
+                if (project.kotlinBuildProperties.isTeamcityBuild) {
+                    println("##teamcity[buildStatisticValue key='DexMethodCount_${artifactOrArchiveName}_OwnPackages' value='$totalOwnPackages']")
+                    println("##teamcity[buildStatisticValue key='DexMethodCount_${artifactOrArchiveName}_OtherPackages' value='$totalOtherPackages']")
+                }
+            }
+        }
+    }
+}
+
+fun Project.printStats(dexMethodCount: TaskProvider<DexMethodCount>) {
+    val dexMethodCountStats = tasks.register("dexMethodCountStats", DexMethodCountStats::class.java) {
+        dependsOn(dexMethodCount)
+        from = dexMethodCount
+    }
+
+    dexMethodCount.configure {
+        finalizedBy(dexMethodCountStats)
+    }
+}
+
+fun Project.dexMethodCount(action: DexMethodCount.() -> Unit): TaskProvider<DexMethodCount> {
+    val dexMethodCount = tasks.register("dexMethodCount", DexMethodCount::class.java, action)
+    printStats(dexMethodCount)
+    tasks.getByName("check").dependsOn(dexMethodCount)
+    return dexMethodCount
+}
 
 private val DexMethod.`package`: String get() = declaringType.substringBeforeLast('.')
 private fun Int.padRight() = toString().padStart(5, ' ')

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

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

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

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

buildSrc/src/main/kotlin/publish.kt

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

buildSrc/src/main/kotlin/tasks.kt

@@ -79,21 +79,20 @@ fun Project.projectTest(
         }
     }
 
-    doFirst {
-        val agent = tasks.findByPath(":test-instrumenter:jar")!!.outputs.files.singleFile
-
-        val args = project.findProperty("kotlin.test.instrumentation.args")?.let { "=$it" }.orEmpty()
-
-        jvmArgs("-javaagent:$agent$args")
+    if (project.findProperty("kotlin.test.instrumentation.disable")?.toString()?.toBoolean() != true) {
+        doFirst {
+            val agent = tasks.findByPath(":test-instrumenter:jar")!!.outputs.files.singleFile
+            val args = project.findProperty("kotlin.test.instrumentation.args")?.let { "=$it" }.orEmpty()
+            jvmArgs("-javaagent:$agent$args")
+        }
+        dependsOn(":test-instrumenter:jar")
     }
 
-    dependsOn(":test-instrumenter:jar")
-
     jvmArgs(
         "-ea",
         "-XX:+HeapDumpOnOutOfMemoryError",
         "-XX:+UseCodeCacheFlushing",
-        "-XX:ReservedCodeCacheSize=128m",
+        "-XX:ReservedCodeCacheSize=256m",
         "-Djna.nosys=true"
     )
 
@@ -106,6 +105,11 @@ fun Project.projectTest(
     environment("PROJECT_BUILD_DIR", buildDir)
     systemProperty("jps.kotlin.home", rootProject.extra["distKotlinHomeDir"]!!)
     systemProperty("kotlin.ni", if (rootProject.hasProperty("newInferenceTests")) "true" else "false")
+    systemProperty("org.jetbrains.kotlin.skip.muted.tests", if (rootProject.hasProperty("skipMutedTests")) "true" else "false")
+
+    if (Platform[202].orHigher()) {
+        systemProperty("idea.ignore.disabled.plugins", "true")
+    }
 
     var subProjectTempRoot: Path? = null
     doFirst {
@@ -154,6 +158,10 @@ object TaskUtils {
     fun useAndroidJar(task: Task) {
         task.useAndroidConfiguration(systemPropertyName = "android.jar", configName = "androidJar")
     }
+
+    fun useAndroidEmulator(task: Task) {
+        task.useAndroidConfiguration(systemPropertyName = "android.sdk", configName = "androidEmulator")
+    }
 }
 
 private fun Task.useAndroidConfiguration(systemPropertyName: String, configName: String) {

buildSrc/src/main/resources/runConfigurations/Pill_Refresh_JPS_Model.xml

@@ -1,21 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="[Pill] Refresh PILL Model" type="GradleRunConfiguration" factoryName="Gradle" singleton="true">
-    <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="pill" />
-        </list>
-      </option>
-      <option name="vmOptions" value="" />
-    </ExternalSystemSettings>
-    <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
-    <method />
-  </configuration>
-</component>

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

@@ -1,14 +1,14 @@
 // 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.3.2'
-        // NOTE: Do not place your application dependencies here; they belong
-        // in the individual module build.gradle files
+        classpath 'com.android.tools.build:gradle:3.5.3'
     }
 }
 apply plugin: 'com.android.application'
@@ -19,7 +19,7 @@ repositories {
 }
 
 android {
-    compileSdkVersion 19
+    compileSdkVersion 26
     buildToolsVersion "28.0.3"
 
     defaultConfig {
@@ -51,7 +51,7 @@ android {
 
     dexOptions {
         dexInProcess false
-        javaMaxHeapSize "1200m"
+        javaMaxHeapSize "1500m"
         maxProcessCount 4
         additionalParameters "--debug"
     }
@@ -60,17 +60,42 @@ android {
         resultsDir = "build/test/results"
     }
 
+    if (isD8Enabled) {
+        compileOptions {
+            sourceCompatibility = 1.8
+            targetCompatibility = 1.8
+        }
+    }
 
     flavorDimensions "box"
 
     productFlavors {
-        ktest0 {
+        common0 {
             dimension "box"
         }
 
-        ktest1 {
+        common1 {
             dimension "box"
         }
+
+        common2 {
+            dimension "box"
+        }
+
+        reflect0 {
+            dimension "box"
+        }
+
+
+        if (isD8Enabled) {
+            jvm80 {
+                dimension "box"
+            }
+
+            reflectjvm80 {
+                dimension "box"
+            }
+        }
     }
 
 }
@@ -78,9 +103,9 @@ android {
 task jarTestFolders() {
     println "Jar folders..."
     new File("${projectDir}/libs/").listFiles().each { File file ->
-        if (file.isDirectory() && !file.name.equals("test")) {
+        if (file.isDirectory()) {
             println "Jar '${file.name}' folder..."
-            ant.jar(basedir: "libs/${file.name}/", destfile: "libs/test/" +  file.name  + ".jar")
+            ant.jar(basedir: "libs/${file.name}/", destfile: "libs/" +  file.name  + ".jar")
         }
     }
 }
@@ -90,10 +115,18 @@ tasks.withType(JavaCompile) {
 }
 
 dependencies {
-    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation fileTree(dir: 'libs', include: ['kotlin-test.jar', 'kotlin-stdlib.jar'])
     androidTestImplementation 'junit:junit:4.12'
     androidTestImplementation 'com.android.support.test:runner:1.0.2'
 
-    ktest0Implementation fileTree(dir: 'libs/test', include: ['libtest0.jar'])
-    ktest1Implementation fileTree(dir: 'libs/test', include: ['libtest1.jar'])
+    android.applicationVariants.all { variant ->
+        variant.productFlavors.each {
+            def configuration = configurations.getByName(it.name + 'Implementation').name
+            add(configuration, project.fileTree(dir: 'libs', include: [it.name + ".jar"]))
+
+            if (it.name.startsWith("reflect")) {
+                add(configuration, project.fileTree(dir: 'libs', include: ['kotlin-reflect.jar']))
+            }
+        }
+    }
 }

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

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

compiler/android-tests/build.gradle.kts

@@ -1,3 +1,4 @@
+import TaskUtils.useAndroidEmulator
 
 plugins {
     kotlin("jvm")
@@ -13,7 +14,10 @@ dependencies {
     compile(project(":kotlin-reflect"))
     compile(projectTests(":compiler:tests-common"))
     compile(commonDep("junit:junit"))
-    compileOnly(intellijDep()) { includeJars("openapi") }
+
+    Platform[193].orLower {
+        compileOnly(intellijDep()) { includeJars("openapi") }
+    }
 
     testCompile(project(":compiler:incremental-compilation-impl"))
     testCompile(project(":core:descriptors"))
@@ -21,9 +25,16 @@ dependencies {
     testCompile(project(":compiler:frontend.java"))
     testCompile(projectTests(":jps-plugin"))
     testCompile(commonDep("junit:junit"))
-    testCompile(intellijDep()) { includeJars("openapi", "util", "idea", "idea_rt", "groovy-all", rootProject = rootProject) }
-    Platform[191].orLower {
-        testCompile(intellijDep()) { includeJars("jps-builders") }
+    Platform[193].orLower {
+        testCompile(intellijDep()) { includeJars("openapi", rootProject = rootProject) }
+    }
+
+    testCompile(intellijDep()) { includeJars("util", "idea", "idea_rt", rootProject = rootProject) }
+    Platform[202].orHigher {
+        testCompile(intellijDep()) { includeJars("groovy", rootProject = rootProject) }
+    }
+    Platform[201].orLower {
+        testCompile(intellijDep()) { includeJars("groovy-all", rootProject = rootProject) }
     }
     Platform[192].orHigher {
         testCompile(intellijPluginDep("java")) { includeJars("jps-builders") }
@@ -52,6 +63,7 @@ projectTest {
     }
 
     workingDir = rootDir
+    useAndroidEmulator(this)
 }
 
 val generateAndroidTests by generator("org.jetbrains.kotlin.android.tests.CodegenTestsOnAndroidGenerator")

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

@@ -19,10 +19,8 @@ package org.jetbrains.kotlin.android.tests
 import com.intellij.util.PlatformUtils
 import junit.framework.TestCase
 import junit.framework.TestSuite
-import org.jetbrains.kotlin.android.tests.download.SDKDownloader
 import org.jetbrains.kotlin.android.tests.emulator.Emulator
 import org.jetbrains.kotlin.android.tests.gradle.GradleRunner
-import org.jetbrains.kotlin.android.tests.run.PermissionManager
 import org.junit.Assert
 import org.w3c.dom.Element
 import org.xml.sax.SAXException
@@ -39,8 +37,6 @@ class CodegenTestsOnAndroidRunner private constructor(private val pathManager: P
     private fun runTestsInEmulator(): TestSuite {
         val rootSuite = TestSuite("Root")
 
-        downloadDependencies()
-
         val emulatorType = if (isTeamcity) Emulator.ARM else Emulator.X86
         println("Using $emulatorType emulator!")
         val emulator = Emulator(pathManager, emulatorType)
@@ -56,16 +52,16 @@ class CodegenTestsOnAndroidRunner private constructor(private val pathManager: P
             try {
                 emulator.waitEmulatorStart()
 
-                runTestsOnEmulator(gradleRunner, TestSuite("Dex")).apply {
+                runTestsOnEmulator(gradleRunner, TestSuite("D8")).apply {
                     rootSuite.addTest(this)
                 }
 
                 renameFlavorFolder()
-                enableD8(true)
-                runTestsOnEmulator(gradleRunner, TestSuite("D8")).apply {
+                enableD8(false)
+                runTestsOnEmulator(gradleRunner, TestSuite("DX")).apply {
                     (0 until this.countTestCases()).forEach {
                         val testCase = testAt(it) as TestCase
-                        testCase.name += "_D8"
+                        testCase.name += "_DX"
                     }
                     rootSuite.addTest(this)
                 }
@@ -106,14 +102,14 @@ class CodegenTestsOnAndroidRunner private constructor(private val pathManager: P
                 testCases.forEach { aCase -> suite.addTest(aCase) }
                 Assert.assertNotEquals("There is no test results in report", 0, testCases.size.toLong())
             }
-        } catch (e: Exception) {
+        } catch (e: Throwable) {
             throw RuntimeException("Can't parse test results in $reportFolder\n$resultOutput", e)
         }
     }
 
     private fun renameFlavorFolder() {
         val reportFolder = File(flavorFolder())
-        reportFolder.renameTo(File(reportFolder.parentFile, reportFolder.name + "_dex"))
+        reportFolder.renameTo(File(reportFolder.parentFile, reportFolder.name + "_d8"))
     }
 
     private fun flavorFolder() = pathManager.tmpFolder + "/build/test/results/connected/flavors"
@@ -134,18 +130,6 @@ class CodegenTestsOnAndroidRunner private constructor(private val pathManager: P
 
     }
 
-    private fun downloadDependencies() {
-        val rootForAndroidDependencies = File(pathManager.dependenciesRoot)
-        if (!rootForAndroidDependencies.exists()) {
-            rootForAndroidDependencies.mkdirs()
-        }
-
-        val downloader = SDKDownloader(pathManager)
-        downloader.downloadAll()
-        downloader.unzipAll()
-        PermissionManager.setPermissions(pathManager)
-    }
-
     companion object {
 
         @JvmStatic

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

@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.android.tests;
 
-import org.jetbrains.kotlin.android.tests.download.SDKDownloader;
+import org.jetbrains.kotlin.test.KotlinTestUtils;
 
 import java.io.File;
 
@@ -35,7 +35,7 @@ public class PathManager {
     }
 
     public String getAndroidAvdRoot() {
-        String androidEmulatorRoot = getAndroidSdkRoot() + "/emulatoravd";
+        String androidEmulatorRoot = getAndroidSdkRoot() + "/compiler_box_test_avd";
         new File(androidEmulatorRoot).mkdirs();
         return androidEmulatorRoot;
     }
@@ -52,12 +52,8 @@ public class PathManager {
         return getAndroidSdkRoot() + "/emulator";
     }
 
-    public String getBuildToolsFolderInAndroidSdk() {
-        return getAndroidSdkRoot() + "/build-tools";
-    }
-
-    public String getOutputForCompiledFiles(int index) {
-        return tmpFolder + "/libs/libtest" + index;
+    public String getOutputForCompiledFiles(String flavor) {
+        return tmpFolder + "/libs/" + flavor;
     }
 
     public String getLibsFolderInAndroidTmpFolder() {
@@ -73,19 +69,7 @@ public class PathManager {
     }
 
     public String getAndroidSdkRoot() {
-        return getDependenciesRoot() + "/android-sdk";
-    }
-
-    public String getDependenciesRoot() {
-        return rootFolder + "/dependencies/android.tests.dependencies";
-    }
-
-    public String getGradleBinFolder() {
-        return getDependenciesRoot() + "/gradle-" + SDKDownloader.GRADLE_VERSION + "/bin";
-    }
-
-    public String getRootForDownload() {
-        return getDependenciesRoot() + "/download";
+        return KotlinTestUtils.getAndroidSdkSystemIndependentPath();
     }
 
     public String getAndroidModuleRoot() {

compiler/android-tests/src/org/jetbrains/kotlin/android/tests/download/SDKDownloader.java

@@ -1,269 +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.download;
-
-import com.intellij.openapi.util.SystemInfo;
-import com.intellij.openapi.util.io.FileUtil;
-import org.jetbrains.kotlin.android.tests.PathManager;
-import org.jetbrains.kotlin.android.tests.run.RunUtils;
-
-import java.io.*;
-import java.net.URL;
-import java.net.URLConnection;
-import java.util.zip.ZipEntry;
-import java.util.zip.ZipInputStream;
-
-public class SDKDownloader {
-    private final String platformZipPath;
-    private final String armImage;
-    private final String x86Image;
-    private final String platformToolsZipPath;
-    private final String skdToolsZipPath;
-    private final String buildToolsZipPath;
-    private final String gradleZipPath;
-    private final String emulatorZipPath;
-
-    private final PathManager pathManager;
-
-    private static final String PLATFORM_TOOLS = "28.0.1";
-    private static final String SDK_TOOLS = "4333796"; //"26.1.1";
-    public static final String BUILD_TOOLS = "28.0.3";
-    private static final int ANDROID_VERSION = 19;
-    public static final String GRADLE_VERSION = "5.1.1";
-    public static final String EMULATOR_TOOLS_VERSION = "5264690"; //"28.0.23";
-
-
-    public SDKDownloader(PathManager pathManager) {
-        this.pathManager = pathManager;
-        platformZipPath = pathManager.getRootForDownload() + "/platform" + ANDROID_VERSION + ".zip";
-        armImage = pathManager.getRootForDownload() + "/arm-image.zip";
-        x86Image = pathManager.getRootForDownload() + "/x86-image.zip";
-        platformToolsZipPath = pathManager.getRootForDownload() + "/platform-tools" + PLATFORM_TOOLS + ".zip";
-        skdToolsZipPath = pathManager.getRootForDownload() + "/sdk-tools" + SDK_TOOLS + ".zip";
-        buildToolsZipPath = pathManager.getRootForDownload() + "/build-tools" + BUILD_TOOLS + ".zip";
-        gradleZipPath = pathManager.getRootForDownload() + "/gradle" + GRADLE_VERSION + ".zip";
-        emulatorZipPath = pathManager.getRootForDownload() + "/emulator" + EMULATOR_TOOLS_VERSION + ".zip";
-    }
-
-    public void downloadPlatform() {
-        download("https://dl-ssl.google.com/android/repository/android-" + ANDROID_VERSION + "_r04.zip", platformZipPath);  //Same for all platforms
-    }
-
-    private void downloadAbi() {
-        download("https://dl.google.com/android/repository/sys-img/android/armeabi-v7a-" + ANDROID_VERSION + "_r05.zip", armImage);  //Same for all platforms
-        download("https://dl.google.com/android/repository/sys-img/android/x86-" + ANDROID_VERSION + "_r06.zip", x86Image);  //Same for all platforms
-    }
-
-    public void downloadPlatformTools() {
-        download(getDownloadUrl("https://dl-ssl.google.com/android/repository/platform-tools_r" + PLATFORM_TOOLS), platformToolsZipPath);
-    }
-
-    public void downloadSdkTools() {
-        download("https://dl.google.com/android/repository/sdk-tools-" + getPlatformName() + "-" + SDK_TOOLS + ".zip",
-                 skdToolsZipPath);
-    }
-
-    public void downloadBuildTools() {
-        download(getDownloadUrl("https://dl.google.com/android/repository/build-tools_r" + BUILD_TOOLS), buildToolsZipPath);
-    }
-    public void downloadEmulator() {
-        download("https://dl.google.com/android/repository/emulator-" + getPlatformName() + "-" + EMULATOR_TOOLS_VERSION + ".zip",
-                 emulatorZipPath);
-    }
-
-    public void downloadGradle() {
-        download("https://services.gradle.org/distributions/gradle-" + GRADLE_VERSION + "-bin.zip", gradleZipPath);
-    }
-
-    private static String getDownloadUrl(String prefix) {
-        String suffix;
-        if (SystemInfo.isWindows) {
-            suffix = "-windows.zip";
-        }
-        else if (SystemInfo.isMac) {
-            suffix = "-macosx.zip";
-        }
-        else if (SystemInfo.isUnix) {
-            suffix = "-linux.zip";
-        }
-        else {
-            throw new IllegalStateException("Your operating system isn't supported yet.");
-        }
-        return prefix + suffix;
-    }
-
-
-    private static String getPlatformName() {
-        if (SystemInfo.isWindows) {
-            return "windows";
-        }
-        else if (SystemInfo.isMac) {
-            return "darwin";
-        }
-        else if (SystemInfo.isUnix) {
-            return "linux";
-        }
-        else {
-            throw new IllegalStateException("Your operating system isn't supported yet.");
-        }
-    }
-
-    public void downloadAll() {
-        downloadSdkTools();
-        downloadAbi();
-        downloadPlatform();
-        downloadPlatformTools();
-        downloadBuildTools();
-        downloadGradle();
-        downloadEmulator();
-    }
-
-
-    public void unzipAll() {
-        String androidSdkRoot = pathManager.getAndroidSdkRoot();
-        unzip(platformZipPath, pathManager.getPlatformFolderInAndroidSdk());
-        new File(pathManager.getPlatformFolderInAndroidSdk() + "/android-4.4.2").renameTo(new File(pathManager.getPlatformFolderInAndroidSdk() + "/android-" + ANDROID_VERSION));
-
-        unzip(armImage, androidSdkRoot + "/system-images/android-" + ANDROID_VERSION + "/default/");
-        unzip(x86Image, androidSdkRoot + "/system-images/android-" + ANDROID_VERSION + "/default/");
-
-        unzip(platformToolsZipPath, androidSdkRoot);
-        unzip(skdToolsZipPath, androidSdkRoot);
-
-        unzip(gradleZipPath, pathManager.getDependenciesRoot());
-
-        //BUILD TOOLS
-        String buildTools = androidSdkRoot + "/build-tools/";
-        unzip(buildToolsZipPath, buildTools);
-
-        unzip(emulatorZipPath, androidSdkRoot);
-    }
-
-    public void deleteAll() {
-        delete(platformZipPath);
-        delete(platformToolsZipPath);
-        delete(skdToolsZipPath);
-        delete(buildToolsZipPath);
-        delete(armImage);
-        delete(x86Image);
-        delete(gradleZipPath);
-    }
-
-    private static void download(String urlString, String output) {
-        System.out.println("Start downloading: " + urlString + " to " + output);
-        OutputStream outStream = null;
-        URLConnection urlConnection;
-
-        InputStream is;
-        try {
-            URL Url;
-            byte[] buf;
-            int read;
-            //int written = 0;
-            Url = new URL(urlString);
-
-            File outputFile = new File(output);
-            outputFile.getParentFile().mkdirs();
-            if (outputFile.exists()) {
-                System.out.println("File was already downloaded: " + output);
-                return;
-            }
-            outputFile.createNewFile();
-            FileOutputStream outputStream = new FileOutputStream(outputFile);
-            outStream = new BufferedOutputStream(outputStream);
-
-            urlConnection = Url.openConnection();
-            is = urlConnection.getInputStream();
-            buf = new byte[1024];
-            while ((read = is.read(buf)) != -1) {
-                outStream.write(buf, 0, read);
-                //written += read;
-            }
-        }
-        catch (Exception e) {
-            throw new RuntimeException(e);
-        }
-        finally {
-            RunUtils.close(outStream);
-        }
-        System.out.println("Finish downloading: " + urlString + " to " + output);
-    }
-
-    protected void unzip(String pathToFile, String outputFolder) {
-        System.out.println("Start unzipping: " + pathToFile + " to " + outputFolder);
-        String pathToUnzip;
-        if (outputFolder.equals(pathManager.getPlatformFolderInAndroidSdk())) {
-            pathToUnzip = outputFolder;
-        }
-        else {
-            pathToUnzip = outputFolder + "/" + FileUtil.getNameWithoutExtension(new File(pathToFile));
-        }
-        if (new File(pathToUnzip).listFiles() != null) {
-            System.out.println("File was already unzipped: " + pathToFile);
-            return;
-        }
-        try {
-            byte[] buf = new byte[1024];
-            ZipEntry zipEntry = null;
-            try (ZipInputStream zipInputStream = new ZipInputStream(new FileInputStream(pathToFile))) {
-                zipEntry = zipInputStream.getNextEntry();
-                while (zipEntry != null) {
-                    String entryName = zipEntry.getName();
-                    int n;
-                    File outputFile = new File(outputFolder + "/" + entryName);
-
-                    if (zipEntry.isDirectory()) {
-                        outputFile.mkdirs();
-                        zipInputStream.closeEntry();
-                        zipEntry = zipInputStream.getNextEntry();
-                        continue;
-                    }
-                    else {
-                        File parentFile = outputFile.getParentFile();
-                        if (parentFile != null && !parentFile.exists()) {
-                            parentFile.mkdirs();
-                        }
-                        outputFile.createNewFile();
-                    }
-
-                    try (FileOutputStream fileOutputStream = new FileOutputStream(outputFile)) {
-                        while ((n = zipInputStream.read(buf, 0, 1024)) > -1) {
-                            fileOutputStream.write(buf, 0, n);
-                        }
-                    }
-                    zipInputStream.closeEntry();
-                    zipEntry = zipInputStream.getNextEntry();
-                }
-            }
-            catch (IOException e) {
-                if (zipEntry != null) {
-                    System.err.println("Entry name: " + zipEntry.getName());
-                }
-                e.printStackTrace();
-            }
-        }
-        catch (Exception e) {
-            e.printStackTrace();
-        }
-        System.out.println("Finish unzipping: " + pathToFile + " to " + outputFolder);
-    }
-
-    private static void delete(String filePath) {
-        new File(filePath).delete();
-    }
-}
-

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

@@ -48,8 +48,8 @@ public class Emulator {
 
     private GeneralCommandLine getCreateCommand() {
         GeneralCommandLine commandLine = new GeneralCommandLine();
-        String androidCmdName = SystemInfo.isWindows ? "android.bat" : "android";
-        commandLine.setExePath(pathManager.getToolsFolderInAndroidSdk() + "/" + androidCmdName);
+        String androidCmdName = SystemInfo.isWindows ? "avdmanager.bat" : "avdmanager";
+        commandLine.setExePath(pathManager.getToolsFolderInAndroidSdk() + "/bin/" + androidCmdName);
         commandLine.addParameter("create");
         commandLine.addParameter("avd");
         commandLine.addParameter("--force");

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

@@ -31,8 +31,8 @@ public class GradleRunner {
 
     public GradleRunner(PathManager pathManager) {
         listOfCommands = new ArrayList<>();
-        String cmdName = SystemInfo.isWindows ? "gradle.bat" : "gradle";
-        listOfCommands.add(pathManager.getGradleBinFolder() + "/" + cmdName);
+        String cmdName = SystemInfo.isWindows ? "gradlew.bat" : "gradlew";
+        listOfCommands.add(pathManager.getTmpFolder() + "/" + cmdName);
         listOfCommands.add("--no-daemon");
         listOfCommands.add("--build-file");
         listOfCommands.add(pathManager.getTmpFolder() + "/build.gradle");

compiler/android-tests/src/org/jetbrains/kotlin/android/tests/run/PermissionManager.java

@@ -1,64 +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.run;
-
-import com.intellij.execution.configurations.GeneralCommandLine;
-import com.intellij.openapi.util.SystemInfo;
-import org.jetbrains.kotlin.android.tests.PathManager;
-import org.jetbrains.kotlin.android.tests.download.SDKDownloader;
-
-import java.io.File;
-
-public class PermissionManager {
-    private PermissionManager() {
-    }
-
-    public static void setPermissions(PathManager pathManager) {
-        if (!SystemInfo.isWindows) {
-            setExecPermissionForSimpleNamedFiles(new File(pathManager.getToolsFolderInAndroidSdk()));
-            setExecPermissionForSimpleNamedFiles(new File(pathManager.getBuildToolsFolderInAndroidSdk() + "/" + SDKDownloader.BUILD_TOOLS));
-            setExecPermissionForSimpleNamedFiles(new File(pathManager.getPlatformToolsFolderInAndroidSdk()));
-            setExecPermissionForSimpleNamedFiles(new File(pathManager.getToolsFolderInAndroidSdk() +"/bin"));
-            setExecPermissionForSimpleNamedFiles(new File(pathManager.getEmulatorFolderInAndroidSdk()));
-            setExecPermissionForSimpleNamedFiles(new File(pathManager.getEmulatorFolderInAndroidSdk() +"/bin"));
-            setExecPermissionForSimpleNamedFiles(new File(pathManager.getEmulatorFolderInAndroidSdk() +"/bin64"));
-            setExecPermissionForSimpleNamedFiles(new File(pathManager.getEmulatorFolderInAndroidSdk() +"/qemu/linux-x86_64"));
-            setExecPermissionForSimpleNamedFiles(new File(pathManager.getAndroidSdkRoot() + "/system-images/android-19/default/armeabi-v7a/"));
-
-            RunUtils.execute(generateChmodCmd(pathManager.getGradleBinFolder() + "/gradle"));
-        }
-    }
-
-    private static void setExecPermissionForSimpleNamedFiles(File folder) {
-        File[] files = folder.listFiles();
-        if (files != null) {
-            for (File file : files) {
-                if (file.isFile() && !file.getName().contains(".")) {
-                    RunUtils.execute(generateChmodCmd(file.getAbsolutePath()));
-                }
-            }
-        }
-    }
-
-    private static GeneralCommandLine generateChmodCmd(String path) {
-        GeneralCommandLine commandLine = new GeneralCommandLine();
-        commandLine.setExePath("chmod");
-        commandLine.addParameter("a+x");
-        commandLine.addParameter(path);
-        return commandLine;
-    }
-}

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

@@ -41,7 +41,7 @@ public class AndroidJpsBuildTestCase extends BaseKotlinJpsBuildTestCase {
     }
 
     @Override
-    protected void runTest() throws Throwable {
+    protected void runTest() {
         doTest();
     }
 

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

@@ -17,10 +17,10 @@
 package org.jetbrains.kotlin.android.tests
 
 import com.intellij.openapi.util.Ref
-import org.jetbrains.kotlin.codegen.CodegenTestCase
 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 java.io.File
 import java.util.regex.Pattern
 
@@ -34,7 +34,7 @@ private data class OldPackageAndNew(val oldFqName: FqName, val newFqName: FqName
 
 internal fun patchFilesAndAddTest(
     testFile: File,
-    testFiles: List<CodegenTestCase.TestFile>,
+    testFiles: List<KotlinBaseTest.TestFile>,
     filesHolder: CodegenTestsOnAndroidGenerator.FilesWriter
 ): FqName? {
     if (testFiles.any { it.name.endsWith(".java") }) {
@@ -46,18 +46,21 @@ internal fun patchFilesAndAddTest(
 
     val newPackagePrefix = testFile.path.replace("\\\\|-|\\.|/".toRegex(), "_")
     val oldPackage = Ref<FqName>()
+    val isJvmName = Ref<Boolean>(false)
     val isSingle = testFiles.size == 1
     val resultFiles = testFiles.map {
         val fileName = if (isSingle) it.name else testFile.name.substringBeforeLast(".kt") + "/" + it.name
         TestClassInfo(
             fileName,
-            changePackage(newPackagePrefix, it.content, oldPackage),
+            changePackage(newPackagePrefix, it.content, oldPackage, isJvmName),
             oldPackage.get(),
+            isJvmName.get(),
             getGeneratedClassName(File(fileName), it.content, newPackagePrefix, oldPackage.get())
         )
     }
     val packages =
-        resultFiles.map { OldPackageAndNew(it.oldPackage, it.newClassId.parent()) }.sortedByDescending { it.oldFqName.asString().length }
+        resultFiles.map { OldPackageAndNew(it.oldPackage, it.newPackagePartClassId.parent()) }
+            .sortedByDescending { it.oldFqName.asString().length }
 
     //If files contain any val or var declaration with same name as any package name
     // then use old conservative renaming scheme, otherwise use aggressive one
@@ -94,7 +97,7 @@ internal fun patchFilesAndAddTest(
     /*replace all Class.forName*/
     resultFiles.forEach { file ->
         file.content = resultFiles.fold(file.content) { r, param ->
-            patchClassForName(param.newClassId, param.oldPackage, r, conservativeRenameScheme)
+            patchClassForName(param.newPackagePartClassId, param.oldPackage, r, conservativeRenameScheme)
         }
     }
 
@@ -103,6 +106,13 @@ internal fun patchFilesAndAddTest(
         file.content = file.content.patchSelfImports(file.newPackage)
     }
 
+    //patch root package parts usages in strings
+    resultFiles.forEach { file ->
+        file.content = resultFiles.fold(file.content) { r, param ->
+            patchRootPartNamesInStrings(param.newPackagePartClassId, param.oldPackage, param.isJvmName, r)
+        }
+    }
+
     val boxFiles = resultFiles.filter { hasBoxMethod(it.content) }
     if (boxFiles.size != 1) {
         println("Several box methods in $testFile")
@@ -110,22 +120,22 @@ internal fun patchFilesAndAddTest(
 
     filesHolder.addTest(
         resultFiles.filter { resultFile -> resultFile.name.endsWith(".kt") || resultFile.name.endsWith(".kts") },
-        TestInfo("", boxFiles.last().newClassId, testFile)
+        TestInfo("", boxFiles.last().newPackagePartClassId, testFile)
     )
 
-    return boxFiles.last().newClassId
+    return boxFiles.last().newPackagePartClassId
 }
 
 private fun hasBoxMethod(text: String): Boolean {
     return text.contains("fun box()")
 }
 
-class TestClassInfo(val name: String, var content: String, val oldPackage: FqName, val newClassId: FqName) {
-    val newPackage = newClassId.parent()
+class TestClassInfo(val name: String, var content: String, val oldPackage: FqName, val isJvmName: Boolean, val newPackagePartClassId: FqName) {
+    val newPackage = newPackagePartClassId.parent()
 }
 
 
-private fun changePackage(newPackagePrefix: String, text: String, oldPackage: Ref<FqName>): String {
+private fun changePackage(newPackagePrefix: String, text: String, oldPackage: Ref<FqName>, isJvmName: Ref<Boolean>): String {
     val matcher = packagePattern.matcher(text)
     if (matcher.find()) {
         val oldPackageName = matcher.toMatchResult().group(1)
@@ -137,6 +147,7 @@ private fun changePackage(newPackagePrefix: String, text: String, oldPackage: Re
         if (text.contains("@file:")) {
             val index = text.lastIndexOf("@file:")
             val packageDirectiveIndex = text.indexOf("\n", index)
+            isJvmName.set(true)
             return text.substring(0, packageDirectiveIndex + 1) + packageDirective + text.substring(packageDirectiveIndex + 1)
         } else {
             return packageDirective + text
@@ -169,6 +180,19 @@ private fun patchClassForName(className: FqName, oldPackage: FqName, text: Strin
     )
 }
 
+private fun patchRootPartNamesInStrings(
+    className: FqName,
+    oldPackage: FqName,
+    isJvmName: Boolean,
+    text: String
+): String {
+    if (!oldPackage.isRoot || isJvmName) return text
+    return text.replace(
+        ("\"" + oldPackage.child(className.shortName()).asString()).toRegex(),
+        "\"" + className.asString()
+    )
+}
+
 private fun patchPackages(newPackage: FqName, oldPackage: FqName, text: String): String {
     if (oldPackage.isRoot) return text
 

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

@@ -5,7 +5,9 @@
 
 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
 import com.intellij.openapi.util.io.FileUtilRt
 import org.jetbrains.kotlin.cli.common.output.writeAllTo
@@ -17,50 +19,102 @@ 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.idea.KotlinFileType
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.*
 import org.junit.Assert
-import org.junit.Ignore
 import java.io.File
 import java.io.FileWriter
 import java.io.IOException
+import kotlin.test.assertTrue
 
 data class ConfigurationKey(val kind: ConfigurationKind, val jdkKind: TestJdkKind, val configuration: String)
 
-@Ignore
-class CodegenTestsOnAndroidGenerator private constructor(private val pathManager: PathManager) : CodegenTestCase() {
-    private var writtenFilesCount = 0
-
+class CodegenTestsOnAndroidGenerator private constructor(private val pathManager: PathManager) {
     private var currentModuleIndex = 1
 
     private val pathFilter: String? = System.getProperties().getProperty("kotlin.test.android.path.filter")
 
-    private val pendingUnitTestGenerators = hashMapOf<Int, UnitTestFileWriter>()
+    private val pendingUnitTestGenerators = hashMapOf<String, UnitTestFileWriter>()
 
     //keep it globally to avoid test grouping on TC
     private val generatedTestNames = hashSetOf<String>()
 
-    fun getFlavorUnitTestFilePath(index: Int): String {
-        return pathManager.srcFolderInAndroidTmpFolder + "/androidTestKtest$index/java/" + testClassPackage.replace(
-            ".",
-            "/"
-        ) + "/" + testClassName + "$index.java"
+    private val COMMON = FlavorConfig("common", 3);
+    private val REFLECT = FlavorConfig("reflect", 1);
+    private val JVM8 = FlavorConfig("jvm8", 1);
+    private val JVM8REFLECT = FlavorConfig("reflectjvm8", 1);
+
+    class FlavorConfig(private val prefix: String, val limit: Int) {
+
+        private var writtenFilesCount = 0
+
+        fun printStatistics() {
+            println("FlavorTestCompiler: $prefix, generated file count: $writtenFilesCount")
+        }
+
+        fun getFlavorForNewFiles(newFilesCount: Int): String {
+            writtenFilesCount += newFilesCount
+            //2500 files per folder that would be used by flavor to avoid multidex usage,
+            // each folder would be jared by build.gradle script
+            val index = writtenFilesCount / 2500
+
+            return getFlavorName(index, prefix).also {
+                assertTrue("Please Add  new flavor in build.gradle for $it") { index < limit }
+            }
+        }
+
+        private fun getFlavorName(index: Int, prefix: String): String {
+            return prefix + index
+        }
+
     }
 
-    private fun prepareAndroidModuleAndGenerateTests() {
-        prepareAndroidModule()
+    private fun prepareAndroidModuleAndGenerateTests(skipSdkDirWriting: Boolean) {
+        prepareAndroidModule(skipSdkDirWriting)
         generateTestsAndFlavourSuites()
     }
 
-    private fun prepareAndroidModule() {
+    private fun prepareAndroidModule(skipSdkDirWriting: Boolean) {
         FileUtil.copyDir(File(pathManager.androidModuleRoot), File(pathManager.tmpFolder))
-        writeAndroidSkdToLocalProperties(pathManager)
+        if (!skipSdkDirWriting) {
+            writeAndroidSkdToLocalProperties(pathManager)
+        }
 
         println("Copying kotlin-stdlib.jar and kotlin-reflect.jar in android module...")
         copyKotlinRuntimeJars()
+        copyGradleWrapperAndPatch()
     }
 
+    private fun copyGradleWrapperAndPatch() {
+        val projectRoot = File(pathManager.tmpFolder)
+        val target = File(projectRoot, "gradle/wrapper")
+        File("./gradle/wrapper/").copyRecursively(target)
+        val gradlew = File(projectRoot, "gradlew")
+        File("./gradlew").copyTo(gradlew).also {
+            if (!SystemInfo.isWindows) {
+                it.setExecutable(true)
+            }
+        }
+        File("./gradlew.bat").copyTo(File(projectRoot, "gradlew.bat"));
+        val file = File(target, "gradle-wrapper.properties")
+        file.readLines().map {
+            when {
+                it.startsWith("distributionUrl") -> "distributionUrl=https\\://services.gradle.org/distributions/gradle-$GRADLE_VERSION-bin.zip"
+                it.startsWith("distributionSha256Sum") -> "distributionSha256Sum=$GRADLE_SHA_256"
+                else -> it
+            }
+        }.let { lines ->
+            FileWriter(file).use { fw ->
+                lines.forEach { line ->
+                    fw.write("$line\n")
+                }
+            }
+        }
+    }
+
+
     private fun copyKotlinRuntimeJars() {
         FileUtil.copy(
             ForTestCompileRuntime.runtimeJarForTests(),
@@ -96,9 +150,15 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
         holders.values.forEach {
             it.writeFilesOnDisk()
         }
+
+        COMMON.printStatistics()
+        REFLECT.printStatistics()
+        JVM8.printStatistics()
+        JVM8REFLECT.printStatistics()
     }
 
     internal inner class FilesWriter(
+        private val flavorConfig: FlavorConfig,
         private val configuration: CompilerConfiguration
     ) {
         private val rawFiles = arrayListOf<TestClassInfo>()
@@ -113,38 +173,40 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
         }
 
         fun writeFilesOnDisk() {
-            val disposable = TestDisposable()
-
+            val disposable = Disposer.newDisposable()
             val environment = KotlinCoreEnvironment.createForTests(
                 disposable,
                 configuration.copy().apply { put(CommonConfigurationKeys.MODULE_NAME, "android-module-" + currentModuleIndex++) },
                 EnvironmentConfigFiles.JVM_CONFIG_FILES
             )
 
-            writeFiles(
-                rawFiles.map {
-                    try {
-                        CodegenTestFiles.create(it.name, it.content, environment.project).psiFile
-                    } catch (e: Throwable) {
-                        throw RuntimeException("Error on processing ${it.name}:\n${it.content}", e)
-                    }
-                }, environment
-            )
-            Disposer.dispose(disposable)
-            rawFiles.clear()
-            unitTestDescriptions.clear()
+            try {
+                writeFiles(
+                    rawFiles.map {
+                        try {
+                            CodegenTestFiles.create(it.name, it.content, environment.project).psiFile
+                        } catch (e: Throwable) {
+                            throw RuntimeException("Error on processing ${it.name}:\n${it.content}", e)
+                        }
+                    }, environment, unitTestDescriptions
+                )
+            } finally {
+                rawFiles.clear()
+                unitTestDescriptions.clear()
+                Disposer.dispose(disposable)
+            }
         }
 
-        private fun writeFiles(filesToCompile: List<KtFile>, environment: KotlinCoreEnvironment) {
+        private fun writeFiles(
+            filesToCompile: List<KtFile>,
+            environment: KotlinCoreEnvironment,
+            unitTestDescriptions: ArrayList<TestInfo>
+        ) {
             if (filesToCompile.isEmpty()) return
 
-            //3000 files per folder that would be used by flavor to avoid multidex usage,
-            // each folder would be jared by build.gradle script
-            writtenFilesCount += filesToCompile.size
-            val index = writtenFilesCount / 3000
-            val outputDir = File(pathManager.getOutputForCompiledFiles(index))
-            assertTrue("Add flavors for ktest$index", index < 2)
+            val flavorName = flavorConfig.getFlavorForNewFiles(filesToCompile.size)
 
+            val outputDir = File(pathManager.getOutputForCompiledFiles(flavorName))
             println("Generating ${filesToCompile.size} files into ${outputDir.name}, configuration: '${environment.configuration}'...")
 
             val outputFiles = GenerationUtils.compileFiles(filesToCompile, environment).run { destroy(); factory }
@@ -153,10 +215,10 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
                 outputDir.mkdirs()
             }
             Assert.assertTrue("Cannot create directory for compiled files", outputDir.exists())
-            val unitTestFileWriter = pendingUnitTestGenerators.getOrPut(index) {
+            val unitTestFileWriter = pendingUnitTestGenerators.getOrPut(flavorName) {
                 UnitTestFileWriter(
-                    getFlavorUnitTestFilePath(index),
-                    index,
+                    getFlavorUnitTestFolder(flavorName),
+                    flavorName,
                     generatedTestNames
                 )
             }
@@ -164,6 +226,12 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
             outputFiles.writeAllTo(outputDir)
         }
 
+        private fun getFlavorUnitTestFolder(flavourName: String): String {
+            return pathManager.srcFolderInAndroidTmpFolder +
+                    "/androidTest${flavourName.capitalize()}/java/" +
+                    testClassPackage.replace(".", "/") + "/"
+        }
+
         fun addTest(testFiles: List<TestClassInfo>, info: TestInfo) {
             rawFiles.addAll(testFiles)
             unitTestDescriptions.add(info)
@@ -180,9 +248,6 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
         }
 
         for (file in files) {
-            if (SpecialFiles.getExcludedFiles().contains(file.name)) {
-                continue
-            }
             if (file.isDirectory) {
                 val listFiles = file.listFiles()
                 if (listFiles != null) {
@@ -195,7 +260,9 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
                     continue
                 }
 
-                if (!InTextDirectivesUtils.isPassingTarget(TargetBackend.JVM, file)) {
+                if (!InTextDirectivesUtils.isPassingTarget(TargetBackend.JVM, file) ||
+                    InTextDirectivesUtils.isIgnoredTarget(TargetBackend.ANDROID, file)
+                ) {
                     continue
                 }
 
@@ -211,23 +278,32 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
                 if (fullFileText.contains("@file:JvmPackageName(")) continue
                 // TODO: Support jvm assertions
                 if (fullFileText.contains("// KOTLIN_CONFIGURATION_FLAGS: ASSERTIONS_MODE=jvm")) continue
-                // TODO: support JVM 8 test with D8
-                if (fullFileText.contains("// JVM_TARGET")) 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
+
                 // TODO: support SKIP_JDK6 on new platforms
                 if (fullFileText.contains("// SKIP_JDK6")) continue
 
                 if (hasBoxMethod(fullFileText)) {
                     val testFiles = createTestFiles(file, fullFileText)
-                    val kind = extractConfigurationKind(testFiles)
-                    val jdkKind = getJdkKind(testFiles)
+                    val kind = KotlinBaseTest.extractConfigurationKind(testFiles)
+                    val jdkKind = KotlinBaseTest.getTestJdkKind(testFiles)
                     val keyConfiguration = CompilerConfiguration()
-                    updateConfigurationByDirectivesInTestFiles(testFiles, keyConfiguration)
+                    KotlinBaseTest.updateConfigurationByDirectivesInTestFiles(testFiles, keyConfiguration)
 
                     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 filesHolder = holders.getOrPut(key) {
-                        FilesWriter(KotlinTestUtils.newConfiguration(kind, jdkKind, KotlinTestUtils.getAnnotationsJar()).apply {
+                        FilesWriter(compiler, KotlinTestUtils.newConfiguration(kind, jdkKind, KotlinTestUtils.getAnnotationsJar()).apply {
                             println("Creating new configuration by $key")
-                            updateConfigurationByDirectivesInTestFiles(testFiles, this)
+                            KotlinBaseTest.updateConfigurationByDirectivesInTestFiles(testFiles, this)
                         })
                     }
 
@@ -237,19 +313,12 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
         }
     }
 
-    private fun createTestFiles(file: File, expectedText: String): List<TestFile> =
-        TestFiles.createTestFiles(
-            file.name,
-            expectedText,
-            object : TestFiles.TestFileFactoryNoModules<TestFile>() {
-                override fun create(fileName: String, text: String, directives: Map<String, String>): TestFile {
-                    return TestFile(fileName, text)
-                }
-            }, false,
-            "kotlin.coroutines"
-        )
+    private fun createTestFiles(file: File, expectedText: String): List<KotlinBaseTest.TestFile> =
+        CodegenTestCase.createTestFilesFromFile(file, expectedText, "kotlin.coroutines", false, TargetBackend.JVM)
 
     companion object {
+        const val GRADLE_VERSION = "5.6.4" // update GRADLE_SHA_256 on change
+        const val GRADLE_SHA_256 = "1f3067073041bc44554d0efe5d402a33bc3d3c93cc39ab684f308586d732a80d"
         const val testClassPackage = "org.jetbrains.kotlin.android.tests"
         const val testClassName = "CodegenTestCaseOnAndroid"
         const val baseTestClassPackage = "org.jetbrains.kotlin.android.tests"
@@ -257,10 +326,11 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
         const val generatorName = "CodegenTestsOnAndroidGenerator"
 
 
+        @JvmOverloads
         @JvmStatic
         @Throws(Throwable::class)
-        fun generate(pathManager: PathManager) {
-            CodegenTestsOnAndroidGenerator(pathManager).prepareAndroidModuleAndGenerateTests()
+        fun generate(pathManager: PathManager, skipSdkDirWriting: Boolean = false) {
+            CodegenTestsOnAndroidGenerator(pathManager).prepareAndroidModuleAndGenerateTests(skipSdkDirWriting)
         }
 
         private fun hasBoxMethod(text: String): Boolean {
@@ -269,7 +339,7 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
 
         @Throws(IOException::class)
         internal fun writeAndroidSkdToLocalProperties(pathManager: PathManager) {
-            val sdkRoot = File(pathManager.androidSdkRoot).invariantSeparatorsPath
+            val sdkRoot = KotlinTestUtils.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") }
@@ -281,7 +351,8 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
             println("Created temporary folder for android tests: " + tmpFolder.absolutePath)
             val rootFolder = File("")
             val pathManager = PathManager(rootFolder.absolutePath, tmpFolder.absolutePath)
-            generate(pathManager)
+            generate(pathManager, true)
+            println("Android test project is generated into " + tmpFolder.absolutePath + " folder")
         }
     }
 }

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

@@ -1,90 +0,0 @@
-/*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.android.tests;
-
-import java.util.HashSet;
-import java.util.Set;
-
-public class SpecialFiles {
-    private static final Set<String> excludedFiles = new HashSet<>();
-
-    static {
-        fillExcludedFiles();
-    }
-
-    public static Set<String> getExcludedFiles() {
-        return excludedFiles;
-    }
-
-    private static void fillExcludedFiles() {
-        // Reflection
-        excludedFiles.add("enclosing");
-        excludedFiles.add("kt10259.kt");
-        excludedFiles.add("simpleClassLiteral.kt");
-
-        //UnsatisfiedLinkError
-        excludedFiles.add("nativePropertyAccessors.kt");
-        excludedFiles.add("topLevel.kt");
-
-        //Test with no reflection at runtime
-        excludedFiles.add("noReflectAtRuntime");
-        excludedFiles.add("noReflect");
-        excludedFiles.add("functionNtoStringNoReflect.kt");
-        excludedFiles.add("getDelegateWithoutReflection.kt");
-
-        // "IOOBE: Invalid index 4, size is 4" for java.lang.reflect.ParameterizedType on Android
-        excludedFiles.add("innerGenericTypeArgument.kt");
-
-        // Cannot change package name
-        excludedFiles.add("kt6990.kt");
-        excludedFiles.add("typeParameters.kt");
-        excludedFiles.add("kt13133.kt");
-
-        // StackOverflow with StringBuilder (escape())
-        excludedFiles.add("kt684.kt");
-
-        // Wrong enclosing info or signature after package renaming
-        excludedFiles.add("enclosingInfo");
-        excludedFiles.add("signature");
-
-        // Some classes are not visible on android
-        excludedFiles.add("classpath.kt");
-
-        // Out of memory
-        excludedFiles.add("manyNumbers.kt");
-
-        // Native methods
-        excludedFiles.add("external");
-
-        // Additional nested class in 'Thread' class on Android
-        excludedFiles.add("nestedClasses.kt");
-
-        // KT-8120
-        excludedFiles.add("closureOfInnerLocalClass.kt");
-        excludedFiles.add("closureWithSelfInstantiation.kt");
-        excludedFiles.add("quotedClassName.kt");
-
-        //wrong function resolution after package renaming
-        excludedFiles.add("apiVersionAtLeast1.kt");
-
-        //special symbols in names
-        excludedFiles.add("nameWithWhitespace.kt");
-    }
-
-    private SpecialFiles() {
-    }
-}

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

@@ -15,7 +15,11 @@ import java.io.FileWriter
 
 class TestInfo(val name: String, val fqName: FqName, val file: File)
 
-class UnitTestFileWriter(private val fileName: String, private val index: Int, private val generatedTestNames: MutableSet<String>) {
+class UnitTestFileWriter(
+    private val flavourFolder: String,
+    private val flavourName: String,
+    private val generatedTestNames: MutableSet<String>
+) {
     private val infos = arrayListOf<TestInfo>()
 
     fun addTests(info: List<TestInfo>) {
@@ -23,7 +27,7 @@ class UnitTestFileWriter(private val fileName: String, private val index: Int, p
     }
 
     fun generate() {
-        FileWriter(File(fileName).also { it.parentFile.mkdirs() }).use { suite ->
+        FileWriter(File(flavourFolder, flavourName.capitalize() + ".java").also { it.parentFile.mkdirs() }).use { suite ->
             val p = Printer(suite)
             p.println(
                 """package ${CodegenTestsOnAndroidGenerator.testClassPackage};
@@ -31,7 +35,7 @@ class UnitTestFileWriter(private val fileName: String, private val index: Int, p
                 |import ${CodegenTestsOnAndroidGenerator.baseTestClassPackage}.${CodegenTestsOnAndroidGenerator.baseTestClassName};
                 |
                 |/* This class is generated by ${CodegenTestsOnAndroidGenerator.generatorName}. DO NOT MODIFY MANUALLY */
-                |public class ${CodegenTestsOnAndroidGenerator.testClassName}$index extends ${CodegenTestsOnAndroidGenerator.baseTestClassName} {
+                |public class ${flavourName.capitalize()} extends ${CodegenTestsOnAndroidGenerator.baseTestClassName} {
                 |
             """.trimMargin()
             )

compiler/backend-common/build.gradle.kts

@@ -8,7 +8,6 @@ dependencies {
     compile(project(":core:descriptors"))
     compile(project(":compiler:util"))
     compile(project(":compiler:frontend"))
-    compile(project(":compiler:ir.tree"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
 }
 

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

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

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

@@ -16,17 +16,11 @@
 
 package org.jetbrains.kotlin.backend.common
 
-import org.jetbrains.kotlin.backend.common.CodegenUtil.getMemberToGenerate
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
-import org.jetbrains.kotlin.psi.KtClass
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtParameter
 import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.BindingContextUtils
 
 /**
  * A platform-independent logic for generating data class synthetic methods.

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

@@ -18,15 +18,16 @@ package org.jetbrains.kotlin.backend.common.bridges
 
 import org.jetbrains.kotlin.utils.DFS
 import java.util.*
+import kotlin.collections.LinkedHashMap
 
 interface FunctionHandle {
     val isDeclaration: Boolean
     val isAbstract: Boolean
 
     /** On finding concrete super declaration we should distinguish non-abstract java8/js default methods from
-    * class ones (see [findConcreteSuperDeclaration] method in bridges.kt).
-    * Note that interface methods with body compiled to jvm 8 target are assumed to be non-abstract in bridges method calculation
-    * (more details in [DescriptorBasedFunctionHandle.isBodyOwner] comment).*/
+     * class ones (see [findConcreteSuperDeclaration] method in bridges.kt).
+     * Note that interface methods with body compiled to jvm 8 target are assumed to be non-abstract in bridges method calculation
+     * (more details in [DescriptorBasedFunctionHandle.isBodyOwner] comment).*/
     val mayBeUsedAsSuperImplementation: Boolean
 
     fun getOverridden(): Iterable<FunctionHandle>
@@ -34,18 +35,19 @@ interface FunctionHandle {
     val mightBeIncorrectCode: Boolean get() = false
 }
 
-data class Bridge<out Signature>(
-        val from: Signature,
-        val to: Signature
+data class Bridge<out Signature, out Function : FunctionHandle>(
+    val from: Signature,
+    val to: Signature,
+    val originalFunctions: Set<Function>
 ) {
     override fun toString() = "$from -> $to"
 }
 
 
 fun <Function : FunctionHandle, Signature> generateBridges(
-        function: Function,
-        signature: (Function) -> Signature
-): Set<Bridge<Signature>> {
+    function: Function,
+    signature: (Function) -> Signature
+): Set<Bridge<Signature, Function>> {
     // If it's an abstract function, no bridges are needed: when an implementation will appear in some concrete subclass, all necessary
     // bridges will be generated there
     if (function.isAbstract) return setOf()
@@ -58,7 +60,7 @@ fun <Function : FunctionHandle, Signature> generateBridges(
 
     val implementation = findConcreteSuperDeclaration(function) ?: return setOf()
 
-    val bridgesToGenerate = findAllReachableDeclarations(function).mapTo(LinkedHashSet<Signature>(), signature)
+    val bridgesToGenerate = findAllReachableDeclarations(function).groupByTo(LinkedHashMap(), signature)
 
     if (fake) {
         // If it's a concrete fake override, some of the bridges may be inherited from the super-classes. Specifically, bridges for all
@@ -67,14 +69,20 @@ fun <Function : FunctionHandle, Signature> generateBridges(
         @Suppress("UNCHECKED_CAST")
         for (overridden in function.getOverridden() as Iterable<Function>) {
             if (!overridden.isAbstract) {
-                bridgesToGenerate.removeAll(findAllReachableDeclarations(overridden).map(signature))
+                for (reachable in findAllReachableDeclarations(overridden)) {
+                    bridgesToGenerate.remove(signature(reachable))
+                }
             }
         }
     }
 
     val method = signature(implementation)
     bridgesToGenerate.remove(method)
-    return bridgesToGenerate.map { Bridge(it, method) }.toSet()
+    return bridgesToGenerate.entries
+        .map { (overriddenSignature, overriddenFunctions) ->
+            Bridge(overriddenSignature, method, overriddenFunctions.toSet())
+        }
+        .toSet()
 }
 
 fun <Function : FunctionHandle> findAllReachableDeclarations(function: Function): MutableSet<Function> {
@@ -95,7 +103,7 @@ fun <Function : FunctionHandle> findAllReachableDeclarations(function: Function)
  * The implementation is guaranteed to exist because if it wouldn't, the given function would've been abstract
  */
 fun <Function : FunctionHandle> findConcreteSuperDeclaration(function: Function): Function? {
-    require(!function.isAbstract, { "Only concrete functions have implementations: $function" })
+    require(!function.isAbstract) { "Only concrete functions have implementations: $function" }
 
     if (function.isDeclaration) return function
 

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

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

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

@@ -21,6 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.codegen.inline.FileMapping;
 import org.jetbrains.kotlin.codegen.inline.SMAPBuilder;
+import org.jetbrains.kotlin.codegen.inline.SourceMapper;
 import org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin;
 import org.jetbrains.org.objectweb.asm.*;
@@ -38,8 +39,6 @@ public abstract class AbstractClassBuilder implements ClassBuilder {
 
     private final JvmSerializationBindings serializationBindings = new JvmSerializationBindings();
 
-    private final List<FileMapping> fileMappings = new ArrayList<>();
-
     private String sourceName;
 
     private String debugInfo;
@@ -106,15 +105,7 @@ public abstract class AbstractClassBuilder implements ClassBuilder {
 
     @Override
     public void done() {
-        if (!fileMappings.isEmpty() && GENERATE_SMAP) {
-            FileMapping origin = fileMappings.get(0);
-            assert sourceName == null || origin.getName().equals(sourceName) : "Error " + origin.getName() +  " != "  + sourceName;
-            getVisitor().visitSource(origin.getName(), new SMAPBuilder(origin.getName(), origin.getPath(), fileMappings).build());
-        }
-        else {
-            getVisitor().visitSource(sourceName, debugInfo);
-        }
-
+        getVisitor().visitSource(sourceName, debugInfo);
         getVisitor().visitEnd();
     }
 
@@ -134,10 +125,21 @@ public abstract class AbstractClassBuilder implements ClassBuilder {
 
     @Override
     public void visitSource(@NotNull String name, @Nullable String debug) {
+        assert sourceName == null || sourceName.equals(name) : "inconsistent file name: " + sourceName + " vs " + name;
         sourceName = name;
         debugInfo = debug;
     }
 
+    @Override
+    public void visitSMAP(@NotNull SourceMapper smap, boolean backwardsCompatibleSyntax) {
+        if (!GENERATE_SMAP) return;
+
+        List<FileMapping> fileMappings = smap.getResultMappings();
+        if (fileMappings.isEmpty()) return;
+
+        visitSource(fileMappings.get(0).getName(), SMAPBuilder.INSTANCE.build(fileMappings, backwardsCompatibleSyntax));
+    }
+
     @Override
     public void visitOuterClass(@NotNull String owner, @Nullable String name, @Nullable String desc) {
         getVisitor().visitOuterClass(owner, name, desc);
@@ -154,9 +156,4 @@ public abstract class AbstractClassBuilder implements ClassBuilder {
         assert thisName != null : "This name isn't set";
         return thisName;
     }
-
-    @Override
-    public void addSMAP(FileMapping mapping) {
-        fileMappings.add(mapping);
-    }
 }

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

@@ -28,6 +28,7 @@ import org.jetbrains.kotlin.descriptors.annotations.*;
 import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor;
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
 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.AnnotationChecker;
@@ -40,7 +41,6 @@ import org.jetbrains.kotlin.types.FlexibleType;
 import org.jetbrains.kotlin.types.FlexibleTypesKt;
 import org.jetbrains.kotlin.types.KotlinType;
 import org.jetbrains.kotlin.types.TypeUtils;
-import org.jetbrains.kotlin.types.checker.SimpleClassicTypeSystemContext;
 import org.jetbrains.org.objectweb.asm.*;
 
 import java.lang.annotation.*;
@@ -90,12 +90,18 @@ public abstract class AnnotationCodegen {
     private final KotlinTypeMapper typeMapper;
     private final ModuleDescriptor module;
     private final GenerationState state;
+    private final boolean skipNullabilityAnnotations;
 
     private AnnotationCodegen(@NotNull InnerClassConsumer innerClassConsumer, @NotNull GenerationState state) {
+        this(innerClassConsumer, state, false);
+    }
+
+    private AnnotationCodegen(@NotNull InnerClassConsumer innerClassConsumer, @NotNull GenerationState state, boolean skipNullabilityAnnotations) {
         this.innerClassConsumer = innerClassConsumer;
         this.typeMapper = state.getTypeMapper();
         this.module = state.getModule();
         this.state = state;
+        this.skipNullabilityAnnotations = skipNullabilityAnnotations;
     }
 
     /**
@@ -105,6 +111,16 @@ public abstract class AnnotationCodegen {
             @Nullable Annotated annotated,
             @Nullable Type returnType,
             @Nullable KotlinType typeForTypeAnnotations
+    ) {
+        genAnnotations(annotated, returnType, typeForTypeAnnotations, null, Collections.emptyList());
+    }
+
+    public void genAnnotations(
+            @Nullable Annotated annotated,
+            @Nullable Type returnType,
+            @Nullable KotlinType typeForTypeAnnotations,
+            @Nullable DeclarationDescriptorWithVisibility parameterContainer,
+            @NotNull List<Class<?>> additionalAnnotations
     ) {
         if (annotated == null) return;
 
@@ -139,22 +155,28 @@ public abstract class AnnotationCodegen {
             }
         }
 
-        generateAdditionalAnnotations(annotated, returnType, annotationDescriptorsAlreadyPresent);
+        for (Class<?> annotation : additionalAnnotations) {
+            String descriptor = generateAnnotationIfNotPresent(annotationDescriptorsAlreadyPresent, annotation);
+            annotationDescriptorsAlreadyPresent.add(descriptor);
+        }
+
+        generateAdditionalAnnotations(annotated, returnType, annotationDescriptorsAlreadyPresent, parameterContainer);
         generateTypeAnnotations(annotated, typeForTypeAnnotations);
     }
 
     private void generateAdditionalAnnotations(
             @NotNull Annotated annotated,
             @Nullable Type returnType,
-            @NotNull Set<String> annotationDescriptorsAlreadyPresent
+            @NotNull Set<String> annotationDescriptorsAlreadyPresent,
+            @Nullable DeclarationDescriptorWithVisibility parameterContainer
     ) {
         if (annotated instanceof CallableDescriptor) {
-            generateAdditionalCallableAnnotations((CallableDescriptor) annotated, returnType, annotationDescriptorsAlreadyPresent);
+            generateAdditionalCallableAnnotations((CallableDescriptor) annotated, returnType, annotationDescriptorsAlreadyPresent, parameterContainer);
         }
         else if (annotated instanceof FieldDescriptor) {
             generateAdditionalCallableAnnotations(
-                    ((FieldDescriptor) annotated).getCorrespondingProperty(), returnType, annotationDescriptorsAlreadyPresent
-            );
+                    ((FieldDescriptor) annotated).getCorrespondingProperty(), returnType, annotationDescriptorsAlreadyPresent,
+                    parameterContainer);
         }
         else if (annotated instanceof ClassDescriptor) {
             generateAdditionalClassAnnotations(annotationDescriptorsAlreadyPresent, (ClassDescriptor) annotated);
@@ -164,11 +186,15 @@ public abstract class AnnotationCodegen {
     private void generateAdditionalCallableAnnotations(
             @NotNull CallableDescriptor descriptor,
             @Nullable Type returnType,
-            @NotNull Set<String> annotationDescriptorsAlreadyPresent
+            @NotNull Set<String> annotationDescriptorsAlreadyPresent,
+            @Nullable DeclarationDescriptorWithVisibility parameterContainer
     ) {
         // No need to annotate privates, synthetic accessors and their parameters
         if (isInvisibleFromTheOutside(descriptor)) return;
-        if (descriptor instanceof ValueParameterDescriptor && isInvisibleFromTheOutside(descriptor.getContainingDeclaration())) return;
+        if (descriptor instanceof ParameterDescriptor &&
+            isInvisibleFromTheOutside(parameterContainer != null ? parameterContainer : descriptor.getContainingDeclaration())) {
+            return;
+        }
 
         // No need to annotate annotation methods since they're always non-null
         if (descriptor instanceof PropertyGetterDescriptor &&
@@ -176,7 +202,7 @@ public abstract class AnnotationCodegen {
             return;
         }
 
-        if (returnType != null && !AsmUtil.isPrimitive(returnType)) {
+        if (returnType != null && !AsmUtil.isPrimitive(returnType) && !skipNullabilityAnnotations) {
             generateNullabilityAnnotation(descriptor.getReturnType(), annotationDescriptorsAlreadyPresent);
         }
     }
@@ -254,12 +280,11 @@ public abstract class AnnotationCodegen {
         jvm8.put(KotlinTarget.TYPE, ElementType.TYPE_USE);
 
         annotationTargetMaps.put(JvmTarget.JVM_1_6, jvm6);
-        annotationTargetMaps.put(JvmTarget.JVM_1_8, jvm8);
-        annotationTargetMaps.put(JvmTarget.JVM_9, jvm8);
-        annotationTargetMaps.put(JvmTarget.JVM_10, jvm8);
-        annotationTargetMaps.put(JvmTarget.JVM_11, jvm8);
-        annotationTargetMaps.put(JvmTarget.JVM_12, jvm8);
-        annotationTargetMaps.put(JvmTarget.JVM_13, jvm8);
+        for (JvmTarget target : JvmTarget.values()) {
+            if (target != JvmTarget.JVM_1_6) {
+                annotationTargetMaps.put(target, jvm8);
+            }
+        }
     }
 
     private void generateTargetAnnotation(
@@ -313,11 +338,13 @@ public abstract class AnnotationCodegen {
         visitor.visitEnd();
     }
 
-    private void generateAnnotationIfNotPresent(Set<String> annotationDescriptorsAlreadyPresent, Class<?> annotationClass) {
+    @NotNull
+    private String generateAnnotationIfNotPresent(Set<String> annotationDescriptorsAlreadyPresent, Class<?> annotationClass) {
         String descriptor = Type.getType(annotationClass).getDescriptor();
         if (!annotationDescriptorsAlreadyPresent.contains(descriptor)) {
             visitAnnotation(descriptor, false).visitEnd();
         }
+        return descriptor;
     }
 
     private static boolean isBareTypeParameterWithNullableUpperBound(@NotNull KotlinType type) {
@@ -434,8 +461,13 @@ public abstract class AnnotationCodegen {
 
             @Override
             public Void visitEnumValue(EnumValue value, Void data) {
-                String enumClassInternalName = AsmUtil.asmTypeByClassId(value.getEnumClassId()).getDescriptor();
+                ClassId enumClassId = value.getEnumClassId();
+                String enumClassInternalName = AsmUtil.asmTypeByClassId(enumClassId).getDescriptor();
                 String enumEntryName = value.getEnumEntryName().asString();
+                ClassDescriptor descriptor = FindClassInModuleKt.findClassAcrossModuleDependencies(state.getModule(), enumClassId);
+                if (descriptor != null) {
+                    innerClassConsumer.addInnerClassInfoFromAnnotation(descriptor);
+                }
                 annotationVisitor.visitEnum(name, enumClassInternalName, enumEntryName);
                 return null;
             }
@@ -452,8 +484,9 @@ public abstract class AnnotationCodegen {
 
             @Override
             public Void visitAnnotationValue(AnnotationValue value, Void data) {
-                String internalAnnName = typeMapper.mapType(value.getValue().getType()).getDescriptor();
-                AnnotationVisitor visitor = annotationVisitor.visitAnnotation(name, internalAnnName);
+                KotlinType classType = value.getValue().getType();
+                innerClassConsumer.addInnerClassInfoFromAnnotation(DescriptorUtils.getClassDescriptorForType(classType));
+                AnnotationVisitor visitor = annotationVisitor.visitAnnotation(name, typeMapper.mapType(classType).getDescriptor());
                 genAnnotationArguments(value.getValue(), visitor);
                 visitor.visitEnd();
                 return null;
@@ -461,7 +494,9 @@ public abstract class AnnotationCodegen {
 
             @Override
             public Void visitKClassValue(KClassValue value, Void data) {
-                annotationVisitor.visit(name, typeMapper.mapType(value.getArgumentType(module)));
+                KotlinType classType = value.getArgumentType(module);
+                innerClassConsumer.addInnerClassInfoFromAnnotation(DescriptorUtils.getClassDescriptorForType(classType));
+                annotationVisitor.visit(name, typeMapper.mapType(classType));
                 return null;
             }
 
@@ -593,7 +628,16 @@ public abstract class AnnotationCodegen {
             @NotNull InnerClassConsumer innerClassConsumer,
             @NotNull GenerationState state
     ) {
-        return new AnnotationCodegen(innerClassConsumer, state) {
+        return forMethod(mv, innerClassConsumer, state, false);
+    }
+
+    public static AnnotationCodegen forMethod(
+            @NotNull MethodVisitor mv,
+            @NotNull InnerClassConsumer innerClassConsumer,
+            @NotNull GenerationState state,
+            boolean skipNullabilityAnnotations
+    ) {
+        return new AnnotationCodegen(innerClassConsumer, state, skipNullabilityAnnotations) {
             @NotNull
             @Override
             AnnotationVisitor visitAnnotation(String descr, boolean visible) {
@@ -613,7 +657,16 @@ public abstract class AnnotationCodegen {
             @NotNull InnerClassConsumer innerClassConsumer,
             @NotNull GenerationState state
     ) {
-        return new AnnotationCodegen(innerClassConsumer, state) {
+        return forField(fv, innerClassConsumer, state, false);
+    }
+
+    public static AnnotationCodegen forField(
+            @NotNull FieldVisitor fv,
+            @NotNull InnerClassConsumer innerClassConsumer,
+            @NotNull GenerationState state,
+            boolean skipNullabilityAnnotations
+    ) {
+        return new AnnotationCodegen(innerClassConsumer, state, skipNullabilityAnnotations) {
             @NotNull
             @Override
             AnnotationVisitor visitAnnotation(String descr, boolean visible) {
@@ -632,9 +685,10 @@ public abstract class AnnotationCodegen {
             int parameter,
             @NotNull MethodVisitor mv,
             @NotNull InnerClassConsumer innerClassConsumer,
-            @NotNull GenerationState state
+            @NotNull GenerationState state,
+            boolean skipNullabilityAnnotations
     ) {
-        return new AnnotationCodegen(innerClassConsumer, state) {
+        return new AnnotationCodegen(innerClassConsumer, state, skipNullabilityAnnotations) {
             @NotNull
             @Override
             AnnotationVisitor visitAnnotation(String descr, boolean visible) {

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

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

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

@@ -22,10 +22,7 @@ import org.jetbrains.kotlin.codegen.intrinsics.HashCode;
 import org.jetbrains.kotlin.codegen.intrinsics.IntrinsicMethods;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
-import org.jetbrains.kotlin.config.ApiVersion;
-import org.jetbrains.kotlin.config.JvmTarget;
-import org.jetbrains.kotlin.config.LanguageFeature;
-import org.jetbrains.kotlin.config.LanguageVersionSettings;
+import org.jetbrains.kotlin.config.*;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
 import org.jetbrains.kotlin.lexer.KtTokens;
@@ -42,10 +39,10 @@ import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.InlineClassDescriptorResolver;
 import org.jetbrains.kotlin.resolve.InlineClassesUtilsKt;
-import org.jetbrains.kotlin.resolve.checkers.ExpectedActualDeclarationChecker;
 import org.jetbrains.kotlin.resolve.deprecation.DeprecationResolver;
 import org.jetbrains.kotlin.resolve.inline.InlineUtil;
 import org.jetbrains.kotlin.resolve.jvm.*;
+import org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin;
 import org.jetbrains.kotlin.serialization.DescriptorSerializer;
 import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor;
@@ -69,7 +66,6 @@ import static org.jetbrains.kotlin.resolve.DescriptorUtils.*;
 import static org.jetbrains.kotlin.resolve.inline.InlineOnlyKt.isInlineOnlyPrivateInBytecode;
 import static org.jetbrains.kotlin.resolve.inline.InlineOnlyKt.isInlineWithReified;
 import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.*;
-import static org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt.hasJvmDefaultAnnotation;
 import static org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt.hasJvmSyntheticAnnotation;
 import static org.jetbrains.kotlin.types.TypeUtils.isNullableType;
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
@@ -309,9 +305,10 @@ public class AsmUtil {
         return new Method(name, Type.getMethodDescriptor(returnType, parameterTypes));
     }
 
-    public static boolean isAbstractMethod(FunctionDescriptor functionDescriptor, OwnerKind kind) {
+    public static boolean isAbstractMethod(FunctionDescriptor functionDescriptor, OwnerKind kind, JvmDefaultMode jvmDefaultMode) {
         return (functionDescriptor.getModality() == Modality.ABSTRACT ||
-                (isJvmInterface(functionDescriptor.getContainingDeclaration()) && !hasJvmDefaultAnnotation(functionDescriptor)))
+                (isJvmInterface(functionDescriptor.getContainingDeclaration()) && !JvmAnnotationUtilKt
+                        .isCompiledToJvmDefault(functionDescriptor, jvmDefaultMode)))
                && !isStaticMethod(kind, functionDescriptor);
     }
 
@@ -326,10 +323,15 @@ public class AsmUtil {
     }
 
     public static int getMethodAsmFlags(FunctionDescriptor functionDescriptor, OwnerKind kind, GenerationState state) {
-        return getMethodAsmFlags(functionDescriptor, kind, state.getDeprecationProvider());
+        return getMethodAsmFlags(functionDescriptor, kind, state.getDeprecationProvider(), state.getJvmDefaultMode());
     }
 
-    public static int getMethodAsmFlags(FunctionDescriptor functionDescriptor, OwnerKind kind, DeprecationResolver deprecationResolver) {
+    public static int getMethodAsmFlags(
+            FunctionDescriptor functionDescriptor,
+            OwnerKind kind,
+            DeprecationResolver deprecationResolver,
+            JvmDefaultMode jvmDefaultMode
+    ) {
         int flags = getCommonCallableFlags(functionDescriptor, kind, deprecationResolver);
 
         for (AnnotationCodegen.JvmFlagAnnotation flagAnnotation : AnnotationCodegen.METHOD_FLAGS) {
@@ -357,7 +359,7 @@ public class AsmUtil {
             flags |= ACC_STATIC;
         }
 
-        if (isAbstractMethod(functionDescriptor, kind)) {
+        if (isAbstractMethod(functionDescriptor, kind, jvmDefaultMode)) {
             flags |= ACC_ABSTRACT;
         }
 
@@ -430,9 +432,6 @@ public class AsmUtil {
         if (descriptor instanceof SyntheticClassDescriptorForLambda) {
             return getVisibilityAccessFlagForAnonymous(descriptor);
         }
-        if (ExpectedActualDeclarationChecker.isOptionalAnnotationClass(descriptor)) {
-            return NO_FLAG_PACKAGE_PRIVATE;
-        }
         if (descriptor.getKind() == ClassKind.ENUM_ENTRY) {
             return NO_FLAG_PACKAGE_PRIVATE;
         }
@@ -1023,9 +1022,7 @@ public class AsmUtil {
             }
             value.put(asmType, v);
             v.visitLdcInsn(name);
-            String methodName = state.getLanguageVersionSettings().getApiVersion().compareTo(ApiVersion.KOTLIN_1_4) >= 0
-                                ? "checkNotNullParameter"
-                                : "checkParameterIsNotNull";
+            String methodName = state.getUnifiedNullChecks() ? "checkNotNullParameter" : "checkParameterIsNotNull";
             v.invokestatic(IntrinsicMethods.INTRINSICS_CLASS_NAME, methodName, "(Ljava/lang/Object;Ljava/lang/String;)V", false);
         }
     }
@@ -1048,9 +1045,7 @@ public class AsmUtil {
                 if (innerType.getSort() == Type.OBJECT || innerType.getSort() == Type.ARRAY) {
                     v.dup();
                     v.visitLdcInsn(runtimeAssertionInfo.getMessage());
-                    String methodName = state.getLanguageVersionSettings().getApiVersion().compareTo(ApiVersion.KOTLIN_1_4) >= 0
-                                        ? "checkNotNullExpressionValue"
-                                        : "checkExpressionValueIsNotNull";
+                    String methodName = state.getUnifiedNullChecks() ? "checkNotNullExpressionValue" : "checkExpressionValueIsNotNull";
                     v.invokestatic(IntrinsicMethods.INTRINSICS_CLASS_NAME, methodName, "(Ljava/lang/Object;Ljava/lang/String;)V", false);
                 }
                 StackValue.coerce(innerType, innerKotlinType, type, kotlinType, v);
@@ -1081,27 +1076,23 @@ public class AsmUtil {
     }
 
     public static void pushDefaultValueOnStack(@NotNull Type type, @NotNull InstructionAdapter v) {
-        if (type.getSort() == Type.OBJECT || type.getSort() == Type.ARRAY) {
-            v.aconst(null);
-        }
-        else {
-            pushDefaultPrimitiveValueOnStack(type, v);
-        }
+        v.visitInsn(defaultValueOpcode(type));
     }
 
-    public static void pushDefaultPrimitiveValueOnStack(@NotNull Type type, @NotNull InstructionAdapter v) {
+    public static int defaultValueOpcode(@NotNull Type type) {
+        if (type.getSort() == Type.OBJECT || type.getSort() == Type.ARRAY) {
+            return ACONST_NULL;
+        }
         if (type.getSort() == Type.FLOAT) {
-            v.fconst(0);
+            return FCONST_0;
         }
-        else if (type.getSort() == Type.DOUBLE) {
-            v.dconst(0);
+        if (type.getSort() == Type.DOUBLE) {
+            return DCONST_0;
         }
-        else if (type.getSort() == Type.LONG) {
-            v.lconst(0);
-        }
-        else {
-            v.iconst(0);
+        if (type.getSort() == Type.LONG) {
+            return LCONST_0;
         }
+        return ICONST_0;
     }
 
     public static boolean isInstancePropertyWithStaticBackingField(@NotNull PropertyDescriptor propertyDescriptor) {

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

@@ -6,6 +6,8 @@
 package org.jetbrains.kotlin.codegen
 
 import org.jetbrains.kotlin.codegen.coroutines.createCustomCopy
+import org.jetbrains.kotlin.codegen.optimization.common.InsnSequence
+import org.jetbrains.kotlin.codegen.optimization.common.findPreviousOrNull
 import org.jetbrains.kotlin.config.JVMAssertionsMode
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.isTopLevelInPackage
@@ -19,12 +21,15 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
 import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategy
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
+import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 import org.jetbrains.org.objectweb.asm.Label
 import org.jetbrains.org.objectweb.asm.MethodVisitor
 import org.jetbrains.org.objectweb.asm.Opcodes
 import org.jetbrains.org.objectweb.asm.Type
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
 import org.jetbrains.org.objectweb.asm.tree.FieldInsnNode
+import org.jetbrains.org.objectweb.asm.tree.LdcInsnNode
+import org.jetbrains.org.objectweb.asm.tree.MethodInsnNode
 import org.jetbrains.org.objectweb.asm.tree.MethodNode
 
 const val ASSERTIONS_DISABLED_FIELD_NAME = "\$assertionsDisabled"
@@ -130,7 +135,7 @@ private fun inlineAlwaysInlineAssert(resolvedCall: ResolvedCall<*>, codegen: Exp
     )
 }
 
-fun generateAssertionsDisabledFieldInitialization(classBuilder: ClassBuilder, clInitBuilder: MethodVisitor) {
+fun generateAssertionsDisabledFieldInitialization(classBuilder: ClassBuilder, clInitBuilder: MethodVisitor, className: String) {
     classBuilder.newField(
         JvmDeclarationOrigin.NO_ORIGIN, Opcodes.ACC_STATIC or Opcodes.ACC_FINAL or Opcodes.ACC_SYNTHETIC, ASSERTIONS_DISABLED_FIELD_NAME,
         "Z", null, null
@@ -139,7 +144,7 @@ fun generateAssertionsDisabledFieldInitialization(classBuilder: ClassBuilder, cl
     val elseLabel = Label()
     with(InstructionAdapter(clInitBuilder)) {
         mark(Label())
-        aconst(Type.getObjectType(classBuilder.thisName))
+        aconst(Type.getObjectType(className))
         invokevirtual("java/lang/Class", "desiredAssertionStatus", "()Z", false)
         ifne(thenLabel)
         iconst(1)
@@ -153,6 +158,16 @@ fun generateAssertionsDisabledFieldInitialization(classBuilder: ClassBuilder, cl
     }
 }
 
+fun rewriteAssertionsDisabledFieldInitialization(methodNode: MethodNode, className: String) {
+    InsnSequence(methodNode.instructions).firstOrNull {
+        it is FieldInsnNode && it.opcode == Opcodes.PUTSTATIC && it.name == ASSERTIONS_DISABLED_FIELD_NAME
+    }?.findPreviousOrNull {
+        it is MethodInsnNode && it.opcode == Opcodes.INVOKEVIRTUAL
+                && it.owner == "java/lang/Class" && it.name == "desiredAssertionStatus" && it.desc == "()Z"
+    }?.previous?.safeAs<LdcInsnNode>()?.cst =
+        Type.getObjectType(className)
+}
+
 private fun <D : FunctionDescriptor> ResolvedCall<D>.replaceAssertWithAssertInner(): ResolvedCall<D> {
     val newCandidateDescriptor = resultingDescriptor.createCustomCopy {
         setName(Name.identifier(ALWAYS_ENABLED_ASSERT_FUNCTION_NAME))

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

@@ -47,7 +47,7 @@ interface BaseExpressionCodegen {
         functionReferenceReceiver: StackValue?
     )
 
-    fun markLineNumberAfterInlineIfNeeded()
+    fun markLineNumberAfterInlineIfNeeded(registerLineNumberAfterwards: Boolean)
 
     fun consumeReifiedOperationMarker(typeParameter: TypeParameterMarker)
 

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

@@ -240,8 +240,9 @@ class ObjectCompare(
 
     companion object {
         fun getObjectCompareOpcode(opToken: IElementType): Int = when (opToken) {
-            KtTokens.EQEQEQ -> IF_ACMPNE
-            KtTokens.EXCLEQEQEQ -> IF_ACMPEQ
+            // "==" and "!=" are here because enum values are compared using reference equality.
+            KtTokens.EQEQEQ, KtTokens.EQEQ -> IF_ACMPNE
+            KtTokens.EXCLEQEQEQ, KtTokens.EXCLEQ -> IF_ACMPEQ
             else -> throw UnsupportedOperationException("don't know how to generate this condjump")
         }
     }

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

@@ -37,7 +37,7 @@ interface Callable {
 
     fun invokeMethodWithArguments(resolvedCall: ResolvedCall<*>, receiver: StackValue, codegen: ExpressionCodegen): StackValue {
         // it's important to use unsubstituted return type here to unbox value if it comes from type variable
-        return StackValue.functionCall(returnType, resolvedCall.resultingDescriptor.original.returnType) {
+        return StackValue.functionCall(returnType, returnKotlinType ?: resolvedCall.resultingDescriptor.original.returnType) {
             codegen.invokeMethodWithArguments(this, resolvedCall, receiver)
         }
     }

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

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

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

@@ -10,10 +10,10 @@ import kotlin.collections.CollectionsKt;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.backend.common.CodegenUtil;
-import org.jetbrains.kotlin.backend.common.bridges.ImplKt;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.codegen.context.ClassContext;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
+import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.psi.synthetics.SyntheticClassOrObjectDescriptor;
@@ -21,6 +21,7 @@ import org.jetbrains.kotlin.psi.synthetics.SyntheticClassOrObjectDescriptorKt;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.InlineClassesUtilsKt;
+import org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature;
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter;
@@ -36,8 +37,8 @@ import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isJvmInterface;
 import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.enumEntryNeedSubclass;
 import static org.jetbrains.kotlin.resolve.DescriptorToSourceUtils.descriptorToDeclaration;
 import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.OBJECT_TYPE;
-import static org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt.hasJvmDefaultAnnotation;
 import static org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKind.CLASS_MEMBER_DELEGATION_TO_DEFAULT_IMPL;
+import static org.jetbrains.kotlin.util.DeclarationUtilKt.findInterfaceImplementation;
 
 public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject> {
     @NotNull
@@ -124,7 +125,7 @@ public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject
         for (DeclarationDescriptor memberDescriptor : DescriptorUtils.getAllDescriptors(descriptor.getDefaultType().getMemberScope())) {
             if (memberDescriptor instanceof CallableMemberDescriptor) {
                 CallableMemberDescriptor member = (CallableMemberDescriptor) memberDescriptor;
-                if (!member.getKind().isReal() && ImplKt.findInterfaceImplementation(member) == null) {
+                if (!member.getKind().isReal() && findInterfaceImplementation(member) == null) {
                     if (member instanceof FunctionDescriptor) {
                         functionCodegen.generateBridges((FunctionDescriptor) member);
                     }
@@ -219,17 +220,29 @@ public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject
     protected void generateDelegatesToDefaultImpl() {
         if (isJvmInterface(descriptor)) return;
 
+        boolean isErasedInlineClass = InlineClassesUtilsKt.isInlineClass(descriptor) && kind == OwnerKind.ERASED_INLINE_CLASS;
+        JvmKotlinType receiverType = new JvmKotlinType(typeMapper.mapType(descriptor), descriptor.getDefaultType());
+
         for (Map.Entry<FunctionDescriptor, FunctionDescriptor> entry : CodegenUtil.getNonPrivateTraitMethods(descriptor).entrySet()) {
-            FunctionDescriptor interfaceFun = entry.getKey();
-            //skip java 8 default methods
-            if (!CodegenUtilKt.isDefinitelyNotDefaultImplsMethod(interfaceFun) && !hasJvmDefaultAnnotation(interfaceFun)) {
-                generateDelegationToDefaultImpl(interfaceFun, entry.getValue());
-            }
+            generateDelegationToDefaultImpl(entry.getKey(), entry.getValue(), receiverType, functionCodegen, state, isErasedInlineClass);
         }
     }
 
-    private void generateDelegationToDefaultImpl(@NotNull FunctionDescriptor interfaceFun, @NotNull FunctionDescriptor inheritedFun) {
+    public static void generateDelegationToDefaultImpl(
+            @NotNull FunctionDescriptor interfaceFun,
+            @NotNull FunctionDescriptor inheritedFun,
+            @NotNull JvmKotlinType receiverType,
+            @NotNull FunctionCodegen functionCodegen,
+            @NotNull GenerationState state,
+            boolean isErasedInlineClass
+    ) {
+        // Skip Java 8 default methods
+        if (CodegenUtilKt.isDefinitelyNotDefaultImplsMethod(interfaceFun) ||
+            JvmAnnotationUtilKt.checkIsImplementationCompiledToJvmDefault(interfaceFun, state.getJvmDefaultMode())) {
+            return;
+        }
 
+        KotlinTypeMapper typeMapper = state.getTypeMapper();
         functionCodegen.generateMethod(
                 new JvmDeclarationOrigin(
                         CLASS_MEMBER_DELEGATION_TO_DEFAULT_IMPL, descriptorToDeclaration(interfaceFun), interfaceFun, null
@@ -244,7 +257,7 @@ public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject
                         DeclarationDescriptor declarationInheritedFun = inheritedFun.getContainingDeclaration();
                         PsiElement classForInheritedFun = descriptorToDeclaration(declarationInheritedFun);
                         if (classForInheritedFun instanceof KtDeclaration) {
-                            codegen.markLineNumber((KtElement) classForInheritedFun, false);
+                            codegen.markLineNumber(classForInheritedFun, false);
                         }
 
                         ClassDescriptor containingTrait = (ClassDescriptor) containingDeclaration;
@@ -278,18 +291,15 @@ public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject
                         InstructionAdapter iv = codegen.v;
                         Type[] myArgTypes = signature.getAsmMethod().getArgumentTypes();
                         Type[] toArgTypes = defaultImplsMethod.getArgumentTypes();
-                        boolean isErasedInlineClass =
-                                InlineClassesUtilsKt.isInlineClass(descriptor) && kind == OwnerKind.ERASED_INLINE_CLASS;
 
                         int myArgI = 0;
                         int argVar = 0;
 
-                        Type receiverType = typeMapper.mapType(descriptor);
                         KotlinType interfaceKotlinType = ((ClassDescriptor) inheritedFun.getContainingDeclaration()).getDefaultType();
-                        StackValue.local(argVar, receiverType, descriptor.getDefaultType())
+                        StackValue.local(argVar, receiverType.getType(), receiverType.getKotlinType())
                                 .put(OBJECT_TYPE, interfaceKotlinType, iv);
                         if (isErasedInlineClass) myArgI++;
-                        argVar += receiverType.getSize();
+                        argVar += receiverType.getType().getSize();
 
                         int toArgI = 1;