JavaClassifierTypeImpl.resolutionResult dropped

.bunch

@@ -1,7 +1,7 @@
-201
-202
-203_202
 193
-as40_193
-as41
-as42_202
+201
+202_201
+192
+as36_192
+as40
+as41_201

.gitattributes

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

.gitignore

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

.idea/codeStyles/Project.xml

@@ -13,6 +13,21 @@
       </option>
     </JavaCodeStyleSettings>
     <JetCodeStyleSettings>
+      <option name="PACKAGES_TO_USE_STAR_IMPORTS">
+        <value>
+          <package name="java.util" alias="false" withSubpackages="false" />
+          <package name="kotlinx.android.synthetic" alias="false" withSubpackages="true" />
+        </value>
+      </option>
+      <option name="PACKAGES_IMPORT_LAYOUT">
+        <value>
+          <package name="" alias="false" withSubpackages="true" />
+          <package name="java" alias="false" withSubpackages="true" />
+          <package name="javax" alias="false" withSubpackages="true" />
+          <package name="kotlin" alias="false" withSubpackages="true" />
+          <package name="" alias="true" withSubpackages="true" />
+        </value>
+      </option>
       <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
     </JetCodeStyleSettings>
     <MarkdownNavigatorCodeStyleSettings>
@@ -101,4 +116,4 @@
       <option name="ALIGN_MULTILINE_PARAMETERS_IN_CALLS" value="true" />
     </codeStyleSettings>
   </code_scheme>
-</component>
+</component>

.idea/dictionaries/svyatoslav_kuzmich.xml

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

.idea/dictionaries/yan.xml

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

.idea/inspectionProfiles/idea_default.xml

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

.idea/runConfigurations/Test__KMM.xml

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

.idea/runConfigurations/Test__stdlib_js_public_kotlin_api_test__overwrite_results.xml

@@ -4,13 +4,12 @@
       <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="scriptParameters" value="--tests &quot;org.jetbrains.kotlin.js.test.ApiTest&quot; -Poverwrite.output=true" />
       <option name="taskDescriptions">
         <list />
       </option>
       <option name="taskNames">
         <list>
-          <option value=":js:js.tests:cleanTest" />
           <option value=":js:js.tests:test" />
         </list>
       </option>

.idea/scopes/Apply_copyright.xml

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

ReadMe.md

@@ -5,10 +5,7 @@
 
 # Kotlin Programming Language
 
