Update Kotlin/Native version

#KT-37406 Fixed

.bunch

@@ -1,7 +1,9 @@
-192
 193
-191
-183_191
-as34_183_191
-as35_191
-as36
+201
+192
+191_192
+183_191_192
+as34_183_191_192
+as35_191_192
+as36_192
+as40

.idea/dictionaries/sergey_igushkin.xml

@@ -0,0 +1,7 @@
+<component name="ProjectDictionaryState">
+  <dictionary name="sergey.igushkin">
+    <words>
+      <w>klib</w>
+    </words>
+  </dictionary>
+</component>

.idea/misc.xml

@@ -12,14 +12,8 @@
       <item index="2" class="java.lang.String" itemvalue="org.gradle.api.tasks.options.Option" />
     </list>
   </component>
-  <component name="FacetAutodetectingManager">
-    <autodetection-disabled>
-      <facet-type id="Python">
-        <modules>
-          <module name="Jet" />
-        </modules>
-      </facet-type>
-    </autodetection-disabled>
+  <component name="FrameworkDetectionExcludesConfiguration">
+    <file type="web" url="file://$PROJECT_DIR$" />
   </component>
   <component name="IdProvider" IDEtalkID="71A301FF1940049D6D82F12C40F1E1D5" />
   <component name="JavadocGenerationManager">

build-common/build.gradle.kts

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

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