-Welcome to [Kotlin](https://kotlinlang.org/)!   
-It is an open-source, statically typed programming language supported and developed by [JetBrains](https://www.jetbrains.com/) and open-source contributors.
-
-Some handy links:
+Welcome to [Kotlin](https://kotlinlang.org/)! Some handy links:
 
  * [Kotlin Site](https://kotlinlang.org/)
  * [Getting Started Guide](https://kotlinlang.org/docs/tutorials/getting-started.html)
@@ -21,16 +18,6 @@ Some handy links:
  * [Public Slack channel](https://slack.kotlinlang.org/)
  * [TeamCity CI build](https://teamcity.jetbrains.com/project.html?tab=projectOverview&projectId=Kotlin)
 
-## Kotlin Multiplatform capabilities
-
-Support for multiplatform programming is one of Kotlin’s key benefits. It reduces time spent writing and maintaining the same code for [different platforms](https://kotlinlang.org/docs/reference/mpp-supported-platforms.html) while retaining the flexibility and benefits of native programming.
-
- * [Kotlin Multiplatform Mobile](https://kotlinlang.org/lp/mobile/) for sharing code between Android and iOS
- * [Getting Started with Kotlin Multiplatform Mobile Guide](https://kotlinlang.org/docs/mobile/create-first-app.html)
- * [Kotlin Multiplatform Benefits](https://kotlinlang.org/docs/reference/multiplatform.html)
- * [Share code on all platforms](https://kotlinlang.org/docs/reference/mpp-share-on-platforms.html#share-code-on-all-platforms)
- * [Share code on similar platforms](https://kotlinlang.org/docs/reference/mpp-share-on-platforms.html#share-code-on-similar-platforms)
-
 ## Editing Kotlin
 
  * [Kotlin IntelliJ IDEA Plugin](https://kotlinlang.org/docs/tutorials/getting-started.html)
@@ -54,12 +41,7 @@ For local development, if you're not working on bytecode generation or the stand
 
 You also can use [Gradle properties](https://docs.gradle.org/current/userguide/build_environment.html#sec:gradle_configuration_properties) to setup `JDK_*` variables.
 
-Note: The JDK 6 for MacOS is not available on Oracle's site. You can install it by
-
-```bash
-$ brew tap caskroom/versions
-$ brew cask install java6
-```
+> Note: The JDK 6 for MacOS is not available on Oracle's site. You can [download it here](https://support.apple.com/kb/DL1572).
 
 On Windows you might need to add long paths setting to the repo:
 
@@ -99,8 +81,6 @@ command line parameters on the first run:
 - `compilerTest` - build and run all compiler tests
 - `ideaPluginTest` - build and run all IDEA plugin tests
 
-To reproduce TeamCity build use `-Pteamcity=true` flag. Local builds don't run proguard and have jar compression disabled by default.
-
 **OPTIONAL:** Some artifacts, mainly Maven plugin ones, are built separately with Maven.
 Refer to [libraries/ReadMe.md](libraries/ReadMe.md) for details.
 

benchmarks/build.gradle.kts

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

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

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

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

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

build-common/build.gradle.kts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -3,7 +3,7 @@
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
-package org.jetbrains.kotlin.build.report
+package org.jetbrains.kotlin.incremental
 
 import org.jetbrains.kotlin.cli.common.ExitCode
 import java.io.File
@@ -17,5 +17,3 @@ interface ICReporter {
     fun reportMarkDirtyMember(affectedFiles: Iterable<File>, scope: String, name: String)
     fun reportMarkDirty(affectedFiles: Iterable<File>, reason: String)
 }
-
-

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -20,7 +20,6 @@ import org.jetbrains.kotlin.build.GeneratedFile
 import org.jetbrains.kotlin.build.GeneratedJvmClass
 import org.jetbrains.kotlin.build.JvmSourceRoot
 import org.jetbrains.kotlin.build.isModuleMappingFile
-import org.jetbrains.kotlin.build.report.ICReporter
 import org.jetbrains.kotlin.config.Services
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache
@@ -32,7 +31,6 @@ import org.jetbrains.kotlin.progress.CompilationCanceledStatus
 import org.jetbrains.kotlin.resolve.sam.SAM_LOOKUP_NAME
 import org.jetbrains.kotlin.utils.addToStdlib.flattenTo
 import java.io.File
-import java.nio.file.Files
 import java.util.*
 import kotlin.collections.HashSet
 import kotlin.collections.LinkedHashSet
@@ -68,7 +66,7 @@ fun makeModuleFile(
         friendDirs
     )
 
-    val scriptFile = Files.createTempFile("kjps", sanitizeJavaIdentifier(name) + ".script.xml").toFile()
+    val scriptFile = File.createTempFile("kjps", sanitizeJavaIdentifier(name) + ".script.xml")
     scriptFile.writeText(builder.asText().toString())
     return scriptFile
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

build.gradle.kts

@@ -7,7 +7,7 @@ import proguard.gradle.ProGuardTask
 buildscript {
     val cacheRedirectorEnabled = findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() == true
 
-    kotlinBootstrapFrom(BootstrapOption.SpaceBootstrap(kotlinBuildProperties.kotlinBootstrapVersion!!, cacheRedirectorEnabled))
+    kotlinBootstrapFrom(BootstrapOption.BintrayBootstrap(kotlinBuildProperties.kotlinBootstrapVersion!!, cacheRedirectorEnabled))
 
     repositories {
         bootstrapKotlinRepo?.let(::maven)
@@ -27,11 +27,9 @@ buildscript {
     dependencies {
         bootstrapCompilerClasspath(kotlin("compiler-embeddable", bootstrapKotlinVersion))
 
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.21")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.17")
         classpath(kotlin("gradle-plugin", bootstrapKotlinVersion))
-        classpath(kotlin("serialization", bootstrapKotlinVersion))
         classpath("org.jetbrains.dokka:dokka-gradle-plugin:0.9.17")
-        classpath("org.jfrog.buildinfo:build-info-extractor-gradle:4.17.2")
     }
 }
 
@@ -154,7 +152,6 @@ rootProject.apply {
     from(rootProject.file("gradle/jps.gradle.kts"))
     from(rootProject.file("gradle/checkArtifacts.gradle.kts"))
     from(rootProject.file("gradle/checkCacheability.gradle.kts"))
-    from(rootProject.file("gradle/retryPublishing.gradle.kts"))
 }
 
 IdeVersionConfigurator.setCurrentIde(project)
@@ -168,8 +165,9 @@ extra["versions.junit"] = "4.12"
 extra["versions.javaslang"] = "2.0.6"
 extra["versions.ant"] = "1.8.2"
 extra["versions.android"] = "2.3.1"
-extra["versions.kotlinx-coroutines-core"] = "1.3.8"
-extra["versions.kotlinx-coroutines-jdk8"] = "1.3.8"
+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"
@@ -178,8 +176,8 @@ extra["versions.org.springframework"] = "4.2.0.RELEASE"
 extra["versions.jflex"] = "1.7.0"
 extra["versions.markdown"] = "0.1.25"
 extra["versions.trove4j"] = "1.0.20181211"
-extra["versions.completion-ranking-kotlin"] = "0.1.3"
-extra["versions.r8"] = "2.0.88"
+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
@@ -188,13 +186,12 @@ extra["versions.kotlinx-collections-immutable-jvm"] = immutablesVersion
 extra["versions.ktor-network"] = "1.0.1"
 
 if (!project.hasProperty("versions.kotlin-native")) {
-    extra["versions.kotlin-native"] = "1.4.30-dev-17200"
+    extra["versions.kotlin-native"] = "1.4-M3-dev-15627"
 }
 
 val intellijUltimateEnabled by extra(project.kotlinBuildProperties.intellijUltimateEnabled)
 val effectSystemEnabled by extra(project.getBooleanProperty("kotlin.compiler.effectSystemEnabled") ?: false)
 val newInferenceEnabled by extra(project.getBooleanProperty("kotlin.compiler.newInferenceEnabled") ?: false)
-val useJvmIrBackend by extra(project.kotlinBuildProperties.useIR)
 
 val intellijSeparateSdks = project.getBooleanProperty("intellijSeparateSdks") ?: false
 
@@ -222,8 +219,6 @@ extra["compilerModules"] = arrayOf(
     ":compiler:config",
     ":compiler:config.jvm",
     ":compiler:container",
-    ":compiler:resolution.common",
-    ":compiler:resolution.common.jvm",
     ":compiler:resolution",
     ":compiler:serialization",
     ":compiler:psi",
@@ -232,8 +227,6 @@ extra["compilerModules"] = arrayOf(
     ":compiler:frontend.java",
     ":compiler:cli-common",
     ":compiler:ir.tree",
-    ":compiler:ir.tree.impl",
-    ":compiler:ir.tree.persistent",
     ":compiler:ir.psi2ir",
     ":compiler:ir.backend.common",
     ":compiler:backend.jvm",
@@ -242,7 +235,6 @@ extra["compilerModules"] = arrayOf(
     ":compiler:ir.serialization.common",
     ":compiler:ir.serialization.js",
     ":compiler:ir.serialization.jvm",
-    ":compiler:ir.interpreter",
     ":kotlin-util-io",
     ":kotlin-util-klib",
     ":kotlin-util-klib-metadata",
@@ -268,22 +260,17 @@ extra["compilerModules"] = arrayOf(
     ":kotlin-build-common",
     ":core:metadata",
     ":core:metadata.jvm",
-    ":core:deserialization.common",
-    ":core:deserialization.common.jvm",
-    ":core:compiler.common",
-    ":core:compiler.common.jvm",
-    ":compiler:backend.common.jvm",
     ":core:descriptors",
     ":core:descriptors.jvm",
     ":core:descriptors.runtime",
     ":core:deserialization",
     ":core:util.runtime",
+    ":core:type-system",
     ":compiler:fir:cones",
     ":compiler:fir:resolve",
     ":compiler:fir:fir-serialization",
-    ":compiler:fir:fir-deserialization",
     ":compiler:fir:tree",
-    ":compiler:fir:raw-fir:raw-fir.common",
+    ":compiler:fir:raw-fir:fir-common",
     ":compiler:fir:raw-fir:psi2fir",
     ":compiler:fir:raw-fir:light-tree2fir",
     ":compiler:fir:fir2ir",
@@ -291,12 +278,11 @@ extra["compilerModules"] = arrayOf(
     ":compiler:fir:java",
     ":compiler:fir:jvm",
     ":compiler:fir:checkers",
-    ":compiler:fir:entrypoint",
-    ":compiler:fir:analysis-tests",
-    ":wasm:wasm.ir"
+    ":compiler:fir:analysis-tests"
 )
 
 extra["compilerModulesForJps"] = listOf(
+    ":core:type-system",
     ":kotlin-build-common",
     ":kotlin-util-io",
     ":kotlin-util-klib",
@@ -305,8 +291,6 @@ extra["compilerModulesForJps"] = listOf(
     ":kotlin-compiler-runner",
     ":daemon-common",
     ":daemon-common-new",
-    ":core:compiler.common",
-    ":core:compiler.common.jvm",
     ":core:descriptors",
     ":core:descriptors.jvm",
     ":idea:idea-jps-common",
@@ -323,6 +307,7 @@ val coreLibProjects = listOfNotNull(
     ":kotlin-stdlib",
     ":kotlin-stdlib-common",
     ":kotlin-stdlib-js",
+    ":kotlin-stdlib-js-ir",
     ":kotlin-stdlib-jdk7",
     ":kotlin-stdlib-jdk8",
     ":kotlin-test:kotlin-test-annotations-common",
@@ -332,6 +317,7 @@ val coreLibProjects = listOfNotNull(
     ":kotlin-test:kotlin-test-junit5",
     ":kotlin-test:kotlin-test-testng",
     ":kotlin-test:kotlin-test-js".takeIf { !kotlinBuildProperties.isInJpsBuildIdeaSync },
+    ":kotlin-test:kotlin-test-js-ir".takeIf { !kotlinBuildProperties.isInJpsBuildIdeaSync },
     ":kotlin-reflect",
     ":kotlin-coroutines-experimental-compat"
 )
@@ -342,8 +328,7 @@ val gradlePluginProjects = listOf(
     ":kotlin-allopen",
     ":kotlin-annotation-processing-gradle",
     ":kotlin-noarg",
-    ":kotlin-sam-with-receiver",
-    ":kotlin-parcelize-compiler"
+    ":kotlin-sam-with-receiver"
 )
 
 apply {
@@ -367,7 +352,7 @@ fun Task.listConfigurationContents(configName: String) {
 }
 
 val defaultJvmTarget = "1.8"
-val defaultJavaHome = jdkPath(if (Platform[203].orHigher()) "11" else defaultJvmTarget)
+val defaultJavaHome = jdkPath(defaultJvmTarget)
 val ignoreTestFailures by extra(project.kotlinBuildProperties.ignoreTestFailures)
 
 allprojects {
@@ -381,15 +366,6 @@ allprojects {
         }
     }
 
-    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
 
@@ -420,6 +396,9 @@ allprojects {
     val commonCompilerArgs = listOfNotNull(
         "-Xopt-in=kotlin.RequiresOptIn",
         "-Xread-deserialized-contracts",
+        "-Xjvm-default=compatibility",
+        "-Xno-optimized-callable-references",
+        "-Xno-kotlin-nothing-value-exception",
         "-progressive".takeIf { hasProperty("test.progressive.mode") }
     )
 
@@ -431,21 +410,9 @@ allprojects {
         }
     }
 
-    val jvmCompilerArgs = listOf(
-        "-Xjvm-default=compatibility",
-        "-Xno-optimized-callable-references",
-        "-Xno-kotlin-nothing-value-exception",
-        "-Xnormalize-constructor-calls=enable"
-    )
-
     tasks.withType<org.jetbrains.kotlin.gradle.dsl.KotlinJvmCompile> {
         kotlinOptions {
-            freeCompilerArgs = commonCompilerArgs + jvmCompilerArgs
-
-            if (useJvmIrBackend) {
-                useIR = true
-                freeCompilerArgs += "-Xir-binary-with-stable-abi"
-            }
+            freeCompilerArgs = commonCompilerArgs + listOf("-Xnormalize-constructor-calls=enable")
         }
     }
 
@@ -475,7 +442,6 @@ allprojects {
             ignore("META-INF/MANIFEST.MF")
             ignore("META-INF/compiler.version")
             ignore("META-INF/plugin.xml")
-            ignore("kotlin/KotlinVersionCurrentValue.class")
         }
     }
 
@@ -525,23 +491,6 @@ allprojects {
         }
 
         apply(from = "$rootDir/gradle/cacheRedirector.gradle.kts")
-        apply(from = "$rootDir/gradle/testRetry.gradle.kts")
-    }
-}
-
-gradle.buildFinished {
-    val taskGraph = gradle?.taskGraph
-    if (taskGraph != null) {
-        taskGraph.allTasks
-                .filterIsInstance<SourceTask>()
-                .filter { it.didWork }
-                .forEach {
-                    it.source.visit {
-                        if (file.isDirectory && file.listFiles()?.isEmpty() == true) {
-                            logger.warn("Empty source directories may cause build cache misses: " + file.absolutePath)
-                        }
-                    }
-                }
     }
 }
 
@@ -549,12 +498,9 @@ gradle.taskGraph.whenReady {
     fun Boolean.toOnOff(): String = if (this) "on" else "off"
     val profile = if (isTeamcityBuild) "CI" else "Local"
 
-    val proguardMessage = "proguard is ${kotlinBuildProperties.proguard.toOnOff()}"
-    val jarCompressionMessage = "jar compression is ${kotlinBuildProperties.jarCompression.toOnOff()}"
-                val profileMessage = "$profile build profile is active ($proguardMessage, $jarCompressionMessage). " +
-            "Use -Pteamcity=<true|false> to reproduce CI/local build"
-
-    logger.warn("\n\n$profileMessage")
+    logger.warn("$profile build profile is active (proguard is ${kotlinBuildProperties.proguard.toOnOff()}" +
+                            ", jar compression is ${kotlinBuildProperties.jarCompression.toOnOff()})." +
+                            " Use -Pteamcity=<true|false> to reproduce CI/local build")
 
     allTasks.filterIsInstance<org.gradle.jvm.tasks.Jar>().forEach { task ->
         task.entryCompression = if (kotlinBuildProperties.jarCompression)
@@ -568,10 +514,6 @@ val dist = tasks.register("dist") {
     dependsOn(":kotlin-compiler:dist")
 }
 
-val syncMutedTests = tasks.register("syncMutedTests") {
-    dependsOn(":compiler:tests-mutes:run")
-}
-
 val copyCompilerToIdeaPlugin by task<Copy> {
     dependsOn(dist)
     into(ideaPluginDir)
@@ -597,7 +539,7 @@ tasks {
         }
     }
 
-    listOf("clean", "assemble", "install").forEach { taskName ->
+    listOf("clean", "assemble", "install", "dist").forEach { taskName ->
         register("coreLibs${taskName.capitalize()}") {
             coreLibProjects.forEach { projectName -> dependsOn("$projectName:$taskName") }
         }
@@ -606,8 +548,6 @@ tasks {
     register("coreLibsTest") {
         (coreLibProjects + listOf(
             ":kotlin-stdlib:samples",
-            ":kotlin-stdlib-js-ir",
-            ":kotlin-test:kotlin-test-js-ir".takeIf { !kotlinBuildProperties.isInJpsBuildIdeaSync },
             ":kotlin-test:kotlin-test-js:kotlin-test-js-it".takeIf { !kotlinBuildProperties.isInJpsBuildIdeaSync },
             ":kotlinx-metadata-jvm",
             ":tools:binary-compatibility-validator"
@@ -651,11 +591,8 @@ tasks {
     }
 
     register("wasmCompilerTest") {
-        dependsOn(":js:js.tests:wasmTest")
-        // Windows WABT release requires Visual C++ Redistributable
-        if (!kotlinBuildProperties.isTeamcityBuild || !org.gradle.internal.os.OperatingSystem.current().isWindows) {
-            dependsOn(":wasm:wasm.ir:test")
-        }
+//  TODO: fix once
+//        dependsOn(":js:js.tests:wasmTest")
     }
 
     register("nativeCompilerTest") {
@@ -699,7 +636,6 @@ tasks {
         dependsOn(":kotlin-scripting-jsr223-test:embeddableTest")
         dependsOn(":kotlin-main-kts-test:test")
         dependsOn(":kotlin-scripting-ide-services-test:test")
-        dependsOn(":kotlin-scripting-ide-services-test:embeddableTest")
         dependsOn(":kotlin-scripting-js-test:test")
     }
 
@@ -718,12 +654,9 @@ tasks {
         dependsOn("scriptingTest")
         dependsOn(":kotlin-build-common:test")
         dependsOn(":compiler:incremental-compilation-impl:test")
-        dependsOn(":compiler:incremental-compilation-impl:testJvmICWithJdk11")
         dependsOn(":core:descriptors.runtime:test")
 
         dependsOn("jvmCompilerIntegrationTest")
-
-        dependsOn(":plugins:parcelize:parcelize-compiler:test")
     }
 
     register("toolsTest") {
@@ -759,9 +692,16 @@ tasks {
         dependsOn(":jps-plugin:test")
     }
 
+    register("idea-plugin-main-tests") {
+        dependsOn("dist")
+        dependsOn(":idea:test")
+    }
+
     register("idea-plugin-additional-tests") {
         dependsOn("dist")
         dependsOn(
+            ":idea:idea-gradle:test",
+            ":idea:idea-gradle-native:test",
             ":idea:idea-maven:test",
             ":j2k:test",
             ":nj2k:test",
@@ -784,57 +724,37 @@ tasks {
         }
     }
 
+    register("idea-plugin-tests") {
+        dependsOn("dist")
+        dependsOn(
+            "idea-plugin-main-tests",
+            "idea-plugin-additional-tests"
+        )
+        if (Ide.IJ()) {
+            dependsOn("idea-new-project-wizard-tests")
+        }
+    }
+
     register("idea-plugin-performance-tests") {
-        dependsOn(
-            "dist",
-            ":idea:performanceTests:performanceTest",
-            ":idea:performanceTests:aggregateResults"
-        )
-    }
-
-    register("idea-fir-plugin-performance-tests") {
         dependsOn("dist")
         dependsOn(
-            ":idea:idea-fir-performance-tests:ideaFirPerformanceTest"
+            ":idea:performanceTests:performanceTest"
         )
     }
 
-    register("idea-fir-plugin-tests") {
-        dependsOn("dist")
-        dependsOn(
-            ":idea:idea-fir:test",
-            ":idea:idea-frontend-api:test",
-            ":idea:idea-frontend-fir:test",
-            ":idea:idea-frontend-fir:idea-fir-low-level-api:test"
-        )
-    }
-
-
     register("android-ide-tests") {
         dependsOn("dist")
         dependsOn(
             ":plugins:android-extensions-ide:test",
             ":idea:idea-android:test",
+            ":kotlin-annotation-processing:test"
+        )
+    }
+
+    register("plugins-tests") {
+        dependsOn("dist")
+        dependsOn(
             ":kotlin-annotation-processing:test",
-            ":plugins:parcelize:parcelize-ide:test"
-        )
-    }
-
-    register("ideaPluginTest") {
-        dependsOn(
-            "mainIdeTests",
-            "gradleIdeTest",
-            "kaptIdeTest",
-            "miscIdeTests"
-        )
-    }
-
-    register("mainIdeTests") {
-        dependsOn(":idea:test")
-    }
-
-    register("miscIdeTests") {
-        dependsOn(
             ":kotlin-allopen-compiler-plugin:test",
             ":kotlin-noarg-compiler-plugin:test",
             ":kotlin-sam-with-receiver-compiler-plugin:test",
@@ -842,42 +762,53 @@ tasks {
             ":kotlin-annotation-processing-gradle:test",
             ":kotlinx-serialization-compiler-plugin:test",
             ":kotlinx-serialization-ide-plugin:test",
-            ":idea:jvm-debugger:jvm-debugger-test:test",
-            "idea-plugin-additional-tests",
+            ":idea:jvm-debugger:jvm-debugger-test:test"
+        )
+    }
+
+
+    register("ideaPluginTest") {
+        dependsOn(
+            "idea-plugin-tests",
             "jps-tests",
+            "plugins-tests",
+            "android-ide-tests",
             ":generators:test"
         )
-        if (Ide.IJ()) {
-            dependsOn("idea-new-project-wizard-tests")
+    }
+
+    register("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"
+            )
         }
     }
 
-    register("kaptIdeTest") {
-        dependsOn(":kotlin-annotation-processing:test")
-    }
-
-    register("gradleIdeTest") {
-        dependsOn(
-            ":idea:idea-gradle:test",
-            ":idea:idea-gradle-native:test"
-        )
-    }
-
-    register("kmmTest", AggregateTest::class) {
-        dependsOn(
-            ":idea:idea-gradle:test",
-            ":idea:test",
-            ":compiler:test",
-            ":js:js.tests:test"
-        )
-
-        dependsOn(":kotlin-gradle-plugin-integration-tests:test")
-        if (Ide.AS40.orHigher())
-            dependsOn(":kotlin-ultimate:ide:android-studio-native:test")
-
-        testPatternFile = file("tests/mpp/kmm-patterns.csv")
-    }
-
     register("test") {
         doLast {
             throw GradleException("Don't use directly, use aggregate tasks *-check instead")
@@ -895,41 +826,6 @@ tasks {
             }
         }
     }
-
-    register("publishIdeArtifacts") {
-        idePluginDependency {
-            dependsOn(
-                ":prepare:ide-plugin-dependencies:android-extensions-compiler-plugin-for-ide:publish",
-                ":prepare:ide-plugin-dependencies:allopen-compiler-plugin-for-ide:publish",
-                ":prepare:ide-plugin-dependencies:allopen-compiler-plugin-tests-for-ide:publish",
-                ":prepare:ide-plugin-dependencies:incremental-compilation-impl-tests-for-ide:publish",
-                ":prepare:ide-plugin-dependencies:kotlin-build-common-tests-for-ide:publish",
-                ":prepare:ide-plugin-dependencies:kotlin-compiler-for-ide:publish",
-                ":prepare:ide-plugin-dependencies:kotlin-gradle-statistics-for-ide:publish",
-                ":prepare:ide-plugin-dependencies:kotlinx-serialization-compiler-plugin-for-ide:publish",
-                ":prepare:ide-plugin-dependencies:noarg-compiler-plugin-for-ide:publish",
-                ":prepare:ide-plugin-dependencies:sam-with-receiver-compiler-plugin-for-ide:publish",
-                ":prepare:ide-plugin-dependencies:compiler-components-for-jps:publish",
-                ":prepare:ide-plugin-dependencies:parcelize-compiler-plugin-for-ide:publish",
-                ":kotlin-script-runtime:publish",
-                ":kotlin-script-util:publish",
-                ":kotlin-scripting-common:publish",
-                ":kotlin-scripting-jvm:publish",
-                ":kotlin-scripting-compiler:publish",
-                ":kotlin-scripting-compiler-impl:publish",
-                ":kotlin-android-extensions-runtime:publish",
-                ":kotlin-stdlib-common:publish",
-                ":kotlin-stdlib:publish",
-                ":kotlin-stdlib-jdk7:publish",
-                ":kotlin-stdlib-jdk8:publish",
-                ":kotlin-reflect:publish",
-                ":kotlin-main-kts:publish",
-                ":kotlin-stdlib-js:publish",
-                ":kotlin-test:kotlin-test-js:publish",
-                ":kotlin-coroutines-experimental-compat:publish"
-            )
-        }
-    }
 }
 
 fun CopySpec.setExecutablePermissions() {
@@ -993,7 +889,7 @@ val zipPlugin by task<Zip> {
     setExecutablePermissions()
 
     doLast {
-        logger.lifecycle("Plugin artifacts packed to ${archiveFile.get()}")
+        logger.lifecycle("Plugin artifacts packed to $archiveFile")
     }
 }
 
@@ -1162,4 +1058,4 @@ if (disableVerificationTasks) {
             }
         }
     }
-}
+}

buildSrc/build.gradle.kts

@@ -1,5 +1,3 @@
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-
 extra["versions.native-platform"] = "0.14"
 
 buildscript {
@@ -7,7 +5,7 @@ buildscript {
     val cacheRedirectorEnabled = findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() == true
 
     extra["defaultSnapshotVersion"] = kotlinBuildProperties.defaultSnapshotVersion
-    kotlinBootstrapFrom(BootstrapOption.SpaceBootstrap(kotlinBuildProperties.kotlinBootstrapVersion!!, cacheRedirectorEnabled))
+    kotlinBootstrapFrom(BootstrapOption.BintrayBootstrap(kotlinBuildProperties.kotlinBootstrapVersion!!, cacheRedirectorEnabled))
 
     repositories {
         if (cacheRedirectorEnabled) {
@@ -24,7 +22,7 @@ buildscript {
     }
 
     dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.21")
+        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}")
     }
@@ -98,9 +96,8 @@ repositories {
 
 dependencies {
     implementation(kotlin("stdlib", embeddedKotlinVersion))
-    implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:${project.bootstrapKotlinVersion}")
-    implementation("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.21")
-    implementation("com.gradle.publish:plugin-publish-plugin:0.12.0")
+    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")}")
@@ -112,8 +109,6 @@ dependencies {
     implementation("org.jetbrains.intellij.deps:asm-all:8.0.1")
 
     implementation("gradle.plugin.org.jetbrains.gradle.plugin.idea-ext:gradle-idea-ext:0.5")
-
-    implementation("org.gradle:test-retry-gradle-plugin:1.1.9")
 }
 
 samWithReceiver {
@@ -128,11 +123,6 @@ java {
     targetCompatibility = JavaVersion.VERSION_1_8
 }
 
-tasks.withType<KotlinCompile>().configureEach {
-    kotlinOptions.freeCompilerArgs +=
-        listOf("-Xopt-in=kotlin.RequiresOptIn", "-Xskip-runtime-version-check")
-}
-
 tasks["build"].dependsOn(":prepare-deps:build")
 
 allprojects {

buildSrc/prepare-deps/build.gradle.kts

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

buildSrc/settings.gradle

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

buildSrc/src/main/kotlin/AggregateTest.kt

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

buildSrc/src/main/kotlin/CommonUtil.kt

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

buildSrc/src/main/kotlin/IdeCompatibilityDsl.kt

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

buildSrc/src/main/kotlin/SmartJavaExec.kt

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

buildSrc/src/main/kotlin/artifacts.kt

@@ -27,7 +27,6 @@ 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
 
 
@@ -71,6 +70,18 @@ fun Project.noDefaultJar() {
     }
 }
 
+fun <T : Task> Project.runtimeJarArtifactBy(
+    task: TaskProvider<T>,
+    artifactRef: Any,
+    body: ConfigurablePublishArtifact.() -> Unit = {}
+) {
+    addArtifact("archives", task, artifactRef, body)
+    addArtifact("runtimeJar", task, artifactRef, body)
+    configurations.findByName("runtime")?.let {
+        addArtifact(it.name, task, artifactRef, body)
+    }
+}
+
 fun Project.runtimeJar(body: Jar.() -> Unit = {}): TaskProvider<Jar> = runtimeJar(getOrCreateTask("jar", body)) { }
 
 fun <T : Jar> Project.runtimeJar(task: TaskProvider<T>, body: T.() -> Unit = {}): TaskProvider<T> {
@@ -91,11 +102,7 @@ fun <T : Jar> Project.runtimeJar(task: TaskProvider<T>, body: T.() -> Unit = {})
         body()
     }
 
-    project.addArtifact("archives", task, task)
-    project.addArtifact("runtimeJar", task, task)
-    project.configurations.findByName("runtime")?.let {
-        project.addArtifact(it.name, task, task)
-    }
+    project.runtimeJarArtifactBy(task, task)
 
     val runtimeJar = configurations.maybeCreate("runtimeJar").apply {
         isCanBeConsumed = true
@@ -122,16 +129,10 @@ fun Project.sourcesJar(body: Jar.() -> Unit = {}): TaskProvider<Jar> {
     }
 
     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.sources())
+        from(project.mainSourceSet.allSource)
 
         project.configurations.findByName("embedded")?.let { embedded ->
             from(provider {
@@ -140,7 +141,10 @@ fun Project.sourcesJar(body: Jar.() -> Unit = {}): TaskProvider<Jar> {
                     .map { it.id.componentIdentifier }
                     .filterIsInstance<ProjectComponentIdentifier>()
                     .mapNotNull {
-                        project(it.projectPath).sources()
+                        project(it.projectPath)
+                            .findJavaPluginConvention()
+                            ?.mainSourceSet
+                            ?.allSource
                     }
             })
         }

buildSrc/src/main/kotlin/dependencies.kt

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

buildSrc/src/main/kotlin/embeddable.kt

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

buildSrc/src/main/kotlin/localDependencies.kt

@@ -80,8 +80,6 @@ fun Project.androidDxJar() = "org.jetbrains.kotlin:android-dx:${rootProject.extr
 
 fun Project.jpsBuildTest() = "com.jetbrains.intellij.idea:jps-build-test:${rootProject.extra["versions.intellijSdk"]}"
 
-fun Project.kotlinxCollectionsImmutable() = "org.jetbrains.kotlinx:kotlinx-collections-immutable-jvm:${rootProject.extra["versions.kotlinx-collections-immutable"]}"
-
 /**
  * Runtime version of annotations that are already in Kotlin stdlib (historically Kotlin has older version of this one).
  *
@@ -132,10 +130,12 @@ object IntellijRootUtils {
     }
 }
 
-@Suppress("UNCHECKED_CAST")
-fun ModuleDependency.includeIntellijCoreJarDependencies(project: Project, jarsFilterPredicate: (String) -> Boolean = { true }): Unit =
+fun ModuleDependency.includeIntellijCoreJarDependencies(project: Project) =
+    includeJars(*(project.rootProject.extra["IntellijCoreDependencies"] as List<String>).toTypedArray(), rootProject = project.rootProject)
+
+fun ModuleDependency.includeIntellijCoreJarDependencies(project: Project, jarsFilterPredicate: (String) -> Boolean) =
     includeJars(
-        *(project.rootProject.extra["IntellijCoreDependencies"] as List<String>).filter(jarsFilterPredicate).toTypedArray(),
+        *(project.rootProject.extra["IntellijCoreDependencies"] as List<String>).filter { jarsFilterPredicate(it) }.toTypedArray(),
         rootProject = project.rootProject
     )
 
@@ -165,7 +165,7 @@ fun Project.runIdeTask(name: String, ideaPluginDir: File, ideaSandboxDir: File,
 
         classpath = mainSourceSet.runtimeClasspath
 
-        mainClass.set("com.intellij.idea.Main")
+        main = "com.intellij.idea.Main"
 
         workingDir = File(intellijRootDir(), "bin")
 
@@ -178,14 +178,13 @@ fun Project.runIdeTask(name: String, ideaPluginDir: File, ideaSandboxDir: File,
             "-Didea.system.path=$ideaSandboxDir",
             "-Didea.config.path=$ideaSandboxConfigDir",
             "-Didea.tooling.debug=true",
-            "-Dfus.internal.test.mode=true",
             "-Dapple.laf.useScreenMenuBar=true",
             "-Dapple.awt.graphics.UseQuartz=true",
             "-Dsun.io.useCanonCaches=false",
             "-Dplugin.path=${ideaPluginDir.absolutePath}"
         )
 
-        if (Platform[201].orHigher() && !isIntellijUltimateSdkAvailable()) {
+        if (Platform[201].orHigher()) {
             jvmArgs("-Didea.platform.prefix=Idea")
         }
 

buildSrc/src/main/kotlin/pluginMarkers.kt

@@ -9,16 +9,12 @@ 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"
 
-@OptIn(ExperimentalStdlibApi::class)
 fun Project.publishPluginMarkers(withEmptyJars: Boolean = true) {
     val pluginDevelopment = extensions.getByType<PluginBundleExtension>()
     val publishingExtension = extensions.getByType<PublishingExtension>()
@@ -29,10 +25,6 @@ fun Project.publishPluginMarkers(withEmptyJars: Boolean = true) {
         if (withEmptyJars) {
             addEmptyJarArtifacts(markerPublication)
         }
-
-        tasks.named<PublishToMavenRepository>(
-            "publish${markerPublication.name.capitalize(Locale.ROOT)}PublicationTo${KotlinBuildPublishingPlugin.REPOSITORY_NAME}Repository"
-        ).configureRepository()
     }
 }
 

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

@@ -8,20 +8,20 @@ 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.Sign
 import org.gradle.plugins.signing.SigningExtension
 import org.gradle.plugins.signing.SigningPlugin
 import java.util.*
 import javax.inject.Inject
 
+
 class KotlinBuildPublishingPlugin @Inject constructor(
     private val componentFactory: SoftwareComponentFactory
 ) : Plugin<Project> {
@@ -45,7 +45,7 @@ class KotlinBuildPublishingPlugin @Inject constructor(
             }
         }
 
-        val kotlinLibraryComponent = componentFactory.adhoc(ADHOC_COMPONENT_NAME)
+        val kotlinLibraryComponent = componentFactory.adhoc(ADHOC_COMPONENT_NAME) as AdhocComponentWithVariants
         components.add(kotlinLibraryComponent)
         kotlinLibraryComponent.addVariantsFromConfiguration(publishedCompile) { mapToMavenScope("compile") }
         kotlinLibraryComponent.addVariantsFromConfiguration(publishedRuntime) { mapToMavenScope("runtime") }
@@ -106,27 +106,38 @@ class KotlinBuildPublishingPlugin @Inject constructor(
             }
         }
 
-        val signingRequired = provider {
-            project.findProperty("signingRequired")?.toString()?.toBoolean()
-                ?: project.property("isSonatypeRelease") as Boolean
-        }
-
         configure<SigningExtension> {
-            setRequired(signingRequired)
-            sign(extensions.getByType<PublishingExtension>().publications[PUBLICATION_NAME])
-            useGpgCmd()
-        }
+            setRequired(provider {
+                project.findProperty("signingRequired")?.toString()?.toBoolean()
+                    ?: project.property("isSonatypeRelease") as Boolean
+            })
 
-        tasks.withType<Sign>().configureEach {
-            setOnlyIf { signingRequired.get() }
+            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()
+        tasks.named<PublishToMavenRepository>("publish${PUBLICATION_NAME}PublicationTo${REPOSITORY_NAME}Repository") {
+            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 = uri(repoUrl)
+                    if (url.scheme != "file" && username != null && password != null) {
+                        credentials {
+                            this.username = username
+                            this.password = password
+                        }
+                    }
+                }
+            }
+        }
     }
 
     companion object {
@@ -137,28 +148,8 @@ class KotlinBuildPublishingPlugin @Inject constructor(
         const val COMPILE_CONFIGURATION = "publishedCompile"
         const val RUNTIME_CONFIGURATION = "publishedRuntime"
 
-        @OptIn(ExperimentalStdlibApi::class)
+        @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

@@ -1,4 +1,3 @@
-@file:Suppress("DEPRECATION")
 package plugins
 
 import org.codehaus.groovy.runtime.InvokerHelper
@@ -17,8 +16,10 @@ import org.gradle.plugins.signing.Sign
 import org.gradle.plugins.signing.SigningExtension
 import kotlin.properties.Delegates
 
+
 /**
  * Configures a Kotlin module for publication.
+ *
  */
 open class PublishedKotlinModule : Plugin<Project> {
 
@@ -51,7 +52,6 @@ open class PublishedKotlinModule : Plugin<Project> {
                 configure<SigningExtension> {
                     isRequired = signingRequired
                     sign(configurations["archives"])
-                    useGpgCmd()
                 }
 
                 tasks.named<Sign>("signArchives").configure {

buildSrc/src/main/kotlin/tasks.kt

@@ -31,47 +31,6 @@ import java.lang.Character.isUpperCase
 import java.nio.file.Files
 import java.nio.file.Path
 
-fun Task.dependsOnKotlinPluginInstall() {
-    dependsOn(
-        ":kotlin-allopen:install",
-        ":kotlin-noarg:install",
-        ":kotlin-sam-with-receiver:install",
-        ":kotlin-android-extensions:install",
-        ":kotlin-parcelize-compiler:install",
-        ":kotlin-build-common:install",
-        ":kotlin-compiler-embeddable:install",
-        ":native:kotlin-native-utils:install",
-        ":kotlin-util-klib:install",
-        ":kotlin-util-io:install",
-        ":kotlin-compiler-runner:install",
-        ":kotlin-daemon-embeddable:install",
-        ":kotlin-daemon-client:install",
-        ":kotlin-gradle-plugin-api:install",
-        ":kotlin-gradle-plugin:install",
-        ":kotlin-gradle-plugin-model:install",
-        ":kotlin-reflect:install",
-        ":kotlin-annotation-processing-gradle:install",
-        ":kotlin-test:kotlin-test-common:install",
-        ":kotlin-test:kotlin-test-annotations-common:install",
-        ":kotlin-test:kotlin-test-jvm:install",
-        ":kotlin-test:kotlin-test-js:install",
-        ":kotlin-test:kotlin-test-junit:install",
-        ":kotlin-gradle-subplugin-example:install",
-        ":kotlin-stdlib-common:install",
-        ":kotlin-stdlib:install",
-        ":kotlin-stdlib-jdk8:install",
-        ":kotlin-stdlib-js:install",
-        ":examples:annotation-processor-example:install",
-        ":kotlin-script-runtime:install",
-        ":kotlin-scripting-common:install",
-        ":kotlin-scripting-jvm:install",
-        ":kotlin-scripting-compiler-embeddable:install",
-        ":kotlin-scripting-compiler-impl-embeddable:install",
-        ":kotlin-test-js-runner:install",
-        ":native:kotlin-klib-commonizer-embeddable:install"
-    )
-}
-
 fun Project.projectTest(
     taskName: String = "test",
     parallel: Boolean = false,
@@ -154,7 +113,7 @@ fun Project.projectTest(
 
     var subProjectTempRoot: Path? = null
     doFirst {
-        val teamcity = rootProject.findProperty("teamcity") as? Map<*, *>
+        val teamcity = rootProject.findProperty("teamcity") as? Map<Any?, *>
         val systemTempRoot =
             // TC by default doesn't switch `teamcity.build.tempDir` to 'java.io.tmpdir' so it could cause to wasted disk space
             // Should be fixed soon on Teamcity side
@@ -180,7 +139,7 @@ fun Project.projectTest(
     if (parallel) {
         maxParallelForks =
             project.findProperty("kotlin.test.maxParallelForks")?.toString()?.toInt()
-                ?: (Runtime.getRuntime().availableProcessors() / if (kotlinBuildProperties.isTeamcityBuild) 2 else 4).coerceAtLeast(1)
+                ?: Math.max(Runtime.getRuntime().availableProcessors() / if (kotlinBuildProperties.isTeamcityBuild) 2 else 4, 1)
     }
     body()
 }

compiler/android-tests/build.gradle.kts

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

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

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

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

@@ -27,9 +27,6 @@ import org.junit.Assert
 import java.io.File
 import java.io.FileWriter
 import java.io.IOException
-import kotlin.io.path.ExperimentalPathApi
-import kotlin.io.path.Path
-import kotlin.io.path.createTempDirectory
 import kotlin.test.assertTrue
 
 data class ConfigurationKey(val kind: ConfigurationKind, val jdkKind: TestJdkKind, val configuration: String)
@@ -297,7 +294,7 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
                     val kind = KotlinBaseTest.extractConfigurationKind(testFiles)
                     val jdkKind = KotlinBaseTest.getTestJdkKind(testFiles)
                     val keyConfiguration = CompilerConfiguration()
-                    KotlinBaseTest.updateConfigurationByDirectivesInTestFiles(testFiles, keyConfiguration)
+                    CodegenTestCase.updateConfigurationByDirectivesInTestFiles(testFiles, keyConfiguration)
 
                     val key = ConfigurationKey(kind, jdkKind, keyConfiguration.toString())
                     val compiler = if (isJvm8Target) {
@@ -306,7 +303,7 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
                     val filesHolder = holders.getOrPut(key) {
                         FilesWriter(compiler, KotlinTestUtils.newConfiguration(kind, jdkKind, KotlinTestUtils.getAnnotationsJar()).apply {
                             println("Creating new configuration by $key")
-                            KotlinBaseTest.updateConfigurationByDirectivesInTestFiles(testFiles, this)
+                            CodegenTestCase.updateConfigurationByDirectivesInTestFiles(testFiles, this)
                         })
                     }
 
@@ -348,15 +345,14 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
             FileWriter(file).use { fw -> fw.write("sdk.dir=$sdkRoot") }
         }
 
-        @OptIn(ExperimentalPathApi::class)
         @JvmStatic
         fun main(args: Array<String>) {
-            val tmpFolder = createTempDirectory().toAbsolutePath().toString()
-            println("Created temporary folder for android tests: $tmpFolder")
-            val rootFolder = Path("").toAbsolutePath().toString()
-            val pathManager = PathManager(rootFolder, tmpFolder)
+            val tmpFolder = createTempDir()
+            println("Created temporary folder for android tests: " + tmpFolder.absolutePath)
+            val rootFolder = File("")
+            val pathManager = PathManager(rootFolder.absolutePath, tmpFolder.absolutePath)
             generate(pathManager, true)
-            println("Android test project is generated into $tmpFolder folder")
+            println("Android test project is generated into " + tmpFolder.absolutePath + " folder")
         }
     }
 }

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

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

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

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.backend.common
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.backend.common.bridges.findInterfaceImplementation
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.diagnostics.Errors
@@ -23,7 +24,6 @@ import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.multiplatform.ExpectedActualResolver
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.util.getExceptionMessage
-import org.jetbrains.kotlin.util.getNonPrivateTraitMembersForDelegation
 import org.jetbrains.kotlin.utils.DFS
 import org.jetbrains.kotlin.utils.KotlinExceptionWithAttachments
 
@@ -55,8 +55,14 @@ object CodegenUtil {
     @JvmOverloads
     fun getNonPrivateTraitMethods(descriptor: ClassDescriptor, copy: Boolean = true): Map<FunctionDescriptor, FunctionDescriptor> {
         val result = linkedMapOf<FunctionDescriptor, FunctionDescriptor>()
+        for (declaration in DescriptorUtils.getAllDescriptors(descriptor.defaultType.memberScope)) {
+            if (declaration !is CallableMemberDescriptor) continue
+
+            val traitMember = findInterfaceImplementation(declaration)
+            if (traitMember == null ||
+                    Visibilities.isPrivate(traitMember.visibility) ||
+                    traitMember.visibility == Visibilities.INVISIBLE_FAKE) continue
 
-        for ((declaration, traitMember) in getNonPrivateTraitMembersForDelegation(descriptor)) {
             assert(traitMember.modality !== Modality.ABSTRACT) { "Cannot delegate to abstract trait method: $declaration" }
 
             // inheritedMember can be abstract here. In order for FunctionCodegen to generate the method body, we're creating a copy here
@@ -65,7 +71,7 @@ object CodegenUtil {
                 if (copy)
                     copyFunctions(
                         declaration, traitMember, declaration.containingDeclaration, traitMember.modality,
-                        DescriptorVisibilities.PUBLIC, CallableMemberDescriptor.Kind.DECLARATION, true
+                        Visibilities.PUBLIC, CallableMemberDescriptor.Kind.DECLARATION, true
                     )
                 else mapMembers(declaration, traitMember)
             )
@@ -74,13 +80,13 @@ object CodegenUtil {
     }
 
     fun copyFunctions(
-            inheritedMember: CallableMemberDescriptor,
-            traitMember: CallableMemberDescriptor,
-            newOwner: DeclarationDescriptor,
-            modality: Modality,
-            visibility: DescriptorVisibility,
-            kind: CallableMemberDescriptor.Kind,
-            copyOverrides: Boolean
+        inheritedMember: CallableMemberDescriptor,
+        traitMember: CallableMemberDescriptor,
+        newOwner: DeclarationDescriptor,
+        modality: Modality,
+        visibility: Visibility,
+        kind: CallableMemberDescriptor.Kind,
+        copyOverrides: Boolean
     ): Map<FunctionDescriptor, FunctionDescriptor> =
         mapMembers(inheritedMember.copy(newOwner, modality, visibility, kind, copyOverrides), traitMember)
 
@@ -232,13 +238,12 @@ object CodegenUtil {
     }
 
     @JvmStatic
-    fun reportBackendException(exception: Throwable, phase: String, location: String?, additionalMessage: String? = null): Nothing {
+    fun reportBackendException(exception: Throwable, phase: String, fileUrl: String?): Nothing {
         // CompilationException (the only KotlinExceptionWithAttachments possible here) is already supposed
         // to have all information about the context.
         if (exception is KotlinExceptionWithAttachments) throw exception
-        throw BackendException(
-            getExceptionMessage("Backend", "Exception during $phase", exception, location) +
-                    additionalMessage?.let { "\n" + it }.orEmpty(),
+        throw IllegalStateException(
+            getExceptionMessage("Backend", "Exception during $phase", exception, fileUrl),
             exception
         )
     }

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

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

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

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

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

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

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

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

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

@@ -1,43 +0,0 @@
-/*
- * Copyright 2010-2016 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.codegen.signature
-
-import org.jetbrains.kotlin.builtins.PrimitiveType
-import org.jetbrains.kotlin.codegen.AsmUtil
-import org.jetbrains.kotlin.load.kotlin.JvmTypeFactory
-import org.jetbrains.kotlin.resolve.jvm.AsmTypes
-import org.jetbrains.org.objectweb.asm.Type
-
-object AsmTypeFactory : JvmTypeFactory<Type> {
-    override fun boxType(possiblyPrimitiveType: Type): Type =
-        AsmUtil.boxType(possiblyPrimitiveType)
-
-    override fun createFromString(representation: String): Type =
-        Type.getType(representation)
-
-    override fun createPrimitiveType(primitiveType: PrimitiveType): Type =
-        AsmTypes.valueTypeForPrimitive(primitiveType)
-
-    override fun createObjectType(internalName: String): Type =
-        Type.getObjectType(internalName)
-
-    override fun toString(type: Type): String =
-        type.descriptor
-
-    override val javaLangClassType: Type
-        get() = AsmTypes.JAVA_CLASS_TYPE
-}

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

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

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

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

compiler/backend/build.gradle.kts

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

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

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

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

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

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

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

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

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

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

@@ -90,18 +90,12 @@ public abstract class AnnotationCodegen {
     private final KotlinTypeMapper typeMapper;
     private final ModuleDescriptor module;
     private final GenerationState state;
-    private final boolean skipNullabilityAnnotations;
 
     private AnnotationCodegen(@NotNull InnerClassConsumer innerClassConsumer, @NotNull GenerationState state) {
-        this(innerClassConsumer, state, false);
-    }
-
-    private AnnotationCodegen(@NotNull InnerClassConsumer innerClassConsumer, @NotNull GenerationState state, boolean skipNullabilityAnnotations) {
         this.innerClassConsumer = innerClassConsumer;
         this.typeMapper = state.getTypeMapper();
         this.module = state.getModule();
         this.state = state;
-        this.skipNullabilityAnnotations = skipNullabilityAnnotations;
     }
 
     /**
@@ -111,16 +105,6 @@ public abstract class AnnotationCodegen {
             @Nullable Annotated annotated,
             @Nullable Type returnType,
             @Nullable KotlinType typeForTypeAnnotations
-    ) {
-        genAnnotations(annotated, returnType, typeForTypeAnnotations, null, Collections.emptyList());
-    }
-
-    public void genAnnotations(
-            @Nullable Annotated annotated,
-            @Nullable Type returnType,
-            @Nullable KotlinType typeForTypeAnnotations,
-            @Nullable DeclarationDescriptorWithVisibility parameterContainer,
-            @NotNull List<String> additionalVisibleAnnotations
     ) {
         if (annotated == null) return;
 
@@ -142,7 +126,7 @@ public abstract class AnnotationCodegen {
                 && !applicableTargets.contains(KotlinTarget.CLASS)
                 && !applicableTargets.contains(KotlinTarget.ANNOTATION_CLASS)) {
                 ClassDescriptor classDescriptor = (ClassDescriptor) annotated;
-                if (classDescriptor.getVisibility() == DescriptorVisibilities.LOCAL) {
+                if (classDescriptor.getVisibility() == Visibilities.LOCAL) {
                     assert applicableTargets.contains(KotlinTarget.EXPRESSION) :
                             "Inconsistent target list for object literal annotation: " + applicableTargets + " on " + annotated;
                     continue;
@@ -155,28 +139,22 @@ public abstract class AnnotationCodegen {
             }
         }
 
-        for (String annotation : additionalVisibleAnnotations) {
-            generateAnnotationIfNotPresent(annotationDescriptorsAlreadyPresent, annotation, true);
-            annotationDescriptorsAlreadyPresent.add(annotation);
-        }
-
-        generateAdditionalAnnotations(annotated, returnType, annotationDescriptorsAlreadyPresent, parameterContainer);
+        generateAdditionalAnnotations(annotated, returnType, annotationDescriptorsAlreadyPresent);
         generateTypeAnnotations(annotated, typeForTypeAnnotations);
     }
 
     private void generateAdditionalAnnotations(
             @NotNull Annotated annotated,
             @Nullable Type returnType,
-            @NotNull Set<String> annotationDescriptorsAlreadyPresent,
-            @Nullable DeclarationDescriptorWithVisibility parameterContainer
+            @NotNull Set<String> annotationDescriptorsAlreadyPresent
     ) {
         if (annotated instanceof CallableDescriptor) {
-            generateAdditionalCallableAnnotations((CallableDescriptor) annotated, returnType, annotationDescriptorsAlreadyPresent, parameterContainer);
+            generateAdditionalCallableAnnotations((CallableDescriptor) annotated, returnType, annotationDescriptorsAlreadyPresent);
         }
         else if (annotated instanceof FieldDescriptor) {
             generateAdditionalCallableAnnotations(
-                    ((FieldDescriptor) annotated).getCorrespondingProperty(), returnType, annotationDescriptorsAlreadyPresent,
-                    parameterContainer);
+                    ((FieldDescriptor) annotated).getCorrespondingProperty(), returnType, annotationDescriptorsAlreadyPresent
+            );
         }
         else if (annotated instanceof ClassDescriptor) {
             generateAdditionalClassAnnotations(annotationDescriptorsAlreadyPresent, (ClassDescriptor) annotated);
@@ -186,15 +164,11 @@ public abstract class AnnotationCodegen {
     private void generateAdditionalCallableAnnotations(
             @NotNull CallableDescriptor descriptor,
             @Nullable Type returnType,
-            @NotNull Set<String> annotationDescriptorsAlreadyPresent,
-            @Nullable DeclarationDescriptorWithVisibility parameterContainer
+            @NotNull Set<String> annotationDescriptorsAlreadyPresent
     ) {
         // No need to annotate privates, synthetic accessors and their parameters
         if (isInvisibleFromTheOutside(descriptor)) return;
-        if (descriptor instanceof ParameterDescriptor &&
-            isInvisibleFromTheOutside(parameterContainer != null ? parameterContainer : descriptor.getContainingDeclaration())) {
-            return;
-        }
+        if (descriptor instanceof ValueParameterDescriptor && isInvisibleFromTheOutside(descriptor.getContainingDeclaration())) return;
 
         // No need to annotate annotation methods since they're always non-null
         if (descriptor instanceof PropertyGetterDescriptor &&
@@ -202,7 +176,7 @@ public abstract class AnnotationCodegen {
             return;
         }
 
-        if (returnType != null && !AsmUtil.isPrimitive(returnType) && !skipNullabilityAnnotations) {
+        if (returnType != null && !AsmUtil.isPrimitive(returnType)) {
             generateNullabilityAnnotation(descriptor.getReturnType(), annotationDescriptorsAlreadyPresent);
         }
     }
@@ -221,7 +195,7 @@ public abstract class AnnotationCodegen {
     private static boolean isInvisibleFromTheOutside(@Nullable DeclarationDescriptor descriptor) {
         if (isAccessor(descriptor)) return true;
         if (descriptor instanceof MemberDescriptor) {
-            return DescriptorAsmUtil.getVisibilityAccessFlag((MemberDescriptor) descriptor) == Opcodes.ACC_PRIVATE;
+            return AsmUtil.getVisibilityAccessFlag((MemberDescriptor) descriptor) == Opcodes.ACC_PRIVATE;
         }
         return false;
     }
@@ -248,17 +222,17 @@ public abstract class AnnotationCodegen {
             if (!TypeUtils.isNullableType(flexibleType.getLowerBound()) && TypeUtils.isNullableType(flexibleType.getUpperBound())) {
                 AnnotationDescriptor notNull = type.getAnnotations().findAnnotation(JvmAnnotationNames.JETBRAINS_NOT_NULL_ANNOTATION);
                 if (notNull != null) {
-                    generateAnnotationIfNotPresent(annotationDescriptorsAlreadyPresent, Type.getType(NotNull.class).getDescriptor(), false);
+                    generateAnnotationIfNotPresent(annotationDescriptorsAlreadyPresent, NotNull.class);
                 }
                 return;
             }
         }
 
-        generateAnnotationIfNotPresent(
-                annotationDescriptorsAlreadyPresent,
-                TypeUtils.isNullableType(type) ? Type.getType(Nullable.class).getDescriptor() : Type.getType(NotNull.class).getDescriptor(),
-                false
-        );
+        boolean isNullableType = TypeUtils.isNullableType(type);
+
+        Class<?> annotationClass = isNullableType ? Nullable.class : NotNull.class;
+
+        generateAnnotationIfNotPresent(annotationDescriptorsAlreadyPresent, annotationClass);
     }
 
     private static final Map<JvmTarget, Map<KotlinTarget, ElementType>> annotationTargetMaps = new EnumMap<>(JvmTarget.class);
@@ -338,13 +312,10 @@ public abstract class AnnotationCodegen {
         visitor.visitEnd();
     }
 
-    private void generateAnnotationIfNotPresent(
-            Set<String> annotationDescriptorsAlreadyPresent,
-            String annotationDescriptor,
-            boolean visible
-    ) {
-        if (!annotationDescriptorsAlreadyPresent.contains(annotationDescriptor)) {
-            visitAnnotation(annotationDescriptor, visible).visitEnd();
+    private void generateAnnotationIfNotPresent(Set<String> annotationDescriptorsAlreadyPresent, Class<?> annotationClass) {
+        String descriptor = Type.getType(annotationClass).getDescriptor();
+        if (!annotationDescriptorsAlreadyPresent.contains(descriptor)) {
+            visitAnnotation(descriptor, false).visitEnd();
         }
     }
 
@@ -629,16 +600,7 @@ public abstract class AnnotationCodegen {
             @NotNull InnerClassConsumer innerClassConsumer,
             @NotNull GenerationState state
     ) {
-        return forMethod(mv, innerClassConsumer, state, false);
-    }
-
-    public static AnnotationCodegen forMethod(
-            @NotNull MethodVisitor mv,
-            @NotNull InnerClassConsumer innerClassConsumer,
-            @NotNull GenerationState state,
-            boolean skipNullabilityAnnotations
-    ) {
-        return new AnnotationCodegen(innerClassConsumer, state, skipNullabilityAnnotations) {
+        return new AnnotationCodegen(innerClassConsumer, state) {
             @NotNull
             @Override
             AnnotationVisitor visitAnnotation(String descr, boolean visible) {
@@ -658,16 +620,7 @@ public abstract class AnnotationCodegen {
             @NotNull InnerClassConsumer innerClassConsumer,
             @NotNull GenerationState state
     ) {
-        return forField(fv, innerClassConsumer, state, false);
-    }
-
-    public static AnnotationCodegen forField(
-            @NotNull FieldVisitor fv,
-            @NotNull InnerClassConsumer innerClassConsumer,
-            @NotNull GenerationState state,
-            boolean skipNullabilityAnnotations
-    ) {
-        return new AnnotationCodegen(innerClassConsumer, state, skipNullabilityAnnotations) {
+        return new AnnotationCodegen(innerClassConsumer, state) {
             @NotNull
             @Override
             AnnotationVisitor visitAnnotation(String descr, boolean visible) {
@@ -686,10 +639,9 @@ public abstract class AnnotationCodegen {
             int parameter,
             @NotNull MethodVisitor mv,
             @NotNull InnerClassConsumer innerClassConsumer,
-            @NotNull GenerationState state,
-            boolean skipNullabilityAnnotations
+            @NotNull GenerationState state
     ) {
-        return new AnnotationCodegen(innerClassConsumer, state, skipNullabilityAnnotations) {
+        return new AnnotationCodegen(innerClassConsumer, state) {
             @NotNull
             @Override
             AnnotationVisitor visitAnnotation(String descr, boolean visible) {

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

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

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

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

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

@@ -254,14 +254,14 @@ public class ClassFileFactory implements OutputFileCollection {
     public PackageCodegen forPackage(@NotNull FqName fqName, @NotNull Collection<KtFile> files) {
         assert !isDone : "Already done!";
         registerSourceFiles(files);
-        return new PackageCodegenImpl(state, files, fqName);
+        return state.getCodegenFactory().createPackageCodegen(state, files, fqName);
     }
 
     @NotNull
     public MultifileClassCodegen forMultifileClass(@NotNull FqName facadeFqName, @NotNull Collection<KtFile> files) {
         assert !isDone : "Already done!";
         registerSourceFiles(files);
-        return new MultifileClassCodegenImpl(state, files, facadeFqName);
+        return state.getCodegenFactory().createMultifileClassCodegen(state, files, facadeFqName);
     }
 
     private void registerSourceFiles(Collection<KtFile> files) {

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

@@ -31,7 +31,6 @@ import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader;
 import org.jetbrains.kotlin.metadata.ProtoBuf;
 import org.jetbrains.kotlin.psi.KtElement;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
-import org.jetbrains.kotlin.resolve.InlineClassesUtilsKt;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKt;
@@ -51,9 +50,8 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
-import static org.jetbrains.kotlin.codegen.AsmUtil.CAPTURED_THIS_FIELD;
+import static org.jetbrains.kotlin.codegen.AsmUtil.*;
 import static org.jetbrains.kotlin.codegen.CallableReferenceUtilKt.*;
-import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.*;
 import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isConst;
 import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.CLOSURE;
 import static org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings.METHOD_FOR_FUNCTION;
@@ -141,7 +139,7 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
 
         this.asmType = typeMapper.mapClass(classDescriptor);
 
-        visibilityFlag = DescriptorAsmUtil.getVisibilityAccessFlagForClass(classDescriptor);
+        visibilityFlag = AsmUtil.getVisibilityAccessFlagForClass(classDescriptor);
     }
 
     @Override
@@ -368,11 +366,6 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
                 value = StackValue.local(slot, type, bridgeParameterKotlinTypes.get(i));
                 slot += type.getSize();
             }
-            if (InlineClassesCodegenUtilKt.isInlineClassWithUnderlyingTypeAnyOrAnyN(parameterType) &&
-                functionReferenceCall == null
-            ) {
-                parameterType = InlineClassesUtilsKt.unsubstitutedUnderlyingParameter(parameterType).getType();
-            }
             value.put(typeMapper.mapType(calleeParameter), parameterType, iv);
         }
 
@@ -596,8 +589,4 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
         MemberScope scope = functionClass.getDefaultType().getMemberScope();
         return scope.getContributedFunctions(OperatorNameConventions.INVOKE, NoLookupLocation.FROM_BACKEND).iterator().next();
     }
-
-    public boolean isCallableReference() {
-        return functionReferenceTarget != null;
-    }
 }

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

@@ -26,6 +26,10 @@ import org.jetbrains.kotlin.psi.KtFile
 interface CodegenFactory {
     fun generateModule(state: GenerationState, files: Collection<KtFile>)
 
+    fun createPackageCodegen(state: GenerationState, files: Collection<KtFile>, fqName: FqName): PackageCodegen
+
+    fun createMultifileClassCodegen(state: GenerationState, files: Collection<KtFile>, fqName: FqName): MultifileClassCodegen
+
     companion object {
         fun doCheckCancelled(state: GenerationState) {
             if (state.classBuilderMode.generateBodies) {
@@ -45,7 +49,8 @@ object DefaultCodegenFactory : CodegenFactory {
 
             if (fileClassInfo.withJvmMultifileClass) {
                 filesInMultifileClasses.putValue(fileClassInfo.facadeClassFqName, file)
-            } else {
+            }
+            else {
                 filesInPackages.putValue(file.packageFqName, file)
             }
         }
@@ -63,17 +68,23 @@ object DefaultCodegenFactory : CodegenFactory {
         }
     }
 
+    override fun createPackageCodegen(state: GenerationState, files: Collection<KtFile>, fqName: FqName) =
+            PackageCodegenImpl(state, files, fqName)
+
+    override fun createMultifileClassCodegen(state: GenerationState, files: Collection<KtFile>, fqName: FqName) =
+            MultifileClassCodegenImpl(state, files, fqName)
+
     private fun generateMultifileClass(state: GenerationState, multifileClassFqName: FqName, files: Collection<KtFile>) {
         state.factory.forMultifileClass(multifileClassFqName, files).generate()
     }
 
     fun generatePackage(
-        state: GenerationState,
-        packageFqName: FqName,
-        ktFiles: Collection<KtFile>
+            state: GenerationState,
+            packageFqName: FqName,
+            jetFiles: Collection<KtFile>
     ) {
         // We do not really generate package class, but use old package fqName to identify package in module-info.
         //FqName packageClassFqName = PackageClassUtils.getPackageClassFqName(packageFqName);
-        state.factory.forPackage(packageFqName, ktFiles).generate()
+        state.factory.forPackage(packageFqName, jetFiles).generate()
     }
 }