@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.utils.Printer
 import java.io.File
 
 abstract class BasicMap<K : Comparable<K>, V>(
-        storageFile: File,
+        internal val storageFile: File,
         keyDescriptor: KeyDescriptor<K>,
         valueExternalizer: DataExternalizer<V>
 ) {

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

@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.utils.Printer
 import java.io.File
 
 abstract class BasicMap<K : Comparable<K>, V>(
-        storageFile: File,
+        internal val storageFile: File,
         keyDescriptor: KeyDescriptor<K>,
         valueExternalizer: DataExternalizer<V>
 ) {

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

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.incremental.storage
 
 import org.jetbrains.annotations.TestOnly
 import java.io.File
+import java.io.IOException
 
 open class BasicMapsOwner(val cachesDir: File) {
     private val maps = arrayListOf<BasicMap<*, *>>()
@@ -35,16 +36,35 @@ open class BasicMapsOwner(val cachesDir: File) {
     }
 
     open fun clean() {
-        maps.forEach { it.clean() }
+        forEachMapSafe("clean", BasicMap<*, *>::clean)
     }
 
     open fun close() {
-        maps.forEach { it.close() }
+        forEachMapSafe("close", BasicMap<*, *>::close)
     }
 
     open fun flush(memoryCachesOnly: Boolean) {
-        maps.forEach { it.flush(memoryCachesOnly) }
+        forEachMapSafe("flush") { it.flush(memoryCachesOnly) }
     }
 
-    @TestOnly fun dump(): String = maps.joinToString("\n\n") { it.dump() }
+    private fun forEachMapSafe(actionName: String, action: (BasicMap<*, *>) -> Unit) {
+        val actionExceptions = LinkedHashMap<String, Exception>()
+        maps.forEach {
+            try {
+                action(it)
+            } catch (e: Exception) {
+                actionExceptions[it.storageFile.name] = e
+            }
+        }
+        if (actionExceptions.isNotEmpty()) {
+            val desc = "Could not $actionName incremental caches in $cachesDir: ${actionExceptions.keys.joinToString(", ")}"
+            val allIOExceptions = actionExceptions.all { it is IOException }
+            val ex = if (allIOExceptions) IOException(desc) else Exception(desc)
+            actionExceptions.forEach { (_, e) -> ex.addSuppressed(e) }
+            throw ex
+        }
+    }
+
+    @TestOnly
+    fun dump(): String = maps.joinToString("\n\n") { it.dump() }
 }

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

@@ -79,11 +79,10 @@ class CachingLazyStorage<K, V>(
     override fun clean() {
         try {
             storage?.close()
-        } catch (ignored: Throwable) {
+        } finally {
+            PersistentHashMap.deleteFilesStartingWith(storageFile)
+            storage = null
         }
-
-        PersistentHashMap.deleteFilesStartingWith(storageFile)
-        storage = null
     }
 
     @Synchronized

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.gradle.kts

@@ -8,7 +8,7 @@ buildscript {
     extra["defaultSnapshotVersion"] = "1.3-SNAPSHOT"
     val cacheRedirectorEnabled = findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() == true
 
-    kotlinBootstrapFrom(BootstrapOption.BintrayBootstrap("1.3.70-dev-1806", cacheRedirectorEnabled))
+    kotlinBootstrapFrom(BootstrapOption.BintrayBootstrap("1.3.70-eap-145", cacheRedirectorEnabled))
 
     repositories {
         bootstrapKotlinRepo?.let(::maven)
@@ -171,7 +171,7 @@ extra["versions.completion-ranking-kotlin"] = "0.0.2"
 extra["versions.ktor-network"] = "1.0.1"
 
 if (!project.hasProperty("versions.kotlin-native")) {
-    extra["versions.kotlin-native"] = "1.3.70-dev-13747"
+    extra["versions.kotlin-native"] = "1.3.72"
 }
 
 val intellijUltimateEnabled by extra(project.kotlinBuildProperties.intellijUltimateEnabled)
@@ -189,11 +189,11 @@ extra["IntellijCoreDependencies"] =
         "jdom",
         "jna",
         "log4j",
-        "picocontainer",
+        if (Platform[201].orHigher()) null else "picocontainer",
         "snappy-in-java",
         "streamex",
         "trove4j"
-    )
+    ).filterNotNull()
 
 
 extra["compilerModules"] = arrayOf(
@@ -621,11 +621,20 @@ tasks {
         )
     }
 
+    register("idea-new-project-wizard-tests") {
+        dependsOn("dist")
+        dependsOn(
+            ":libraries:tools:new-project-wizard:test",
+            ":libraries:tools:new-project-wizard:new-project-wizard-cli:test"
+        )
+    }
+
     register("idea-plugin-tests") {
         dependsOn("dist")
         dependsOn(
             "idea-plugin-main-tests",
-            "idea-plugin-additional-tests"
+            "idea-plugin-additional-tests",
+            "idea-new-project-wizard-tests"
         )
     }
 

buildSrc/gradle.properties.as40

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

buildSrc/prepare-deps/build.gradle.kts

@@ -115,8 +115,7 @@ val repoDir = File(customDepsRepoDir, customDepsOrg)
 
 dependencies {
     if (androidStudioRelease != null) {
-        val extension = if (androidStudioOs == "linux" &&
-            (androidStudioRelease.startsWith("3.5") || androidStudioRelease.startsWith("3.6")))
+        val extension = if (androidStudioOs == "linux")
             "tar.gz"
         else
             "zip"

buildSrc/src/main/kotlin/IdeCompatibilityDsl.kt

@@ -26,7 +26,7 @@ fun CompatibilityPredicate.or(other: CompatibilityPredicate): CompatibilityPredi
 }
 
 enum class Platform : CompatibilityPredicate {
-    P183, P191, P192, P193;
+    P183, P191, P192, P193, P201;
 
     val version: Int = name.drop(1).toInt()
 
@@ -45,10 +45,12 @@ enum class Ide(val platform: Platform) : CompatibilityPredicate {
     IJ191(Platform.P191),
     IJ192(Platform.P192),
     IJ193(Platform.P193),
+    IJ201(Platform.P201),
 
     AS34(Platform.P183),
     AS35(Platform.P183),
-    AS36(Platform.P192);
+    AS36(Platform.P192),
+    AS40(Platform.P193);
 
     val kind = Kind.values().first { it.shortName == name.take(2) }
     val version = name.dropWhile { !it.isDigit() }.toInt()

buildSrc/src/main/kotlin/localDependencies.kt

@@ -24,7 +24,9 @@ import org.gradle.api.artifacts.dsl.RepositoryHandler
 import org.gradle.api.artifacts.repositories.IvyArtifactRepository
 import org.gradle.api.tasks.JavaExec
 import org.gradle.api.tasks.TaskProvider
-import org.gradle.kotlin.dsl.*
+import org.gradle.kotlin.dsl.DependencyHandlerScope
+import org.gradle.kotlin.dsl.extra
+import org.gradle.kotlin.dsl.register
 import java.io.File
 
 private fun Project.kotlinBuildLocalDependenciesDir(): File =
@@ -171,6 +173,7 @@ fun Project.runIdeTask(name: String, ideaPluginDir: File, ideaSandboxDir: File,
             "-XX:ReservedCodeCacheSize=240m",
             "-XX:+HeapDumpOnOutOfMemoryError",
             "-ea",
+            "-Didea.platform.prefix=Idea",
             "-Didea.debug.mode=true",
             "-Didea.system.path=$ideaSandboxDir",
             "-Didea.config.path=$ideaSandboxConfigDir",

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

@@ -130,14 +130,13 @@ fun parse(project: Project, libraries: List<PLibrary>, context: ParserContext):
  */
 private val CONFIGURATION_MAPPING = mapOf(
     listOf("runtimeClasspath") to Scope.RUNTIME,
-    listOf("compile", "embedded") to Scope.COMPILE,
-    listOf("compileOnly") to Scope.PROVIDED
+    listOf("compileClasspath", "compileOnly") to Scope.PROVIDED,
+    listOf("embedded") to Scope.COMPILE
 )
 
 private val TEST_CONFIGURATION_MAPPING = mapOf(
     listOf("runtimeClasspath", "testRuntimeClasspath") to Scope.RUNTIME,
-    listOf("compile", "testCompile") to Scope.COMPILE,
-    listOf("compileOnly", "testCompileOnly") to Scope.PROVIDED,
+    listOf("compileClasspath", "testCompileClasspath", "compileOnly", "testCompileOnly") to Scope.PROVIDED,
     listOf("jpsTest") to Scope.TEST
 )
 

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

@@ -231,6 +231,7 @@ class JpsCompatiblePlugin : Plugin<Project> {
         val platformDirProjectRelative = "\$PROJECT_DIR\$/" + platformDir.toRelativeString(projectDir)
 
         val runManagerComponent = rootElement.getOrCreateChild("component", "name" to "RunManager")
+
         val junitConfiguration = runManagerComponent.getOrCreateChild(
             "configuration",
             "default" to "true",
@@ -238,7 +239,14 @@ class JpsCompatiblePlugin : Plugin<Project> {
             "factoryName" to "JUnit"
         )
 
-        junitConfiguration.apply {
+        val kotlinJunitConfiguration = runManagerComponent.getOrCreateChild(
+            "configuration",
+            "default" to "true",
+            "type" to "KotlinJUnit",
+            "factoryName" to "Kotlin JUnit"
+        )
+
+        fun Element.applyJUnitTemplate() {
             getOrCreateChild("option", "name" to "WORKING_DIRECTORY").setAttribute("value", "file://\$PROJECT_DIR\$")
             getOrCreateChild("option", "name" to "VM_PARAMETERS").also { vmParams ->
                 var options = vmParams.getAttributeValue("value", "")
@@ -251,18 +259,12 @@ class JpsCompatiblePlugin : Plugin<Project> {
                     options = if (value == null) optionsWithoutNewValue else (optionsWithoutNewValue + listOf("-D$name=$value"))
                 }
 
-                val robolectricClasspath = project.rootProject
-                    .project(":plugins:android-extensions-compiler")
-                    .configurations.getByName("robolectricClasspath")
-                    .files.joinToString(File.pathSeparator)
-
                 if (options.none { it == "-ea" }) {
                     options += "-ea"
                 }
 
                 addOrReplaceOptionValue("idea.home.path", platformDirProjectRelative)
                 addOrReplaceOptionValue("ideaSdk.androidPlugin.path", platformDirProjectRelative + "/plugins/android/lib")
-                addOrReplaceOptionValue("robolectric.classpath", robolectricClasspath)
                 addOrReplaceOptionValue("use.jps", "true")
                 addOrReplaceOptionValue("kotlinVersion", project.rootProject.extra["kotlinVersion"].toString())
 
@@ -281,6 +283,9 @@ class JpsCompatiblePlugin : Plugin<Project> {
             }
         }
 
+        junitConfiguration.applyJUnitTemplate()
+        kotlinJunitConfiguration.applyJUnitTemplate()
+
         val output = XMLOutputter().also {
             it.format = Format.getPrettyFormat().apply {
                 setEscapeStrategy { Verifier.isHighSurrogate(it) || it == '"' }

compiler/android-tests/build.gradle.kts

@@ -13,7 +13,10 @@ dependencies {
     compile(project(":kotlin-reflect"))
     compile(projectTests(":compiler:tests-common"))
     compile(commonDep("junit:junit"))
-    compileOnly(intellijDep()) { includeJars("openapi") }
+
+    Platform[193].orLower {
+        compileOnly(intellijDep()) { includeJars("openapi") }
+    }
 
     testCompile(project(":compiler:incremental-compilation-impl"))
     testCompile(project(":core:descriptors"))
@@ -21,7 +24,11 @@ dependencies {
     testCompile(project(":compiler:frontend.java"))
     testCompile(projectTests(":jps-plugin"))
     testCompile(commonDep("junit:junit"))
-    testCompile(intellijDep()) { includeJars("openapi", "util", "idea", "idea_rt", "groovy-all", rootProject = rootProject) }
+    Platform[193].orLower {
+        testCompile(intellijDep()) { includeJars("openapi", rootProject = rootProject) }
+    }
+
+    testCompile(intellijDep()) { includeJars("util", "idea", "idea_rt", "groovy-all", rootProject = rootProject) }
     Platform[191].orLower {
         testCompile(intellijDep()) { includeJars("jps-builders") }
     }

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

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

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

@@ -21,6 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
+import org.jetbrains.kotlin.config.JVMConfigurationKeys;
 import org.jetbrains.kotlin.config.JvmTarget;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.*;
@@ -87,17 +88,23 @@ public abstract class AnnotationCodegen {
     private final InnerClassConsumer innerClassConsumer;
     private final KotlinTypeMapper typeMapper;
     private final ModuleDescriptor module;
+    private final GenerationState state;
 
     private AnnotationCodegen(@NotNull InnerClassConsumer innerClassConsumer, @NotNull GenerationState state) {
         this.innerClassConsumer = innerClassConsumer;
         this.typeMapper = state.getTypeMapper();
         this.module = state.getModule();
+        this.state = state;
     }
 
     /**
      * @param returnType can be null if not applicable (e.g. {@code annotated} is a class)
      */
-    public void genAnnotations(@Nullable Annotated annotated, @Nullable Type returnType) {
+    public void genAnnotations(
+            @Nullable Annotated annotated,
+            @Nullable Type returnType,
+            @Nullable KotlinType typeForTypeAnnotations
+    ) {
         if (annotated == null) return;
 
         Set<String> annotationDescriptorsAlreadyPresent = new HashSet<>();
@@ -125,13 +132,14 @@ public abstract class AnnotationCodegen {
                 }
             }
 
-            String descriptor = genAnnotation(annotation);
+            String descriptor = genAnnotation(annotation, null, false);
             if (descriptor != null) {
                 annotationDescriptorsAlreadyPresent.add(descriptor);
             }
         }
 
         generateAdditionalAnnotations(annotated, returnType, annotationDescriptorsAlreadyPresent);
+        generateTypeAnnotations(annotated, typeForTypeAnnotations);
     }
 
     private void generateAdditionalAnnotations(
@@ -184,15 +192,17 @@ public abstract class AnnotationCodegen {
     }
 
     private static boolean isInvisibleFromTheOutside(@Nullable DeclarationDescriptor descriptor) {
-        if (descriptor instanceof CallableMemberDescriptor && KotlinTypeMapper.isAccessor((CallableMemberDescriptor) descriptor)) {
-            return true;
-        }
+        if (isAccessor(descriptor)) return true;
         if (descriptor instanceof MemberDescriptor) {
             return AsmUtil.getVisibilityAccessFlag((MemberDescriptor) descriptor) == Opcodes.ACC_PRIVATE;
         }
         return false;
     }
 
+    private static boolean isAccessor(@Nullable Annotated descriptor) {
+        return descriptor instanceof CallableMemberDescriptor && KotlinTypeMapper.isAccessor((CallableMemberDescriptor) descriptor);
+    }
+
     private void generateNullabilityAnnotation(@Nullable KotlinType type, @NotNull Set<String> annotationDescriptorsAlreadyPresent) {
         if (type == null) return;
 
@@ -321,7 +331,11 @@ public abstract class AnnotationCodegen {
     }
 
     @Nullable
-    private String genAnnotation(@NotNull AnnotationDescriptor annotationDescriptor) {
+    private String genAnnotation(
+            @NotNull AnnotationDescriptor annotationDescriptor,
+            @Nullable TypePath path,
+            boolean isTypeAnnotation
+    ) {
         ClassDescriptor classDescriptor = getAnnotationClass(annotationDescriptor);
         assert classDescriptor != null : "Annotation descriptor has no class: " + annotationDescriptor;
         RetentionPolicy rp = getRetentionPolicy(classDescriptor);
@@ -339,7 +353,9 @@ public abstract class AnnotationCodegen {
         innerClassConsumer.addInnerClassInfoFromAnnotation(classDescriptor);
 
         String asmTypeDescriptor = typeMapper.mapType(annotationDescriptor.getType()).getDescriptor();
-        AnnotationVisitor annotationVisitor = visitAnnotation(asmTypeDescriptor, rp == RetentionPolicy.RUNTIME);
+        AnnotationVisitor annotationVisitor = isTypeAnnotation
+                                              ? visitTypeAnnotation(asmTypeDescriptor, path, rp == RetentionPolicy.RUNTIME)
+                                              : visitAnnotation(asmTypeDescriptor, rp == RetentionPolicy.RUNTIME);
 
         genAnnotationArguments(annotationDescriptor, annotationVisitor);
         annotationVisitor.visitEnd();
@@ -552,6 +568,11 @@ public abstract class AnnotationCodegen {
     @NotNull
     abstract AnnotationVisitor visitAnnotation(String descr, boolean visible);
 
+    @NotNull
+    AnnotationVisitor visitTypeAnnotation(String descr, TypePath path, boolean visible) {
+        throw new RuntimeException("Not implemented");
+    }
+
     public static AnnotationCodegen forClass(
             @NotNull ClassVisitor cv,
             @NotNull InnerClassConsumer innerClassConsumer,
@@ -577,6 +598,12 @@ public abstract class AnnotationCodegen {
             AnnotationVisitor visitAnnotation(String descr, boolean visible) {
                 return safe(mv.visitAnnotation(descr, visible));
             }
+
+            @NotNull
+            @Override
+            AnnotationVisitor visitTypeAnnotation(String descr, TypePath path, boolean visible) {
+                return safe(mv.visitTypeAnnotation(TypeReference.newTypeReference(TypeReference.METHOD_RETURN).getValue(), path, descr, visible));
+            }
         };
     }
 
@@ -591,6 +618,12 @@ public abstract class AnnotationCodegen {
             AnnotationVisitor visitAnnotation(String descr, boolean visible) {
                 return safe(fv.visitAnnotation(descr, visible));
             }
+
+            @NotNull
+            @Override
+            AnnotationVisitor visitTypeAnnotation(String descr, TypePath path, boolean visible) {
+                return safe(fv.visitTypeAnnotation(TypeReference.newTypeReference(TypeReference.FIELD).getValue(), path, descr, visible));
+            }
         };
     }
 
@@ -606,6 +639,12 @@ public abstract class AnnotationCodegen {
             AnnotationVisitor visitAnnotation(String descr, boolean visible) {
                 return safe(mv.visitParameterAnnotation(parameter, descr, visible));
             }
+
+            @NotNull
+            @Override
+            AnnotationVisitor visitTypeAnnotation(String descr, TypePath path, boolean visible) {
+                return safe(mv.visitTypeAnnotation(TypeReference.newFormalParameterReference(parameter).getValue(), path, descr, visible));
+            }
         };
     }
 
@@ -627,4 +666,22 @@ public abstract class AnnotationCodegen {
     private static AnnotationVisitor safe(@Nullable AnnotationVisitor av) {
         return av == null ? NO_ANNOTATION_VISITOR : av;
     }
+
+    private void generateTypeAnnotations(@NotNull Annotated annotated, @Nullable KotlinType type) {
+        if (isAccessor(annotated) ||
+            type == null ||
+            state.getTarget() == JvmTarget.JVM_1_6 ||
+            !state.getConfiguration().getBoolean(JVMConfigurationKeys.EMIT_JVM_TYPE_ANNOTATIONS)) {
+            return;
+        }
+
+        Iterable<TypePathInfo> infos =
+                new TypeAnnotationCollector().collectTypeAnnotations(type, TypeReference.METHOD_FORMAL_PARAMETER);
+        for (TypePathInfo info : infos) {
+            for (AnnotationDescriptor annotationDescriptor : info.getAnnotations()) {
+                genAnnotation(annotationDescriptor, info.getPath(), true);
+            }
+        }
+    }
+
 }

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

@@ -150,7 +150,11 @@ class DefaultParameterValueSubstitutor(val state: GenerationState) {
             FunctionCodegen.getThrownExceptions(functionDescriptor, typeMapper)
         )
 
-        AnnotationCodegen.forMethod(mv, memberCodegen, state).genAnnotations(functionDescriptor, signature.returnType)
+        AnnotationCodegen.forMethod(mv, memberCodegen, state).genAnnotations(
+            functionDescriptor,
+            signature.returnType,
+            functionDescriptor.returnType
+        )
 
         if (state.classBuilderMode == ClassBuilderMode.KAPT3) {
             mv.visitAnnotation(ANNOTATION_TYPE_DESCRIPTOR_FOR_JVM_OVERLOADS_GENERATED_METHODS, false)

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

@@ -4495,10 +4495,16 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         // We can use the $$delegatedProperties array as in non-inline functions and upon inlining, detect elements at what indices
         // of that array are used in the inline function body, load the corresponding initializing bytecode from <clinit> of the
         // container class (where the PropertyReferenceNImpl instance is created), copy and adapt it at the call site
-        //noinspection ConstantConditions
-        StackValue value = context.getFunctionDescriptor().isInline()
-                           ? generatePropertyReference(variable.getDelegate(), variableDescriptor, variableDescriptor, null)
-                           : PropertyCodegen.getDelegatedPropertyMetadata(variableDescriptor, bindingContext);
+        StackValue value;
+        if (PropertyCodegen.isDelegatedPropertyWithOptimizedMetadata(variableDescriptor, bindingContext)) {
+            value = PropertyCodegen.getOptimizedDelegatedPropertyMetadataValue();
+        } else if (context.getFunctionDescriptor().isInline()) {
+            //noinspection ConstantConditions
+            value = generatePropertyReference(variable.getDelegate(), variableDescriptor, variableDescriptor, null);
+        }
+        else {
+            value = PropertyCodegen.getDelegatedPropertyMetadata(variableDescriptor, bindingContext);
+        }
         value.put(K_PROPERTY_TYPE, null, v);
         metadataVar.storeSelector(K_PROPERTY_TYPE, null, v);
     }

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

@@ -26,7 +26,6 @@ import org.jetbrains.kotlin.codegen.state.TypeMapperUtilsKt;
 import org.jetbrains.kotlin.config.JvmDefaultMode;
 import org.jetbrains.kotlin.config.LanguageFeature;
 import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.descriptors.annotations.Annotated;
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor;
 import org.jetbrains.kotlin.load.java.BuiltinMethodsWithSpecialGenericSignature;
@@ -56,7 +55,10 @@ import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterSignature
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature;
 import org.jetbrains.kotlin.types.KotlinType;
 import org.jetbrains.kotlin.types.TypeUtils;
-import org.jetbrains.org.objectweb.asm.*;
+import org.jetbrains.org.objectweb.asm.Label;
+import org.jetbrains.org.objectweb.asm.MethodVisitor;
+import org.jetbrains.org.objectweb.asm.Opcodes;
+import org.jetbrains.org.objectweb.asm.Type;
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
 import org.jetbrains.org.objectweb.asm.commons.Method;
 import org.jetbrains.org.objectweb.asm.util.TraceMethodVisitor;
@@ -301,7 +303,9 @@ public class FunctionCodegen {
             annotationsOwner = functionDescriptor;
         }
 
-        AnnotationCodegen.forMethod(mv, memberCodegen, state).genAnnotations(annotationsOwner, asmMethod.getReturnType());
+        AnnotationCodegen.forMethod(mv, memberCodegen, state)
+                .genAnnotations(annotationsOwner, asmMethod.getReturnType(), functionDescriptor.getReturnType());
+
         generateParameterAnnotations(annotationsOwner, mv, jvmSignature, memberCodegen, state);
     }
 
@@ -531,7 +535,7 @@ public class FunctionCodegen {
                 continue;
             }
 
-            Annotated annotated =
+            ParameterDescriptor annotated =
                     kind == JvmMethodParameterKind.VALUE
                     ? iterator.next()
                     : kind == JvmMethodParameterKind.RECEIVER
@@ -540,8 +544,9 @@ public class FunctionCodegen {
 
             if (annotated != null) {
                 //noinspection ConstantConditions
-                AnnotationCodegen.forParameter(i - syntheticParameterCount, mv, innerClassConsumer, state)
-                        .genAnnotations(annotated, parameterSignature.getAsmType());
+                int parameterIndex = i - syntheticParameterCount;
+                AnnotationCodegen.forParameter(parameterIndex, mv, innerClassConsumer, state)
+                        .genAnnotations(annotated, parameterSignature.getAsmType(), annotated.getReturnType());
             }
         }
     }

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

@@ -232,7 +232,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
         writeEnclosingMethod();
 
-        AnnotationCodegen.forClass(v.getVisitor(), this, state).genAnnotations(descriptor, null);
+        AnnotationCodegen.forClass(v.getVisitor(), this, state).genAnnotations(descriptor, null, null);
 
         generateEnumEntries();
     }
@@ -905,7 +905,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
                                          type.getDescriptor(), typeMapper.mapFieldSignature(property.getType(), property),
                                          info.defaultValue);
 
-            AnnotationCodegen.forField(fv, this, state).genAnnotations(property, type);
+            AnnotationCodegen.forField(fv, this, state).genAnnotations(property, type, null);
 
             //This field are always static and final so if it has constant initializer don't do anything in clinit,
             //field would be initialized via default value in v.newField(...) - see JVM SPEC Ch.4
@@ -1087,7 +1087,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
             int isDeprecated = KotlinBuiltIns.isDeprecated(descriptor) ? ACC_DEPRECATED : 0;
             FieldVisitor fv = v.newField(JvmDeclarationOriginKt.OtherOrigin(enumEntry, descriptor), ACC_PUBLIC | ACC_ENUM | ACC_STATIC | ACC_FINAL | isDeprecated,
                                          descriptor.getName().asString(), classAsmType.getDescriptor(), null, null);
-            AnnotationCodegen.forField(fv, this, state).genAnnotations(descriptor, null);
+            AnnotationCodegen.forField(fv, this, state).genAnnotations(descriptor, null, null);
         }
 
         initializeEnumConstants(enumEntries);

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

@@ -261,7 +261,7 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
         int flags = ACC_DEPRECATED | ACC_STATIC | ACC_SYNTHETIC | AsmUtil.getVisibilityAccessFlag(descriptor);
         MethodVisitor mv = v.newMethod(JvmDeclarationOriginKt.OtherOrigin(descriptor), flags, syntheticMethod.getName(),
                                        syntheticMethod.getDescriptor(), null, null);
-        AnnotationCodegen.forMethod(mv, this, state).genAnnotations(new AnnotatedImpl(annotations), Type.VOID_TYPE);
+        AnnotationCodegen.forMethod(mv, this, state).genAnnotations(new AnnotatedImpl(annotations), Type.VOID_TYPE, null);
         mv.visitCode();
         mv.visitInsn(Opcodes.RETURN);
         mv.visitEnd();

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

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.codegen;
 
+import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.progress.ProcessCanceledException;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.util.SmartList;
@@ -37,6 +38,7 @@ import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.checkers.ExpectedActualDeclarationChecker;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKt;
 import org.jetbrains.kotlin.resolve.lazy.descriptors.PackageDescriptorUtilKt;
+import org.jetbrains.kotlin.utils.KotlinExceptionWithAttachments;
 import org.jetbrains.org.objectweb.asm.Type;
 
 import java.util.ArrayList;
@@ -44,6 +46,8 @@ import java.util.Collection;
 import java.util.List;
 
 public class PackageCodegenImpl implements PackageCodegen {
+    private static final Logger LOG = Logger.getInstance(PackageCodegenImpl.class);
+
     private final GenerationState state;
     private final Collection<KtFile> files;
     private final PackageFragmentDescriptor packageFragment;
@@ -147,10 +151,13 @@ public class PackageCodegenImpl implements PackageCodegen {
         for (KtFile file : files) {
             PackageFragmentDescriptor fragment =
                     PackageDescriptorUtilKt.findPackageFragmentForFile(state.getModule(), file);
-            assert fragment != null : "package fragment is null for " + file + "\n" + file.getText();
-
-            assert expectedPackageFqName.equals(fragment.getFqName()) :
-                    "expected package fq name: " + expectedPackageFqName + ", actual: " + fragment.getFqName();
+            if (fragment == null) {
+                LOG.error(new KotlinExceptionWithAttachments(
+                        "package fragment is not found for module:" + state.getModule() + " file:" + file)
+                        .withAttachment("file.kt", file.getText()));
+            } else if (!expectedPackageFqName.equals(fragment.getFqName())) {
+                LOG.error("expected package fq name: " + expectedPackageFqName + ", actual: " + fragment.getFqName());
+            }
 
             if (!fragments.contains(fragment)) {
                 fragments.add(fragment);

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

@@ -86,7 +86,7 @@ public class PackagePartCodegen extends MemberCodegen<KtFile> {
             }
         }
         Annotated annotatedFile = new AnnotatedImpl(Annotations.Companion.create(fileAnnotationDescriptors));
-        AnnotationCodegen.forClass(v.getVisitor(), this, state).genAnnotations(annotatedFile, null);
+        AnnotationCodegen.forClass(v.getVisitor(), this, state).genAnnotations(annotatedFile, null, null);
     }
 
     @Override

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

@@ -270,7 +270,7 @@ public class PropertyCodegen {
         PropertyGetterDescriptor getter = descriptor.getGetter();
         assert getter != null : "Annotation property should have a getter: " + descriptor;
         v.getSerializationBindings().put(METHOD_FOR_FUNCTION, getter, asmMethod);
-        AnnotationCodegen.forMethod(mv, memberCodegen, state).genAnnotations(getter, asmMethod.getReturnType());
+        AnnotationCodegen.forMethod(mv, memberCodegen, state).genAnnotations(getter, asmMethod.getReturnType(), null);
 
         KtExpression defaultValue = loadAnnotationArgumentDefaultValue(parameter, descriptor, expectedAnnotationConstructor);
         if (defaultValue != null) {
@@ -417,7 +417,8 @@ public class PropertyCodegen {
             );
 
             if (annotatedField != null) {
-                AnnotationCodegen.forField(fv, memberCodegen, state).genAnnotations(annotatedField, type);
+                AnnotationCodegen.forField(fv, memberCodegen, state)
+                        .genAnnotations(annotatedField, type, propertyDescriptor.getType());
             }
         }
     }
@@ -563,13 +564,24 @@ public class PropertyCodegen {
         return codegen.invokeFunction(resolvedCall, receiver);
     }
 
+    public static boolean isDelegatedPropertyWithOptimizedMetadata(
+            @NotNull VariableDescriptorWithAccessors descriptor,
+            @NotNull BindingContext bindingContext
+    ) {
+        return Boolean.TRUE == bindingContext.get(DELEGATED_PROPERTY_WITH_OPTIMIZED_METADATA, descriptor);
+    }
+
+    public static @NotNull StackValue getOptimizedDelegatedPropertyMetadataValue() {
+        return StackValue.constant(null, K_PROPERTY_TYPE);
+    }
+
     @NotNull
     public static StackValue getDelegatedPropertyMetadata(
             @NotNull VariableDescriptorWithAccessors descriptor,
             @NotNull BindingContext bindingContext
     ) {
-        if (Boolean.TRUE == bindingContext.get(DELEGATED_PROPERTY_WITH_OPTIMIZED_METADATA, descriptor)) {
-            return StackValue.constant(null, K_PROPERTY_TYPE);
+        if (isDelegatedPropertyWithOptimizedMetadata(descriptor, bindingContext)) {
+            return getOptimizedDelegatedPropertyMetadataValue();
         }
 
         Type owner = bindingContext.get(DELEGATED_PROPERTY_METADATA_OWNER, descriptor);

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

@@ -51,7 +51,7 @@ class ScriptCodegen private constructor(
                     typeMapper.mapSupertype(it.defaultType, null).internalName
                 }.toTypedArray()
         )
-        AnnotationCodegen.forClass(v.visitor, this, state).genAnnotations(scriptDescriptor, null)
+        AnnotationCodegen.forClass(v.visitor, this, state).genAnnotations(scriptDescriptor, null, null)
     }
 
     override fun generateBody() {
@@ -99,7 +99,8 @@ class ScriptCodegen private constructor(
                 OtherOrigin(scriptDeclaration, scriptDescriptor.unsubstitutedPrimaryConstructor),
                 ACC_PUBLIC, jvmSignature.asmMethod.name, jvmSignature.asmMethod.descriptor, null, null)
 
-        AnnotationCodegen.forMethod(mv, this, state).genAnnotations(scriptDescriptor.unsubstitutedPrimaryConstructor, asmMethod.returnType)
+        AnnotationCodegen.forMethod(mv, this, state)
+            .genAnnotations(scriptDescriptor.unsubstitutedPrimaryConstructor, asmMethod.returnType, null)
 
         if (state.classBuilderMode.generateBodies) {
             mv.visitCode()

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

@@ -797,7 +797,7 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
 
             if (valueArgument == null || newResolvedCall.getExpectedTypeForSamConvertedArgument(valueArgument) == null) continue;
 
-            valueParametersWithSAMConversion.add(valueParameter.getOriginal());
+            valueParametersWithSAMConversion.add(valueParameter);
         }
         writeSamValueForValueParameters(valueParametersWithSAMConversion, newResolvedCall.getValueArgumentsByIndex());
 

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

@@ -475,7 +475,8 @@ class CoroutineCodegenForLambda private constructor(
                         shouldPreserveClassInitialization = constructorCallNormalizationMode.shouldPreserveClassInitialization,
                         containingClassInternalName = v.thisName,
                         isForNamedFunction = false,
-                        languageVersionSettings = languageVersionSettings
+                        languageVersionSettings = languageVersionSettings,
+                        disableTailCallOptimizationForFunctionReturningUnit = false
                     )
                     return if (forInline) AddEndLabelMethodVisitor(
                         MethodNodeCopyingMethodVisitor(

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

@@ -63,6 +63,10 @@ class CoroutineTransformerMethodVisitor(
     // These two are needed to report diagnostics about suspension points inside critical section
     private val element: KtElement,
     private val diagnostics: DiagnosticSink,
+    // Since tail-call optimization of functions with Unit return type relies on ability of call-site to recognize them,
+    // in order to ignore return value and push Unit, when we cannot ensure this ability, for example, when the function overrides function,
+    // returning Any, we need to disable tail-call optimization for these functions.
+    private val disableTailCallOptimizationForFunctionReturningUnit: Boolean,
     // It's only matters for named functions, may differ from '!isStatic(access)' in case of DefaultImpls
     private val needDispatchReceiver: Boolean = false,
     // May differ from containingClassInternalName in case of DefaultImpls
@@ -111,7 +115,8 @@ class CoroutineTransformerMethodVisitor(
             val examiner = MethodNodeExaminer(
                 languageVersionSettings,
                 containingClassInternalName,
-                methodNode
+                methodNode,
+                disableTailCallOptimizationForFunctionReturningUnit
             )
             if (examiner.allSuspensionPointsAreTailCalls(suspensionPoints)) {
                 examiner.replacePopsBeforeSafeUnitInstancesWithCoroutineSuspendedChecks()
@@ -899,7 +904,8 @@ class CoroutineTransformerMethodVisitor(
 private class MethodNodeExaminer(
     val languageVersionSettings: LanguageVersionSettings,
     val containingClassInternalName: String,
-    val methodNode: MethodNode
+    val methodNode: MethodNode,
+    disableTailCallOptimizationForFunctionReturningUnit: Boolean
 ) {
     private val sourceFrames: Array<Frame<SourceValue>?> =
         MethodTransformer.analyze(containingClassInternalName, methodNode, IgnoringCopyOperationSourceInterpreter())
@@ -912,25 +918,27 @@ private class MethodNodeExaminer(
     private val meaningfulPredecessorsCache = hashMapOf<AbstractInsnNode, List<AbstractInsnNode>>()
 
     init {
-        // retrieve all POP insns
-        val pops = methodNode.instructions.asSequence().filter { it.opcode == Opcodes.POP }
-        // for each of them check that all successors are PUSH Unit
-        val popsBeforeUnitInstances = pops.map { it to it.meaningfulSuccessors() }
-            .filter { (_, succs) -> succs.all { it.isUnitInstance() } }
-            .map { it.first }.toList()
-        for (pop in popsBeforeUnitInstances) {
-            val units = pop.meaningfulSuccessors()
-            val allUnitsAreSafe = units.all { unit ->
-                // check no other predecessor exists
-                unit.meaningfulPredecessors().all { it in popsBeforeUnitInstances } &&
-                        // check they have only returns among successors
-                        unit.meaningfulSuccessors().all { it.opcode == Opcodes.ARETURN }
+        if (!disableTailCallOptimizationForFunctionReturningUnit) {
+            // retrieve all POP insns
+            val pops = methodNode.instructions.asSequence().filter { it.opcode == Opcodes.POP }
+            // for each of them check that all successors are PUSH Unit
+            val popsBeforeUnitInstances = pops.map { it to it.meaningfulSuccessors() }
+                .filter { (_, succs) -> succs.all { it.isUnitInstance() } }
+                .map { it.first }.toList()
+            for (pop in popsBeforeUnitInstances) {
+                val units = pop.meaningfulSuccessors()
+                val allUnitsAreSafe = units.all { unit ->
+                    // check no other predecessor exists
+                    unit.meaningfulPredecessors().all { it in popsBeforeUnitInstances } &&
+                            // check they have only returns among successors
+                            unit.meaningfulSuccessors().all { it.opcode == Opcodes.ARETURN }
+                }
+                if (!allUnitsAreSafe) continue
+                // save them all to the properties
+                popsBeforeSafeUnitInstances += pop
+                safeUnitInstances += units
+                units.flatMapTo(areturnsAfterSafeUnitInstances) { it.meaningfulSuccessors() }
             }
-            if (!allUnitsAreSafe) continue
-            // save them all to the properties
-            popsBeforeSafeUnitInstances += pop
-            safeUnitInstances += units
-            units.flatMapTo(areturnsAfterSafeUnitInstances) { it.meaningfulSuccessors() }
         }
     }
 

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

@@ -19,6 +19,7 @@ import org.jetbrains.kotlin.psi.KtFunction
 import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.OtherOrigin
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
+import org.jetbrains.kotlin.types.typeUtil.isUnit
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 import org.jetbrains.kotlin.utils.sure
 import org.jetbrains.org.objectweb.asm.MethodVisitor
@@ -100,10 +101,27 @@ open class SuspendFunctionGenerationStrategy(
             shouldPreserveClassInitialization = constructorCallNormalizationMode.shouldPreserveClassInitialization,
             needDispatchReceiver = originalSuspendDescriptor.dispatchReceiverParameter != null,
             internalNameForDispatchReceiver = containingClassInternalNameOrNull(),
-            languageVersionSettings = languageVersionSettings
+            languageVersionSettings = languageVersionSettings,
+            disableTailCallOptimizationForFunctionReturningUnit = originalSuspendDescriptor.returnType?.isUnit() == true &&
+                    originalSuspendDescriptor.overriddenDescriptors.isNotEmpty() &&
+                    !originalSuspendDescriptor.allOverriddenFunctionsReturnUnit()
         )
     }
 
+    private fun FunctionDescriptor.allOverriddenFunctionsReturnUnit(): Boolean {
+        val visited = mutableSetOf<FunctionDescriptor>()
+
+        fun bfs(descriptor: FunctionDescriptor): Boolean {
+            if (!visited.add(descriptor)) return true
+            if (descriptor.original.returnType?.isUnit() != true) return false
+            for (parent in descriptor.overriddenDescriptors) {
+                if (!bfs(parent)) return false
+            }
+            return true
+        }
+        return bfs(this)
+    }
+
     private fun containingClassInternalNameOrNull() =
         originalSuspendDescriptor.containingDeclaration.safeAs<ClassDescriptor>()?.let(state.typeMapper::mapClass)?.internalName
 

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

@@ -253,11 +253,7 @@ class AnonymousObjectTransformer(
         // Since $$forInline functions are not generated if retransformation is the last one (i.e. call site is not inline)
         // link to the function in OUTERCLASS field becomes invalid. However, since $$forInline function always has no-inline
         // companion without the suffix, use it.
-        if (info.isSuspend && info.isInlineOrInsideInline) {
-            visitor.visitOuterClass(info.ownerClassName, info.functionName?.removeSuffix(FOR_INLINE_SUFFIX), info.functionDesc)
-        } else {
-            visitor.visitOuterClass(info.ownerClassName, info.functionName, info.functionDesc)
-        }
+        visitor.visitOuterClass(info.ownerClassName, info.functionName?.removeSuffix(FOR_INLINE_SUFFIX), info.functionDesc)
     }
 
     private fun inlineMethodAndUpdateGlobalResult(

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

@@ -222,7 +222,11 @@ class ReifiedTypeInliner<KT : KotlinTypeMarker>(
         generateAsCast(InstructionAdapter(newMethodNode), kotlinType, asmType, safe, languageVersionSettings)
 
         instructions.insert(insn, newMethodNode.instructions)
-        instructions.remove(stubCheckcast)
+        // Keep stubCheckcast to avoid VerifyErrors on 1.8+ bytecode,
+        // it's safe to remove cast to Object as FrameMap will use it as default value for merged branches
+        if (stubCheckcast.desc == AsmTypes.OBJECT_TYPE.internalName) {
+            instructions.remove(stubCheckcast)
+        }
 
         // TODO: refine max stack calculation (it's not always as big as +4)
         maxStackSize = max(maxStackSize, 4)

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/coroutines/CoroutineTransformer.kt

@@ -17,11 +17,20 @@ import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
 import org.jetbrains.kotlin.config.isReleaseCoroutines
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.load.java.JvmAnnotationNames
+import org.jetbrains.kotlin.load.kotlin.FileBasedKotlinClass
+import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader
+import org.jetbrains.kotlin.load.kotlin.header.ReadKotlinClassHeaderAnnotationVisitor
+import org.jetbrains.kotlin.metadata.ProtoBuf
+import org.jetbrains.kotlin.metadata.deserialization.*
+import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmProtoBufUtil
+import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
+import org.jetbrains.kotlin.serialization.deserialization.getClassId
+import org.jetbrains.kotlin.serialization.deserialization.getName
 import org.jetbrains.kotlin.utils.addToStdlib.cast
-import org.jetbrains.org.objectweb.asm.MethodVisitor
-import org.jetbrains.org.objectweb.asm.Opcodes
+import org.jetbrains.org.objectweb.asm.*
 import org.jetbrains.org.objectweb.asm.tree.*
 import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
 import org.jetbrains.org.objectweb.asm.tree.analysis.SourceInterpreter
@@ -108,7 +117,8 @@ class CoroutineTransformer(
                     languageVersionSettings = state.languageVersionSettings,
                     shouldPreserveClassInitialization = state.constructorCallNormalizationMode.shouldPreserveClassInitialization,
                     containingClassInternalName = classBuilder.thisName,
-                    isForNamedFunction = false
+                    isForNamedFunction = false,
+                    disableTailCallOptimizationForFunctionReturningUnit = false
                 )
             )
 
@@ -137,6 +147,8 @@ class CoroutineTransformer(
                 ArrayUtil.toStringArray(node.exceptions)
             )
         ) {
+            // If the node already has state-machine, it is safer to generate state-machine.
+            val disableTailCallOptimization = methods.find { it.name == name && it.desc == node.desc }?.let { isStateMachine(it) } ?: false
             val stateMachineBuilder = surroundNoinlineCallsWithMarkers(
                 node,
                 CoroutineTransformerMethodVisitor(
@@ -149,7 +161,8 @@ class CoroutineTransformer(
                     containingClassInternalName = classBuilder.thisName,
                     isForNamedFunction = true,
                     needDispatchReceiver = true,
-                    internalNameForDispatchReceiver = classBuilder.thisName
+                    internalNameForDispatchReceiver = classBuilder.thisName,
+                    disableTailCallOptimizationForFunctionReturningUnit = disableTailCallOptimization
                 )
             )
 

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

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.codegen
+
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
+import org.jetbrains.kotlin.load.kotlin.FileBasedKotlinClass
+import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinarySourceElement
+import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedClassDescriptor
+import org.jetbrains.kotlin.types.*
+import org.jetbrains.org.objectweb.asm.Opcodes
+import org.jetbrains.org.objectweb.asm.TypePath
+
+
+class TypePathInfo(
+    val path: TypePath?,
+    val annotations: List<AnnotationDescriptor>
+)
+
+private class State(val type: Int, val path: MutableList<String>) {
+
+    val results = arrayListOf<TypePathInfo>()
+
+
+    fun addStep(step: String) {
+        path.add(step)
+    }
+
+    fun removeStep(step: String) {
+        path.removeAt(path.lastIndex)
+    }
+
+    fun rememberAnnotations(annotations: List<AnnotationDescriptor>) {
+        results.add(TypePathInfo(TypePath.fromString(path.joinToString("")), annotations))
+    }
+}
+
+class TypeAnnotationCollector {
+
+    private lateinit var state: State
+
+    fun collectTypeAnnotations(kotlinType: KotlinType, annotationType: Int): ArrayList<TypePathInfo> {
+        state = State(annotationType, arrayListOf())
+        kotlinType.collectTypeAnnotations()
+        return state.results
+    }
+
+    private fun KotlinType.collectTypeAnnotations() {
+        if (isFlexible()) {
+            return upperIfFlexible().collectTypeAnnotations()
+        } else if ((this.constructor.declarationDescriptor as? ClassDescriptor)?.isInner == true) {
+            //skip inner classes for now it's not clear should type annotations on outer be supported or not
+            return
+        }
+
+        typeAnnotations.takeIf { it.isNotEmpty() }?.let { state.rememberAnnotations(it) }
+
+        arguments.forEachIndexed { index, type ->
+            //skip in/out variance for now it's not clear should type annotations on wildcard bound be supported or not
+            if (type.projectionKind == Variance.INVARIANT) {
+                when {
+                    KotlinBuiltIns.isArray(this) -> type.type.process("[")
+                    else -> type.type.process("$index;")
+                }
+            }
+        }
+    }
+
+    fun KotlinType.process(step: String) {
+        state.addStep(step)
+        this.collectTypeAnnotations()
+        state.removeStep(step)
+    }
+
+
+    private val KotlinType.typeAnnotations
+        get() = annotations.filter {
+            //We only generate annotations which have the TYPE_USE Java target.
+            // Those are type annotations which were compiled with JVM target bytecode version 1.8 or greater
+            (it.annotationClass as? DeserializedClassDescriptor)?.let { classDescriptor ->
+                ((classDescriptor.source as? KotlinJvmBinarySourceElement)?.binaryClass as? FileBasedKotlinClass)?.classVersion ?: 0 >= Opcodes.V1_8
+            } ?: true
+        }
+
+}

compiler/build.gradle.kts

@@ -67,7 +67,10 @@ dependencies {
         testCompileOnly(project(it))
     }
     testCompileOnly(intellijCoreDep()) { includeJars("intellij-core") }
-    testCompileOnly(intellijDep()) { includeJars("openapi", "idea", "idea_rt", "util", "asm-all", rootProject = rootProject) }
+    Platform[193].orLower {
+        testCompileOnly(intellijDep()) { includeJars("openapi", rootProject = rootProject) }
+    }
+    testCompileOnly(intellijDep()) { includeJars("idea", "idea_rt", "util", "asm-all", rootProject = rootProject) }
 
     Platform[192].orHigher {
         testRuntimeOnly(intellijPluginDep("java"))

compiler/cli/build.gradle.kts

@@ -24,6 +24,10 @@ dependencies {
     compile(project(":compiler:fir:resolve"))
     compile(project(":compiler:fir:java"))
     compile(project(":compiler:fir:fir2ir"))
+    compile(project(":kotlin-util-klib"))
+    compile(project(":kotlin-util-io"))
+    compile(project(":compiler:ir.serialization.common"))
+
     compile(toolsJar())
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
     compileOnly(intellijDep()) { includeIntellijCoreJarDependencies(project) }

compiler/cli/cli-common/src/org/jetbrains/kotlin/analyzer/common/CommonResolverForModuleFactory.kt

@@ -17,10 +17,8 @@
 package org.jetbrains.kotlin.analyzer.common
 
 import com.intellij.openapi.components.ServiceManager
-import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analyzer.*
-import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.container.StorageComponentContainer
@@ -30,6 +28,7 @@ import org.jetbrains.kotlin.container.useInstance
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.context.ProjectContext
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.frontend.di.configureModule
@@ -38,7 +37,6 @@ import org.jetbrains.kotlin.load.kotlin.MetadataFinderFactory
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.CommonPlatforms
 import org.jetbrains.kotlin.platform.TargetPlatform
-import org.jetbrains.kotlin.platform.TargetPlatformVersion
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.checkers.ExpectedActualDeclarationChecker
@@ -60,14 +58,20 @@ class CommonResolverForModuleFactory(
     private val platformParameters: CommonAnalysisParameters,
     private val targetEnvironment: TargetEnvironment,
     private val targetPlatform: TargetPlatform,
-    private val shouldCheckExpectActual: Boolean
+    private val shouldCheckExpectActual: Boolean,
+    private val commonDependenciesContainer: CommonDependenciesContainer? = null
 ) : ResolverForModuleFactory() {
     private class SourceModuleInfo(
         override val name: Name,
         override val capabilities: Map<ModuleDescriptor.Capability<*>, Any?>,
+        private val dependencies: Iterable<ModuleInfo>,
+        override val expectedBy: List<ModuleInfo>,
+        private val modulesWhoseInternalsAreVisible: Collection<ModuleInfo>,
         private val dependOnOldBuiltIns: Boolean
     ) : ModuleInfo {
-        override fun dependencies() = listOf(this)
+        override fun dependencies() = listOf(this, *dependencies.toList().toTypedArray() )
+
+        override fun modulesWhoseInternalsAreVisible(): Collection<ModuleInfo> = modulesWhoseInternalsAreVisible
 
         override fun dependencyOnBuiltIns(): ModuleInfo.DependencyOnBuiltIns =
             if (dependOnOldBuiltIns) ModuleInfo.DependencyOnBuiltIns.LAST else ModuleInfo.DependencyOnBuiltIns.NONE
@@ -101,10 +105,13 @@ class CommonResolverForModuleFactory(
             languageVersionSettings, CommonPlatforms.defaultCommonPlatform, CommonPlatformAnalyzerServices, shouldCheckExpectActual
         )
 
-        val packageFragmentProviders = listOf(
-            container.get<ResolveSession>().packageFragmentProvider,
-            container.get<MetadataPackageFragmentProvider>()
-        )
+        val packageFragmentProviders =
+            /** If this is a dependency module that [commonDependenciesContainer] knows about, get the package fragments from there */
+            commonDependenciesContainer?.packageFragmentProviderForModuleInfo(moduleInfo)?.let(::listOf)
+                ?: listOf(
+                    container.get<ResolveSession>().packageFragmentProvider,
+                    container.get<MetadataPackageFragmentProvider>()
+                )
 
         return ResolverForModule(CompositePackageFragmentProvider(packageFragmentProviders), container)
     }
@@ -113,9 +120,17 @@ class CommonResolverForModuleFactory(
         fun analyzeFiles(
             files: Collection<KtFile>, moduleName: Name, dependOnBuiltIns: Boolean, languageVersionSettings: LanguageVersionSettings,
             capabilities: Map<ModuleDescriptor.Capability<*>, Any?> = emptyMap(),
+            dependenciesContainer: CommonDependenciesContainer? = null,
             metadataPartProviderFactory: (ModuleContent<ModuleInfo>) -> MetadataPartProvider
         ): AnalysisResult {
-            val moduleInfo = SourceModuleInfo(moduleName, capabilities, dependOnBuiltIns)
+            val moduleInfo = SourceModuleInfo(
+                moduleName,
+                capabilities,
+                dependenciesContainer?.moduleInfos?.toList().orEmpty(),
+                dependenciesContainer?.refinesModuleInfos.orEmpty(),
+                dependenciesContainer?.friendModuleInfos.orEmpty(),
+                dependOnBuiltIns
+            )
             val project = files.firstOrNull()?.project ?: throw AssertionError("No files to analyze")
 
             val multiplatformLanguageSettings = object : LanguageVersionSettings by languageVersionSettings {
@@ -128,21 +143,25 @@ class CommonResolverForModuleFactory(
                 CommonAnalysisParameters(metadataPartProviderFactory),
                 CompilerEnvironment,
                 CommonPlatforms.defaultCommonPlatform,
-                shouldCheckExpectActual = false
+                shouldCheckExpectActual = false,
+                dependenciesContainer
             )
 
             @Suppress("NAME_SHADOWING")
-            val resolver = ResolverForSingleModuleProject(
+            val resolver = ResolverForSingleModuleProject<ModuleInfo>(
                 "sources for metadata serializer",
                 ProjectContext(project, "metadata serializer"),
                 moduleInfo,
                 resolverForModuleFactory,
                 GlobalSearchScope.allScope(project),
                 languageVersionSettings = multiplatformLanguageSettings,
-                syntheticFiles = files
+                syntheticFiles = files,
+                knownDependencyModuleDescriptors = dependenciesContainer?.moduleInfos
+                    ?.associateWith(dependenciesContainer::moduleDescriptorForModuleInfo).orEmpty()
             )
 
             val moduleDescriptor = resolver.descriptorForModule(moduleInfo)
+
             val container = resolver.resolverForModule(moduleInfo).componentProvider
 
             container.get<LazyTopDownAnalyzer>().analyzeDeclarations(TopDownAnalysisMode.TopLevelDeclarations, files)
@@ -152,6 +171,16 @@ class CommonResolverForModuleFactory(
     }
 }
 
+interface CommonDependenciesContainer {
+    val moduleInfos: List<ModuleInfo>
+
+    fun moduleDescriptorForModuleInfo(moduleInfo: ModuleInfo): ModuleDescriptor
+
+    fun packageFragmentProviderForModuleInfo(moduleInfo: ModuleInfo): PackageFragmentProvider?
+    val friendModuleInfos: List<ModuleInfo>
+    val refinesModuleInfos: List<ModuleInfo>
+}
+
 private fun createContainerToResolveCommonCode(
     moduleContext: ModuleContext,
     bindingTrace: BindingTrace,

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/CommonCompilerArguments.kt

@@ -175,6 +175,13 @@ abstract class CommonCompilerArguments : CommonToolArguments() {
     )
     var useExperimental: Array<String>? by FreezableVar(null)
 
+    @Argument(
+        value = "-Xopt-in",
+        valueDescription = "<fq.name>",
+        description = "Enable usages of API that requires opt-in with an opt-in requirement marker with the given fully qualified name"
+    )
+    var optIn: Array<String>? by FreezableVar(null)
+
     @Argument(
         value = "-Xproper-ieee754-comparisons",
         description = "Generate proper IEEE 754 comparisons in all cases if values are statically known to be of primitive numeric types"
@@ -313,6 +320,12 @@ abstract class CommonCompilerArguments : CommonToolArguments() {
     )
     var useMixedNamedArguments: Boolean by FreezableVar(false)
 
+    @Argument(
+        value = "-Xklib-mpp",
+        description = "Enable experimental support for multi-platform klib libraries"
+    )
+    var klibBasedMpp: Boolean by FreezableVar(false)
+
     @Argument(value = "-Xdisable-default-scripting-plugin", description = "Do not enable scripting plugin by default")
     var disableDefaultScriptingPlugin: Boolean by FreezableVar(false)
 
@@ -328,8 +341,13 @@ abstract class CommonCompilerArguments : CommonToolArguments() {
         return HashMap<AnalysisFlag<*>, Any>().apply {
             put(AnalysisFlags.skipMetadataVersionCheck, skipMetadataVersionCheck)
             put(AnalysisFlags.multiPlatformDoNotCheckActual, noCheckActual)
-            put(AnalysisFlags.experimental, experimental?.toList().orEmpty())
-            put(AnalysisFlags.useExperimental, useExperimental?.toList().orEmpty())
+            put(AnalysisFlags.klibBasedMpp, klibBasedMpp)
+            val experimentalFqNames = experimental?.toList().orEmpty()
+            if (experimentalFqNames.isNotEmpty()) {
+                put(AnalysisFlags.experimental, experimentalFqNames)
+                collector.report(CompilerMessageSeverity.WARNING, "'-Xexperimental' is deprecated and will be removed in a future release")
+            }
+            put(AnalysisFlags.useExperimental, useExperimental?.toList().orEmpty() + optIn?.toList().orEmpty())
             put(AnalysisFlags.explicitApiVersion, apiVersion != null)
             put(AnalysisFlags.allowResultReturnType, allowResultReturnType)
             ExplicitApiMode.fromString(explicitApi)?.also { put(AnalysisFlags.explicitApiMode, it) } ?: collector.report(

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JSDceArguments.kt

@@ -1,21 +1,13 @@
 /*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
 package org.jetbrains.kotlin.cli.common.arguments
 
+import org.jetbrains.kotlin.cli.common.arguments.DevModeOverwritingStrategies.ALL
+import org.jetbrains.kotlin.cli.common.arguments.DevModeOverwritingStrategies.OLDER
+
 class K2JSDceArguments : CommonToolArguments() {
     companion object {
         @JvmStatic private val serialVersionUID = 0L
@@ -48,4 +40,16 @@ class K2JSDceArguments : CommonToolArguments() {
     )
     @GradleOption(DefaultValues.BooleanFalseDefault::class)
     var devMode: Boolean by FreezableVar(false)
+
+    @Argument(
+        value = "-Xdev-mode-overwriting-strategy",
+        valueDescription = "{$OLDER|$ALL}",
+        description = "Overwriting strategy during copy dependencies in development mode"
+    )
+    var devModeOverwritingStrategy: String? by NullableStringFreezableVar(null)
+}
+
+object DevModeOverwritingStrategies {
+    const val OLDER = "older"
+    const val ALL = "all"
 }

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JVMCompilerArguments.kt

@@ -50,7 +50,7 @@ class K2JVMCompilerArguments : CommonCompilerArguments() {
     var noReflect: Boolean by FreezableVar(false)
 
     @Argument(value = "-Xexpression", description = "Evaluate the given string as a Kotlin script")
-    var expressions: Array<String>? by FreezableVar(null)
+    var expression: String? by FreezableVar(null)
 
     @Argument(
         value = "-script-templates",
@@ -289,6 +289,12 @@ class K2JVMCompilerArguments : CommonCompilerArguments() {
     )
     var allowNoSourceFiles: Boolean by FreezableVar(false)
 
+    @Argument(
+        value = "-Xemit-jvm-type-annotations",
+        description = "Emit JVM type annotations in bytecode"
+    )
+    var emitJvmTypeAnnotations: Boolean by FreezableVar(false)
+
     override fun configureAnalysisFlags(collector: MessageCollector): MutableMap<AnalysisFlag<*>, Any> {
         val result = super.configureAnalysisFlags(collector)
         result[JvmAnalysisFlags.strictMetadataVersionSemantics] = strictMetadataVersionSemantics

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2MetadataCompilerArguments.kt

@@ -40,4 +40,18 @@ class K2MetadataCompilerArguments : CommonCompilerArguments() {
         description = "Enable in JPS"
     )
     var enabledInJps: Boolean by FreezableVar(false)
+
+    @Argument(
+        value = "-Xfriend-paths",
+        valueDescription = "<path>",
+        description = "Paths to output directories for friend modules (whose internals should be visible)"
+    )
+    var friendPaths: Array<String>? by FreezableVar(null)
+
+    @Argument(
+        value = "-Xfriend-paths",
+        valueDescription = "<path>",
+        description = "Paths to output directories for friend modules (whose internals should be visible)"
+    )
+    var refinesPaths: Array<String>? by FreezableVar(null)
 }

compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JsIrCompiler.kt

@@ -31,10 +31,7 @@ import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.incremental.js.IncrementalDataProvider
 import org.jetbrains.kotlin.incremental.js.IncrementalResultsConsumer
-import org.jetbrains.kotlin.ir.backend.js.compile
-import org.jetbrains.kotlin.ir.backend.js.generateKLib
-import org.jetbrains.kotlin.ir.backend.js.jsPhases
-import org.jetbrains.kotlin.ir.backend.js.jsResolveLibraries
+import org.jetbrains.kotlin.ir.backend.js.*
 import org.jetbrains.kotlin.js.config.EcmaVersion
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
 import org.jetbrains.kotlin.js.config.JsConfig
@@ -185,31 +182,39 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
                 else
                     outputFilePath
 
-            generateKLib(
-                project = config.project,
-                files = sourcesFiles,
-                configuration = config.configuration,
-                allDependencies = resolvedLibraries,
-                friendDependencies = friendDependencies,
-                outputKlibPath = outputKlibPath,
-                nopack = arguments.irProduceKlibDir
-            )
+            try {
+                generateKLib(
+                    project = config.project,
+                    files = sourcesFiles,
+                    configuration = config.configuration,
+                    allDependencies = resolvedLibraries,
+                    friendDependencies = friendDependencies,
+                    outputKlibPath = outputKlibPath,
+                    nopack = arguments.irProduceKlibDir
+                )
+            } catch (e: JsIrCompilationError) {
+                return COMPILATION_ERROR
+            }
         }
 
         if (arguments.irProduceJs) {
             val phaseConfig = createPhaseConfig(jsPhases, arguments, messageCollector)
 
-            val compiledModule = compile(
-                projectJs,
-                sourcesFiles,
-                config.configuration,
-                phaseConfig,
-                allDependencies = resolvedLibraries,
-                friendDependencies = friendDependencies,
-                mainArguments = mainCallArguments,
-                generateFullJs = !arguments.irDce,
-                generateDceJs = arguments.irDce
-            )
+            val compiledModule = try {
+                compile(
+                    projectJs,
+                    sourcesFiles,
+                    config.configuration,
+                    phaseConfig,
+                    allDependencies = resolvedLibraries,
+                    friendDependencies = friendDependencies,
+                    mainArguments = mainCallArguments,
+                    generateFullJs = !arguments.irDce,
+                    generateDceJs = arguments.irDce
+                )
+            } catch (e: JsIrCompilationError) {
+                return COMPILATION_ERROR
+            }
 
             val jsCode = if (arguments.irDce) compiledModule.dceJsCode!! else compiledModule.jsCode!!
             outputFile.writeText(jsCode)
@@ -370,7 +375,7 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
 }
 
 fun messageCollectorLogger(collector: MessageCollector) = object : Logger {
-    override fun warning(message: String)= collector.report(STRONG_WARNING, message)
+    override fun warning(message: String) = collector.report(STRONG_WARNING, message)
     override fun error(message: String) = collector.report(ERROR, message)
     override fun log(message: String) = collector.report(LOGGING, message)
     override fun fatal(message: String): Nothing {

compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/dce/K2JSDce.kt

@@ -1,23 +1,13 @@
 /*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
 package org.jetbrains.kotlin.cli.js.dce
 
 import org.jetbrains.kotlin.cli.common.CLITool
 import org.jetbrains.kotlin.cli.common.ExitCode
+import org.jetbrains.kotlin.cli.common.arguments.DevModeOverwritingStrategies
 import org.jetbrains.kotlin.cli.common.arguments.K2JSDceArguments
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
@@ -63,7 +53,13 @@ class K2JSDce : CLITool<K2JSDceArguments>() {
         return if (!arguments.devMode) {
             performDce(files, arguments, messageCollector)
         } else {
-            copyFiles(files)
+            val devModeOverwritingStrategy =
+                arguments.devModeOverwritingStrategy ?:
+                System.getProperty("kotlin.js.dce.devmode.overwriting.strategy", DevModeOverwritingStrategies.OLDER)
+
+            val overwriteOnlyOlderFiles = devModeOverwritingStrategy == DevModeOverwritingStrategies.OLDER
+
+            copyFiles(files, overwriteOnlyOlderFiles)
             ExitCode.OK
         }
     }
@@ -96,21 +92,22 @@ class K2JSDce : CLITool<K2JSDceArguments>() {
         return ExitCode.OK
     }
 
-    private fun copyFiles(files: List<InputFile>) {
+    private fun copyFiles(files: List<InputFile>, overwriteOnlyOlderFiles: Boolean) {
         for (file in files) {
-            copyResource(file.resource, File(file.outputPath))
+            copyResource(file.resource, File(file.outputPath), overwriteOnlyOlderFiles)
             file.sourceMapResource?.let { sourceMap ->
                 val sourceMapTarget = File(file.outputPath + ".map")
                 val inputFile = File(sourceMap.name)
                 if (!inputFile.exists() || !mapSourcePaths(inputFile, sourceMapTarget)) {
-                    copyResource(sourceMap, sourceMapTarget)
+                    copyResource(sourceMap, sourceMapTarget, overwriteOnlyOlderFiles)
                 }
             }
         }
     }
 
-    private fun copyResource(resource: InputResource, targetFile: File) {
-        if (targetFile.exists() && resource.lastModified() < targetFile.lastModified()) return
+    private fun copyResource(resource: InputResource, targetFile: File, overwriteOnlyOlderFiles: Boolean) {
+        // TODO shouldn't it be "<="?
+        if (overwriteOnlyOlderFiles && targetFile.exists() && resource.lastModified() < targetFile.lastModified()) return
 
         targetFile.parentFile.mkdirs()
         resource.reader().use { input ->

compiler/cli/cli-runner/src/org/jetbrains/kotlin/runner/Main.kt

@@ -42,9 +42,17 @@ object Main {
         var collectingExpressions = false
         var needsCompiler = false
         val arguments = arrayListOf<String>()
-        val expressions = arrayListOf<String>()
+        var expression: String? = null
         var noReflect = false
 
+        fun setExpression(expr: String) {
+            if (expression == null) {
+                expression = expr
+            } else {
+                throw RunnerException("Only single -e/-expression argument supported")
+            }
+        }
+
         var i = 0
         while (i < args.size) {
             val arg = args[i]
@@ -58,7 +66,7 @@ object Main {
 
             if (collectingExpressions) {
                 if ("-expression" == arg || "-e" == arg) {
-                    expressions.add(next())
+                    setExpression(next())
                     i++
                     continue
                 } else {
@@ -89,7 +97,7 @@ object Main {
                 }
             }
             else if ("-expression" == arg || "-e" == arg) {
-                expressions.add(next())
+                setExpression(next())
                 collectingExpressions = true
                 needsCompiler = true
             }
@@ -125,8 +133,8 @@ object Main {
             classpath.addPath(KOTLIN_HOME.toString() + "/lib/kotlin-reflect.jar")
         }
 
-        if (expressions.isNotEmpty()) {
-            runner = ExpressionRunner(expressions)
+        if (expression != null) {
+            runner = ExpressionRunner(expression!!)
         } else if (runner == null) {
             runner = ReplRunner()
             needsCompiler = true

compiler/cli/cli-runner/src/org/jetbrains/kotlin/runner/runners.kt

@@ -147,14 +147,11 @@ class ScriptRunner(private val path: String) : RunnerWithCompiler() {
     }
 }
 
-class ExpressionRunner(private val code: List<String>) : RunnerWithCompiler() {
+class ExpressionRunner(private val code: String) : RunnerWithCompiler() {
     override fun run(classpath: List<URL>, arguments: List<String>, compilerClasspath: List<URL>) {
         val compilerArgs = ArrayList<String>().apply {
             addClasspathArgIfNeeded(classpath)
-            code.forEach {
-                add("-Xexpression")
-                add(it)
-            }
+            add("-Xexpression=$code")
             addAll(arguments)
         }
         runCompiler(compilerClasspath, compilerArgs)

compiler/cli/src/org/jetbrains/kotlin/cli/common/CLITool.kt

@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.cli.common.messages.*
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.INFO
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.STRONG_WARNING
 import org.jetbrains.kotlin.cli.jvm.compiler.CompileEnvironmentException
+import org.jetbrains.kotlin.cli.jvm.compiler.setupIdeaStandaloneExecution
 import org.jetbrains.kotlin.config.KotlinCompilerVersion
 import org.jetbrains.kotlin.config.LanguageFeature.Kind.BUG_FIX
 import org.jetbrains.kotlin.config.LanguageFeature.State.ENABLED
@@ -204,6 +205,9 @@ abstract class CLITool<A : CommonToolArguments> {
             if (System.getProperty(PlainTextMessageRenderer.KOTLIN_COLORS_ENABLED_PROPERTY) == null) {
                 System.setProperty(PlainTextMessageRenderer.KOTLIN_COLORS_ENABLED_PROPERTY, "true")
             }
+
+            setupIdeaStandaloneExecution()
+
             val exitCode = doMainNoExit(compiler, args)
             if (exitCode != ExitCode.OK) {
                 exitProcess(exitCode.code)

compiler/cli/src/org/jetbrains/kotlin/cli/common/arguments.kt

@@ -23,6 +23,7 @@ fun <A : CommonCompilerArguments> CompilerConfiguration.setupCommonArguments(
 ) {
     put(CommonConfigurationKeys.DISABLE_INLINE, arguments.noInline)
     put(CommonConfigurationKeys.USE_FIR, arguments.useFir)
+    put(CommonConfigurationKeys.KLIB_MPP, arguments.klibBasedMpp)
     putIfNotNull(CLIConfigurationKeys.INTELLIJ_PLUGIN_ROOT, arguments.intellijPluginRoot)
     put(CommonConfigurationKeys.REPORT_OUTPUT_FILES, arguments.reportOutputFiles)
 

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.kt

@@ -77,7 +77,7 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
         configuration.configureAdvancedJvmOptions(arguments)
 
         if (arguments.buildFile == null && !arguments.version  && !arguments.allowNoSourceFiles &&
-            (arguments.script || arguments.expressions != null || arguments.freeArgs.isEmpty())) {
+            (arguments.script || arguments.expression != null || arguments.freeArgs.isEmpty())) {
 
             // script or repl
             if (arguments.script && arguments.freeArgs.isEmpty()) {
@@ -92,7 +92,7 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
                 )
             projectEnvironment.registerExtensionsFromPlugins(configuration)
 
-            if (arguments.script || arguments.expressions != null) {
+            if (arguments.script || arguments.expression != null) {
                 val scriptingEvaluator = ScriptEvaluationExtension.getInstances(projectEnvironment.project).find { it.isAccepted(arguments) }
                 if (scriptingEvaluator == null) {
                     messageCollector.report(ERROR, "Unable to evaluate script, no scripting plugin loaded")

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreApplicationEnvironment.java

@@ -5,39 +5,72 @@
 package org.jetbrains.kotlin.cli.jvm.compiler;
 
 import com.intellij.codeInsight.ContainerProvider;
+import com.intellij.codeInsight.JavaContainerProvider;
+import com.intellij.codeInsight.folding.JavaCodeFoldingSettings;
+import com.intellij.codeInsight.folding.impl.JavaCodeFoldingSettingsBase;
+import com.intellij.codeInsight.folding.impl.JavaFoldingBuilderBase;
 import com.intellij.codeInsight.runner.JavaMainMethodProvider;
 import com.intellij.core.CoreApplicationEnvironment;
-import com.intellij.core.JavaCoreApplicationEnvironment;
+import com.intellij.core.CoreJavaDirectoryService;
+import com.intellij.core.CorePsiPackageImplementationHelper;
+import com.intellij.ide.highlighter.ArchiveFileType;
+import com.intellij.ide.highlighter.JavaClassFileType;
+import com.intellij.ide.highlighter.JavaFileType;
+import com.intellij.lang.LanguageASTFactory;
 import com.intellij.lang.MetaLanguage;
+import com.intellij.lang.folding.LanguageFolding;
+import com.intellij.lang.java.JavaLanguage;
+import com.intellij.lang.java.JavaParserDefinition;
+import com.intellij.navigation.ItemPresentationProviders;
 import com.intellij.openapi.Disposable;
 import com.intellij.openapi.extensions.Extensions;
 import com.intellij.openapi.extensions.ExtensionsArea;
 import com.intellij.openapi.fileTypes.FileTypeExtensionPoint;
+import com.intellij.openapi.fileTypes.PlainTextFileType;
+import com.intellij.openapi.fileTypes.PlainTextLanguage;
+import com.intellij.openapi.fileTypes.PlainTextParserDefinition;
+import com.intellij.openapi.projectRoots.JavaVersionService;
 import com.intellij.openapi.vfs.VirtualFileSystem;
-import com.intellij.psi.FileContextProvider;
+import com.intellij.psi.*;
 import com.intellij.psi.augment.PsiAugmentProvider;
 import com.intellij.psi.augment.TypeAnnotationModifier;
 import com.intellij.psi.compiled.ClassFileDecompilers;
+import com.intellij.psi.impl.LanguageConstantExpressionEvaluator;
+import com.intellij.psi.impl.PsiExpressionEvaluator;
+import com.intellij.psi.impl.PsiSubstitutorFactoryImpl;
+import com.intellij.psi.impl.compiled.ClassFileStubBuilder;
+import com.intellij.psi.impl.file.PsiPackageImplementationHelper;
+import com.intellij.psi.impl.search.MethodSuperSearcher;
+import com.intellij.psi.impl.source.tree.JavaASTFactory;
+import com.intellij.psi.impl.source.tree.PlainTextASTFactory;
 import com.intellij.psi.meta.MetaDataContributor;
+import com.intellij.psi.presentation.java.*;
+import com.intellij.psi.search.searches.SuperMethodsSearch;
 import com.intellij.psi.stubs.BinaryFileStubBuilders;
+import com.intellij.util.QueryExecutor;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.cli.jvm.modules.CoreJrtFileSystem;
 
-// Mostly a placeholder for the functionality added to the bunch 193
-public class KotlinCoreApplicationEnvironment extends JavaCoreApplicationEnvironment {
+/**
+ * adapted from com.intellij.core.JavaCoreApplicationEnvironment
+ * TODO: initiate removal original from com.intellij.core since it seems that there are no usages left
+ */
+public class KotlinCoreApplicationEnvironment extends CoreApplicationEnvironment {
 
   public static KotlinCoreApplicationEnvironment create(@NotNull Disposable parentDisposable, boolean unitTestMode) {
-    Extensions.cleanRootArea(parentDisposable);
-    registerExtensionPoints();
     return new KotlinCoreApplicationEnvironment(parentDisposable, unitTestMode);
   }
 
   private KotlinCoreApplicationEnvironment(@NotNull Disposable parentDisposable, boolean unitTestMode) {
     super(parentDisposable, unitTestMode);
+
+    registerExtensionPoints();
+
+    registerExtensions();
   }
 
-  private static void registerExtensionPoints() {
+  private void registerExtensionPoints() {
     ExtensionsArea area = Extensions.getRootArea();
 
     CoreApplicationEnvironment.registerExtensionPoint(area, BinaryFileStubBuilders.EP_NAME, FileTypeExtensionPoint.class);
@@ -56,6 +89,59 @@ public class KotlinCoreApplicationEnvironment extends JavaCoreApplicationEnviron
     IdeaExtensionPoints.INSTANCE.registerVersionSpecificAppExtensionPoints(area);
   }
 
+  private void registerExtensions() {
+    registerFileType(JavaClassFileType.INSTANCE, "class");
+    registerFileType(JavaFileType.INSTANCE, "java");
+    registerFileType(ArchiveFileType.INSTANCE, "jar;zip");
+    registerFileType(PlainTextFileType.INSTANCE, "txt;sh;bat;cmd;policy;log;cgi;MF;jad;jam;htaccess");
+
+    addExplicitExtension(LanguageASTFactory.INSTANCE, PlainTextLanguage.INSTANCE, new PlainTextASTFactory());
+    registerParserDefinition(new PlainTextParserDefinition());
+
+    addExplicitExtension(FileTypeFileViewProviders.INSTANCE, JavaClassFileType.INSTANCE, new ClassFileViewProviderFactory());
+    addExplicitExtension(BinaryFileStubBuilders.INSTANCE, JavaClassFileType.INSTANCE, new ClassFileStubBuilder());
+
+    addExplicitExtension(LanguageASTFactory.INSTANCE, JavaLanguage.INSTANCE, new JavaASTFactory());
+    registerParserDefinition(new JavaParserDefinition());
+    addExplicitExtension(LanguageConstantExpressionEvaluator.INSTANCE, JavaLanguage.INSTANCE, new PsiExpressionEvaluator());
+
+    addExtension(ContainerProvider.EP_NAME, new JavaContainerProvider());
+
+    myApplication.registerService(PsiPackageImplementationHelper.class, new CorePsiPackageImplementationHelper());
+    myApplication.registerService(PsiSubstitutorFactory.class, new PsiSubstitutorFactoryImpl());
+
+    myApplication.registerService(JavaDirectoryService.class, createJavaDirectoryService());
+    myApplication.registerService(JavaVersionService.class, new JavaVersionService());
+
+    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiPackage.class, new PackagePresentationProvider());
+    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiClass.class, new ClassPresentationProvider());
+    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiMethod.class, new MethodPresentationProvider());
+    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiField.class, new FieldPresentationProvider());
+    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiLocalVariable.class, new VariablePresentationProvider());
+    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiParameter.class, new VariablePresentationProvider());
+
+    registerApplicationService(JavaCodeFoldingSettings.class, new JavaCodeFoldingSettingsBase());
+    addExplicitExtension(LanguageFolding.INSTANCE, JavaLanguage.INSTANCE, new JavaFoldingBuilderBase() {
+      @Override
+      protected boolean shouldShowExplicitLambdaType(@NotNull PsiAnonymousClass anonymousClass, @NotNull PsiNewExpression expression) {
+        return false;
+      }
+
+      @Override
+      protected boolean isBelowRightMargin(@NotNull PsiFile file, int lineLength) {
+        return false;
+      }
+    });
+
+    registerApplicationExtensionPoint(SuperMethodsSearch.EP_NAME, QueryExecutor.class);
+    addExtension(SuperMethodsSearch.EP_NAME, new MethodSuperSearcher());
+  }
+
+  // overridden in upsource
+  protected CoreJavaDirectoryService createJavaDirectoryService() {
+    return new CoreJavaDirectoryService();
+  }
+
   @Nullable
   @Override
   protected VirtualFileSystem createJrtFileSystem() {

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreApplicationEnvironment.java.192

@@ -0,0 +1,64 @@
+/*
+ * 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.cli.jvm.compiler;
+
+import com.intellij.codeInsight.ContainerProvider;
+import com.intellij.codeInsight.runner.JavaMainMethodProvider;
+import com.intellij.core.CoreApplicationEnvironment;
+import com.intellij.core.JavaCoreApplicationEnvironment;
+import com.intellij.lang.MetaLanguage;
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.extensions.Extensions;
+import com.intellij.openapi.extensions.ExtensionsArea;
+import com.intellij.openapi.fileTypes.FileTypeExtensionPoint;
+import com.intellij.openapi.vfs.VirtualFileSystem;
+import com.intellij.psi.FileContextProvider;
+import com.intellij.psi.augment.PsiAugmentProvider;
+import com.intellij.psi.augment.TypeAnnotationModifier;
+import com.intellij.psi.compiled.ClassFileDecompilers;
+import com.intellij.psi.meta.MetaDataContributor;
+import com.intellij.psi.stubs.BinaryFileStubBuilders;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.cli.jvm.modules.CoreJrtFileSystem;
+
+// Mostly a placeholder for the functionality added to the bunch 193
+public class KotlinCoreApplicationEnvironment extends JavaCoreApplicationEnvironment {
+
+  public static KotlinCoreApplicationEnvironment create(@NotNull Disposable parentDisposable, boolean unitTestMode) {
+    Extensions.cleanRootArea(parentDisposable);
+    registerExtensionPoints();
+    return new KotlinCoreApplicationEnvironment(parentDisposable, unitTestMode);
+  }
+
+  private KotlinCoreApplicationEnvironment(@NotNull Disposable parentDisposable, boolean unitTestMode) {
+    super(parentDisposable, unitTestMode);
+  }
+
+  private static void registerExtensionPoints() {
+    ExtensionsArea area = Extensions.getRootArea();
+
+    CoreApplicationEnvironment.registerExtensionPoint(area, BinaryFileStubBuilders.EP_NAME, FileTypeExtensionPoint.class);
+    CoreApplicationEnvironment.registerExtensionPoint(area, FileContextProvider.EP_NAME, FileContextProvider.class);
+
+    CoreApplicationEnvironment.registerExtensionPoint(area, MetaDataContributor.EP_NAME, MetaDataContributor.class);
+    CoreApplicationEnvironment.registerExtensionPoint(area, PsiAugmentProvider.EP_NAME, PsiAugmentProvider.class);
+    CoreApplicationEnvironment.registerExtensionPoint(area, JavaMainMethodProvider.EP_NAME, JavaMainMethodProvider.class);
+
+    CoreApplicationEnvironment.registerExtensionPoint(area, ContainerProvider.EP_NAME, ContainerProvider.class);
+    CoreApplicationEnvironment.registerExtensionPoint(area, ClassFileDecompilers.EP_NAME, ClassFileDecompilers.Decompiler.class);
+
+    CoreApplicationEnvironment.registerExtensionPoint(area, TypeAnnotationModifier.EP_NAME, TypeAnnotationModifier.class);
+    CoreApplicationEnvironment.registerExtensionPoint(area, MetaLanguage.EP_NAME, MetaLanguage.class);
+
+    IdeaExtensionPoints.INSTANCE.registerVersionSpecificAppExtensionPoints(area);
+  }
+
+  @Nullable
+  @Override
+  protected VirtualFileSystem createJrtFileSystem() {
+    return new CoreJrtFileSystem();
+  }
+}

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreApplicationEnvironment.java.201

@@ -0,0 +1,55 @@
+/*
+ * 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.cli.jvm.compiler;
+
+import com.intellij.DynamicBundle;
+import com.intellij.codeInsight.ContainerProvider;
+import com.intellij.codeInsight.runner.JavaMainMethodProvider;
+import com.intellij.core.JavaCoreApplicationEnvironment;
+import com.intellij.lang.MetaLanguage;
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.extensions.Extensions;
+import com.intellij.openapi.vfs.VirtualFileSystem;
+import com.intellij.psi.FileContextProvider;
+import com.intellij.psi.augment.PsiAugmentProvider;
+import com.intellij.psi.compiled.ClassFileDecompilers;
+import com.intellij.psi.meta.MetaDataContributor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.cli.jvm.modules.CoreJrtFileSystem;
+
+public class KotlinCoreApplicationEnvironment extends JavaCoreApplicationEnvironment {
+    public static KotlinCoreApplicationEnvironment create(@NotNull Disposable parentDisposable, boolean unitTestMode) {
+        KotlinCoreApplicationEnvironment environment = new KotlinCoreApplicationEnvironment(parentDisposable, unitTestMode);
+        registerExtensionPoints();
+        return environment;
+    }
+
+    private KotlinCoreApplicationEnvironment(@NotNull Disposable parentDisposable, boolean unitTestMode) {
+        super(parentDisposable, unitTestMode);
+    }
+
+    private static void registerExtensionPoints() {
+        registerApplicationExtensionPoint(DynamicBundle.LanguageBundleEP.EP_NAME, DynamicBundle.LanguageBundleEP.class);
+        registerApplicationExtensionPoint(FileContextProvider.EP_NAME, FileContextProvider.class);
+
+        registerApplicationExtensionPoint(MetaDataContributor.EP_NAME, MetaDataContributor.class);
+        registerApplicationExtensionPoint(PsiAugmentProvider.EP_NAME, PsiAugmentProvider.class);
+        registerApplicationExtensionPoint(JavaMainMethodProvider.EP_NAME, JavaMainMethodProvider.class);
+
+        registerApplicationExtensionPoint(ContainerProvider.EP_NAME, ContainerProvider.class);
+        registerApplicationExtensionPoint(ClassFileDecompilers.EP_NAME, ClassFileDecompilers.Decompiler.class);
+
+        registerApplicationExtensionPoint(MetaLanguage.EP_NAME, MetaLanguage.class);
+
+        IdeaExtensionPoints.INSTANCE.registerVersionSpecificAppExtensionPoints(Extensions.getRootArea());
+    }
+
+    @Nullable
+    @Override
+    protected VirtualFileSystem createJrtFileSystem() {
+        return new CoreJrtFileSystem();
+    }
+}

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt

@@ -216,7 +216,7 @@ class KotlinCoreEnvironment private constructor(
         )
 
         val (initialRoots, javaModules) =
-                classpathRootsResolver.convertClasspathRoots(configuration.getList(CLIConfigurationKeys.CONTENT_ROOTS))
+            classpathRootsResolver.convertClasspathRoots(configuration.getList(CLIConfigurationKeys.CONTENT_ROOTS))
         this.initialRoots.addAll(initialRoots)
 
         if (!configuration.getBoolean(JVMConfigurationKeys.SKIP_RUNTIME_VERSION_CHECK) && messageCollector != null) {
@@ -228,7 +228,7 @@ class KotlinCoreEnvironment private constructor(
         }
 
         val (roots, singleJavaFileRoots) =
-                initialRoots.partition { (file) -> file.isDirectory || file.extension != JavaFileType.DEFAULT_EXTENSION }
+            initialRoots.partition { (file) -> file.isDirectory || file.extension != JavaFileType.DEFAULT_EXTENSION }
 
         // REPL and kapt2 update classpath dynamically
         rootsIndex = JvmDependenciesDynamicCompoundIndex().apply {
@@ -421,6 +421,7 @@ class KotlinCoreEnvironment private constructor(
         fun createForProduction(
             parentDisposable: Disposable, configuration: CompilerConfiguration, configFiles: EnvironmentConfigFiles
         ): KotlinCoreEnvironment {
+            setupIdeaStandaloneExecution()
             val appEnv = getOrCreateApplicationEnvironmentForProduction(parentDisposable, configuration)
             val projectEnv = ProjectEnvironment(parentDisposable, appEnv)
             val environment = KotlinCoreEnvironment(projectEnv, configuration, configFiles)
@@ -516,8 +517,6 @@ class KotlinCoreEnvironment private constructor(
         }
 
         private fun registerApplicationExtensionPointsAndExtensionsFrom(configuration: CompilerConfiguration, configFilePath: String) {
-            workaroundIbmJdkStaxReportCdataEventIssue()
-
             fun File.hasConfigFile(configFile: String): Boolean =
                 if (isDirectory) File(this, "META-INF" + File.separator + configFile).exists()
                 else try {
@@ -528,7 +527,7 @@ class KotlinCoreEnvironment private constructor(
                     false
                 }
 
-            val pluginRoot =
+            val pluginRoot: File =
                 configuration.get(CLIConfigurationKeys.INTELLIJ_PLUGIN_ROOT)?.let(::File)
                     ?: PathUtil.getResourcePathForClass(this::class.java).takeIf { it.hasConfigFile(configFilePath) }
                     // hack for load extensions when compiler run directly from project directory (e.g. in tests)
@@ -538,39 +537,7 @@ class KotlinCoreEnvironment private constructor(
                                 "(cp:\n  ${(Thread.currentThread().contextClassLoader as? UrlClassLoader)?.urls?.joinToString("\n  ") { it.file }})"
                     )
 
-            CoreApplicationEnvironment.registerExtensionPointAndExtensions(pluginRoot, configFilePath, Extensions.getRootArea())
-        }
-
-        private fun workaroundIbmJdkStaxReportCdataEventIssue() {
-            if (!SystemInfo.isIbmJvm) return
-
-            // On IBM JDK, XMLInputFactory does not support "report-cdata-event" property, but JDOMUtil sets it unconditionally in the
-            // static XML_INPUT_FACTORY field and fails with an exception (Logger.error throws exception in the compiler) if unsuccessful.
-            // Until this is fixed in the platform, we workaround the issue by setting that field to a value that does not attempt
-            // to set the unsupported property.
-            // See IDEA-206446 for more information
-            val field = JDOMUtil::class.java.getDeclaredField("XML_INPUT_FACTORY")
-            field.isAccessible = true
-            Field::class.java.getDeclaredField("modifiers")
-                .apply { isAccessible = true }
-                .setInt(field, field.modifiers and Modifier.FINAL.inv())
-            field.set(null, object : NotNullLazyValue<XMLInputFactory>() {
-                override fun compute(): XMLInputFactory {
-                    val factory: XMLInputFactory = try {
-                        // otherwise wst can be used (in tests/dev run)
-                        val clazz = Class.forName("com.sun.xml.internal.stream.XMLInputFactoryImpl")
-                        clazz.newInstance() as XMLInputFactory
-                    } catch (e: Exception) {
-                        // ok, use random
-                        XMLInputFactory.newFactory()
-                    }
-
-                    factory.setProperty(XMLInputFactory.IS_COALESCING, true)
-                    factory.setProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, false)
-                    factory.setProperty(XMLInputFactory.SUPPORT_DTD, false)
-                    return factory
-                }
-            })
+            registerExtensionPointAndExtensionsEx(pluginRoot, configFilePath, Extensions.getRootArea())
         }
 
         @JvmStatic
@@ -714,5 +681,4 @@ class KotlinCoreEnvironment private constructor(
             }
         }
     }
-}
-
+}

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/MockExternalAnnotationsManager.kt.201

@@ -0,0 +1,62 @@
+/*
+ * 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.cli.jvm.compiler
+
+import com.intellij.codeInsight.ExternalAnnotationsManager
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.psi.*
+
+class MockExternalAnnotationsManager : ExternalAnnotationsManager() {
+    override fun chooseAnnotationsPlace(element: PsiElement): AnnotationPlace = AnnotationPlace.NOWHERE
+    override fun chooseAnnotationsPlaceNoUi(element: PsiElement): AnnotationPlace = AnnotationPlace.NOWHERE
+
+    override fun isExternalAnnotationWritable(listOwner: PsiModifierListOwner, annotationFQN: String): Boolean = false
+    override fun isExternalAnnotation(annotation: PsiAnnotation): Boolean = false
+
+    override fun findExternalAnnotationsFiles(listOwner: PsiModifierListOwner): List<PsiFile>? = null
+    override fun findExternalAnnotation(listOwner: PsiModifierListOwner, annotationFQN: String): PsiAnnotation? = null
+    override fun findExternalAnnotations(listOwner: PsiModifierListOwner): Array<out PsiAnnotation>? = null
+
+    override fun annotateExternally(
+        listOwner: PsiModifierListOwner,
+        annotationFQName: String,
+        fromFile: PsiFile,
+        value: Array<out PsiNameValuePair>?
+    ) {
+        throw UnsupportedOperationException("not implemented")
+    }
+
+    override fun deannotate(listOwner: PsiModifierListOwner, annotationFQN: String): Boolean {
+        throw UnsupportedOperationException("not implemented")
+    }
+
+    override fun editExternalAnnotation(
+        listOwner: PsiModifierListOwner,
+        annotationFQN: String,
+        value: Array<out PsiNameValuePair>?
+    ): Boolean {
+        throw UnsupportedOperationException("not implemented")
+    }
+
+    override fun hasAnnotationRootsForFile(file: VirtualFile): Boolean = false
+
+    override fun findDefaultConstructorExternalAnnotations(aClass: PsiClass, annotationFQN: String): List<PsiAnnotation> = emptyList()
+
+    override fun findDefaultConstructorExternalAnnotations(aClass: PsiClass): List<PsiAnnotation> = emptyList()
+
+    override fun findExternalAnnotations(listOwner: PsiModifierListOwner, annotationFQN: String): List<PsiAnnotation> = emptyList()
+}

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/compat.kt

@@ -0,0 +1,9 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.cli.jvm.compiler
+
+fun setupIdeaStandaloneExecution() {
+}

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/compat.kt.201

@@ -0,0 +1,14 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.cli.jvm.compiler
+
+fun setupIdeaStandaloneExecution() {
+    System.getProperties().setProperty("idea.home.path",  System.getProperty("java.io.tmpdir"))
+    System.getProperties().setProperty("project.structure.add.tools.jar.to.new.jdk", "false")
+    System.getProperties().setProperty("psi.track.invalidation", "true")
+    System.getProperties().setProperty("psi.incremental.reparse.depth.limit", "1000")
+    System.getProperties().setProperty("ide.hide.excluded.files", "false")
+}

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/coreApplicationEnvironmentCompat.kt

@@ -0,0 +1,16 @@
+/*
+ * 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.cli.jvm.compiler
+
+import com.intellij.core.CoreApplicationEnvironment
+import com.intellij.openapi.extensions.ExtensionsArea
+import java.io.File
+
+// BUNCH: 193
+fun registerExtensionPointAndExtensionsEx(pluginFile: File, fileName: String, area: ExtensionsArea) {
+    @Suppress("MissingRecentApi")
+    CoreApplicationEnvironment.registerExtensionPointAndExtensions(pluginFile, fileName, area)
+}

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/coreApplicationEnvironmentCompat.kt.201

@@ -0,0 +1,18 @@
+/*
+ * 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.cli.jvm.compiler
+
+import com.intellij.core.CoreApplicationEnvironment
+import com.intellij.openapi.extensions.ExtensionsArea
+import java.io.File
+import java.nio.file.FileSystems
+
+// BUNCH: 193
+fun registerExtensionPointAndExtensionsEx(pluginFile: File, fileName: String, area: ExtensionsArea) {
+    val pluginRoot = FileSystems.getDefault().getPath(pluginFile.path)
+    @Suppress("MissingRecentApi")
+    CoreApplicationEnvironment.registerExtensionPointAndExtensions(pluginRoot, fileName, area)
+}

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/config/JvmContentRoots.kt

@@ -26,7 +26,9 @@ interface JvmContentRoot : ContentRoot {
     val file: File
 }
 
-data class JvmClasspathRoot(override val file: File) : JvmContentRoot
+data class JvmClasspathRoot(override val file: File, val isSdkRoot: Boolean) : JvmContentRoot {
+    constructor(file: File) : this(file, false)
+}
 
 data class JavaSourceRoot(override val file: File, val packagePrefix: String?) : JvmContentRoot
 
@@ -41,7 +43,7 @@ fun CompilerConfiguration.addJvmClasspathRoots(files: List<File>) {
 }
 
 fun CompilerConfiguration.addJvmSdkRoots(files: List<File>) {
-    addAll(CLIConfigurationKeys.CONTENT_ROOTS, 0, files.map(::JvmClasspathRoot))
+    addAll(CLIConfigurationKeys.CONTENT_ROOTS, 0, files.map { file -> JvmClasspathRoot(file, true) })
 }
 
 val CompilerConfiguration.jvmClasspathRoots: List<File>

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/config/K2MetadataConfigurationKeys.kt

@@ -0,0 +1,13 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.cli.jvm.config
+
+import org.jetbrains.kotlin.config.CompilerConfigurationKey
+
+object K2MetadataConfigurationKeys {
+    val FRIEND_PATHS = CompilerConfigurationKey.create<List<String>>("friend module paths")
+    val REFINES_PATHS = CompilerConfigurationKey.create<List<String>>("refined module paths")
+}

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/jvmArguments.kt

@@ -152,6 +152,7 @@ fun CompilerConfiguration.configureAdvancedJvmOptions(arguments: K2JVMCompilerAr
         arguments.noExceptionOnExplicitEqualsForBoxedNull
     )
     put(JVMConfigurationKeys.DISABLE_OPTIMIZATION, arguments.noOptimize)
+    put(JVMConfigurationKeys.EMIT_JVM_TYPE_ANNOTATIONS, arguments.emitJvmTypeAnnotations)
 
     if (!JVMConstructorCallNormalizationMode.isSupportedValue(arguments.constructorCallNormalizationMode)) {
         getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY).report(

compiler/cli/src/org/jetbrains/kotlin/cli/metadata/CommonAnalysis.kt

@@ -0,0 +1,59 @@
+/*
+ * 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.cli.metadata
+
+import org.jetbrains.kotlin.analyzer.common.CommonDependenciesContainer
+import org.jetbrains.kotlin.analyzer.common.CommonResolverForModuleFactory
+import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
+import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.config.CommonConfigurationKeys
+import org.jetbrains.kotlin.config.languageVersionSettings
+import org.jetbrains.kotlin.name.Name
+import java.io.File
+
+internal val KotlinCoreEnvironment.destDir: File?
+    get() = configuration.get(CLIConfigurationKeys.METADATA_DESTINATION_DIRECTORY)
+
+internal fun runCommonAnalysisForSerialization(
+    environment: KotlinCoreEnvironment,
+    dependOnBuiltins: Boolean,
+    dependencyContainer: CommonDependenciesContainer?
+): AnalyzerWithCompilerReport? {
+    if (environment.destDir == null) {
+        val configuration = environment.configuration
+        val messageCollector = configuration.getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
+        messageCollector.report(CompilerMessageSeverity.ERROR, "Specify destination via -d")
+        return null
+    }
+
+    return runCommonAnalysis(environment, dependOnBuiltins, dependencyContainer)
+}
+
+private fun runCommonAnalysis(
+    environment: KotlinCoreEnvironment,
+    dependOnBuiltins: Boolean,
+    dependencyContainer: CommonDependenciesContainer?
+): AnalyzerWithCompilerReport {
+    val configuration = environment.configuration
+    val messageCollector = configuration.getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
+    val files = environment.getSourceFiles()
+    val moduleName = Name.special("<${configuration.getNotNull(CommonConfigurationKeys.MODULE_NAME)}>")
+
+    val analyzer = AnalyzerWithCompilerReport(messageCollector, configuration.languageVersionSettings)
+
+    analyzer.analyzeAndReport(files) {
+        CommonResolverForModuleFactory.analyzeFiles(
+            files, moduleName, dependOnBuiltins, configuration.languageVersionSettings,
+            dependenciesContainer = dependencyContainer
+        ) { content ->
+            environment.createPackagePartProvider(content.moduleContentScope)
+        }
+    }
+
+    return analyzer
+}

compiler/cli/src/org/jetbrains/kotlin/cli/metadata/K2MetadataCompiler.kt

@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.cli.common.messages.MessageUtil
 import org.jetbrains.kotlin.cli.common.messages.OutputMessageUtil
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.config.K2MetadataConfigurationKeys
 import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots
 import org.jetbrains.kotlin.cli.jvm.plugins.PluginCliParser
 import org.jetbrains.kotlin.codegen.CompilationException
@@ -73,6 +74,10 @@ class K2MetadataCompiler : CLICompiler<K2MetadataCompilerArguments>() {
 
         configuration.put(CLIConfigurationKeys.ALLOW_KOTLIN_PACKAGE, arguments.allowKotlinPackage)
 
+        configuration.putIfNotNull(K2MetadataConfigurationKeys.FRIEND_PATHS, arguments.friendPaths?.toList())
+        configuration.putIfNotNull(K2MetadataConfigurationKeys.REFINES_PATHS, arguments.refinesPaths?.toList())
+
+
         val destination = arguments.destination
         if (destination != null) {
             if (destination.endsWith(".jar")) {
@@ -101,7 +106,11 @@ class K2MetadataCompiler : CLICompiler<K2MetadataCompilerArguments>() {
         try {
             val metadataVersion =
                 configuration.get(CommonConfigurationKeys.METADATA_VERSION) as? BuiltInsBinaryVersion ?: BuiltInsBinaryVersion.INSTANCE
-            MetadataSerializer(metadataVersion, true).serialize(environment)
+            if (arguments.klibBasedMpp) {
+                K2MetadataKlibSerializer(metadataVersion).serialize(environment)
+            } else {
+                MetadataSerializer(metadataVersion, true).serialize(environment)
+            }
         } catch (e: CompilationException) {
             collector.report(EXCEPTION, OutputMessageUtil.renderException(e), MessageUtil.psiElementToMessageLocation(e.element))
             return ExitCode.INTERNAL_ERROR

compiler/cli/src/org/jetbrains/kotlin/cli/metadata/K2MetadataKlibSerializer.kt

@@ -0,0 +1,229 @@
+/*
+ * 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.cli.metadata
+
+import org.jetbrains.kotlin.analyzer.*
+import org.jetbrains.kotlin.analyzer.common.CommonDependenciesContainer
+import org.jetbrains.kotlin.analyzer.common.CommonPlatformAnalyzerServices
+import org.jetbrains.kotlin.backend.common.serialization.DescriptorTable
+import org.jetbrains.kotlin.backend.common.serialization.metadata.KlibMetadataMonolithicSerializer
+import org.jetbrains.kotlin.backend.common.serialization.metadata.KlibMetadataVersion
+import org.jetbrains.kotlin.builtins.DefaultBuiltIns
+import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot
+import org.jetbrains.kotlin.cli.jvm.config.JvmContentRoot
+import org.jetbrains.kotlin.cli.jvm.config.K2MetadataConfigurationKeys
+import org.jetbrains.kotlin.config.CommonConfigurationKeys
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.KotlinCompilerVersion
+import org.jetbrains.kotlin.config.languageVersionSettings
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.descriptors.konan.DeserializedKlibModuleOrigin
+import org.jetbrains.kotlin.konan.util.KlibMetadataFactories
+import org.jetbrains.kotlin.library.KotlinAbiVersion
+import org.jetbrains.kotlin.library.KotlinLibrary
+import org.jetbrains.kotlin.library.KotlinLibraryVersioning
+import org.jetbrains.kotlin.library.SerializedMetadata
+import org.jetbrains.kotlin.library.impl.buildKoltinLibrary
+import org.jetbrains.kotlin.library.impl.createKotlinLibrary
+import org.jetbrains.kotlin.library.metadata.parseModuleHeader
+import org.jetbrains.kotlin.metadata.builtins.BuiltInsBinaryVersion
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.platform.CommonPlatforms
+import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.resolve.CompilerDeserializationConfiguration
+import org.jetbrains.kotlin.resolve.PlatformDependentAnalyzerServices
+import org.jetbrains.kotlin.serialization.konan.impl.KlibMetadataModuleDescriptorFactoryImpl
+import org.jetbrains.kotlin.storage.LockBasedStorageManager
+import org.jetbrains.kotlin.storage.StorageManager
+import org.jetbrains.kotlin.utils.keysToMap
+import java.io.File
+
+internal class K2MetadataKlibSerializer(private val metadataVersion: BuiltInsBinaryVersion) {
+    fun serialize(environment: KotlinCoreEnvironment) {
+        val configuration = environment.configuration
+
+        val dependencyContainer = KlibMetadataDependencyContainer(
+            configuration,
+            LockBasedStorageManager("K2MetadataKlibSerializer")
+        )
+
+        val analyzer = runCommonAnalysisForSerialization(environment, true, dependencyContainer)
+
+        if (analyzer == null || analyzer.hasErrors()) return
+
+        val (_, moduleDescriptor) = analyzer.analysisResult
+
+        val destDir = checkNotNull(environment.destDir)
+        performSerialization(configuration, moduleDescriptor, destDir)
+    }
+
+    private fun performSerialization(
+        configuration: CompilerConfiguration,
+        module: ModuleDescriptor,
+        destDir: File
+    ) {
+        val serializedMetadata: SerializedMetadata = KlibMetadataMonolithicSerializer(
+            configuration.languageVersionSettings,
+            metadataVersion,
+            DescriptorTable.createDefault(),
+            skipExpects = false,
+            includeOnlyModuleContent = true
+        ).serializeModule(module)
+
+        val versions = KotlinLibraryVersioning(
+            abiVersion = KotlinAbiVersion.CURRENT,
+            libraryVersion = null,
+            compilerVersion = KotlinCompilerVersion.getVersion(),
+            metadataVersion = KlibMetadataVersion.INSTANCE.toString(),
+            irVersion = null
+        )
+
+        buildKoltinLibrary(
+            emptyList(),
+            serializedMetadata,
+            null,
+            versions,
+            destDir.absolutePath,
+            configuration[CommonConfigurationKeys.MODULE_NAME]!!,
+            nopack = true,
+            manifestProperties = null,
+            dataFlowGraph = null
+        )
+    }
+}
+
+private class KlibMetadataDependencyContainer(
+    private val configuration: CompilerConfiguration,
+    private val storageManager: StorageManager
+) : CommonDependenciesContainer {
+
+    private val kotlinLibraries = run {
+        val classpathFiles =
+            configuration.getList(CLIConfigurationKeys.CONTENT_ROOTS).filterIsInstance<JvmClasspathRoot>().map(JvmContentRoot::file)
+
+        val klibFiles = classpathFiles
+            .filter { it.extension == "klib" || it.isDirectory }
+
+        klibFiles.map { createKotlinLibrary(org.jetbrains.kotlin.konan.file.File(it.absolutePath)) }
+    }
+
+    private val friendPaths = configuration.get(K2MetadataConfigurationKeys.FRIEND_PATHS).orEmpty().toSet()
+    private val refinesPaths = configuration.get(K2MetadataConfigurationKeys.REFINES_PATHS).orEmpty().toSet()
+
+    private val builtIns
+        get() = DefaultBuiltIns.Instance
+
+    private class KlibModuleInfo(
+        override val name: Name,
+        val kotlinLibrary: KotlinLibrary,
+        private val dependOnKlibModules: List<ModuleInfo>
+    ) : ModuleInfo {
+        override fun dependencies(): List<ModuleInfo> = dependOnKlibModules
+
+        override fun dependencyOnBuiltIns(): ModuleInfo.DependencyOnBuiltIns = ModuleInfo.DependencyOnBuiltIns.LAST
+
+        override val platform: TargetPlatform
+            get() = CommonPlatforms.defaultCommonPlatform
+
+        override val analyzerServices: PlatformDependentAnalyzerServices
+            get() = CommonPlatformAnalyzerServices
+    }
+
+    private val moduleDescriptorsForKotlinLibraries: Map<KotlinLibrary, ModuleDescriptorImpl> =
+        kotlinLibraries.keysToMap { library ->
+            val moduleHeader = parseModuleHeader(library.moduleHeaderData)
+            val moduleName = Name.special(moduleHeader.moduleName)
+            val moduleOrigin = DeserializedKlibModuleOrigin(library)
+            MetadataFactories.DefaultDescriptorFactory.createDescriptor(
+                moduleName, storageManager, builtIns, moduleOrigin
+            )
+        }.also { result ->
+            val resultValues = result.values.toList()
+            val dependenciesForModuleDescriptors = resultValues + builtIns.builtInsModule
+            resultValues.forEach { module ->
+                module.setDependencies(dependenciesForModuleDescriptors)
+            }
+        }
+
+    private val moduleInfosImpl: List<KlibModuleInfo> = mutableListOf<KlibModuleInfo>().apply {
+        addAll(
+            moduleDescriptorsForKotlinLibraries.map { (kotlinLibrary, moduleDescriptor) ->
+                KlibModuleInfo(moduleDescriptor.name, kotlinLibrary, this@apply)
+            }
+        )
+    }
+
+    override val moduleInfos: List<ModuleInfo> get() = moduleInfosImpl
+
+    override val friendModuleInfos: List<ModuleInfo> = moduleInfosImpl.filter {
+        it.kotlinLibrary.libraryFile.absolutePath in friendPaths
+    }
+
+    override val refinesModuleInfos: List<ModuleInfo> = moduleInfosImpl.filter {
+        it.kotlinLibrary.libraryFile.absolutePath in refinesPaths
+    }
+
+    override fun moduleDescriptorForModuleInfo(moduleInfo: ModuleInfo): ModuleDescriptor {
+        if (moduleInfo !in moduleInfos)
+            error("Unknown module info $moduleInfo")
+        moduleInfo as KlibModuleInfo
+
+        // Ensure that the package fragment provider has been created and the module descriptor has been
+        // initialized with the package fragment provider:
+        packageFragmentProviderForModuleInfo(moduleInfo)
+
+        return moduleDescriptorsForKotlinLibraries.getValue(moduleInfo.kotlinLibrary)
+    }
+
+    override fun packageFragmentProviderForModuleInfo(
+        moduleInfo: ModuleInfo
+    ): PackageFragmentProvider? {
+        if (moduleInfo !in moduleInfos)
+            return null
+        moduleInfo as KlibModuleInfo
+        return packageFragmentProviderForKotlinLibrary(moduleInfo.kotlinLibrary)
+    }
+
+    private val klibMetadataModuleDescriptorFactory by lazy {
+        KlibMetadataModuleDescriptorFactoryImpl(
+            MetadataFactories.DefaultDescriptorFactory,
+            MetadataFactories.DefaultPackageFragmentsFactory,
+            MetadataFactories.flexibleTypeDeserializer
+        )
+    }
+
+    private fun packageFragmentProviderForKotlinLibrary(
+        library: KotlinLibrary
+    ): PackageFragmentProvider {
+        val languageVersionSettings = configuration.languageVersionSettings
+
+        val libraryModuleDescriptor = moduleDescriptorsForKotlinLibraries.getValue(library)
+        val packageFragmentNames = parseModuleHeader(library.moduleHeaderData).packageFragmentNameList
+
+        return klibMetadataModuleDescriptorFactory.createPackageFragmentProvider(
+            library,
+            packageAccessHandler = null,
+            packageFragmentNames = packageFragmentNames,
+            storageManager = LockBasedStorageManager("KlibMetadataPackageFragmentProvider"),
+            moduleDescriptor = libraryModuleDescriptor,
+            configuration = CompilerDeserializationConfiguration(languageVersionSettings),
+            compositePackageFragmentAddend = null
+        ).also {
+            libraryModuleDescriptor.initialize(it)
+        }
+    }
+
+}
+
+private val MetadataFactories =
+    KlibMetadataFactories(
+        { DefaultBuiltIns.Instance },
+        org.jetbrains.kotlin.serialization.konan.NullFlexibleTypeDeserializer
+    )

compiler/cli/src/org/jetbrains/kotlin/cli/metadata/MetadataSerializer.kt

@@ -16,14 +16,8 @@
 
 package org.jetbrains.kotlin.cli.metadata
 
-import org.jetbrains.kotlin.analyzer.common.CommonResolverForModuleFactory
-import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
-import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.codegen.JvmCodegenUtil
-import org.jetbrains.kotlin.config.CommonConfigurationKeys
-import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
@@ -37,7 +31,6 @@ import org.jetbrains.kotlin.metadata.jvm.deserialization.PackageParts
 import org.jetbrains.kotlin.metadata.jvm.deserialization.serializeToByteArray
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
@@ -56,28 +49,14 @@ open class MetadataSerializer(
     protected var totalFiles = 0
 
     fun serialize(environment: KotlinCoreEnvironment) {
-        val configuration = environment.configuration
-        val messageCollector = configuration.getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
-        val files = environment.getSourceFiles()
-        val moduleName = Name.special("<${configuration.getNotNull(CommonConfigurationKeys.MODULE_NAME)}>")
+        val analyzer = runCommonAnalysisForSerialization(environment, dependOnOldBuiltIns, dependencyContainer = null)
 
-        val destDir = configuration.get(CLIConfigurationKeys.METADATA_DESTINATION_DIRECTORY) ?: run {
-            messageCollector.report(CompilerMessageSeverity.ERROR, "Specify destination via -d")
-            return
-        }
-
-        val analyzer = AnalyzerWithCompilerReport(messageCollector, configuration.languageVersionSettings)
-        analyzer.analyzeAndReport(files) {
-            CommonResolverForModuleFactory.analyzeFiles(files, moduleName, dependOnOldBuiltIns, configuration.languageVersionSettings) { content ->
-                environment.createPackagePartProvider(content.moduleContentScope)
-            }
-        }
-
-        if (analyzer.hasErrors()) return
+        if (analyzer == null || analyzer.hasErrors()) return
 
         val (bindingContext, moduleDescriptor) = analyzer.analysisResult
 
-        performSerialization(files, bindingContext, moduleDescriptor, destDir)
+        val destDir = checkNotNull(environment.destDir)
+        performSerialization(environment.getSourceFiles(), bindingContext, moduleDescriptor, destDir)
     }
 
     protected open fun performSerialization(

compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/ConeTypes.kt

@@ -144,7 +144,8 @@ fun ConeKotlinType.lowerBoundIfFlexible() = (this as? ConeFlexibleType)?.lowerBo
 
 class ConeCapturedTypeConstructor(
     val projection: ConeKotlinTypeProjection,
-    var supertypes: List<ConeKotlinType>? = null
+    var supertypes: List<ConeKotlinType>? = null,
+    val typeParameterMarker: TypeParameterMarker? = null
 ) : CapturedTypeConstructorMarker
 
 class ConeCapturedType(
@@ -153,11 +154,15 @@ class ConeCapturedType(
     override val nullability: ConeNullability = ConeNullability.NOT_NULL,
     val constructor: ConeCapturedTypeConstructor
 ) : ConeSimpleKotlinType(), CapturedTypeMarker {
-    constructor(captureStatus: CaptureStatus, lowerType: ConeKotlinType?, projection: ConeKotlinTypeProjection) : this(
+    constructor(
+        captureStatus: CaptureStatus, lowerType: ConeKotlinType?, projection: ConeKotlinTypeProjection,
+        typeParameterMarker: TypeParameterMarker
+    ) : this(
         captureStatus,
         lowerType,
         constructor = ConeCapturedTypeConstructor(
-            projection
+            projection,
+            typeParameterMarker = typeParameterMarker
         )
     )
 

compiler/fir/fir2ir/tests/org/jetbrains/kotlin/fir/Fir2IrTextTestGenerated.java

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

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaElementFinder.kt

@@ -57,7 +57,7 @@ class FirJavaElementFinder(
     }
 
     override fun findClasses(qualifiedName: String, scope: GlobalSearchScope): Array<PsiClass> {
-        return findClass(qualifiedName, scope)?.let(::arrayOf) ?: emptyArray()
+        return findClass(qualifiedName, scope)?.let { arrayOf(it) } ?: emptyArray()
     }
 
     override fun findClass(qualifiedName: String, scope: GlobalSearchScope): PsiClass? {

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt

@@ -297,7 +297,9 @@ class JavaSymbolProvider(
                         return firJavaConstructor
                     }
 
-                    if (javaClassDeclaredConstructors.isEmpty() && javaClass.classKind == ClassKind.CLASS) {
+                    if (javaClassDeclaredConstructors.isEmpty()
+                        && javaClass.classKind == ClassKind.CLASS
+                        && javaClass.hasDefaultConstructor()) {
                         addJavaConstructor(isPrimary = true)
                     }
                     for (javaConstructor in javaClassDeclaredConstructors) {

compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/converter/ExpressionsConverter.kt

@@ -599,8 +599,8 @@ class ExpressionsConverter(
         var isNegate = false
         var firExpression: FirExpression = FirErrorExpressionImpl(null, FirSimpleDiagnostic("No range in condition with range", DiagnosticKind.Syntax))
         whenCondition.forEachChildren {
-            when (it.tokenType) {
-                NOT_IN -> isNegate = true
+            when {
+                it.tokenType == OPERATION_REFERENCE && it.asText == NOT_IN.value -> isNegate = true
                 else -> if (it.isExpression()) firExpression = getAsFirExpression(it)
             }
         }

compiler/fir/lightTree/tests/org/jetbrains/kotlin/fir/lightTree/LightTree2FirConverterTestCaseGenerated.java

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

compiler/fir/modularized-tests/build.gradle.kts

@@ -9,8 +9,12 @@ plugins {
 }
 
 dependencies {
+    Platform[193].orLower {
+        testCompileOnly(intellijDep()) { includeJars("openapi", rootProject = rootProject) }
+    }
+
     testCompileOnly(intellijDep()) {
-        includeJars("openapi", "extensions", "idea", "idea_rt", "util", "asm-all", rootProject = rootProject)
+        includeJars("extensions", "idea_rt", "util", "asm-all", rootProject = rootProject)
     }
 
     Platform[191].orLower {

compiler/fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/RawFirBuilderTestCaseGenerated.java

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

compiler/fir/resolve/build.gradle.kts

@@ -13,7 +13,10 @@ dependencies {
     compileOnly(project(":kotlin-reflect-api"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core", "guava", rootProject = rootProject) }
 
-    testCompileOnly(intellijDep()) { includeJars("openapi", "idea", "idea_rt", "util", "asm-all", "extensions", rootProject = rootProject) }
+    Platform[193].orLower {
+        testCompileOnly(intellijDep()) { includeJars("openapi", rootProject = rootProject) }
+    }
+    testCompileOnly(intellijDep()) { includeJars("idea", "idea_rt", "util", "asm-all", "extensions", rootProject = rootProject) }
     testCompileOnly(intellijCoreDep()) { includeJars("intellij-core") }
     testRuntimeOnly(intellijCoreDep()) { includeJars("intellij-core") }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeInferenceContext.kt

@@ -248,6 +248,11 @@ interface ConeInferenceContext : TypeSystemInferenceExtensionContext, ConeTypeCo
         return this.constructor.projection
     }
 
+    override fun CapturedTypeMarker.typeParameter(): TypeParameterMarker? {
+        require(this is ConeCapturedType)
+        return this.constructor.typeParameterMarker
+    }
+
     override fun DefinitelyNotNullTypeMarker.original(): SimpleTypeMarker {
         require(this is ConeDefinitelyNotNullType)
         return this.original as SimpleTypeMarker

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/InferenceUtil.kt

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.resolve.calls.inference.components.ConstraintInjecto
 import org.jetbrains.kotlin.resolve.calls.inference.components.ResultTypeResolver
 import org.jetbrains.kotlin.resolve.calls.inference.components.TrivialConstraintTypeInferenceOracle
 import org.jetbrains.kotlin.resolve.calls.inference.model.NewConstraintSystemImpl
+import org.jetbrains.kotlin.resolve.calls.tower.KotlinResolutionStatelessCallbacksImpl
 import org.jetbrains.kotlin.types.AbstractTypeApproximator
 import org.jetbrains.kotlin.types.checker.KotlinTypeRefiner
 import org.jetbrains.kotlin.types.model.SimpleTypeMarker

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/IntegerLiteralTypeApproximationTransformer.kt

@@ -90,8 +90,8 @@ class IntegerLiteralTypeApproximationTransformer(
         val expectedType: ConeKotlinType? = when {
             !leftIsIlt && !rightIsIlt -> return operatorCall.compose()
             leftIsIlt && rightIsIlt -> null
-            leftIsIlt -> rightArgument.typeRef.coneTypeUnsafe()
-            rightIsIlt -> leftArgument.typeRef.coneTypeUnsafe()
+            leftIsIlt -> rightArgument.typeRef.coneTypeUnsafe<ConeKotlinType>()
+            rightIsIlt -> leftArgument.typeRef.coneTypeUnsafe<ConeKotlinType>()
             else -> throw IllegalStateException()
         }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt

@@ -164,7 +164,8 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty
         require(this is ConeKotlinType)
 
         return this.typeArguments.getOrNull(index)
-            ?: StandardClassIds.Any(session.firSymbolProvider).constructType(emptyArray(), false) // TODO wtf
+            ?: session.builtinTypes.anyType
+                .type//StandardClassIds.Any(session.firSymbolProvider).constructType(emptyArray(), false) // TODO wtf
     }
 
     override fun KotlinTypeMarker.asTypeArgument(): TypeArgumentMarker {
@@ -301,31 +302,32 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty
 
     override fun captureFromArguments(type: SimpleTypeMarker, status: CaptureStatus): SimpleTypeMarker? {
         require(type is ConeKotlinType)
-        val argumentsCount = type.argumentsCount()
+        val argumentsCount = type.typeArguments.size
         if (argumentsCount == 0) return null
 
         val typeConstructor = type.typeConstructor()
         if (argumentsCount != typeConstructor.parametersCount()) return null
 
-        if (type.asArgumentList().all(this) { !it.isStarProjection() && it.getVariance() == TypeVariance.INV }) return null
-        val newArguments = Array(argumentsCount) { index ->
-            val argument = type.getArgument(index)
-            if (!argument.isStarProjection() && argument.getVariance() == TypeVariance.INV) return@Array argument as ConeKotlinTypeProjection
+        if (type.typeArguments.all { it !is ConeStarProjection && it.kind == ProjectionKind.INVARIANT }) return null
 
-            val lowerType = if (!argument.isStarProjection() && argument.getVariance() == TypeVariance.IN) {
-                argument.getType() as ConeKotlinType
+        val newArguments = Array(argumentsCount) { index ->
+            val argument = type.typeArguments[index]
+            if (argument !is ConeStarProjection && argument.kind == ProjectionKind.INVARIANT) return@Array argument
+
+            val lowerType = if (argument !is ConeStarProjection && argument.getVariance() == TypeVariance.IN) {
+                (argument as ConeTypedProjection).type
             } else {
                 null
             }
 
-            ConeCapturedType(status, lowerType, argument as ConeKotlinTypeProjection)
+            ConeCapturedType(status, lowerType, argument, typeConstructor.getParameter(index))
         }
 
         for (index in 0 until argumentsCount) {
-            val oldArgument = type.getArgument(index)
+            val oldArgument = type.typeArguments[index]
             val newArgument = newArguments[index]
 
-            if (!oldArgument.isStarProjection() && oldArgument.getVariance() == TypeVariance.INV) continue
+            if (oldArgument !is ConeStarProjection && oldArgument.kind == ProjectionKind.INVARIANT) continue
 
             val parameter = typeConstructor.getParameter(index)
             val upperBounds = (0 until parameter.upperBoundCount()).mapTo(mutableListOf()) { paramIndex ->
@@ -460,9 +462,7 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty
     override fun TypeParameterMarker.getRepresentativeUpperBound(): KotlinTypeMarker {
         require(this is FirTypeParameterSymbol)
         return this.fir.bounds.getOrNull(0)?.let { (it as? FirResolvedTypeRef)?.type }
-            ?: ConeClassLikeTypeImpl(
-                ConeClassLikeLookupTagImpl(ClassId.topLevel(KotlinBuiltIns.FQ_NAMES.any.toSafe())), emptyArray(), true
-            )
+            ?: session.builtinTypes.nullableAnyType.type
     }
 
     override fun KotlinTypeMarker.getSubstitutedUnderlyingType(): KotlinTypeMarker? {
@@ -514,7 +514,8 @@ class ConeTypeCheckerContext(
             val substitution =
                 declaration.typeParameters.zip(type.typeArguments).associate { (parameter, argument) ->
                     parameter.symbol to ((argument as? ConeTypedProjection)?.type
-                        ?: StandardClassIds.Any(session.firSymbolProvider).constructType(emptyArray(), isNullable = true))
+                        ?: session.builtinTypes.nullableAnyType
+                            .type)//StandardClassIds.Any(session.firSymbolProvider).constructType(emptyArray(), isNullable = true))
                 }
             substitutorByMap(substitution)
         } else {

compiler/fir/resolve/testData/resolve/arguments/lambdaInLambda2.kt

@@ -1,3 +1,5 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
 // FILE: Function.java
 
 public interface Function<Param, Result> {
@@ -20,7 +22,8 @@ interface PsiMethod {
 interface PsiClass
 
 fun test() {
-    val processor = AdapterProcessor<PsiMethod, PsiClass>(
+    // TODO: don't forget to implement preservation flexibility of java type parameters in FIR (this is the reason of error here)
+    val processor = <!INAPPLICABLE_CANDIDATE!>AdapterProcessor<!><PsiMethod, PsiClass>(
         Function { method: PsiMethod? -> method?.containingClass }
     )
 }

compiler/fir/resolve/testData/resolve/arguments/lambdaInLambda2.txt

@@ -7,7 +7,7 @@ FILE: main.kt
     public abstract interface PsiClass : R|kotlin/Any| {
     }
     public final fun test(): R|kotlin/Unit| {
-        lval processor: R|AdapterProcessor<PsiMethod, PsiClass>| = R|/AdapterProcessor.AdapterProcessor|<R|PsiMethod|, R|PsiClass|>(R|/Function|<R|PsiMethod|, R|ft<PsiClass, PsiClass?>!|>(<L> = Function@fun <anonymous>(method: R|PsiMethod?|): R|PsiClass?| {
+        lval processor: <ERROR TYPE REF: Inapplicable(INAPPLICABLE): [/AdapterProcessor.AdapterProcessor]> = <Inapplicable(INAPPLICABLE): [/AdapterProcessor.AdapterProcessor]>#<R|PsiMethod|, R|PsiClass|>(R|/Function|<R|PsiMethod?|, R|PsiClass?|>(<L> = Function@fun <anonymous>(method: R|PsiMethod?|): R|PsiClass?| {
             R|<local>/method|?.R|/PsiMethod.containingClass|
         }
         ))

compiler/fir/resolve/testData/resolve/samConstructors/genericSam.txt

@@ -4,11 +4,11 @@ FILE: main.kt
             R|<local>/x|.R|kotlin/Int.toInt|().R|kotlin/Any.toString|()
         }
         )
-        R|/MyFunction|<R|kotlin/Int|, R|kotlin/String|>(<L> = MyFunction@fun <anonymous>(x: R|kotlin/Int|): R|kotlin/String| {
+        R|/MyFunction|<R|ft<kotlin/Int, kotlin/Int?>!|, R|ft<kotlin/String, kotlin/String?>!|>(<L> = MyFunction@fun <anonymous>(x: R|kotlin/Int|): R|kotlin/String| {
             R|<local>/x|.R|kotlin/Any.toString|()
         }
         )
-        R|/MyFunction|<R|kotlin/Any?|, R|kotlin/String|>(<L> = MyFunction@fun <anonymous>(x: R|kotlin/Any?|): R|kotlin/String| {
+        R|/MyFunction|<R|kotlin/Any?|, R|ft<kotlin/String, kotlin/String?>!|>(<L> = MyFunction@fun <anonymous>(x: R|kotlin/Any?|): R|kotlin/String| {
             String()
         }
         )

compiler/fir/resolve/testData/resolve/samConstructors/genericSamInferenceFromExpectType.txt

@@ -10,19 +10,19 @@ FILE: main.kt
             R|<local>/x|.R|kotlin/Int.toInt|().R|kotlin/Any.toString|()
         }
         ))
-        R|/foo2|(R|/MyFunction|<R|kotlin/Number|, R|kotlin/String|>(<L> = MyFunction@fun <anonymous>(x: R|kotlin/Number|): R|kotlin/String| {
+        R|/foo2|(R|/MyFunction|<R|kotlin/Number|, R|ft<kotlin/String, kotlin/String?>!|>(<L> = MyFunction@fun <anonymous>(x: R|kotlin/Number|): R|kotlin/String| {
             R|<local>/x|.R|kotlin/Number.toInt|().R|kotlin/Any.toString|()
         }
         ))
-        <Inapplicable(INAPPLICABLE): [/foo2]>#(R|/MyFunction|<R|kotlin/Int|, R|kotlin/String|>(<L> = MyFunction@fun <anonymous>(x: R|kotlin/Int|): R|kotlin/String| {
+        <Inapplicable(INAPPLICABLE): [/foo2]>#(R|/MyFunction|<R|ft<kotlin/Int, kotlin/Int?>!|, R|ft<kotlin/String, kotlin/String?>!|>(<L> = MyFunction@fun <anonymous>(x: R|kotlin/Int|): R|kotlin/String| {
             R|<local>/x|.R|kotlin/Any.toString|()
         }
         ))
-        R|/foo3|<R|kotlin/Int|, R|kotlin/String|>(R|/MyFunction|<R|kotlin/Int|, R|kotlin/String|>(<L> = MyFunction@fun <anonymous>(x: R|kotlin/Int|): R|kotlin/String| {
+        R|/foo3|<R|kotlin/Int|, R|ft<kotlin/String, kotlin/String?>!|>(R|/MyFunction|<R|kotlin/Int|, R|ft<kotlin/String, kotlin/String?>!|>(<L> = MyFunction@fun <anonymous>(x: R|kotlin/Int|): R|kotlin/String| {
             R|<local>/x|.R|kotlin/Int.plus|(Int(1)).R|kotlin/Any.toString|()
         }
         ), Int(1))
-        R|/foo3|<R|kotlin/Int|, R|kotlin/String|>(R|/MyFunction|<R|kotlin/Int|, R|kotlin/String|>(<L> = MyFunction@fun <anonymous>(x: R|kotlin/Number|): R|kotlin/String| {
+        R|/foo3|<R|kotlin/Int|, R|ft<kotlin/String, kotlin/String?>!|>(R|/MyFunction|<R|kotlin/Int|, R|ft<kotlin/String, kotlin/String?>!|>(<L> = MyFunction@fun <anonymous>(x: R|kotlin/Number|): R|kotlin/String| {
             R|<local>/x|.R|kotlin/Number.toInt|().R|kotlin/Any.toString|()
         }
         ), Int(2))

compiler/fir/resolve/testData/resolve/samConversions/genericSam.txt

@@ -12,11 +12,11 @@ FILE: main.kt
             R|<local>/x|.R|kotlin/Any.toString|()
         }
         )
-        Q|JavaUsage|.R|/JavaUsage.foo3|<R|kotlin/Int|, R|kotlin/String|>(foo3@fun <anonymous>(x: R|kotlin/Int|): R|kotlin/Unit| {
+        Q|JavaUsage|.R|/JavaUsage.foo3|<R|kotlin/Int|, R|ft<kotlin/String, kotlin/String?>!|>(foo3@fun <anonymous>(x: R|kotlin/Int|): R|kotlin/String| {
             R|<local>/x|.R|kotlin/Int.plus|(Int(1)).R|kotlin/Any.toString|()
         }
         , Int(1))
-        Q|JavaUsage|.R|/JavaUsage.foo3|<R|kotlin/Int|, R|kotlin/String|>(foo3@fun <anonymous>(x: R|kotlin/Number|): R|kotlin/Unit| {
+        Q|JavaUsage|.R|/JavaUsage.foo3|<R|kotlin/Int|, R|ft<kotlin/String, kotlin/String?>!|>(foo3@fun <anonymous>(x: R|kotlin/Number|): R|kotlin/String| {
             R|<local>/x|.R|kotlin/Number.toInt|().R|kotlin/Any.toString|()
         }
         , Int(2))

compiler/fir/resolve/testData/resolve/stdlib/j+k/StaticGenericMethod.txt

@@ -13,7 +13,7 @@ FILE: User.kt
         protected abstract fun createSettings(): R|T|
 
         public final fun foo(): R|kotlin/Unit| {
-            this@R|/User|.R|FakeOverride</User.settings: R|T|>| = Q|StaticOwner|.R|/StaticOwner.newInstance|<R|T|>(this@R|/User|.R|FakeOverride</User.settings: R|T|>|.R|kotlin/jvm/javaClass|)
+            this@R|/User|.R|FakeOverride</User.settings: R|T|>| = Q|StaticOwner|.R|/StaticOwner.newInstance|<R|ft<T, T?>!|>(this@R|/User|.R|FakeOverride</User.settings: R|T|>|.R|kotlin/jvm/javaClass|)
         }
 
     }

compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirOldFrontendDiagnosticsTest.kt

@@ -25,6 +25,7 @@ abstract class AbstractFirOldFrontendDiagnosticsTest : AbstractFirDiagnosticsTes
     }
 
     override fun runAnalysis(testDataFile: File, testFiles: List<TestFile>, firFiles: List<FirFile>) {
+        if (testFiles.any { it.directives.containsKey("FIR_IGNORE") }) return
         val failure: AssertionError? = try {
             doFirResolveTestBench(firFiles, FirTotalResolveTransformer().transformers, gc = false)
             null

compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirDiagnosticsTestGenerated.java

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

compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirDiagnosticsWithCfgAndStdlibTestGenerated.java

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

compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirDiagnosticsWithCfgTestGenerated.java

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

compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirDiagnosticsWithStdlibTestGenerated.java

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

compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirLoadCompiledKotlinGenerated.java

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

compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirOldFrontendDiagnosticsTestGenerated.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -970,6 +970,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/annotations/javaUnrepeatable.kt");
         }
 
+        @TestMetadata("kotlinAnnotationOnJavaInterface.kt")
+        public void testKotlinAnnotationOnJavaInterface() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/annotations/kotlinAnnotationOnJavaInterface.kt");
+        }
+
         @TestMetadata("kt1860-negative.kt")
         public void testKt1860_negative() throws Exception {
             runTest("compiler/testData/diagnostics/tests/annotations/kt1860-negative.kt");
@@ -1789,6 +1794,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirection.kt");
         }
 
+        @TestMetadata("constraintFromLHSWithCorrectDirectionError.kt")
+        public void testConstraintFromLHSWithCorrectDirectionError() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirectionError.kt");
+        }
+
         @TestMetadata("correctInfoAfterArrayLikeCall.kt")
         public void testCorrectInfoAfterArrayLikeCall() throws Exception {
             runTest("compiler/testData/diagnostics/tests/callableReference/correctInfoAfterArrayLikeCall.kt");
@@ -1839,16 +1849,46 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/callableReference/kt32256.kt");
         }
 
+        @TestMetadata("kt32267.kt")
+        public void testKt32267() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/callableReference/kt32267.kt");
+        }
+
+        @TestMetadata("kt34314.kt")
+        public void testKt34314() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/callableReference/kt34314.kt");
+        }
+
+        @TestMetadata("kt34314_lambda.kt")
+        public void testKt34314_lambda() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/callableReference/kt34314_lambda.kt");
+        }
+
+        @TestMetadata("kt35959.kt")
+        public void testKt35959() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/callableReference/kt35959.kt");
+        }
+
         @TestMetadata("kt7430_wrongClassOnLHS.kt")
         public void testKt7430_wrongClassOnLHS() throws Exception {
             runTest("compiler/testData/diagnostics/tests/callableReference/kt7430_wrongClassOnLHS.kt");
         }
 
+        @TestMetadata("lambdaResult.kt")
+        public void testLambdaResult() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/callableReference/lambdaResult.kt");
+        }
+
         @TestMetadata("memberExtensionsImportedFromObjectsUnsupported.kt")
         public void testMemberExtensionsImportedFromObjectsUnsupported() throws Exception {
             runTest("compiler/testData/diagnostics/tests/callableReference/memberExtensionsImportedFromObjectsUnsupported.kt");
         }
 
+        @TestMetadata("noAmbiguityWhenAllReferencesAreInapplicable.kt")
+        public void testNoAmbiguityWhenAllReferencesAreInapplicable() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/callableReference/noAmbiguityWhenAllReferencesAreInapplicable.kt");
+        }
+
         @TestMetadata("noExceptionOnRedCodeWithArrayLikeCall.kt")
         public void testNoExceptionOnRedCodeWithArrayLikeCall() throws Exception {
             runTest("compiler/testData/diagnostics/tests/callableReference/noExceptionOnRedCodeWithArrayLikeCall.kt");
@@ -2342,6 +2382,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 runTest("compiler/testData/diagnostics/tests/callableReference/generic/kt12286.kt");
             }
 
+            @TestMetadata("kt35896.kt")
+            public void testKt35896() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/callableReference/generic/kt35896.kt");
+            }
+
             @TestMetadata("kt7470.kt")
             public void testKt7470() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/callableReference/generic/kt7470.kt");
@@ -2410,6 +2455,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 runTest("compiler/testData/diagnostics/tests/callableReference/property/extensionPropertyOnNullable.kt");
             }
 
+            @TestMetadata("extensionsSameName.kt")
+            public void testExtensionsSameName() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/callableReference/property/extensionsSameName.kt");
+            }
+
             @TestMetadata("genericClass.kt")
             public void testGenericClass() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/callableReference/property/genericClass.kt");
@@ -2488,6 +2538,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 runTest("compiler/testData/diagnostics/tests/callableReference/resolve/ambiguityWhenNoApplicableCallableReferenceCandidate.kt");
             }
 
+            @TestMetadata("ambiguityWithBoundExtensionReceiver.kt")
+            public void testAmbiguityWithBoundExtensionReceiver() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/callableReference/resolve/ambiguityWithBoundExtensionReceiver.kt");
+            }
+
             @TestMetadata("ambiguousWithVararg.kt")
             public void testAmbiguousWithVararg() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/callableReference/resolve/ambiguousWithVararg.kt");
@@ -2513,6 +2568,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 runTest("compiler/testData/diagnostics/tests/callableReference/resolve/byValType.kt");
             }
 
+            @TestMetadata("callableReferenceToVarargWithOverload.kt")
+            public void testCallableReferenceToVarargWithOverload() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/callableReference/resolve/callableReferenceToVarargWithOverload.kt");
+            }
+
             @TestMetadata("chooseCallableReferenceDependingOnInferredReceiver.kt")
             public void testChooseCallableReferenceDependingOnInferredReceiver() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/callableReference/resolve/chooseCallableReferenceDependingOnInferredReceiver.kt");
@@ -2578,6 +2638,21 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 runTest("compiler/testData/diagnostics/tests/callableReference/resolve/kt12751.kt");
             }
 
+            @TestMetadata("kt35887.kt")
+            public void testKt35887() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/callableReference/resolve/kt35887.kt");
+            }
+
+            @TestMetadata("kt35887_simple.kt")
+            public void testKt35887_simple() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/callableReference/resolve/kt35887_simple.kt");
+            }
+
+            @TestMetadata("kt35920.kt")
+            public void testKt35920() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/callableReference/resolve/kt35920.kt");
+            }
+
             @TestMetadata("kt8596.kt")
             public void testKt8596() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/callableReference/resolve/kt8596.kt");
@@ -8022,6 +8097,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/functionLiterals/LabeledFunctionLiterals.kt");
         }
 
+        @TestMetadata("lambdaInLambda2.kt")
+        public void testLambdaInLambda2() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/functionLiterals/lambdaInLambda2.kt");
+        }
+
         @TestMetadata("prematurelyAnalyzingLambdaWhileFixingTypeVariableForAnotherArgument.kt")
         public void testPrematurelyAnalyzingLambdaWhileFixingTypeVariableForAnotherArgument() throws Exception {
             runTest("compiler/testData/diagnostics/tests/functionLiterals/prematurelyAnalyzingLambdaWhileFixingTypeVariableForAnotherArgument.kt");
@@ -8286,6 +8366,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/generics/argumentsForT.kt");
         }
 
+        @TestMetadata("bareTypesWithStarProjections.kt")
+        public void testBareTypesWithStarProjections() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/generics/bareTypesWithStarProjections.kt");
+        }
+
         @TestMetadata("commonSupertypeContravariant.kt")
         public void testCommonSupertypeContravariant() throws Exception {
             runTest("compiler/testData/diagnostics/tests/generics/commonSupertypeContravariant.kt");
@@ -8341,6 +8426,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/generics/kt30590.kt");
         }
 
+        @TestMetadata("kt34729.kt")
+        public void testKt34729() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/generics/kt34729.kt");
+        }
+
         @TestMetadata("kt5508.kt")
         public void testKt5508() throws Exception {
             runTest("compiler/testData/diagnostics/tests/generics/kt5508.kt");
@@ -9713,6 +9803,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/inference/completeInferenceIfManyFailed.kt");
         }
 
+        @TestMetadata("completionOfMultipleLambdas.kt")
+        public void testCompletionOfMultipleLambdas() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/inference/completionOfMultipleLambdas.kt");
+        }
+
         @TestMetadata("conflictingSubstitutions.kt")
         public void testConflictingSubstitutions() throws Exception {
             runTest("compiler/testData/diagnostics/tests/inference/conflictingSubstitutions.kt");
@@ -9838,6 +9933,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/inference/intersectionTypeMultipleBoundsAsReceiver.kt");
         }
 
+        @TestMetadata("intersectionWithEnum.kt")
+        public void testIntersectionWithEnum() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/inference/intersectionWithEnum.kt");
+        }
+
         @TestMetadata("invokeLambdaAsFunction.kt")
         public void testInvokeLambdaAsFunction() throws Exception {
             runTest("compiler/testData/diagnostics/tests/inference/invokeLambdaAsFunction.kt");
@@ -9883,6 +9983,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/inference/kt3184.kt");
         }
 
+        @TestMetadata("kt32196.kt")
+        public void testKt32196() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/inference/kt32196.kt");
+        }
+
         @TestMetadata("kt32415.kt")
         public void testKt32415() throws Exception {
             runTest("compiler/testData/diagnostics/tests/inference/kt32415.kt");
@@ -9893,6 +9998,21 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/inference/kt32434.kt");
         }
 
+        @TestMetadata("kt32462.kt")
+        public void testKt32462() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/inference/kt32462.kt");
+        }
+
+        @TestMetadata("kt33263.kt")
+        public void testKt33263() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/inference/kt33263.kt");
+        }
+
+        @TestMetadata("kt35702.kt")
+        public void testKt35702() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/inference/kt35702.kt");
+        }
+
         @TestMetadata("kt6175.kt")
         public void testKt6175() throws Exception {
             runTest("compiler/testData/diagnostics/tests/inference/kt6175.kt");
@@ -9903,6 +10023,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/inference/kt619.kt");
         }
 
+        @TestMetadata("lambdaArgumentWithLabel.kt")
+        public void testLambdaArgumentWithLabel() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/inference/lambdaArgumentWithLabel.kt");
+        }
+
         @TestMetadata("lambdaInValInitializerWithAnonymousFunctions.kt")
         public void testLambdaInValInitializerWithAnonymousFunctions() throws Exception {
             runTest("compiler/testData/diagnostics/tests/inference/lambdaInValInitializerWithAnonymousFunctions.kt");
@@ -9968,6 +10093,31 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/inference/reportAboutUnresolvedReferenceAsUnresolved.kt");
         }
 
+        @TestMetadata("starApproximation.kt")
+        public void testStarApproximation() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/inference/starApproximation.kt");
+        }
+
+        @TestMetadata("starApproximationBangBang.kt")
+        public void testStarApproximationBangBang() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/inference/starApproximationBangBang.kt");
+        }
+
+        @TestMetadata("starApproximationFlexible.kt")
+        public void testStarApproximationFlexible() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/inference/starApproximationFlexible.kt");
+        }
+
+        @TestMetadata("starApproximationFromDifferentTypeParameter.kt")
+        public void testStarApproximationFromDifferentTypeParameter() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/inference/starApproximationFromDifferentTypeParameter.kt");
+        }
+
+        @TestMetadata("tooEagerSmartcast.kt")
+        public void testTooEagerSmartcast() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/inference/tooEagerSmartcast.kt");
+        }
+
         @TestMetadata("tryNumberLowerBoundsBeforeUpperBounds.kt")
         public void testTryNumberLowerBoundsBeforeUpperBounds() throws Exception {
             runTest("compiler/testData/diagnostics/tests/inference/tryNumberLowerBoundsBeforeUpperBounds.kt");
@@ -10158,6 +10308,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionToUnitForLastLambdaInLambda.kt");
             }
 
+            @TestMetadata("coercionToUnitReference.kt")
+            public void testCoercionToUnitReference() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionToUnitReference.kt");
+            }
+
             @TestMetadata("coercionWithExpectedType.kt")
             public void testCoercionWithExpectedType() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExpectedType.kt");
@@ -10337,6 +10492,59 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             }
         }
 
+        @TestMetadata("compiler/testData/diagnostics/tests/inference/completion")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Completion extends AbstractFirOldFrontendDiagnosticsTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInCompletion() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/completion"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true);
+            }
+
+            @TestMetadata("anonymousFunction.kt")
+            public void testAnonymousFunction() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/completion/anonymousFunction.kt");
+            }
+
+            @TestMetadata("basic.kt")
+            public void testBasic() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/completion/basic.kt");
+            }
+
+            @TestMetadata("equalityConstraintUpstairs.kt")
+            public void testEqualityConstraintUpstairs() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/completion/equalityConstraintUpstairs.kt");
+            }
+
+            @TestMetadata("kt33166.kt")
+            public void testKt33166() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/completion/kt33166.kt");
+            }
+
+            @TestMetadata("lambdaWithVariableAndNothing.kt")
+            public void testLambdaWithVariableAndNothing() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/completion/lambdaWithVariableAndNothing.kt");
+            }
+
+            @TestMetadata("partialForIlt.kt")
+            public void testPartialForIlt() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/completion/partialForIlt.kt");
+            }
+
+            @TestMetadata("transitiveConstraint.kt")
+            public void testTransitiveConstraint() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/completion/transitiveConstraint.kt");
+            }
+
+            @TestMetadata("withExact.kt")
+            public void testWithExact() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/completion/withExact.kt");
+            }
+        }
+
         @TestMetadata("compiler/testData/diagnostics/tests/inference/constraints")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
@@ -10536,6 +10744,16 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             public void testNontrivialCallExpression() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/nontrivialCallExpression.kt");
             }
+
+            @TestMetadata("preferArgumentToNullability.kt")
+            public void testPreferArgumentToNullability() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/preferArgumentToNullability.kt");
+            }
+
+            @TestMetadata("preferNothingToBound.kt")
+            public void testPreferNothingToBound() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/preferNothingToBound.kt");
+            }
         }
 
         @TestMetadata("compiler/testData/diagnostics/tests/inference/nothingType")
@@ -10555,6 +10773,16 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 runTest("compiler/testData/diagnostics/tests/inference/nothingType/complexDependancyOnVariableWithTrivialConstraint.kt");
             }
 
+            @TestMetadata("discriminateNothingForReifiedParameter.kt")
+            public void testDiscriminateNothingForReifiedParameter() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/nothingType/discriminateNothingForReifiedParameter.kt");
+            }
+
+            @TestMetadata("discriminatedNothingAndSmartCast.kt")
+            public void testDiscriminatedNothingAndSmartCast() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/nothingType/discriminatedNothingAndSmartCast.kt");
+            }
+
             @TestMetadata("generateConstraintWithInnerNothingType.kt")
             public void testGenerateConstraintWithInnerNothingType() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/inference/nothingType/generateConstraintWithInnerNothingType.kt");
@@ -10570,6 +10798,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 runTest("compiler/testData/diagnostics/tests/inference/nothingType/implicitNothingConstraintFromReturn.kt");
             }
 
+            @TestMetadata("inferArgumentToNothingFromNullConstant.kt")
+            public void testInferArgumentToNothingFromNullConstant() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/nothingType/inferArgumentToNothingFromNullConstant.kt");
+            }
+
             @TestMetadata("kt24490.kt")
             public void testKt24490() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/inference/nothingType/kt24490.kt");
@@ -10605,6 +10838,16 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 runTest("compiler/testData/diagnostics/tests/inference/nothingType/nestedLambdaInferenceWithIncorporationOfVariables.kt");
             }
 
+            @TestMetadata("notEnoughInformationAndNothing.kt")
+            public void testNotEnoughInformationAndNothing() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/nothingType/notEnoughInformationAndNothing.kt");
+            }
+
+            @TestMetadata("notEnoughInformationFromNullabilityConstraint.kt")
+            public void testNotEnoughInformationFromNullabilityConstraint() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/nothingType/notEnoughInformationFromNullabilityConstraint.kt");
+            }
+
             @TestMetadata("nothingWithCallableReference.kt")
             public void testNothingWithCallableReference() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/inference/nothingType/nothingWithCallableReference.kt");
@@ -10864,6 +11107,16 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 runTest("compiler/testData/diagnostics/tests/inference/regressions/kt3174.kt");
             }
 
+            @TestMetadata("kt32106.kt")
+            public void testKt32106() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/regressions/kt32106.kt");
+            }
+
+            @TestMetadata("kt32250.kt")
+            public void testKt32250() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/regressions/kt32250.kt");
+            }
+
             @TestMetadata("kt32862_both.kt")
             public void testKt32862_both() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/inference/regressions/kt32862_both.kt");
@@ -10909,6 +11162,16 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 runTest("compiler/testData/diagnostics/tests/inference/regressions/kt3559.kt");
             }
 
+            @TestMetadata("kt35844.kt")
+            public void testKt35844() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/regressions/kt35844.kt");
+            }
+
+            @TestMetadata("kt35943.kt")
+            public void testKt35943() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/regressions/kt35943.kt");
+            }
+
             @TestMetadata("kt4420.kt")
             public void testKt4420() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/inference/regressions/kt4420.kt");
@@ -11098,6 +11361,16 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 runTest("compiler/testData/diagnostics/tests/inference/upperBounds/doNotInferFromBoundsOnly.kt");
             }
 
+            @TestMetadata("flexibilityInCommonSuperTypeCalculation.kt")
+            public void testFlexibilityInCommonSuperTypeCalculation() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/upperBounds/flexibilityInCommonSuperTypeCalculation.kt");
+            }
+
+            @TestMetadata("flexibilityInCommonSuperTypeCalculation.ni.kt")
+            public void testFlexibilityInCommonSuperTypeCalculation_ni() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/upperBounds/flexibilityInCommonSuperTypeCalculation.ni.kt");
+            }
+
             @TestMetadata("intersectUpperBounds.kt")
             public void testIntersectUpperBounds() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/inference/upperBounds/intersectUpperBounds.kt");
@@ -14640,6 +14913,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/nullableTypes/elvisOnUnit.kt");
         }
 
+        @TestMetadata("inferenceFlexibleTToNullable.kt")
+        public void testInferenceFlexibleTToNullable() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/nullableTypes/inferenceFlexibleTToNullable.kt");
+        }
+
         @TestMetadata("nullAssertOnTypeWithNullableUpperBound.kt")
         public void testNullAssertOnTypeWithNullableUpperBound() throws Exception {
             runTest("compiler/testData/diagnostics/tests/nullableTypes/nullAssertOnTypeWithNullableUpperBound.kt");
@@ -14685,6 +14963,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/nullableTypes/safeCallWithInvoke.kt");
         }
 
+        @TestMetadata("takingNullabilityFromExplicitTypeArgmentsInsteadOfUsingFlexibleTypes.kt")
+        public void testTakingNullabilityFromExplicitTypeArgmentsInsteadOfUsingFlexibleTypes() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/nullableTypes/takingNullabilityFromExplicitTypeArgmentsInsteadOfUsingFlexibleTypes.kt");
+        }
+
         @TestMetadata("uselessElvis.kt")
         public void testUselessElvis() throws Exception {
             runTest("compiler/testData/diagnostics/tests/nullableTypes/uselessElvis.kt");
@@ -17390,6 +17673,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/regressions/kt302.kt");
         }
 
+        @TestMetadata("kt30245.kt")
+        public void testKt30245() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/regressions/kt30245.kt");
+        }
+
         @TestMetadata("kt306.kt")
         public void testKt306() throws Exception {
             runTest("compiler/testData/diagnostics/tests/regressions/kt306.kt");
@@ -17425,6 +17713,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/regressions/kt32205.kt");
         }
 
+        @TestMetadata("kt32507.kt")
+        public void testKt32507() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/regressions/kt32507.kt");
+        }
+
         @TestMetadata("kt328.kt")
         public void testKt328() throws Exception {
             runTest("compiler/testData/diagnostics/tests/regressions/kt328.kt");
@@ -17465,6 +17758,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/regressions/kt3535.kt");
         }
 
+        @TestMetadata("kt35668.kt")
+        public void testKt35668() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/regressions/kt35668.kt");
+        }
+
         @TestMetadata("kt3647.kt")
         public void testKt3647() throws Exception {
             runTest("compiler/testData/diagnostics/tests/regressions/kt3647.kt");
@@ -17765,6 +18063,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/regressions/SpecififcityByReceiver.kt");
         }
 
+        @TestMetadata("testNestedSpecialCalls.kt")
+        public void testTestNestedSpecialCalls() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/regressions/testNestedSpecialCalls.kt");
+        }
+
         @TestMetadata("TypeMismatchOnUnaryOperations.kt")
         public void testTypeMismatchOnUnaryOperations() throws Exception {
             runTest("compiler/testData/diagnostics/tests/regressions/TypeMismatchOnUnaryOperations.kt");
@@ -18658,6 +18961,21 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/samConversions/SAMAfterSubstitutionKT.kt");
         }
 
+        @TestMetadata("samConversionToGeneric.kt")
+        public void testSamConversionToGeneric() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/samConversions/samConversionToGeneric.kt");
+        }
+
+        @TestMetadata("samConversionsWithSmartCasts.kt")
+        public void testSamConversionsWithSmartCasts() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/samConversions/samConversionsWithSmartCasts.kt");
+        }
+
+        @TestMetadata("sameCandidatesFromKotlinAndJavaInOneScope.kt")
+        public void testSameCandidatesFromKotlinAndJavaInOneScope() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/samConversions/sameCandidatesFromKotlinAndJavaInOneScope.kt");
+        }
+
         @TestMetadata("SimpleCorrect.kt")
         public void testSimpleCorrect() throws Exception {
             runTest("compiler/testData/diagnostics/tests/samConversions/SimpleCorrect.kt");
@@ -22359,6 +22677,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/OverrideGetterOnly.kt");
             }
 
+            @TestMetadata("PartiallySupportedSyntheticJavaPropertyReference.kt")
+            public void testPartiallySupportedSyntheticJavaPropertyReference() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/PartiallySupportedSyntheticJavaPropertyReference.kt");
+            }
+
             @TestMetadata("SetterHasHigherAccess.kt")
             public void testSetterHasHigherAccess() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/SetterHasHigherAccess.kt");

compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirOldFrontendDiagnosticsTestWithStdlibGenerated.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -1856,6 +1856,11 @@ public class FirOldFrontendDiagnosticsTestWithStdlibGenerated extends AbstractFi
             runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt3458.kt");
         }
 
+        @TestMetadata("kt35847.kt")
+        public void testKt35847() throws Exception {
+            runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt35847.kt");
+        }
+
         @TestMetadata("kt4975.kt")
         public void testKt4975() throws Exception {
             runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt4975.kt");
@@ -1898,6 +1903,11 @@ public class FirOldFrontendDiagnosticsTestWithStdlibGenerated extends AbstractFi
                 runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt29307.kt");
             }
 
+            @TestMetadata("kt35210.kt")
+            public void testKt35210() throws Exception {
+                runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt35210.kt");
+            }
+
             @TestMetadata("noInferAndLowPriority.kt")
             public void testNoInferAndLowPriority() throws Exception {
                 runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAndLowPriority.kt");
@@ -1913,6 +1923,16 @@ public class FirOldFrontendDiagnosticsTestWithStdlibGenerated extends AbstractFi
                 runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/notNullAnnotation.kt");
             }
 
+            @TestMetadata("onlyInputTypeAndJava.kt")
+            public void testOnlyInputTypeAndJava() throws Exception {
+                runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypeAndJava.kt");
+            }
+
+            @TestMetadata("onlyInputTypeRecursiveBoundAndProjections.kt")
+            public void testOnlyInputTypeRecursiveBoundAndProjections() throws Exception {
+                runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypeRecursiveBoundAndProjections.kt");
+            }
+
             @TestMetadata("onlyInputTypes.kt")
             public void testOnlyInputTypes() throws Exception {
                 runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypes.kt");
@@ -1938,6 +1958,21 @@ public class FirOldFrontendDiagnosticsTestWithStdlibGenerated extends AbstractFi
                 runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesCaptured.kt");
             }
 
+            @TestMetadata("onlyInputTypesCommonConstraintSystem.kt")
+            public void testOnlyInputTypesCommonConstraintSystem() throws Exception {
+                runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesCommonConstraintSystem.kt");
+            }
+
+            @TestMetadata("onlyInputTypesUpperBound.kt")
+            public void testOnlyInputTypesUpperBound() throws Exception {
+                runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesUpperBound.kt");
+            }
+
+            @TestMetadata("onlyInputTypesWarning.kt")
+            public void testOnlyInputTypesWarning() throws Exception {
+                runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesWarning.kt");
+            }
+
             @TestMetadata("onlyInputTypesWithVarargs.kt")
             public void testOnlyInputTypesWithVarargs() throws Exception {
                 runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesWithVarargs.kt");
@@ -1953,6 +1988,34 @@ public class FirOldFrontendDiagnosticsTestWithStdlibGenerated extends AbstractFi
                 runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/resolveWithOnlyInputTypesAnnotation.kt");
             }
         }
+
+        @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/delegates")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Delegates extends AbstractFirOldFrontendDiagnosticsTestWithStdlib {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInDelegates() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/delegates"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true);
+            }
+
+            @TestMetadata("kt31219.kt")
+            public void testKt31219() throws Exception {
+                runTest("compiler/testData/diagnostics/testsWithStdLib/inference/delegates/kt31219.kt");
+            }
+
+            @TestMetadata("kt31679.kt")
+            public void testKt31679() throws Exception {
+                runTest("compiler/testData/diagnostics/testsWithStdLib/inference/delegates/kt31679.kt");
+            }
+
+            @TestMetadata("kt32249.kt")
+            public void testKt32249() throws Exception {
+                runTest("compiler/testData/diagnostics/testsWithStdLib/inference/delegates/kt32249.kt");
+            }
+        }
     }
 
     @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/inline")

compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/java/FirOldFrontendLightClassesTestGenerated.java

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