ScriptTemplatesClassRootsIndex: inc version and minor fixes

Content was changed, so we should force reindex.

Minor changes:
- There is no need to save a string, we can just save nothing
 by using the Unit value (see UnitKey.save and UnitKey.read)
- Unit can be shared between all indexes, so we can extract UnitKey object
- It would be good to extract abstract class FileListIndex:
  - for better readability: separate the logic of the specific index from the common FileListIndex implementation
  - someone can use it also
- mapOf (Unit to null) will create singletonMap itself and more readable
- ScriptTemplatesClassRootsIndex.KEY perhaps better to call NAME

.bunch

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

.gitattributes

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

.idea/codeStyles/Project.xml

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

.idea/runConfigurations/Test__stdlib_js_public_kotlin_api_test__overwrite_results.xml

@@ -4,12 +4,13 @@
       <option name="executionName" />
       <option name="externalProjectPath" value="$PROJECT_DIR$" />
       <option name="externalSystemIdString" value="GRADLE" />
-      <option name="scriptParameters" value="--tests &quot;org.jetbrains.kotlin.js.test.ApiTest&quot; -Poverwrite.output=true" />
+      <option name="scriptParameters" value="--tests &quot;org.jetbrains.kotlin.js.test.ApiTest&quot; -Poverwrite.output=true --parallel" />
       <option name="taskDescriptions">
         <list />
       </option>
       <option name="taskNames">
         <list>
+          <option value=":js:js.tests:cleanTest" />
           <option value=":js:js.tests:test" />
         </list>
       </option>

ChangeLog.md

@@ -100,6 +100,8 @@
 - [`KT-38668`](https://youtrack.jetbrains.com/issue/KT-38668) Project with module dependency in KN, build fails with Kotlin 1.3.71 and associated libs but passes with 1.3.61.
 - [`KT-38857`](https://youtrack.jetbrains.com/issue/KT-38857) Class versions V1_5 or less must use F_NEW frames.
 - [`KT-39113`](https://youtrack.jetbrains.com/issue/KT-39113) "AssertionError: Uninitialized value on stack" with EXACTLY_ONCE contract in non-inline function and lambda destructuring
+- [`KT-28483`](https://youtrack.jetbrains.com/issue/KT-28483) Override of generic-return-typed function with inline class should lead to a boxing
+- [`KT-37963`](https://youtrack.jetbrains.com/issue/KT-37963) ClassCastException: Value of inline class represented as 'java.lang.Object' is not boxed properly on return from lambda
 
 ### Docs & Examples
 
@@ -325,6 +327,7 @@
 - [`KT-38579`](https://youtrack.jetbrains.com/issue/KT-38579) New Project wizard 1.4+: multiplatform mobile application: build fails on lint task: Configuration with name 'compileClasspath' not found
 - [`KT-38929`](https://youtrack.jetbrains.com/issue/KT-38929) New project wizard: update libraries in project template according to kotlin IDE plugin version
 - [`KT-38417`](https://youtrack.jetbrains.com/issue/KT-38417) Enable new project wizard by-default
+- [`KT-38158`](https://youtrack.jetbrains.com/issue/KT-38158) java.lang.NullPointerException when try to create new project via standard wizard on Mac os
 
 ### JS. Tools
 
@@ -377,6 +380,7 @@
 - [`KT-16529`](https://youtrack.jetbrains.com/issue/KT-16529) Names of KProperty's type parameters are inconsistent with ReadOnlyProperty/ReadWriteProperty
 - [`KT-36356`](https://youtrack.jetbrains.com/issue/KT-36356) Specify which element Iterable.distinctBy(selector) retains
 - [`KT-38060`](https://youtrack.jetbrains.com/issue/KT-38060) runningFold and runningReduce instead of scanReduce
+- [`KT-38566`](https://youtrack.jetbrains.com/issue/KT-38566) Kotlin/JS IR: kx.serialization & ktor+JsonFeature: SerializationException: Can't locate argument-less serializer for class
 
 ### Reflection
 

ReadMe.md

@@ -41,7 +41,12 @@ For local development, if you're not working on bytecode generation or the stand
 
 You also can use [Gradle properties](https://docs.gradle.org/current/userguide/build_environment.html#sec:gradle_configuration_properties) to setup `JDK_*` variables.
 
-> Note: The JDK 6 for MacOS is not available on Oracle's site. You can [download it here](https://support.apple.com/kb/DL1572).
+Note: The JDK 6 for MacOS is not available on Oracle's site. You can install it by
+
+```bash
+$ brew tap caskroom/versions
+$ brew cask install java6
+```
 
 On Windows you might need to add long paths setting to the repo:
 

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

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

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

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

build.gradle.kts

@@ -152,6 +152,7 @@ rootProject.apply {
     from(rootProject.file("gradle/jps.gradle.kts"))
     from(rootProject.file("gradle/checkArtifacts.gradle.kts"))
     from(rootProject.file("gradle/checkCacheability.gradle.kts"))
+    from(rootProject.file("gradle/retryPublishing.gradle.kts"))
 }
 
 IdeVersionConfigurator.setCurrentIde(project)
@@ -365,6 +366,15 @@ allprojects {
         }
     }
 
+    configurations.maybeCreate("embeddedElements").apply {
+        extendsFrom(configurations["embedded"])
+        isCanBeConsumed = true
+        isCanBeResolved = false
+        attributes {
+            attribute(Usage.USAGE_ATTRIBUTE, objects.named("embedded-java-runtime"))
+        }
+    }
+
     jvmTarget = defaultJvmTarget
     javaHome = defaultJavaHome
 
@@ -513,6 +523,10 @@ val dist = tasks.register("dist") {
     dependsOn(":kotlin-compiler:dist")
 }
 
+val syncMutedTests = tasks.register("syncMutedTests") {
+    dependsOn(":compiler:tests-mutes:run")
+}
+
 val copyCompilerToIdeaPlugin by task<Copy> {
     dependsOn(dist)
     into(ideaPluginDir)
@@ -637,6 +651,7 @@ tasks {
         dependsOn(":kotlin-scripting-jsr223-test:embeddableTest")
         dependsOn(":kotlin-main-kts-test:test")
         dependsOn(":kotlin-scripting-ide-services-test:test")
+        dependsOn(":kotlin-scripting-ide-services-test:embeddableTest")
         dependsOn(":kotlin-scripting-js-test:test")
     }
 
@@ -1061,4 +1076,4 @@ if (disableVerificationTasks) {
             }
         }
     }
-}
+}

buildSrc/build.gradle.kts

@@ -96,6 +96,7 @@ repositories {
 
 dependencies {
     implementation(kotlin("stdlib", embeddedKotlinVersion))
+    implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:${project.bootstrapKotlinVersion}")
     implementation("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.17")
     implementation("com.gradle.publish:plugin-publish-plugin:0.11.0")
 

buildSrc/src/main/kotlin/artifacts.kt

@@ -27,6 +27,7 @@ import org.gradle.api.tasks.javadoc.Javadoc
 import org.gradle.jvm.tasks.Jar
 import org.gradle.api.artifacts.dsl.DependencyHandler
 import org.gradle.kotlin.dsl.*
+import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSetContainer
 import plugins.KotlinBuildPublishingPlugin
 
 
@@ -129,10 +130,16 @@ fun Project.sourcesJar(body: Jar.() -> Unit = {}): TaskProvider<Jar> {
     }
 
     val sourcesJar = getOrCreateTask<Jar>("sourcesJar") {
+        fun Project.mainJavaPluginSourceSet() = findJavaPluginConvention()?.sourceSets?.findByName("main")
+        fun Project.mainKotlinSourceSet() =
+            (extensions.findByName("kotlin") as? KotlinSourceSetContainer)?.sourceSets?.findByName("main")
+
+        fun Project.sources() = mainJavaPluginSourceSet()?.allSource ?: mainKotlinSourceSet()?.kotlin
+
         duplicatesStrategy = DuplicatesStrategy.EXCLUDE
         archiveClassifier.set("sources")
 
-        from(project.mainSourceSet.allSource)
+        from(project.sources())
 
         project.configurations.findByName("embedded")?.let { embedded ->
             from(provider {
@@ -141,10 +148,7 @@ fun Project.sourcesJar(body: Jar.() -> Unit = {}): TaskProvider<Jar> {
                     .map { it.id.componentIdentifier }
                     .filterIsInstance<ProjectComponentIdentifier>()
                     .mapNotNull {
-                        project(it.projectPath)
-                            .findJavaPluginConvention()
-                            ?.mainSourceSet
-                            ?.allSource
+                        project(it.projectPath).sources()
                     }
             })
         }

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

@@ -90,12 +90,18 @@ public abstract class AnnotationCodegen {
     private final KotlinTypeMapper typeMapper;
     private final ModuleDescriptor module;
     private final GenerationState state;
+    private final boolean skipNullabilityAnnotations;
 
     private AnnotationCodegen(@NotNull InnerClassConsumer innerClassConsumer, @NotNull GenerationState state) {
+        this(innerClassConsumer, state, false);
+    }
+
+    private AnnotationCodegen(@NotNull InnerClassConsumer innerClassConsumer, @NotNull GenerationState state, boolean skipNullabilityAnnotations) {
         this.innerClassConsumer = innerClassConsumer;
         this.typeMapper = state.getTypeMapper();
         this.module = state.getModule();
         this.state = state;
+        this.skipNullabilityAnnotations = skipNullabilityAnnotations;
     }
 
     /**
@@ -196,9 +202,7 @@ public abstract class AnnotationCodegen {
             return;
         }
 
-        if (returnType != null && !AsmUtil.isPrimitive(returnType) &&
-            !(descriptor instanceof PropertyDescriptor && ((PropertyDescriptor) descriptor).isDelegated())
-        ) {
+        if (returnType != null && !AsmUtil.isPrimitive(returnType) && !skipNullabilityAnnotations) {
             generateNullabilityAnnotation(descriptor.getReturnType(), annotationDescriptorsAlreadyPresent);
         }
     }
@@ -624,7 +628,16 @@ public abstract class AnnotationCodegen {
             @NotNull InnerClassConsumer innerClassConsumer,
             @NotNull GenerationState state
     ) {
-        return new AnnotationCodegen(innerClassConsumer, state) {
+        return forMethod(mv, innerClassConsumer, state, false);
+    }
+
+    public static AnnotationCodegen forMethod(
+            @NotNull MethodVisitor mv,
+            @NotNull InnerClassConsumer innerClassConsumer,
+            @NotNull GenerationState state,
+            boolean skipNullabilityAnnotations
+    ) {
+        return new AnnotationCodegen(innerClassConsumer, state, skipNullabilityAnnotations) {
             @NotNull
             @Override
             AnnotationVisitor visitAnnotation(String descr, boolean visible) {
@@ -644,7 +657,16 @@ public abstract class AnnotationCodegen {
             @NotNull InnerClassConsumer innerClassConsumer,
             @NotNull GenerationState state
     ) {
-        return new AnnotationCodegen(innerClassConsumer, state) {
+        return forField(fv, innerClassConsumer, state, false);
+    }
+
+    public static AnnotationCodegen forField(
+            @NotNull FieldVisitor fv,
+            @NotNull InnerClassConsumer innerClassConsumer,
+            @NotNull GenerationState state,
+            boolean skipNullabilityAnnotations
+    ) {
+        return new AnnotationCodegen(innerClassConsumer, state, skipNullabilityAnnotations) {
             @NotNull
             @Override
             AnnotationVisitor visitAnnotation(String descr, boolean visible) {
@@ -663,9 +685,10 @@ public abstract class AnnotationCodegen {
             int parameter,
             @NotNull MethodVisitor mv,
             @NotNull InnerClassConsumer innerClassConsumer,
-            @NotNull GenerationState state
+            @NotNull GenerationState state,
+            boolean skipNullabilityAnnotations
     ) {
-        return new AnnotationCodegen(innerClassConsumer, state) {
+        return new AnnotationCodegen(innerClassConsumer, state, skipNullabilityAnnotations) {
             @NotNull
             @Override
             AnnotationVisitor visitAnnotation(String descr, boolean visible) {

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

@@ -153,18 +153,18 @@ class DefaultParameterValueSubstitutor(val state: GenerationState) {
             signature.genericsSignature,
             FunctionCodegen.getThrownExceptions(functionDescriptor, typeMapper)
         )
+        val skipNullabilityAnnotations = flags and Opcodes.ACC_PRIVATE != 0 || flags and Opcodes.ACC_SYNTHETIC != 0
 
-        AnnotationCodegen.forMethod(mv, memberCodegen, state).genAnnotations(
-            functionDescriptor,
-            signature.returnType,
-            functionDescriptor.returnType
-        )
+        AnnotationCodegen.forMethod(mv, memberCodegen, state, skipNullabilityAnnotations)
+            .genAnnotations(functionDescriptor, signature.returnType, functionDescriptor.returnType)
 
         if (state.classBuilderMode == ClassBuilderMode.KAPT3) {
             mv.visitAnnotation(ANNOTATION_TYPE_DESCRIPTOR_FOR_JVM_OVERLOADS_GENERATED_METHODS, false)
         }
 
-        FunctionCodegen.generateParameterAnnotations(functionDescriptor, mv, signature, remainingParameters, memberCodegen, state)
+        FunctionCodegen.generateParameterAnnotations(
+            functionDescriptor, mv, signature, remainingParameters, memberCodegen, state, skipNullabilityAnnotations
+        )
 
         if (!state.classBuilderMode.generateBodies) {
             FunctionCodegen.generateLocalVariablesForParameters(

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

@@ -33,10 +33,7 @@ import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.load.java.SpecialBuiltinMembers;
 import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor;
 import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.resolve.BindingContext;
-import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
-import org.jetbrains.kotlin.resolve.DescriptorUtils;
-import org.jetbrains.kotlin.resolve.InlineClassesUtilsKt;
+import org.jetbrains.kotlin.resolve.*;
 import org.jetbrains.kotlin.resolve.annotations.AnnotationUtilKt;
 import org.jetbrains.kotlin.resolve.calls.util.UnderscoreUtilKt;
 import org.jetbrains.kotlin.resolve.constants.ArrayValue;
@@ -205,12 +202,13 @@ public class FunctionCodegen {
 
         MethodVisitor mv =
                 strategy.wrapMethodVisitor(
-                        newMethod(origin,
-                                  flags,
-                                  asmMethod.getName(),
-                                  asmMethod.getDescriptor(),
-                                  strategy.skipGenericSignature() ? null : jvmSignature.getGenericsSignature(),
-                                  getThrownExceptions(functionDescriptor, typeMapper)
+                        newMethod(
+                                origin,
+                                flags,
+                                asmMethod.getName(),
+                                asmMethod.getDescriptor(),
+                                strategy.skipGenericSignature() ? null : jvmSignature.getGenericsSignature(),
+                                getThrownExceptions(functionDescriptor, typeMapper)
                         ),
                         flags, asmMethod.getName(),
                         asmMethod.getDescriptor()
@@ -218,10 +216,14 @@ public class FunctionCodegen {
 
         recordMethodForFunctionIfAppropriate(functionDescriptor, asmMethod);
 
-        generateMethodAnnotationsIfRequired(functionDescriptor, asmMethod, jvmSignature, mv, isCompatibilityStubInDefaultImpls
-                                                                                             ? Collections.singletonList(Deprecated.class)
-                                                                                             : Collections.emptyList());
-
+        boolean skipNullabilityAnnotations =
+                (flags & ACC_PRIVATE) != 0 || (flags & ACC_SYNTHETIC) != 0 ||
+                InlineClassDescriptorResolver.isSpecializedEqualsMethod(functionDescriptor);
+        generateMethodAnnotationsIfRequired(
+                functionDescriptor, asmMethod, jvmSignature, mv,
+                isCompatibilityStubInDefaultImpls ? Collections.singletonList(Deprecated.class) : Collections.emptyList(),
+                skipNullabilityAnnotations
+        );
         GenerateJava8ParameterNamesKt.generateParameterNames(functionDescriptor, mv, jvmSignature, state, (flags & ACC_SYNTHETIC) != 0);
 
         if (contextKind != OwnerKind.ERASED_INLINE_CLASS) {
@@ -283,7 +285,8 @@ public class FunctionCodegen {
             @NotNull Method asmMethod,
             @NotNull JvmMethodGenericSignature jvmSignature,
             @NotNull MethodVisitor mv,
-            @NotNull List<Class<?>> additionalNoArgAnnotations
+            @NotNull List<Class<?>> additionalNoArgAnnotations,
+            boolean skipNullabilityAnnotations
     ) {
         FunctionDescriptor annotationsOwner;
         if (shouldHideConstructorDueToInlineClassTypeValueParameters(functionDescriptor)) {
@@ -298,10 +301,14 @@ public class FunctionCodegen {
             annotationsOwner = functionDescriptor;
         }
 
-        AnnotationCodegen.forMethod(mv, memberCodegen, state)
+        AnnotationCodegen.forMethod(mv, memberCodegen, state, skipNullabilityAnnotations)
                 .genAnnotations(annotationsOwner, asmMethod.getReturnType(), functionDescriptor.getReturnType(), null, additionalNoArgAnnotations);
 
-        generateParameterAnnotations(annotationsOwner, mv, jvmSignature, memberCodegen, state);
+        generateParameterAnnotations(
+                annotationsOwner, mv, jvmSignature,
+                annotationsOwner.getValueParameters(),
+                memberCodegen, state, skipNullabilityAnnotations
+        );
     }
 
     @NotNull
@@ -495,25 +502,14 @@ public class FunctionCodegen {
         return descriptor != null && !InlineUtil.isInlineOrContainingInline(descriptor);
     }
 
-    public static void generateParameterAnnotations(
-            @NotNull FunctionDescriptor functionDescriptor,
-            @NotNull MethodVisitor mv,
-            @NotNull JvmMethodSignature jvmSignature,
-            @NotNull MemberCodegen<?> memberCodegen,
-            @NotNull GenerationState state
-    ) {
-        generateParameterAnnotations(
-                functionDescriptor, mv, jvmSignature, functionDescriptor.getValueParameters(), memberCodegen, state
-        );
-    }
-
     public static void generateParameterAnnotations(
             @NotNull FunctionDescriptor functionDescriptor,
             @NotNull MethodVisitor mv,
             @NotNull JvmMethodSignature jvmSignature,
             @NotNull List<ValueParameterDescriptor> valueParameters,
             @NotNull MemberCodegen<?> memberCodegen,
-            @NotNull GenerationState state
+            @NotNull GenerationState state,
+            boolean skipNullabilityAnnotations
     ) {
         if (isAccessor(functionDescriptor)) return;
 
@@ -536,14 +532,18 @@ public class FunctionCodegen {
                     ? iterator.next()
                     : kind == JvmMethodParameterKind.RECEIVER
                       ? JvmCodegenUtil.getDirectMember(functionDescriptor).getExtensionReceiverParameter()
-                      : isDefaultImpl && kind == JvmMethodParameterKind.THIS ? JvmCodegenUtil.getDirectMember(functionDescriptor)
-                              .getDispatchReceiverParameter() : null;
+                      : kind == JvmMethodParameterKind.THIS && isDefaultImpl
+                        ? JvmCodegenUtil.getDirectMember(functionDescriptor).getDispatchReceiverParameter()
+                        : null;
 
             if (annotated != null) {
-                //noinspection ConstantConditions
                 int parameterIndex = i - syntheticParameterCount;
-                AnnotationCodegen.forParameter(parameterIndex, mv, memberCodegen, state)
-                        .genAnnotations(annotated, parameterSignature.getAsmType(), annotated.getReturnType(), functionDescriptor, Collections.emptyList());
+                AnnotationCodegen
+                        .forParameter(parameterIndex, mv, memberCodegen, state, skipNullabilityAnnotations)
+                        .genAnnotations(
+                                annotated, parameterSignature.getAsmType(), annotated.getReturnType(), functionDescriptor,
+                                Collections.emptyList()
+                        );
             }
         }
     }

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

@@ -16,7 +16,6 @@ import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor;
-import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.KtClassOrObject;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.InlineClassesUtilsKt;
@@ -46,6 +45,7 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator {
     private final GenerationState generationState;
     private final KotlinTypeMapper typeMapper;
     private final JvmKotlinType underlyingType;
+    private final boolean isInErasedInlineClass;
 
     public FunctionsFromAnyGeneratorImpl(
             @NotNull KtClassOrObject declaration,
@@ -67,23 +67,27 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator {
                 typeMapper.mapType(descriptor),
                 InlineClassesUtilsKt.substitutedUnderlyingType(descriptor.getDefaultType())
         );
+        this.isInErasedInlineClass = fieldOwnerContext.getContextKind() == OwnerKind.ERASED_INLINE_CLASS;
     }
 
     @Override
     protected void generateToStringMethod(
-            @NotNull FunctionDescriptor function, @NotNull List<? extends PropertyDescriptor> properties
+            @NotNull FunctionDescriptor function,
+            @NotNull List<? extends PropertyDescriptor> properties
     ) {
         MethodContext context = fieldOwnerContext.intoFunction(function);
         JvmDeclarationOrigin methodOrigin = JvmDeclarationOriginKt.OtherOrigin(function);
         String toStringMethodName = mapFunctionName(function);
         MethodVisitor mv = v.newMethod(methodOrigin, getAccess(), toStringMethodName, getToStringDesc(), null, null);
 
-        if (fieldOwnerContext.getContextKind() != OwnerKind.ERASED_INLINE_CLASS && classDescriptor.isInline()) {
+        if (!isInErasedInlineClass && classDescriptor.isInline()) {
             FunctionCodegen.generateMethodInsideInlineClassWrapper(methodOrigin, function, classDescriptor, mv, typeMapper);
             return;
         }
 
-        visitEndForAnnotationVisitor(mv.visitAnnotation(Type.getDescriptor(NotNull.class), false));
+        if (!isInErasedInlineClass) {
+            visitEndForAnnotationVisitor(mv.visitAnnotation(Type.getDescriptor(NotNull.class), false));
+        }
 
         if (!generationState.getClassBuilderMode().generateBodies) {
             FunctionCodegen.endVisit(mv, toStringMethodName, getDeclaration());
@@ -144,7 +148,7 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator {
         String hashCodeMethodName = mapFunctionName(function);
         MethodVisitor mv = v.newMethod(methodOrigin, getAccess(), hashCodeMethodName, getHashCodeDesc(), null, null);
 
-        if (fieldOwnerContext.getContextKind() != OwnerKind.ERASED_INLINE_CLASS && classDescriptor.isInline()) {
+        if (!isInErasedInlineClass && classDescriptor.isInline()) {
             FunctionCodegen.generateMethodInsideInlineClassWrapper(methodOrigin, function, classDescriptor, mv, typeMapper);
             return;
         }
@@ -213,15 +217,14 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator {
         String equalsMethodName = mapFunctionName(function);
         MethodVisitor mv = v.newMethod(methodOrigin, getAccess(), equalsMethodName, getEqualsDesc(), null, null);
 
-        boolean isErasedInlineClassKind = fieldOwnerContext.getContextKind() == OwnerKind.ERASED_INLINE_CLASS;
-        if (!isErasedInlineClassKind && classDescriptor.isInline()) {
+        if (!isInErasedInlineClass && classDescriptor.isInline()) {
             FunctionCodegen.generateMethodInsideInlineClassWrapper(methodOrigin, function, classDescriptor, mv, typeMapper);
             return;
         }
 
-        visitEndForAnnotationVisitor(
-                mv.visitParameterAnnotation(isErasedInlineClassKind ? 1 : 0, Type.getDescriptor(Nullable.class), false)
-        );
+        if (!isInErasedInlineClass) {
+            visitEndForAnnotationVisitor(mv.visitParameterAnnotation(0, Type.getDescriptor(Nullable.class), false));
+        }
 
         if (!generationState.getClassBuilderMode().generateBodies) {
             FunctionCodegen.endVisit(mv, equalsMethodName, getDeclaration());

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

@@ -210,7 +210,6 @@ public class PropertyCodegen {
         if (kind == OwnerKind.DEFAULT_IMPLS && isDefaultAccessor) return false;
 
         // Delegated or extension properties can only be referenced via accessors
-        //noinspection deprecation
         if (descriptor.isDelegated() || descriptor.getExtensionReceiverParameter() != null) return true;
 
         // Companion object properties should have accessors for non-private properties because these properties can be referenced
@@ -337,11 +336,8 @@ public class PropertyCodegen {
             return;
         }
 
-        @SuppressWarnings("deprecation")
-        boolean isDelegate = descriptor.isDelegated();
-
         Object defaultValue;
-        if (isDelegate) {
+        if (descriptor.isDelegated()) {
             defaultValue = null;
         }
         else if (Boolean.TRUE.equals(bindingContext.get(BindingContext.BACKING_FIELD_REQUIRED, descriptor))) {
@@ -357,7 +353,7 @@ public class PropertyCodegen {
             return;
         }
 
-        generateBackingField(descriptor, isDelegate, defaultValue, isBackingFieldOwner);
+        generateBackingField(descriptor, descriptor.isDelegated(), defaultValue, isBackingFieldOwner);
     }
 
     // Annotations on properties are stored in bytecode on an empty synthetic method. This way they're still
@@ -438,7 +434,13 @@ public class PropertyCodegen {
             );
 
             if (annotatedField != null) {
-                AnnotationCodegen.forField(fv, memberCodegen, state)
+                // Don't emit nullability annotations for backing field if:
+                // - backing field is invisible from Java (private or synthetic);
+                // - property is lateinit (since corresponding field is actually nullable).
+                boolean skipNullabilityAnnotations =
+                        (modifiers & ACC_PRIVATE) != 0 || (modifiers & ACC_SYNTHETIC) != 0 ||
+                        propertyDescriptor.isLateInit();
+                AnnotationCodegen.forField(fv, memberCodegen, state, skipNullabilityAnnotations)
                         .genAnnotations(annotatedField, type, propertyDescriptor.getType());
             }
         }
@@ -516,9 +518,7 @@ public class PropertyCodegen {
 
         FunctionGenerationStrategy strategy;
         if (accessor == null || !accessor.hasBody()) {
-            @SuppressWarnings("deprecation")
-            boolean isDelegated = descriptor.getCorrespondingProperty().isDelegated();
-            if (isDelegated) {
+            if (descriptor.getCorrespondingProperty().isDelegated()) {
                 strategy = new DelegatedPropertyAccessorStrategy(state, descriptor);
             }
             else {

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

@@ -19,6 +19,7 @@ import org.jetbrains.kotlin.codegen.context.MethodContext
 import org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings.METHOD_FOR_FUNCTION
 import org.jetbrains.kotlin.codegen.serialization.JvmSerializerExtension
 import org.jetbrains.kotlin.codegen.state.GenerationState
+import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.isReleaseCoroutines
 import org.jetbrains.kotlin.descriptors.*
@@ -512,7 +513,8 @@ class CoroutineCodegenForLambda private constructor(
                         containingClassInternalName = v.thisName,
                         isForNamedFunction = false,
                         languageVersionSettings = languageVersionSettings,
-                        disableTailCallOptimizationForFunctionReturningUnit = false
+                        disableTailCallOptimizationForFunctionReturningUnit = false,
+                        useOldSpilledVarTypeAnalysis = state.configuration.getBoolean(JVMConfigurationKeys.USE_OLD_SPILLED_VAR_TYPE_ANALYSIS)
                     )
                     val maybeWithForInline = if (forInline)
                         SuspendForInlineCopyingMethodVisitor(stateMachineBuilder, access, name, desc, functionCodegen::newMethod)

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

@@ -5,14 +5,10 @@
 
 package org.jetbrains.kotlin.codegen.coroutines
 
-import org.jetbrains.kotlin.codegen.AsmUtil
-import org.jetbrains.kotlin.codegen.ClassBuilder
-import org.jetbrains.kotlin.codegen.StackValue
-import org.jetbrains.kotlin.codegen.TransformationMethodVisitor
+import org.jetbrains.kotlin.codegen.*
 import org.jetbrains.kotlin.codegen.inline.*
 import org.jetbrains.kotlin.codegen.optimization.common.*
 import org.jetbrains.kotlin.codegen.optimization.fixStack.FixStackMethodTransformer
-import org.jetbrains.kotlin.codegen.linkWithLabel
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.isReleaseCoroutines
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
@@ -65,7 +61,9 @@ class CoroutineTransformerMethodVisitor(
     // May differ from containingClassInternalName in case of DefaultImpls
     private val internalNameForDispatchReceiver: String? = null,
     // JVM_IR backend generates $completion, while old backend does not
-    private val putContinuationParameterToLvt: Boolean = true
+    private val putContinuationParameterToLvt: Boolean = true,
+    // New SourceInterpreter-less analyser can be somewhat unstable, disable it
+    private val useOldSpilledVarTypeAnalysis: Boolean = false
 ) : TransformationMethodVisitor(delegate, access, name, desc, signature, exceptions) {
 
     private val classBuilderForCoroutineState: ClassBuilder by lazy(obtainClassBuilderForCoroutineState)
@@ -594,7 +592,10 @@ class CoroutineTransformerMethodVisitor(
 
     private fun spillVariables(suspensionPoints: List<SuspensionPoint>, methodNode: MethodNode): List<List<SpilledVariableDescriptor>> {
         val instructions = methodNode.instructions
-        val frames = performRefinedTypeAnalysis(methodNode, containingClassInternalName)
+        val frames =
+            if (useOldSpilledVarTypeAnalysis) performRefinedTypeAnalysis(methodNode, containingClassInternalName)
+            else performSpilledVariableFieldTypesAnalysis(methodNode, containingClassInternalName)
+
         fun AbstractInsnNode.index() = instructions.indexOf(this)
 
         // We postpone these actions because they change instruction indices that we use when obtaining frames
@@ -642,11 +643,11 @@ class CoroutineTransformerMethodVisitor(
                     .map { Pair(it, frame.getLocal(it)) }
                     .filter { (index, value) ->
                         (index == 0 && needDispatchReceiver && isForNamedFunction) ||
-                                (value != StrictBasicValue.UNINITIALIZED_VALUE && livenessFrame.isAlive(index))
+                                (value.type != null && livenessFrame.isAlive(index))
                     }
 
             for ((index, basicValue) in variablesToSpill) {
-                if (basicValue === StrictBasicValue.NULL_VALUE) {
+                if (basicValue == StrictBasicValue.NULL_VALUE) {
                     postponedActions.add {
                         with(instructions) {
                             insert(suspension.tryCatchBlockEndLabelAfterSuspensionCall, withInstructionAdapter {
@@ -658,7 +659,7 @@ class CoroutineTransformerMethodVisitor(
                     continue
                 }
 
-                val type = basicValue.type
+                val type = basicValue.type!!
                 val normalizedType = type.normalize()
 
                 val indexBySort = varsCountByType[normalizedType]?.plus(1) ?: 0

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

@@ -1,11 +1,10 @@
 /*
- * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
 package org.jetbrains.kotlin.codegen.coroutines
 
-import org.jetbrains.kotlin.codegen.inline.nodeText
 import org.jetbrains.kotlin.codegen.optimization.boxing.isUnitInstance
 import org.jetbrains.kotlin.codegen.optimization.common.MethodAnalyzer
 import org.jetbrains.kotlin.codegen.optimization.common.asSequence
@@ -13,169 +12,136 @@ import org.jetbrains.kotlin.codegen.optimization.common.removeAll
 import org.jetbrains.kotlin.codegen.optimization.fixStack.top
 import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
+import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 import org.jetbrains.org.objectweb.asm.Opcodes
-import org.jetbrains.org.objectweb.asm.Type
-import org.jetbrains.org.objectweb.asm.tree.*
+import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode
+import org.jetbrains.org.objectweb.asm.tree.LabelNode
+import org.jetbrains.org.objectweb.asm.tree.MethodNode
+import org.jetbrains.org.objectweb.asm.tree.VarInsnNode
 import org.jetbrains.org.objectweb.asm.tree.analysis.BasicInterpreter
 import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
 import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
+import java.util.*
 
-private class PossibleSpilledValue(val source: AbstractInsnNode, type: Type?) : BasicValue(type) {
-    val usages = mutableSetOf<AbstractInsnNode>()
-
-    override fun toString(): String = when {
-        source.opcode == Opcodes.ALOAD -> "" + (source as VarInsnNode).`var`
-        source.isUnitInstance() -> "U"
-        else -> error("unreachable")
-    }
-
-    override fun equals(other: Any?): Boolean =
-        other is PossibleSpilledValue && source == other.source
-
-    override fun hashCode(): Int = super.hashCode() xor source.hashCode()
-}
-
-private object NonSpillableValue : BasicValue(AsmTypes.OBJECT_TYPE) {
-    override fun equals(other: Any?): Boolean = other is NonSpillableValue
-
-    override fun toString(): String = "N"
-}
-
-private object ConstructedValue : BasicValue(AsmTypes.OBJECT_TYPE) {
-    override fun equals(other: Any?): Boolean = other is ConstructedValue
-
-    override fun toString(): String = "C"
-}
-
-fun BasicValue?.nonspillable(): BasicValue? = if (this?.type?.sort == Type.OBJECT) NonSpillableValue else this
-
-private class RedundantSpillingInterpreter : BasicInterpreter(Opcodes.API_VERSION) {
-    val possibleSpilledValues = mutableSetOf<PossibleSpilledValue>()
-
-    override fun newOperation(insn: AbstractInsnNode): BasicValue? {
-        if (insn.opcode == Opcodes.NEW) return ConstructedValue
-        val basicValue = super.newOperation(insn)
-        return if (insn.isUnitInstance())
-            // Unit instances come from inlining suspend functions returning Unit.
-            // They can be spilled before they are eventually popped.
-            // Track them.
-            PossibleSpilledValue(insn, basicValue.type).also { possibleSpilledValues += it }
-        else basicValue.nonspillable()
-    }
-
-    override fun copyOperation(insn: AbstractInsnNode, value: BasicValue?): BasicValue? =
-        when (value) {
-            is ConstructedValue -> value
-            is PossibleSpilledValue -> {
-                value.usages += insn
-                if (insn.opcode == Opcodes.ALOAD || insn.opcode == Opcodes.ASTORE) value
-                else value.nonspillable()
-            }
-            else -> value?.nonspillable()
-        }
-
-    override fun naryOperation(insn: AbstractInsnNode, values: MutableList<out BasicValue?>): BasicValue? {
-        for (value in values.filterIsInstance<PossibleSpilledValue>()) {
-            value.usages += insn
-        }
-        return super.naryOperation(insn, values)?.nonspillable()
-    }
-
-    override fun merge(v: BasicValue?, w: BasicValue?): BasicValue? =
-        if (v is PossibleSpilledValue && w is PossibleSpilledValue && v.source == w.source) v
-        else v?.nonspillable()
-}
-
-// Inliner emits a lot of locals during inlining.
-// Remove all of them since these locals are
-//  1) going to be spilled into continuation object
-//  2) breaking tail-call elimination
+/**
+ * This pass removes unused Unit values. These typically occur as a result of inlining and could end up spilling
+ * into the continuation object or break tail-call elimination.
+ *
+ * Concretely, we remove "GETSTATIC kotlin/Unit.INSTANCE" instructions if they are unused, or all uses are either
+ * POP instructions, or ASTORE instructions to locals which are never read and are not named local variables.
+ *
+ * This pass does not touch [suspensionPoints], as later passes rely on the bytecode patterns around suspension points.
+ */
 internal class RedundantLocalsEliminationMethodTransformer(private val suspensionPoints: List<SuspensionPoint>) : MethodTransformer() {
     override fun transform(internalClassName: String, methodNode: MethodNode) {
-        val interpreter = RedundantSpillingInterpreter()
-        val frames = MethodAnalyzer<BasicValue>(internalClassName, methodNode, interpreter).analyze()
+        val interpreter = UnitSourceInterpreter(methodNode.localVariables?.mapTo(mutableSetOf()) { it.index } ?: setOf())
+        val frames = interpreter.run(internalClassName, methodNode)
 
+        // Mark all unused instructions for deletion (except for labels which may be used in debug information)
         val toDelete = mutableSetOf<AbstractInsnNode>()
-        for (spilledValue in interpreter.possibleSpilledValues.filter { it.usages.isNotEmpty() }) {
-            @Suppress("UNCHECKED_CAST")
-            val aloads = spilledValue.usages.filter { it.opcode == Opcodes.ALOAD } as List<VarInsnNode>
-
-            if (aloads.isEmpty()) continue
-
-            val slot = aloads.first().`var`
-
-            if (aloads.any { it.`var` != slot }) continue
-            for (aload in aloads) {
-                methodNode.instructions.set(aload, spilledValue.source.clone())
-            }
-
-            toDelete.addAll(spilledValue.usages.filter { it.opcode == Opcodes.ASTORE })
-            toDelete.add(spilledValue.source)
+        methodNode.instructions.asSequence().zip(frames.asSequence()).mapNotNullTo(toDelete) { (insn, frame) ->
+            insn.takeIf { frame == null && insn !is LabelNode }
         }
 
-        for (pop in methodNode.instructions.asSequence().filter { it.opcode == Opcodes.POP }) {
-            val value = (frames[methodNode.instructions.indexOf(pop)]?.top() as? PossibleSpilledValue) ?: continue
-            if (value.usages.isEmpty() && value.source !in suspensionPoints) {
-                toDelete.add(pop)
-                toDelete.add(value.source)
-            }
-        }
-
-        // Remove unreachable instructions to simplify further analyses
-        for (index in frames.indices) {
-            if (frames[index] == null) {
-                val insn = methodNode.instructions[index]
-                if (insn !is LabelNode) {
-                    toDelete.add(insn)
-                }
+        // Mark all spillable "GETSTATIC kotlin/Unit.INSTANCE" instructions for deletion
+        for ((unit, uses) in interpreter.unitUsageInformation) {
+            if (unit !in interpreter.unspillableUnitValues && unit !in suspensionPoints) {
+                toDelete += unit
+                toDelete += uses
             }
         }
 
         methodNode.instructions.removeAll(toDelete)
     }
-
-    private fun AbstractInsnNode.clone() = when (this) {
-        is FieldInsnNode -> FieldInsnNode(opcode, owner, name, desc)
-        is VarInsnNode -> VarInsnNode(opcode, `var`)
-        is InsnNode -> InsnNode(opcode)
-        is TypeInsnNode -> TypeInsnNode(opcode, desc)
-        else -> error("clone of $this is not implemented yet")
-    }
 }
 
-// Handy debugging routing
-@Suppress("unused")
-fun MethodNode.nodeTextWithFrames(frames: Array<*>): String {
-    var insns = nodeText.split("\n")
-    val first = insns.indexOfLast { it.trim().startsWith("@") } + 1
-    var last = insns.indexOfFirst { it.trim().startsWith("LOCALVARIABLE") }
-    if (last < 0) last = insns.size
-    val prefix = insns.subList(0, first).joinToString(separator = "\n")
-    val postfix = insns.subList(last, insns.size).joinToString(separator = "\n")
-    insns = insns.subList(first, last)
-    if (insns.any { it.contains("TABLESWITCH") }) {
-        var insideTableSwitch = false
-        var buffer = ""
-        val res = arrayListOf<String>()
-        for (insn in insns) {
-            if (insn.contains("TABLESWITCH")) {
-                insideTableSwitch = true
-            }
-            if (insideTableSwitch) {
-                buffer += insn
-                if (insn.contains("default")) {
-                    insideTableSwitch = false
-                    res += buffer
-                    buffer = ""
-                    continue
-                }
-            } else {
-                res += insn
+// A version of SourceValue which inherits from BasicValue and is only used for Unit values.
+private class UnitValue(val insns: Set<AbstractInsnNode>) : BasicValue(AsmTypes.OBJECT_TYPE) {
+    constructor(insn: AbstractInsnNode) : this(Collections.singleton(insn))
+
+    override fun equals(other: Any?): Boolean = other is UnitValue && insns == other.insns
+    override fun hashCode() = Objects.hash(insns)
+    override fun toString() = "U"
+}
+
+// A specialized SourceInterpreter which only keeps track of the use sites for Unit values which are exclusively used as
+// arguments to POP and unused ASTORE instructions.
+private class UnitSourceInterpreter(private val localVariables: Set<Int>) : BasicInterpreter(Opcodes.API_VERSION) {
+    // All unit values with visible use-sites.
+    val unspillableUnitValues = mutableSetOf<AbstractInsnNode>()
+
+    // Map from unit values to ASTORE/POP use-sites.
+    val unitUsageInformation = mutableMapOf<AbstractInsnNode, MutableSet<AbstractInsnNode>>()
+
+    private fun markUnspillable(value: BasicValue?) =
+        value?.safeAs<UnitValue>()?.let { unspillableUnitValues += it.insns }
+
+    private fun collectUnitUsage(use: AbstractInsnNode, value: UnitValue) {
+        for (def in value.insns) {
+            if (def !in unspillableUnitValues) {
+                unitUsageInformation.getOrPut(def) { mutableSetOf() } += use
             }
         }
-        insns = res
     }
-    return prefix + "\n" + insns.withIndex().joinToString(separator = "\n") { (index, insn) ->
-        if (index >= frames.size) "N/A\t$insn" else "${frames[index]}\t$insn"
-    } + "\n" + postfix
+
+    fun run(internalClassName: String, methodNode: MethodNode): Array<Frame<BasicValue>?> {
+        val frames = MethodAnalyzer<BasicValue>(internalClassName, methodNode, this).analyze()
+        // The ASM analyzer does not visit POP instructions, so we do so here.
+        for ((insn, frame) in methodNode.instructions.asSequence().zip(frames.asSequence())) {
+            if (frame != null && insn.opcode == Opcodes.POP) {
+                val value = frame.top()
+                value.safeAs<UnitValue>()?.let { collectUnitUsage(insn, it) }
+            }
+        }
+        return frames
+    }
+
+    override fun newOperation(insn: AbstractInsnNode?): BasicValue =
+        if (insn?.isUnitInstance() == true) UnitValue(insn) else super.newOperation(insn)
+
+    override fun copyOperation(insn: AbstractInsnNode, value: BasicValue?): BasicValue? {
+        if (value is UnitValue) {
+            if (insn is VarInsnNode && insn.opcode == Opcodes.ASTORE && insn.`var` !in localVariables) {
+                collectUnitUsage(insn, value)
+                // We track the stored value in case it is subsequently read.
+                return value
+            }
+            unspillableUnitValues += value.insns
+        }
+        return super.copyOperation(insn, value)
+    }
+
+    override fun unaryOperation(insn: AbstractInsnNode, value: BasicValue?): BasicValue? {
+        markUnspillable(value)
+        return super.unaryOperation(insn, value)
+    }
+
+    override fun binaryOperation(insn: AbstractInsnNode, value1: BasicValue?, value2: BasicValue?): BasicValue? {
+        markUnspillable(value1)
+        markUnspillable(value2)
+        return super.binaryOperation(insn, value1, value2)
+    }
+
+    override fun ternaryOperation(insn: AbstractInsnNode, value1: BasicValue?, value2: BasicValue?, value3: BasicValue?): BasicValue? {
+        markUnspillable(value1)
+        markUnspillable(value2)
+        markUnspillable(value3)
+        return super.ternaryOperation(insn, value1, value2, value3)
+    }
+
+    override fun naryOperation(insn: AbstractInsnNode, values: List<BasicValue>?): BasicValue? {
+        values?.forEach(this::markUnspillable)
+        return super.naryOperation(insn, values)
+    }
+
+    override fun merge(value1: BasicValue?, value2: BasicValue?): BasicValue? =
+        if (value1 is UnitValue && value2 is UnitValue) {
+            UnitValue(value1.insns.union(value2.insns))
+        } else {
+            // Mark unit values as unspillable if we merge them with non-unit values here.
+            // This is conservative since the value could turn out to be unused.
+            markUnspillable(value1)
+            markUnspillable(value2)
+            super.merge(value1, value2)
+        }
 }

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

@@ -0,0 +1,160 @@
+/*
+ * 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.coroutines
+
+import org.jetbrains.kotlin.codegen.StackValue
+import org.jetbrains.kotlin.codegen.optimization.common.MethodAnalyzer
+import org.jetbrains.kotlin.codegen.optimization.common.OptimizationBasicInterpreter
+import org.jetbrains.org.objectweb.asm.Label
+import org.jetbrains.org.objectweb.asm.Opcodes
+import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
+import org.jetbrains.org.objectweb.asm.tree.*
+import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
+import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
+
+// BasicValue interpreter from ASM does not distinct 'int' types from other int-like types like 'byte' or 'boolean',
+// neither do HotSpot and JVM spec.
+// But it seems like Dalvik does not follow it, and spilling boolean value into an 'int' field fails with VerifyError on Android 4,
+// so this function calculates refined frames' markup.
+// Note that type of some values is only possible to determine by their usages (e.g. ICONST_1, BALOAD both may push boolean or byte on stack)
+// In this case, coerce the type of the value.
+
+internal class IloadedValue(val insns: Set<VarInsnNode>) : BasicValue(Type.INT_TYPE)
+
+private class IntLikeCoerceInterpreter : OptimizationBasicInterpreter() {
+    val needsToBeCoerced = mutableMapOf<VarInsnNode, Type>()
+
+    private fun coerce(value: IloadedValue, type: Type) {
+        for (insn in value.insns) {
+            needsToBeCoerced[insn] = type
+        }
+    }
+
+    override fun copyOperation(insn: AbstractInsnNode, value: BasicValue?): BasicValue? =
+        when {
+            insn.opcode == Opcodes.ILOAD -> IloadedValue(setOf(insn as VarInsnNode))
+            value == null -> null
+            else -> BasicValue(value.type)
+        }
+
+    override fun binaryOperation(insn: AbstractInsnNode, v: BasicValue, w: BasicValue): BasicValue? {
+        if (insn.opcode == Opcodes.PUTFIELD) {
+            val expectedType = Type.getType((insn as FieldInsnNode).desc)
+            if (w is IloadedValue && expectedType.isIntLike()) {
+                coerce(w, expectedType)
+            }
+        }
+        return super.binaryOperation(insn, v, w)
+    }
+
+    override fun unaryOperation(insn: AbstractInsnNode, value: BasicValue?): BasicValue? {
+        if (insn.opcode == Opcodes.PUTSTATIC) {
+            val expectedType = Type.getType((insn as FieldInsnNode).desc)
+            if (value is IloadedValue && expectedType.isIntLike()) {
+                coerce(value, expectedType)
+            }
+        }
+        return super.unaryOperation(insn, value)
+    }
+
+    override fun naryOperation(insn: AbstractInsnNode, values: MutableList<out BasicValue?>): BasicValue? {
+        fun checkTypes(argTypes: Array<Type>, withReceiver: Boolean) {
+            val offset = if (withReceiver) 1 else 0
+            for ((index, argType) in argTypes.withIndex()) {
+                val value = values[index + offset] ?: continue
+                if (argType.isIntLike() && value is IloadedValue) {
+                    coerce(value, argType)
+                }
+            }
+        }
+        when (insn.opcode) {
+            Opcodes.INVOKEDYNAMIC -> {
+                checkTypes(Type.getArgumentTypes((insn as InvokeDynamicInsnNode).desc), false)
+            }
+            Opcodes.INVOKESTATIC -> {
+                checkTypes(Type.getArgumentTypes((insn as MethodInsnNode).desc), false)
+            }
+            Opcodes.INVOKEVIRTUAL, Opcodes.INVOKEINTERFACE, Opcodes.INVOKESPECIAL -> {
+                checkTypes(Type.getArgumentTypes((insn as MethodInsnNode).desc), true)
+            }
+        }
+        return super.naryOperation(insn, values)
+    }
+
+    override fun ternaryOperation(insn: AbstractInsnNode, arrayref: BasicValue?, index: BasicValue?, value: BasicValue?): BasicValue? {
+        when (insn.opcode) {
+            Opcodes.BASTORE -> {
+                if (value is IloadedValue) {
+                    val type = if (arrayref?.type?.descriptor == "[Z") Type.BOOLEAN_TYPE else Type.BYTE_TYPE
+                    coerce(value, type)
+                }
+            }
+            Opcodes.CASTORE -> {
+                if (value is IloadedValue) {
+                    coerce(value, Type.CHAR_TYPE)
+                }
+            }
+            Opcodes.SASTORE -> {
+                if (value is IloadedValue) {
+                    coerce(value, Type.SHORT_TYPE)
+                }
+            }
+        }
+        return super.ternaryOperation(insn, arrayref, index, value)
+    }
+
+    override fun merge(v: BasicValue, w: BasicValue): BasicValue =
+        when {
+            v is IloadedValue && w is IloadedValue && v.type == w.type -> {
+                val insns = v.insns + w.insns
+                insns.find { it in needsToBeCoerced }?.let {
+                    val type = needsToBeCoerced[it]!!
+                    coerce(v, type)
+                    coerce(w, type)
+                }
+                IloadedValue(insns)
+            }
+            v.type == w.type -> {
+                if (w is IloadedValue) w else v
+            }
+            else -> super.merge(v, w)
+        }
+}
+
+internal fun performSpilledVariableFieldTypesAnalysis(
+    methodNode: MethodNode,
+    thisName: String
+): Array<out Frame<BasicValue>?> {
+    val interpreter = IntLikeCoerceInterpreter()
+    MethodAnalyzer(thisName, methodNode, interpreter).analyze()
+    for ((insn, type) in interpreter.needsToBeCoerced) {
+        methodNode.instructions.insert(insn, withInstructionAdapter { coerceInt(type, this) })
+    }
+    return MethodAnalyzer(thisName, methodNode, OptimizationBasicInterpreter()).analyze()
+}
+
+private fun coerceInt(to: Type, v: InstructionAdapter) {
+    if (to == Type.BOOLEAN_TYPE) {
+        with(v) {
+            val zeroLabel = Label()
+            val resLabel = Label()
+            ifeq(zeroLabel)
+            iconst(1)
+            goTo(resLabel)
+            mark(zeroLabel)
+            iconst(0)
+            mark(resLabel)
+        }
+    } else {
+        StackValue.coerce(Type.INT_TYPE, to, v)
+    }
+}
+
+private fun Type.isIntLike(): Boolean = when (sort) {
+    Type.BOOLEAN, Type.BYTE, Type.CHAR, Type.SHORT -> true
+    else -> false
+}

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

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.codegen.inline.addFakeContinuationConstructorCallMar
 import org.jetbrains.kotlin.codegen.inline.coroutines.FOR_INLINE_SUFFIX
 import org.jetbrains.kotlin.codegen.inline.preprocessSuspendMarkers
 import org.jetbrains.kotlin.codegen.state.GenerationState
+import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.config.JVMConstructorCallNormalizationMode
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.languageVersionSettings
@@ -95,7 +96,8 @@ class SuspendFunctionGenerationStrategy(
             languageVersionSettings = languageVersionSettings,
             disableTailCallOptimizationForFunctionReturningUnit = originalSuspendDescriptor.returnType?.isUnit() == true &&
                     originalSuspendDescriptor.overriddenDescriptors.isNotEmpty() &&
-                    !originalSuspendDescriptor.allOverriddenFunctionsReturnUnit()
+                    !originalSuspendDescriptor.allOverriddenFunctionsReturnUnit(),
+            useOldSpilledVarTypeAnalysis = state.configuration.getBoolean(JVMConfigurationKeys.USE_OLD_SPILLED_VAR_TYPE_ANALYSIS)
         )
     }
 

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

@@ -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/backend/src/org/jetbrains/kotlin/codegen/fakeDescriptorsForReferences.kt

@@ -128,7 +128,7 @@ fun createFreeFakeLocalPropertyDescriptor(descriptor: LocalVariableDescriptor, t
     val property = PropertyDescriptorImpl.create(
         descriptor.containingDeclaration, descriptor.annotations, Modality.FINAL, descriptor.visibility, descriptor.isVar,
         descriptor.name, CallableMemberDescriptor.Kind.DECLARATION, descriptor.source, false, descriptor.isConst,
-        false, false, false, @Suppress("DEPRECATION") descriptor.isDelegated
+        false, false, false, descriptor.isDelegated
     )
     property.setType(
         descriptor.type, descriptor.typeParameters,

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

@@ -15,7 +15,10 @@ import org.jetbrains.kotlin.codegen.inline.coroutines.FOR_INLINE_SUFFIX
 import org.jetbrains.kotlin.codegen.intrinsics.IntrinsicArrayConstructors
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
+import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.incremental.components.Position
+import org.jetbrains.kotlin.incremental.components.ScopeKind
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
@@ -87,12 +90,9 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
         isSameModule = sourceCompiler.isCallInsideSameModuleAsDeclared(functionDescriptor)
 
         if (functionDescriptor !is FictitiousArrayConstructor) {
-            val functionOrAccessorName = jvmSignature.asmMethod.name
             //track changes for property accessor and @JvmName inline functions/property accessors
-            if (functionOrAccessorName != functionDescriptor.name.asString()) {
-                val scope = getMemberScope(functionDescriptor)
-                //Fake lookup to track track changes for property accessors and @JvmName functions/property accessors
-                scope?.getContributedFunctions(Name.identifier(functionOrAccessorName), sourceCompiler.lookupLocation)
+            if (jvmSignature.asmMethod.name != functionDescriptor.name.asString()) {
+                trackLookup(functionDescriptor)
             }
         }
     }
@@ -500,19 +500,24 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
         return true
     }
 
+    private fun trackLookup(functionOrAccessor: FunctionDescriptor) {
+        val functionOrAccessorName = jvmSignature.asmMethod.name
+        val lookupTracker = state.configuration.get(CommonConfigurationKeys.LOOKUP_TRACKER) ?: return
+        val location = sourceCompiler.lookupLocation.location ?: return
+        val position = if (lookupTracker.requiresPosition) location.position else Position.NO_POSITION
+        val classOrPackageFragment = functionOrAccessor.containingDeclaration
+        lookupTracker.record(
+            location.filePath,
+            position,
+            DescriptorUtils.getFqName(classOrPackageFragment).asString(),
+            ScopeKind.CLASSIFIER,
+            functionOrAccessorName
+        )
+    }
+
 
     companion object {
 
-        private fun getMemberScope(functionOrAccessor: FunctionDescriptor): MemberScope? {
-            val callableMemberDescriptor = JvmCodegenUtil.getDirectMember(functionOrAccessor)
-            val classOrPackageFragment = callableMemberDescriptor.containingDeclaration
-            return when (classOrPackageFragment) {
-                is ClassDescriptor -> classOrPackageFragment.unsubstitutedMemberScope
-                is PackageFragmentDescriptor -> classOrPackageFragment.getMemberScope()
-                else -> null
-            }
-        }
-
         internal fun createInlineMethodNode(
             functionDescriptor: FunctionDescriptor,
             methodOwner: Type,

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

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.codegen.coroutines.*
 import org.jetbrains.kotlin.codegen.inline.*
 import org.jetbrains.kotlin.codegen.optimization.common.asSequence
 import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
+import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.config.isReleaseCoroutines
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
@@ -95,7 +96,8 @@ class CoroutineTransformer(
                 shouldPreserveClassInitialization = state.constructorCallNormalizationMode.shouldPreserveClassInitialization,
                 containingClassInternalName = classBuilder.thisName,
                 isForNamedFunction = false,
-                disableTailCallOptimizationForFunctionReturningUnit = false
+                disableTailCallOptimizationForFunctionReturningUnit = false,
+                useOldSpilledVarTypeAnalysis = state.configuration.getBoolean(JVMConfigurationKeys.USE_OLD_SPILLED_VAR_TYPE_ANALYSIS)
             )
 
             if (generateForInline)
@@ -131,7 +133,8 @@ class CoroutineTransformer(
                 needDispatchReceiver = true,
                 internalNameForDispatchReceiver = classBuilder.thisName,
                 disableTailCallOptimizationForFunctionReturningUnit = disableTailCallOptimization,
-                putContinuationParameterToLvt = !state.isIrBackend
+                putContinuationParameterToLvt = !state.isIrBackend,
+                useOldSpilledVarTypeAnalysis = state.configuration.getBoolean(JVMConfigurationKeys.USE_OLD_SPILLED_VAR_TYPE_ANALYSIS)
             )
 
             if (generateForInline)

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/CapturedVarsOptimizationMethodTransformer.kt

@@ -242,6 +242,17 @@ class CapturedVarsOptimizationMethodTransformer : MethodTransformer() {
             methodNode.removeUnusedLocalVariables()
         }
 
+        // Be careful to not remove instructions that are the only instruction for a line number. That will
+        // break debugging. If the previous instruction is a line number and the following instruction is
+        // a label followed by a line number, insert a nop instead of deleting the instruction.
+        private fun InsnList.removeOrReplaceByNop(insn: AbstractInsnNode) {
+            if (insn.previous is LineNumberNode && insn.next is LabelNode && insn.next.next is LineNumberNode) {
+                set(insn, InsnNode(Opcodes.NOP))
+            } else {
+                remove(insn)
+            }
+        }
+
         private fun rewriteRefValue(capturedVar: CapturedVarDescriptor) {
             methodNode.instructions.run {
                 val localVar = capturedVar.localVar!!
@@ -259,9 +270,10 @@ class CapturedVarsOptimizationMethodTransformer : MethodTransformer() {
 
                 remove(capturedVar.newInsn)
                 remove(capturedVar.initCallInsn!!)
-                capturedVar.stackInsns.forEach { remove(it) }
-                capturedVar.aloadInsns.forEach { remove(it) }
-                capturedVar.astoreInsns.forEach { remove(it) }
+
+                capturedVar.stackInsns.forEach { removeOrReplaceByNop(it) }
+                capturedVar.aloadInsns.forEach { removeOrReplaceByNop(it) }
+                capturedVar.astoreInsns.forEach { removeOrReplaceByNop(it) }
                 capturedVar.getFieldInsns.forEach { set(it, VarInsnNode(loadOpcode, capturedVar.localVarIndex)) }
                 capturedVar.putFieldInsns.forEach { set(it, VarInsnNode(storeOpcode, capturedVar.localVarIndex)) }
 
@@ -273,6 +285,7 @@ class CapturedVarsOptimizationMethodTransformer : MethodTransformer() {
                 }
             }
         }
+
     }
 }
 

compiler/backend/src/org/jetbrains/kotlin/codegen/range/RangeValues.kt

@@ -74,7 +74,6 @@ fun ExpressionCodegen.createRangeValueForExpression(rangeExpression: KtExpressio
     }
 }
 
-@Suppress("DEPRECATION")
 fun isLocalVarReference(rangeExpression: KtExpression, bindingContext: BindingContext): Boolean {
     if (rangeExpression !is KtSimpleNameExpression) return false
     val resultingDescriptor = rangeExpression.getResolvedCall(bindingContext)?.resultingDescriptor ?: return false

compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.kt

@@ -94,7 +94,13 @@ class JvmSerializerExtension @JvmOverloads constructor(
         writeVersionRequirementForJvmDefaultIfNeeded(descriptor, proto, versionRequirementTable)
 
         if (jvmDefaultMode.forAllMethodsWithBody && isInterface(descriptor)) {
-            proto.setExtension(JvmProtoBuf.jvmClassFlags, JvmFlags.getClassFlags(true))
+            proto.setExtension(
+                JvmProtoBuf.jvmClassFlags,
+                JvmFlags.getClassFlags(
+                    jvmDefaultMode.forAllMethodsWithBody,
+                    JvmDefaultMode.ALL_COMPATIBILITY == jvmDefaultMode
+                )
+            )
         }
     }
 

compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt

@@ -23,7 +23,9 @@ import org.jetbrains.kotlin.codegen.signature.BothSignatureWriter
 import org.jetbrains.kotlin.codegen.signature.JvmSignatureWriter
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.impl.*
+import org.jetbrains.kotlin.descriptors.impl.LocalVariableAccessorDescriptor
+import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor
+import org.jetbrains.kotlin.descriptors.impl.TypeAliasConstructorDescriptor
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
 import org.jetbrains.kotlin.load.java.BuiltinMethodsWithSpecialGenericSignature
 import org.jetbrains.kotlin.load.java.JvmAbi
@@ -1208,7 +1210,7 @@ class KotlinTypeMapper @JvmOverloads constructor(
             return StackValue.sharedTypeForType(mapType(receiverParameter.type))
         }
 
-        if (descriptor is LocalVariableDescriptor && @Suppress("DEPRECATION") descriptor.isDelegated) {
+        if (descriptor is LocalVariableDescriptor && descriptor.isDelegated) {
             return null
         }
 

compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt

@@ -51,7 +51,7 @@ class BuiltInsSerializer(dependOnOldBuiltIns: Boolean) : MetadataSerializer(Buil
                 put(CommonConfigurationKeys.MODULE_NAME, "module for built-ins serialization")
             }
 
-            val environment = KotlinCoreEnvironment.createForTests(rootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
+            val environment = KotlinCoreEnvironment.createForProduction(rootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
 
             serialize(environment)
 

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

@@ -340,6 +340,12 @@ abstract class CommonCompilerArguments : CommonToolArguments() {
     )
     var explicitApi: String by FreezableVar(ExplicitApiMode.DISABLED.state)
 
+    @Argument(
+        value = "-Xdeserialize-fake-overrides",
+        description = "Fallback to deserializing fake overrides"
+    )
+    var deserializeFakeOverrides: Boolean by FreezableVar(false)
+
     open fun configureAnalysisFlags(collector: MessageCollector): MutableMap<AnalysisFlag<*>, Any> {
         return HashMap<AnalysisFlag<*>, Any>().apply {
             put(AnalysisFlags.skipMetadataVersionCheck, skipMetadataVersionCheck)

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

@@ -135,6 +135,9 @@ class K2JSCompilerArguments : CommonCompilerArguments() {
     )
     var irModuleName: String? by NullableStringFreezableVar(null)
 
+    @Argument(value = "-Xir-per-module", description = "Splits generated .js per-module")
+    var irPerModule: Boolean by FreezableVar(false)
+
     @Argument(
         value = "-Xinclude",
         valueDescription = "<path>",
@@ -169,6 +172,9 @@ class K2JSCompilerArguments : CommonCompilerArguments() {
     @Argument(value = "-Xenable-js-scripting", description = "Enable experimental support of .kts files using K/JS (with -Xir only)")
     var enableJsScripting: Boolean by FreezableVar(false)
 
+    @Argument(value = "-Xdisable-fake-override-validator", description = "Disable IR fake override validator")
+    var disableFakeOverrideValidator: Boolean by FreezableVar(false)
+
     override fun checkIrSupport(languageVersionSettings: LanguageVersionSettings, collector: MessageCollector) {
         if (!isIrBackendEnabled()) return
 

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

@@ -369,6 +369,12 @@ class K2JVMCompilerArguments : CommonCompilerArguments() {
     )
     var repeatCompileModules: String? by NullableStringFreezableVar(null)
 
+    @Argument(
+        value = "-Xuse-old-spilled-var-type-analysis",
+        description = "Use old, SourceInterpreter-based analysis for fields, used for spilled variables in coroutines"
+    )
+    var useOldSpilledVarTypeAnalysis: Boolean by FreezableVar(false)
+
     override fun configureAnalysisFlags(collector: MessageCollector): MutableMap<AnalysisFlag<*>, Any> {
         val result = super.configureAnalysisFlags(collector)
         result[JvmAnalysisFlags.strictMetadataVersionSemantics] = strictMetadataVersionSemantics

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

@@ -229,14 +229,19 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
                     mainArguments = mainCallArguments,
                     generateFullJs = !arguments.irDce,
                     generateDceJs = arguments.irDce,
-                    dceDriven = arguments.irDceDriven
+                    dceDriven = arguments.irDceDriven,
+                    multiModule = arguments.irPerModule,
+                    relativeRequirePath = true
                 )
             } catch (e: JsIrCompilationError) {
                 return COMPILATION_ERROR
             }
 
             val jsCode = if (arguments.irDce && !arguments.irDceDriven) compiledModule.dceJsCode!! else compiledModule.jsCode!!
-            outputFile.writeText(jsCode)
+            outputFile.writeText(jsCode.mainModule)
+            jsCode.dependencies.forEach { (name, content) ->
+                outputFile.resolveSibling("$name.js").writeText(content)
+            }
             if (arguments.generateDts) {
                 val dtsFile = outputFile.withReplacedExtensionOrNull(outputFile.extension, "d.ts")!!
                 dtsFile.writeText(compiledModule.tsDefinitions ?: error("No ts definitions"))
@@ -322,6 +327,7 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
         }
 
         configuration.put(JSConfigurationKeys.PRINT_REACHABILITY_INFO, arguments.irDcePrintReachabilityInfo)
+        configuration.put(JSConfigurationKeys.DISABLE_FAKE_OVERRIDE_VALIDATOR, arguments.disableFakeOverrideValidator)
     }
 
     override fun executableScriptFileName(): String {

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

@@ -45,7 +45,7 @@ abstract class CLICompiler<A : CommonCompilerArguments> : CLITool<A>() {
 
     protected abstract val performanceManager: CommonCompilerPerformanceManager
 
-    protected open fun createPerformanceManager(arguments: A): CommonCompilerPerformanceManager = performanceManager
+    protected open fun createPerformanceManager(arguments: A, services: Services): CommonCompilerPerformanceManager = performanceManager
 
     // Used in CompilerRunnerUtil#invokeExecMethod, in Eclipse plugin (KotlinCLICompiler) and in kotlin-gradle-plugin (GradleCompilerRunner)
     fun execAndOutputXml(errStream: PrintStream, services: Services, vararg args: String): ExitCode {
@@ -58,7 +58,7 @@ abstract class CLICompiler<A : CommonCompilerArguments> : CLITool<A>() {
     }
 
     public override fun execImpl(messageCollector: MessageCollector, services: Services, arguments: A): ExitCode {
-        val performanceManager = createPerformanceManager(arguments)
+        val performanceManager = createPerformanceManager(arguments, services)
         if (arguments.reportPerf || arguments.dumpPerf != null) {
             performanceManager.enableCollectingPerformanceStatistics()
         }

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

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.cli.common
 
 import org.jetbrains.kotlin.util.PerformanceCounter
 import java.io.File
+import java.lang.management.GarbageCollectorMXBean
 import java.lang.management.ManagementFactory
 import java.util.concurrent.TimeUnit
 
@@ -18,13 +19,21 @@ abstract class CommonCompilerPerformanceManager(private val presentableName: Str
     private var analysisStart: Long = 0
     private var generationStart: Long = 0
 
+    private var startGCData = mutableMapOf<String, GCData>()
+
+    private var irTranslationStart: Long = 0
+    private var irGenerationStart: Long = 0
+
     fun getMeasurementResults(): List<PerformanceMeasurement> = measurements
 
     fun enableCollectingPerformanceStatistics() {
         isEnabled = true
         PerformanceCounter.setTimeCounterEnabled(true)
+        ManagementFactory.getGarbageCollectorMXBeans().associateTo(startGCData) { it.name to GCData(it) }
     }
 
+    private fun deltaTime(start: Long): Long = PerformanceCounter.currentTime() - start
+
     open fun notifyCompilerInitialized() {
         if (!isEnabled) return
         recordInitializationTime()
@@ -50,9 +59,39 @@ abstract class CommonCompilerPerformanceManager(private val presentableName: Str
         generationStart = PerformanceCounter.currentTime()
     }
 
-    open fun notifyGenerationFinished(lines: Int, files: Int, additionalDescription: String) {
+    open fun notifyGenerationFinished(files: Int, lines: Int, additionalDescription: String) {
         val time = PerformanceCounter.currentTime() - generationStart
-        measurements += CodeGenerationMeasurement(lines, files, TimeUnit.NANOSECONDS.toMillis(time), additionalDescription)
+        measurements += CodeGenerationMeasurement(files, lines, TimeUnit.NANOSECONDS.toMillis(time), additionalDescription)
+    }
+
+    open fun notifyIRTranslationStarted() {
+        irTranslationStart = PerformanceCounter.currentTime()
+    }
+
+    open fun notifyIRTranslationFinished(files: Int, lines: Int, additionalDescription: String?) {
+        val time = deltaTime(irTranslationStart)
+        measurements += IRMeasurement(
+            files,
+            lines,
+            TimeUnit.NANOSECONDS.toMillis(time),
+            additionalDescription,
+            IRMeasurement.Kind.Translation
+        )
+    }
+
+    open fun notifyIRGenerationStarted() {
+        irGenerationStart = PerformanceCounter.currentTime()
+    }
+
+    open fun notifyIRGenerationFinished(files: Int, lines: Int, additionalDescription: String) {
+        val time = deltaTime(irGenerationStart)
+        measurements += IRMeasurement(
+            files,
+            lines,
+            TimeUnit.NANOSECONDS.toMillis(time),
+            additionalDescription,
+            IRMeasurement.Kind.Generation
+        )
     }
 
     fun dumpPerformanceReport(destination: File) {
@@ -63,7 +102,14 @@ abstract class CommonCompilerPerformanceManager(private val presentableName: Str
         if (!isEnabled) return
 
         ManagementFactory.getGarbageCollectorMXBeans().forEach {
-            measurements += GarbageCollectionMeasurement(it.name, it.collectionTime)
+            val startCounts = startGCData[it.name]
+            val startCollectionTime = startCounts?.collectionTime ?: 0
+            val startCollectionCount = startCounts?.collectionCount ?: 0
+            measurements += GarbageCollectionMeasurement(
+                it.name,
+                it.collectionTime - startCollectionTime,
+                it.collectionCount - startCollectionCount
+            )
         }
     }
 
@@ -89,4 +135,8 @@ abstract class CommonCompilerPerformanceManager(private val presentableName: Str
     }.toByteArray()
 
     open fun notifyRepeat(total: Int, number: Int) {}
+
+    private data class GCData(val name: String, val collectionTime: Long, val collectionCount: Long) {
+        constructor(bean: GarbageCollectorMXBean) : this(bean.name, bean.collectionTime, bean.collectionCount)
+    }
 }

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

@@ -26,6 +26,7 @@ fun <A : CommonCompilerArguments> CompilerConfiguration.setupCommonArguments(
     put(CommonConfigurationKeys.EXPECT_ACTUAL_LINKER, arguments.expectActualLinker)
     putIfNotNull(CLIConfigurationKeys.INTELLIJ_PLUGIN_ROOT, arguments.intellijPluginRoot)
     put(CommonConfigurationKeys.REPORT_OUTPUT_FILES, arguments.reportOutputFiles)
+    put(CommonConfigurationKeys.DESERIALIZE_FAKE_OVERRIDES, arguments.deserializeFakeOverrides)
 
     val metadataVersionString = arguments.metadataVersion
     if (metadataVersionString != null) {

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

@@ -20,13 +20,13 @@ class CompilerInitializationMeasurement(private val milliseconds: Long) : Perfor
 }
 
 
-class CodeAnalysisMeasurement(private val files: Int, val lines: Int, private val milliseconds: Long, private val description: String?) :
+class CodeAnalysisMeasurement(val files: Int, val lines: Int, val milliseconds: Long, private val description: String?) :
     PerformanceMeasurement {
 
-    private val speed: Double = lines.toDouble() * 1000 / milliseconds
+    val lps: Double = lines.toDouble() * 1000 / milliseconds
 
     override fun render(): String =
-        "ANALYZE: $files files ($lines lines) ${description ?: ""}in $milliseconds ms - ${"%.3f".format(speed)} loc/s"
+        "ANALYZE: $files files ($lines lines) ${description ?: ""}in $milliseconds ms - ${"%.3f".format(lps)} loc/s"
 }
 
 
@@ -40,11 +40,23 @@ class CodeGenerationMeasurement(private val files: Int, val lines: Int, private
 }
 
 
-class GarbageCollectionMeasurement(private val garbageCollectionKind: String, private val milliseconds: Long) : PerformanceMeasurement {
-    override fun render(): String = "GC time for $garbageCollectionKind is $milliseconds ms"
+class GarbageCollectionMeasurement(val garbageCollectionKind: String, val milliseconds: Long, val count: Long) : PerformanceMeasurement {
+    override fun render(): String = "GC time for $garbageCollectionKind is $milliseconds ms, $count collections"
 }
 
 
 class PerformanceCounterMeasurement(private val counterReport: String) : PerformanceMeasurement {
     override fun render(): String = counterReport
 }
+
+class IRMeasurement(val files: Int, val lines: Int, val milliseconds: Long, private val description: String?, val kind: Kind) :
+    PerformanceMeasurement {
+
+    val lps: Double = lines.toDouble() * 1000 / milliseconds
+    override fun render(): String =
+        "IR: $kind $files files ($lines lines) ${description ?: ""}in $milliseconds ms - ${"%.3f".format(lps)} loc/s"
+
+    enum class Kind {
+        Generation, Translation
+    }
+}

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

@@ -267,7 +267,9 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
     override val performanceManager: CommonCompilerPerformanceManager
         get() = error("Unsupported")
 
-    override fun createPerformanceManager(arguments: K2JVMCompilerArguments): CommonCompilerPerformanceManager {
+    override fun createPerformanceManager(arguments: K2JVMCompilerArguments, services: Services): CommonCompilerPerformanceManager {
+        val externalManager = services[CommonCompilerPerformanceManager::class.java]
+        if (externalManager != null) return externalManager
         val argument = arguments.profileCompilerCommand ?: return K2JVMCompilerPerformanceManager()
         return ProfilingCompilerPerformanceManager.create(argument)
     }

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

@@ -4,147 +4,52 @@
  */
 package org.jetbrains.kotlin.cli.jvm.compiler;
 
+import com.intellij.DynamicBundle;
 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.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.core.JavaCoreApplicationEnvironment;
 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.*;
+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.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;
 
-/**
- * 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 class KotlinCoreApplicationEnvironment extends JavaCoreApplicationEnvironment {
+    public static KotlinCoreApplicationEnvironment create(@NotNull Disposable parentDisposable, boolean unitTestMode) {
+        KotlinCoreApplicationEnvironment environment = new KotlinCoreApplicationEnvironment(parentDisposable, unitTestMode);
+        registerExtensionPoints();
+        return environment;
+    }
 
-  public static KotlinCoreApplicationEnvironment create(@NotNull Disposable parentDisposable, boolean unitTestMode) {
-    return new KotlinCoreApplicationEnvironment(parentDisposable, unitTestMode);
-  }
+    private KotlinCoreApplicationEnvironment(@NotNull Disposable parentDisposable, boolean unitTestMode) {
+        super(parentDisposable, unitTestMode);
+    }
 
-  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);
 
-    registerExtensionPoints();
+        registerApplicationExtensionPoint(MetaDataContributor.EP_NAME, MetaDataContributor.class);
+        registerApplicationExtensionPoint(PsiAugmentProvider.EP_NAME, PsiAugmentProvider.class);
+        registerApplicationExtensionPoint(JavaMainMethodProvider.EP_NAME, JavaMainMethodProvider.class);
 
-    registerExtensions();
-  }
+        registerApplicationExtensionPoint(ContainerProvider.EP_NAME, ContainerProvider.class);
+        registerApplicationExtensionPoint(ClassFileDecompilers.EP_NAME, ClassFileDecompilers.Decompiler.class);
 
-  private void registerExtensionPoints() {
-    ExtensionsArea area = Extensions.getRootArea();
+        registerApplicationExtensionPoint(MetaLanguage.EP_NAME, MetaLanguage.class);
 
-    CoreApplicationEnvironment.registerExtensionPoint(area, BinaryFileStubBuilders.EP_NAME, FileTypeExtensionPoint.class);
-    CoreApplicationEnvironment.registerExtensionPoint(area, FileContextProvider.EP_NAME, FileContextProvider.class);
+        IdeaExtensionPoints.INSTANCE.registerVersionSpecificAppExtensionPoints(Extensions.getRootArea());
+    }
 
-    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);
-  }
-
-  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() {
-    return new CoreJrtFileSystem();
-  }
+    @Nullable
+    @Override
+    protected VirtualFileSystem createJrtFileSystem() {
+        return new CoreJrtFileSystem();
+    }
 }

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

@@ -0,0 +1,150 @@
+/*
+ * 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.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.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.*;
+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;
+
+/**
+ * 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) {
+    return new KotlinCoreApplicationEnvironment(parentDisposable, unitTestMode);
+  }
+
+  private KotlinCoreApplicationEnvironment(@NotNull Disposable parentDisposable, boolean unitTestMode) {
+    super(parentDisposable, unitTestMode);
+
+    registerExtensionPoints();
+
+    registerExtensions();
+  }
+
+  private 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);
+  }
+
+  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() {
+    return new CoreJrtFileSystem();
+  }
+}

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

@@ -1,55 +0,0 @@
-/*
- * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-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/KotlinToJVMBytecodeCompiler.kt

@@ -374,6 +374,7 @@ object KotlinToJVMBytecodeCompiler {
             performanceManager?.notifyGenerationStarted()
             val signaturer = IdSignatureDescriptor(JvmManglerDesc())
 
+            performanceManager?.notifyIRTranslationStarted()
             val (moduleFragment, symbolTable, sourceManager, components) =
                 Fir2IrConverter.createModuleFragment(
                     session, resolveTransformer.scopeSession, firFiles,
@@ -381,6 +382,9 @@ object KotlinToJVMBytecodeCompiler {
                     generatorExtensions = JvmGeneratorExtensions(),
                     mangler = FirJvmKotlinMangler(session)
                 )
+
+            performanceManager?.notifyIRTranslationFinished(ktFiles.size, codeLines, debugTargetDescription)
+
             val dummyBindingContext = NoScopeRecordCliBindingTrace().bindingContext
 
             val codegenFactory = JvmIrCodegenFactory(moduleConfiguration.get(CLIConfigurationKeys.PHASE_CONFIG) ?: PhaseConfig(jvmPhases))
@@ -402,7 +406,7 @@ object KotlinToJVMBytecodeCompiler {
 
             ProgressIndicatorAndCompilationCanceledStatus.checkCanceled()
 
-
+            performanceManager?.notifyIRGenerationStarted()
             generationState.beforeCompile()
             codegenFactory.generateModuleInFrontendIRMode(
                 generationState, moduleFragment, symbolTable, sourceManager
@@ -431,6 +435,7 @@ object KotlinToJVMBytecodeCompiler {
                 generationState.extraJvmDiagnosticsTrace.bindingContext, environment.messageCollector
             )
 
+            performanceManager?.notifyIRGenerationFinished(ktFiles.size, codeLines, additionalDescription = debugTargetDescription)
             ProgressIndicatorAndCompilationCanceledStatus.checkCanceled()
             outputs[module] = generationState
         }

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

@@ -22,6 +22,7 @@ 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

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

@@ -22,7 +22,6 @@ 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

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

@@ -6,4 +6,10 @@
 package org.jetbrains.kotlin.cli.jvm.compiler
 
 fun setupIdeaStandaloneExecution() {
+    System.getProperties().setProperty("idea.plugins.compatible.build", "201.6668.13")
+    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")
+    System.getProperties().setProperty("ast.loading.filter", "false")
 }

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

@@ -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.202

@@ -12,4 +12,6 @@ fun setupIdeaStandaloneExecution() {
     System.getProperties().setProperty("psi.incremental.reparse.depth.limit", "1000")
     System.getProperties().setProperty("ide.hide.excluded.files", "false")
     System.getProperties().setProperty("ast.loading.filter", "false")
+    System.getProperties().setProperty("idea.ignore.disabled.plugins", "true")
+    System.getProperties().setProperty("idea.home.path", System.getProperty("java.io.tmpdir"))
 }

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

@@ -8,9 +8,11 @@ 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
 
 // FIX ME WHEN BUNCH 193 REMOVED
 fun registerExtensionPointAndExtensionsEx(pluginFile: File, fileName: String, area: ExtensionsArea) {
+    val pluginRoot = FileSystems.getDefault().getPath(pluginFile.path)
     @Suppress("MissingRecentApi")
-    CoreApplicationEnvironment.registerExtensionPointAndExtensions(pluginFile, fileName, area)
+    CoreApplicationEnvironment.registerExtensionPointAndExtensions(pluginRoot, fileName, area)
 }

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

@@ -8,11 +8,9 @@ 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
 
 // FIX ME WHEN BUNCH 193 REMOVED
 fun registerExtensionPointAndExtensionsEx(pluginFile: File, fileName: String, area: ExtensionsArea) {
-    val pluginRoot = FileSystems.getDefault().getPath(pluginFile.path)
     @Suppress("MissingRecentApi")
-    CoreApplicationEnvironment.registerExtensionPointAndExtensions(pluginRoot, fileName, area)
+    CoreApplicationEnvironment.registerExtensionPointAndExtensions(pluginFile, fileName, area)
 }

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

@@ -38,6 +38,17 @@ fun CompilerConfiguration.setupJvmSpecificArguments(arguments: K2JVMCompilerArgu
         }
     }
 
+    val jvmTarget = get(JVMConfigurationKeys.JVM_TARGET) ?: JvmTarget.DEFAULT
+    if (jvmTarget.bytecodeVersion < JvmTarget.JVM_1_8.bytecodeVersion) {
+        val jvmDefaultMode = languageVersionSettings.getFlag(JvmAnalysisFlags.jvmDefaultMode)
+        if (jvmDefaultMode.forAllMethodsWithBody) {
+            messageCollector.report(
+                ERROR,
+                "'-Xjvm-default=${jvmDefaultMode.description}' is only supported since JVM target 1.8. Recompile with '-jvm-target 1.8'"
+            )
+        }
+    }
+
     addAll(JVMConfigurationKeys.ADDITIONAL_JAVA_MODULES, arguments.additionalJavaModules?.asList())
 }
 
@@ -198,6 +209,7 @@ fun CompilerConfiguration.configureAdvancedJvmOptions(arguments: K2JVMCompilerAr
 
     put(CLIConfigurationKeys.ALLOW_KOTLIN_PACKAGE, arguments.allowKotlinPackage)
     put(JVMConfigurationKeys.USE_SINGLE_MODULE, arguments.singleModule)
+    put(JVMConfigurationKeys.USE_OLD_SPILLED_VAR_TYPE_ANALYSIS, arguments.useOldSpilledVarTypeAnalysis)
 
     arguments.declarationsOutputPath?.let { put(JVMConfigurationKeys.DECLARATIONS_JSON_PATH, it) }
 }

compiler/compiler.version/src/org/jetbrains/kotlin/config/KotlinCompilerVersion.java

@@ -19,7 +19,7 @@ public class KotlinCompilerVersion {
     // Binaries produced by this compiler with that language version (or any future language version) are going to be marked
     // as "pre-release" and will not be loaded by release versions of the compiler.
     // Change this value before and after every major release
-    private static final boolean IS_PRE_RELEASE = true;
+    private static final boolean IS_PRE_RELEASE = false;
 
     public static final String TEST_IS_PRE_RELEASE_SYSTEM_PROPERTY = "kotlin.test.is.pre.release";
 

compiler/config.jvm/src/org/jetbrains/kotlin/config/JVMConfigurationKeys.java

@@ -122,4 +122,7 @@ public class JVMConfigurationKeys {
 
     public static final CompilerConfigurationKey<Boolean> NO_KOTLIN_NOTHING_VALUE_EXCEPTION =
             CompilerConfigurationKey.create("Do not use KotlinNothingValueException available since 1.4");
+
+    public static final CompilerConfigurationKey<Boolean> USE_OLD_SPILLED_VAR_TYPE_ANALYSIS =
+            CompilerConfigurationKey.create("Use old, SourceInterpreter-based analysis for fields, used for spilled variables in coroutines");
 }

compiler/config/src/org/jetbrains/kotlin/config/CommonConfigurationKeys.kt

@@ -47,6 +47,9 @@ object CommonConfigurationKeys {
 
     @JvmField
     val EXPECT_ACTUAL_LINKER = CompilerConfigurationKey.create<Boolean>("Experimental expext/actual linker")
+
+    @JvmField
+    val DESERIALIZE_FAKE_OVERRIDES = CompilerConfigurationKey.create<Boolean>("Deserialize fake overrides")
 }
 
 var CompilerConfiguration.languageVersionSettings: LanguageVersionSettings

compiler/fir/analysis-tests/testData/builtIns/kotlin.txt

@@ -208,10 +208,10 @@ public final class Byte : R|kotlin/Number|, R|kotlin/Comparable<kotlin/Byte>|, R
         public final const val MIN_VALUE: R|kotlin/Byte| = Byte(-128)
             public get(): R|kotlin/Byte|
 
-        @R|kotlin/SinceKotlin|(version = String(1.3)) public final const val SIZE_BITS: R|kotlin/Int| = Int(8)
+        @PROPERTY:R|kotlin/SinceKotlin|(version = String(1.3)) public final const val SIZE_BITS: R|kotlin/Int| = Int(8)
             public get(): R|kotlin/Int|
 
-        @R|kotlin/SinceKotlin|(version = String(1.3)) public final const val SIZE_BYTES: R|kotlin/Int| = Int(1)
+        @PROPERTY:R|kotlin/SinceKotlin|(version = String(1.3)) public final const val SIZE_BYTES: R|kotlin/Int| = Int(1)
             public get(): R|kotlin/Int|
 
         private constructor(): R|kotlin/Byte.Companion|
@@ -279,7 +279,7 @@ public final class Char : R|kotlin/Comparable<kotlin/Char>|, R|java/io/Serializa
         public final const val MAX_SURROGATE: R|kotlin/Char| = Char(57343)
             public get(): R|kotlin/Char|
 
-        @R|kotlin/SinceKotlin|(version = String(1.3)) public final const val MAX_VALUE: R|kotlin/Char| = Char(65535)
+        @PROPERTY:R|kotlin/SinceKotlin|(version = String(1.3)) public final const val MAX_VALUE: R|kotlin/Char| = Char(65535)
             public get(): R|kotlin/Char|
 
         public final const val MIN_HIGH_SURROGATE: R|kotlin/Char| = Char(55296)
@@ -291,13 +291,13 @@ public final class Char : R|kotlin/Comparable<kotlin/Char>|, R|java/io/Serializa
         public final const val MIN_SURROGATE: R|kotlin/Char| = Char(55296)
             public get(): R|kotlin/Char|
 
-        @R|kotlin/SinceKotlin|(version = String(1.3)) public final const val MIN_VALUE: R|kotlin/Char| = Char(0)
+        @PROPERTY:R|kotlin/SinceKotlin|(version = String(1.3)) public final const val MIN_VALUE: R|kotlin/Char| = Char(0)
             public get(): R|kotlin/Char|
 
-        @R|kotlin/SinceKotlin|(version = String(1.3)) public final const val SIZE_BITS: R|kotlin/Int| = Int(16)
+        @PROPERTY:R|kotlin/SinceKotlin|(version = String(1.3)) public final const val SIZE_BITS: R|kotlin/Int| = Int(16)
             public get(): R|kotlin/Int|
 
-        @R|kotlin/SinceKotlin|(version = String(1.3)) public final const val SIZE_BYTES: R|kotlin/Int| = Int(2)
+        @PROPERTY:R|kotlin/SinceKotlin|(version = String(1.3)) public final const val SIZE_BYTES: R|kotlin/Int| = Int(2)
             public get(): R|kotlin/Int|
 
         private constructor(): R|kotlin/Char.Companion|
@@ -358,6 +358,20 @@ public abstract interface Comparable<in T> : R|kotlin/Any| {
 
 }
 
+@R|kotlin/annotation/Target|() @R|kotlin/annotation/MustBeDocumented|() @R|kotlin/SinceKotlin|(version = String(1.4)) public final annotation class DeprecatedSinceKotlin : R|kotlin/Annotation| {
+    public final val errorSince: R|kotlin/String|
+        public get(): R|kotlin/String|
+
+    public final val hiddenSince: R|kotlin/String|
+        public get(): R|kotlin/String|
+
+    public final val warningSince: R|kotlin/String|
+        public get(): R|kotlin/String|
+
+    public constructor(warningSince: R|kotlin/String| = STUB, errorSince: R|kotlin/String| = STUB, hiddenSince: R|kotlin/String| = STUB): R|kotlin/DeprecatedSinceKotlin|
+
+}
+
 public final enum class DeprecationLevel : R|kotlin/Enum<kotlin/DeprecationLevel>| {
     private constructor(): R|kotlin/DeprecationLevel|
 
@@ -485,10 +499,10 @@ public final class Double : R|kotlin/Number|, R|kotlin/Comparable<kotlin/Double>
         public final const val POSITIVE_INFINITY: R|kotlin/Double| = Double(Infinity)
             public get(): R|kotlin/Double|
 
-        @R|kotlin/SinceKotlin|(version = String(1.4)) public final const val SIZE_BITS: R|kotlin/Int| = Int(64)
+        @PROPERTY:R|kotlin/SinceKotlin|(version = String(1.4)) public final const val SIZE_BITS: R|kotlin/Int| = Int(64)
             public get(): R|kotlin/Int|
 
-        @R|kotlin/SinceKotlin|(version = String(1.4)) public final const val SIZE_BYTES: R|kotlin/Int| = Int(8)
+        @PROPERTY:R|kotlin/SinceKotlin|(version = String(1.4)) public final const val SIZE_BYTES: R|kotlin/Int| = Int(8)
             public get(): R|kotlin/Int|
 
         private constructor(): R|kotlin/Double.Companion|
@@ -664,10 +678,10 @@ public final class Float : R|kotlin/Number|, R|kotlin/Comparable<kotlin/Float>|,
         public final const val POSITIVE_INFINITY: R|kotlin/Float| = Float(Infinity)
             public get(): R|kotlin/Float|
 
-        @R|kotlin/SinceKotlin|(version = String(1.4)) public final const val SIZE_BITS: R|kotlin/Int| = Int(32)
+        @PROPERTY:R|kotlin/SinceKotlin|(version = String(1.4)) public final const val SIZE_BITS: R|kotlin/Int| = Int(32)
             public get(): R|kotlin/Int|
 
-        @R|kotlin/SinceKotlin|(version = String(1.4)) public final const val SIZE_BYTES: R|kotlin/Int| = Int(4)
+        @PROPERTY:R|kotlin/SinceKotlin|(version = String(1.4)) public final const val SIZE_BYTES: R|kotlin/Int| = Int(4)
             public get(): R|kotlin/Int|
 
         private constructor(): R|kotlin/Float.Companion|
@@ -823,10 +837,10 @@ public final class Int : R|kotlin/Number|, R|kotlin/Comparable<kotlin/Int>|, R|j
         public final const val MIN_VALUE: R|kotlin/Int| = Int(-2147483648)
             public get(): R|kotlin/Int|
 
-        @R|kotlin/SinceKotlin|(version = String(1.3)) public final const val SIZE_BITS: R|kotlin/Int| = Int(32)
+        @PROPERTY:R|kotlin/SinceKotlin|(version = String(1.3)) public final const val SIZE_BITS: R|kotlin/Int| = Int(32)
             public get(): R|kotlin/Int|
 
-        @R|kotlin/SinceKotlin|(version = String(1.3)) public final const val SIZE_BYTES: R|kotlin/Int| = Int(4)
+        @PROPERTY:R|kotlin/SinceKotlin|(version = String(1.3)) public final const val SIZE_BYTES: R|kotlin/Int| = Int(4)
             public get(): R|kotlin/Int|
 
         private constructor(): R|kotlin/Int.Companion|
@@ -979,10 +993,10 @@ public final class Long : R|kotlin/Number|, R|kotlin/Comparable<kotlin/Long>|, R
         public final const val MIN_VALUE: R|kotlin/Long| = Long(-9223372036854775808)
             public get(): R|kotlin/Long|
 
-        @R|kotlin/SinceKotlin|(version = String(1.3)) public final const val SIZE_BITS: R|kotlin/Int| = Int(64)
+        @PROPERTY:R|kotlin/SinceKotlin|(version = String(1.3)) public final const val SIZE_BITS: R|kotlin/Int| = Int(64)
             public get(): R|kotlin/Int|
 
-        @R|kotlin/SinceKotlin|(version = String(1.3)) public final const val SIZE_BYTES: R|kotlin/Int| = Int(8)
+        @PROPERTY:R|kotlin/SinceKotlin|(version = String(1.3)) public final const val SIZE_BYTES: R|kotlin/Int| = Int(8)
             public get(): R|kotlin/Int|
 
         private constructor(): R|kotlin/Long.Companion|
@@ -1169,10 +1183,10 @@ public final class Short : R|kotlin/Number|, R|kotlin/Comparable<kotlin/Short>|,
         public final const val MIN_VALUE: R|kotlin/Short| = Short(-32768)
             public get(): R|kotlin/Short|
 
-        @R|kotlin/SinceKotlin|(version = String(1.3)) public final const val SIZE_BITS: R|kotlin/Int| = Int(16)
+        @PROPERTY:R|kotlin/SinceKotlin|(version = String(1.3)) public final const val SIZE_BITS: R|kotlin/Int| = Int(16)
             public get(): R|kotlin/Int|
 
-        @R|kotlin/SinceKotlin|(version = String(1.3)) public final const val SIZE_BYTES: R|kotlin/Int| = Int(2)
+        @PROPERTY:R|kotlin/SinceKotlin|(version = String(1.3)) public final const val SIZE_BYTES: R|kotlin/Int| = Int(2)
             public get(): R|kotlin/Int|
 
         private constructor(): R|kotlin/Short.Companion|

compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/classMembers/ClassObjectPropertyField.txt

@@ -7,7 +7,7 @@ public final class Class : R|kotlin/Any| {
     public constructor(): R|test/Class|
 
     public final companion object Companion : R|kotlin/Any| {
-        public final var property: R|kotlin/Int|
+        @FIELD:R|test/Anno|() public final var property: R|kotlin/Int|
             public get(): R|kotlin/Int|
             public set(value: R|kotlin/Int|): R|kotlin/Unit|
 

compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/classMembers/DelegatedProperty.txt

@@ -4,7 +4,7 @@ public final annotation class Anno : R|kotlin/Annotation| {
 }
 
 public final class Class : R|kotlin/Any| {
-    public final val x: R|kotlin/Int|
+    @PROPERTY:R|test/Anno|() public final val x: R|kotlin/Int|
         public get(): R|kotlin/Int|
 
     public constructor(): R|test/Class|

compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/classMembers/EnumArgument.txt

@@ -9,7 +9,7 @@ public final annotation class Anno : R|kotlin/Annotation| {
 public final class Class : R|kotlin/Any| {
     @R|test/Anno|(t = R|java/lang/annotation/ElementType.METHOD|()) public final fun foo(): R|kotlin/Unit|
 
-    public final var bar: R|kotlin/Int|
+    @FIELD:R|test/Anno|(t = R|java/lang/annotation/ElementType.FIELD|()) public final var bar: R|kotlin/Int|
         public get(): R|kotlin/Int|
         public set(value: R|kotlin/Int|): R|kotlin/Unit|
 

compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/classMembers/HiddenConstructorWithInlineClassParameters.txt

@@ -7,10 +7,10 @@ public sealed class Sealed : R|kotlin/Any| {
     public final val z: R|test/Z|
         public get(): R|test/Z|
 
-    @R|test/Ann|() private constructor(z: R|test/Z|): R|test/Sealed|
+    @R|test/Ann|() private constructor(@R|test/Ann|() z: R|test/Z|): R|test/Sealed|
 
     public final class Derived : R|test/Sealed| {
-        public constructor(z: R|test/Z|): R|test/Sealed.Derived|
+        @R|test/Ann|() public constructor(z: R|test/Z|): R|test/Sealed.Derived|
 
     }
 
@@ -20,11 +20,11 @@ public final class Test : R|kotlin/Any| {
     public final val z: R|test/Z|
         public get(): R|test/Z|
 
-    @R|test/Ann|() public constructor(z: R|test/Z|, a: R|kotlin/Int|): R|test/Test|
+    @R|test/Ann|() public constructor(z: R|test/Z|, @R|test/Ann|() a: R|kotlin/Int|): R|test/Test|
 
-    @R|test/Ann|() private constructor(z: R|test/Z|, s: R|kotlin/String|): R|test/Test|
+    @R|test/Ann|() private constructor(z: R|test/Z|, @R|test/Ann|() s: R|kotlin/String|): R|test/Test|
 
-    @R|test/Ann|() public constructor(z: R|test/Z|): R|test/Test|
+    @R|test/Ann|() public constructor(@R|test/Ann|() z: R|test/Z|): R|test/Test|
 
 }
 

compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/classMembers/PropertyField.txt

@@ -4,7 +4,7 @@ public final annotation class Anno : R|kotlin/Annotation| {
 }
 
 public final class Class : R|kotlin/Any| {
-    public final var property: R|kotlin/Int|
+    @FIELD:R|test/Anno|() public final var property: R|kotlin/Int|
         public get(): R|kotlin/Int|
         public set(value: R|kotlin/Int|): R|kotlin/Unit|
 

compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/parameters/Constructor.txt

@@ -12,6 +12,6 @@ public final class Class : R|kotlin/Any| {
     public final val x: R|kotlin/Int|
         public get(): R|kotlin/Int|
 
-    public constructor(x: R|kotlin/Int|, y: R|kotlin/String|): R|test/Class|
+    public constructor(@R|test/A|() x: R|kotlin/Int|, @R|test/B|() y: R|kotlin/String|): R|test/Class|
 
 }

compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/parameters/EnumConstructor.txt

@@ -15,7 +15,7 @@ public final enum class E : R|kotlin/Enum<test/E>| {
     public final val y: R|kotlin/Int|
         public get(): R|kotlin/Int|
 
-    private constructor(x: R|kotlin/String|, y: R|kotlin/Int|): R|test/E|
+    private constructor(@R|test/A|() x: R|kotlin/String|, @R|test/B|() y: R|kotlin/Int|): R|test/E|
 
     public final static fun values(): R|kotlin/Array<test/E>| {
     }

compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/parameters/ExtensionFunction.txt

@@ -1,4 +1,4 @@
-public final fun R|kotlin/Int|.foo(x: R|kotlin/Int|): R|kotlin/Unit|
+public final fun R|kotlin/Int|.foo(@R|test/A|() x: R|kotlin/Int|): R|kotlin/Unit|
 
 public final annotation class A : R|kotlin/Annotation| {
     public constructor(): R|test/A|

compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/parameters/ExtensionFunctionInClass.txt

@@ -4,7 +4,7 @@ public final annotation class Anno : R|kotlin/Annotation| {
 }
 
 public final class Class : R|kotlin/Any| {
-    public final fun R|kotlin/String|.foo(x: R|kotlin/Int|): R|kotlin/Int|
+    public final fun R|kotlin/String|.foo(@R|test/Anno|() x: R|kotlin/Int|): R|kotlin/Int|
 
     public constructor(): R|test/Class|
 

compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/parameters/ExtensionPropertySetter.txt

@@ -6,7 +6,7 @@ public final annotation class A : R|kotlin/Annotation| {
 public final class Class : R|kotlin/Any| {
     public final var R|kotlin/Int|.foo: R|kotlin/Int|
         public get(): R|kotlin/Int|
-        public set(value: R|kotlin/Int|): R|kotlin/Unit|
+        public set(@R|test/A|() value: R|kotlin/Int|): R|kotlin/Unit|
 
     public constructor(): R|test/Class|
 

compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/parameters/FunctionInClass.txt

@@ -4,7 +4,7 @@ public final annotation class Anno : R|kotlin/Annotation| {
 }
 
 public final class Class : R|kotlin/Any| {
-    public final fun foo(x: R|kotlin/String|): R|kotlin/Unit|
+    public final fun foo(@R|test/Anno|() x: R|kotlin/String|): R|kotlin/Unit|
 
     public constructor(): R|test/Class|
 

compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/parameters/FunctionInTrait.txt

@@ -4,6 +4,6 @@ public final annotation class Anno : R|kotlin/Annotation| {
 }
 
 public abstract interface Trait : R|kotlin/Any| {
-    public open fun foo(x: R|kotlin/String|): R|kotlin/Int|
+    public open fun foo(@R|test/Anno|() x: R|kotlin/String|): R|kotlin/Int|
 
 }

compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/parameters/InnerClassConstructor.txt

@@ -13,7 +13,7 @@ public final class Outer : R|kotlin/Any| {
         public final val y: R|kotlin/String|
             public get(): R|kotlin/String|
 
-        public constructor(y: R|kotlin/String|): R|test/Outer.Inner|
+        public constructor(@R|test/A|(s = String(inner)) y: R|kotlin/String|): R|test/Outer.Inner|
 
     }
 
@@ -21,7 +21,7 @@ public final class Outer : R|kotlin/Any| {
         public final val x: R|kotlin/String|
             public get(): R|kotlin/String|
 
-        public constructor(x: R|kotlin/String|): R|test/Outer.Nested|
+        public constructor(@R|test/A|(s = String(nested)) x: R|kotlin/String|): R|test/Outer.Nested|
 
     }
 

compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/parameters/ManyAnnotations.txt

@@ -1,6 +1,6 @@
-public final fun bar(x: R|kotlin/Int|): R|kotlin/Unit|
+public final fun bar(@R|test/A|() @R|test/B|() @R|test/C|() @R|test/D|() x: R|kotlin/Int|): R|kotlin/Unit|
 
-public final fun foo(x: R|kotlin/Int|, y: R|kotlin/Double|, z: R|kotlin/String|): R|kotlin/Unit|
+public final fun foo(@R|test/A|() @R|test/B|() x: R|kotlin/Int|, @R|test/A|() @R|test/C|() y: R|kotlin/Double|, @R|test/B|() @R|test/C|() @R|test/D|() z: R|kotlin/String|): R|kotlin/Unit|
 
 public final annotation class A : R|kotlin/Annotation| {
     public constructor(): R|test/A|

compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/parameters/PropertySetterInClass.txt

@@ -6,7 +6,7 @@ public final annotation class A : R|kotlin/Annotation| {
 public final class Class : R|kotlin/Any| {
     public final var foo: R|kotlin/Int|
         public get(): R|kotlin/Int|
-        public set(value: R|kotlin/Int|): R|kotlin/Unit|
+        public set(@R|test/A|() value: R|kotlin/Int|): R|kotlin/Unit|
 
     public constructor(): R|test/Class|
 

compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/parameters/TopLevelFunction.txt

@@ -1,4 +1,4 @@
-public final fun foo(x: R|kotlin/Int|): R|kotlin/Unit|
+public final fun foo(@R|test/Anno|() x: R|kotlin/Int|): R|kotlin/Unit|
 
 public final annotation class Anno : R|kotlin/Annotation| {
     public constructor(): R|test/Anno|

compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/propertiesWithoutBackingFields/Class.txt

@@ -4,7 +4,7 @@ public final annotation class Anno : R|kotlin/Annotation| {
 }
 
 public final class Class : R|kotlin/Any| {
-    public final val property: R|kotlin/Int|
+    @PROPERTY:R|test/Anno|() public final val property: R|kotlin/Int|
         public get(): R|kotlin/Int|
 
     public constructor(): R|test/Class|

compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/propertiesWithoutBackingFields/ClassObject.txt

@@ -7,7 +7,7 @@ public final class Class : R|kotlin/Any| {
     public constructor(): R|test/Class|
 
     public final companion object Companion : R|kotlin/Any| {
-        public final val property: R|kotlin/Int|
+        @PROPERTY:R|test/Anno|() public final val property: R|kotlin/Int|
             public get(): R|kotlin/Int|
 
         private constructor(): R|test/Class.Companion|

compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/propertiesWithoutBackingFields/ExtensionsWithSameNameClass.txt

@@ -1,11 +1,11 @@
 public final class Class : R|kotlin/Any| {
-    public final val R|kotlin/Double|.extension: R|kotlin/Int|
+    @PROPERTY:R|test/DoubleAnno|() public final val R|kotlin/Double|.extension: R|kotlin/Int|
         public get(): R|kotlin/Int|
 
-    public final val R|kotlin/Int|.extension: R|kotlin/Int|
+    @PROPERTY:R|test/IntAnno|() public final val R|kotlin/Int|.extension: R|kotlin/Int|
         public get(): R|kotlin/Int|
 
-    public final val R|kotlin/String|.extension: R|kotlin/String|
+    @PROPERTY:R|test/StringAnno|() public final val R|kotlin/String|.extension: R|kotlin/String|
         public get(): R|kotlin/String|
 
     public constructor(): R|test/Class|

compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/propertiesWithoutBackingFields/TraitClassObject.txt

@@ -5,7 +5,7 @@ public final annotation class Anno : R|kotlin/Annotation| {
 
 public abstract interface Trait : R|kotlin/Any| {
     public final companion object Companion : R|kotlin/Any| {
-        public final val property: R|kotlin/Int|
+        @PROPERTY:R|test/Anno|() public final val property: R|kotlin/Int|
             public get(): R|kotlin/Int|
 
         private constructor(): R|test/Trait.Companion|

compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/withUseSiteTarget/DelegateTarget.txt

@@ -4,7 +4,7 @@ public final annotation class Anno : R|kotlin/Annotation| {
 }
 
 public final class Class : R|kotlin/Any| {
-    public final val property: R|kotlin/String|
+    @PROPERTY_DELEGATE_FIELD:R|test/Anno|() public final val property: R|kotlin/String|
         public get(): R|kotlin/String|
 
     public constructor(): R|test/Class|

compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/withUseSiteTarget/FieldTarget.txt

@@ -4,7 +4,7 @@ public final annotation class Anno : R|kotlin/Annotation| {
 }
 
 public final class Class : R|kotlin/Any| {
-    public final var property: R|kotlin/Int|
+    @FIELD:R|test/Anno|() public final var property: R|kotlin/Int|
         public get(): R|kotlin/Int|
         public set(value: R|kotlin/Int|): R|kotlin/Unit|
 

compiler/fir/analysis-tests/testData/loadCompiledKotlin/annotations/withUseSiteTarget/ReceiverTarget.txt

@@ -1,5 +1,5 @@
 public final class A : R|kotlin/Any| {
-    public final fun R|kotlin/String|.myLength(q: R|kotlin/String|): R|kotlin/Int|
+    public final fun R|kotlin/String|.myLength(@R|test/Ann|() q: R|kotlin/String|): R|kotlin/Int|
 
     public final val R|kotlin/String|.myLength2: R|kotlin/Int|
         public get(): R|kotlin/Int|

compiler/fir/analysis-tests/testData/resolve/callResolution/uselessMultipleBounds.kt

@@ -0,0 +1,13 @@
+// ISSUE: KT-39032
+
+interface A {
+    fun foo()
+}
+
+interface B : A {
+    override fun foo()
+}
+
+fun <E> bar(e: E) where E : A, E : B {
+    e.foo()
+}

compiler/fir/analysis-tests/testData/resolve/callResolution/uselessMultipleBounds.txt

@@ -0,0 +1,12 @@
+FILE: uselessMultipleBounds.kt
+    public abstract interface A : R|kotlin/Any| {
+        public abstract fun foo(): R|kotlin/Unit|
+
+    }
+    public abstract interface B : R|A| {
+        public abstract override fun foo(): R|kotlin/Unit|
+
+    }
+    public final fun <E : R|A|, R|B|> bar(e: R|E|): R|kotlin/Unit| {
+        R|<local>/e|.R|/B.foo|()
+    }

compiler/fir/analysis-tests/testData/resolve/cfg/inplaceLambdaInControlFlowExpressions.dot

@@ -61,14 +61,14 @@ digraph inplaceLambdaInControlFlowExpressions_kt {
                     23 [label="Postponed enter to lambda"];
                     subgraph cluster_9 {
                         color=blue
-                        33 [label="Enter function anonymousFunction" style="filled" fillcolor=red];
+                        32 [label="Enter function anonymousFunction" style="filled" fillcolor=red];
                         subgraph cluster_10 {
                             color=blue
-                            34 [label="Enter block"];
-                            35 [label="Function call: R|/materialize|<R|kotlin/String|>()"];
-                            36 [label="Exit block"];
+                            33 [label="Enter block"];
+                            34 [label="Function call: R|/materialize|<R|kotlin/String|>()"];
+                            35 [label="Exit block"];
                         }
-                        37 [label="Exit function anonymousFunction" style="filled" fillcolor=red];
+                        36 [label="Exit function anonymousFunction" style="filled" fillcolor=red];
                     }
                     24 [label="Postponed exit from lambda"];
                     25 [label="Function call: R|kotlin/run|<R|kotlin/String|>(...)"];
@@ -77,11 +77,10 @@ digraph inplaceLambdaInControlFlowExpressions_kt {
                 27 [label="Exit when branch result"];
                 28 [label="Exit when"];
             }
-            29 [label="Call arguments union" style="filled" fillcolor=yellow];
-            30 [label="Variable declaration: lval x: R|kotlin/String|"];
-            31 [label="Exit block"];
+            29 [label="Variable declaration: lval x: R|kotlin/String|"];
+            30 [label="Exit block"];
         }
-        32 [label="Exit function test_1" style="filled" fillcolor=red];
+        31 [label="Exit function test_1" style="filled" fillcolor=red];
     }
     8 -> {9};
     9 -> {10};
@@ -98,7 +97,7 @@ digraph inplaceLambdaInControlFlowExpressions_kt {
     20 -> {28};
     21 -> {22};
     22 -> {23};
-    23 -> {33};
+    23 -> {32};
     23 -> {24} [color=red];
     24 -> {25};
     25 -> {26};
@@ -107,78 +106,77 @@ digraph inplaceLambdaInControlFlowExpressions_kt {
     28 -> {29};
     29 -> {30};
     30 -> {31};
-    31 -> {32};
+    32 -> {33};
     33 -> {34};
     34 -> {35};
     35 -> {36};
-    36 -> {37};
-    37 -> {29} [color=red];
-    37 -> {24} [color=green];
+    36 -> {24} [color=green];
 
     subgraph cluster_11 {
         color=red
-        38 [label="Enter function test_2" style="filled" fillcolor=red];
+        37 [label="Enter function test_2" style="filled" fillcolor=red];
         subgraph cluster_12 {
             color=blue
-            39 [label="Enter block"];
+            38 [label="Enter block"];
             subgraph cluster_13 {
                 color=blue
-                40 [label="Try expression enter"];
+                39 [label="Try expression enter"];
                 subgraph cluster_14 {
                     color=blue
-                    41 [label="Try main block enter"];
+                    40 [label="Try main block enter"];
                     subgraph cluster_15 {
                         color=blue
-                        42 [label="Enter block"];
-                        43 [label="Postponed enter to lambda"];
+                        41 [label="Enter block"];
+                        42 [label="Postponed enter to lambda"];
                         subgraph cluster_16 {
                             color=blue
-                            58 [label="Enter function anonymousFunction" style="filled" fillcolor=red];
+                            57 [label="Enter function anonymousFunction" style="filled" fillcolor=red];
                             subgraph cluster_17 {
                                 color=blue
-                                59 [label="Enter block"];
-                                60 [label="Function call: R|/materialize|<R|kotlin/String|>()"];
-                                61 [label="Exit block"];
+                                58 [label="Enter block"];
+                                59 [label="Function call: R|/materialize|<R|kotlin/String|>()"];
+                                60 [label="Exit block"];
                             }
-                            62 [label="Exit function anonymousFunction" style="filled" fillcolor=red];
+                            61 [label="Exit function anonymousFunction" style="filled" fillcolor=red];
                         }
-                        44 [label="Postponed exit from lambda"];
-                        45 [label="Function call: R|kotlin/run|<R|kotlin/String|>(...)"];
-                        46 [label="Exit block"];
+                        43 [label="Postponed exit from lambda"];
+                        44 [label="Function call: R|kotlin/run|<R|kotlin/String|>(...)"];
+                        45 [label="Exit block"];
                     }
-                    47 [label="Try main block exit"];
+                    46 [label="Try main block exit"];
                 }
                 subgraph cluster_18 {
                     color=blue
-                    48 [label="Catch enter"];
+                    47 [label="Catch enter"];
                     subgraph cluster_19 {
                         color=blue
-                        49 [label="Enter block"];
-                        50 [label="Const: String()"];
-                        51 [label="Exit block"];
+                        48 [label="Enter block"];
+                        49 [label="Const: String()"];
+                        50 [label="Exit block"];
                     }
-                    52 [label="Catch exit"];
+                    51 [label="Catch exit"];
                 }
-                53 [label="Try expression exit"];
+                52 [label="Try expression exit"];
             }
-            54 [label="Call arguments union" style="filled" fillcolor=yellow];
-            55 [label="Variable declaration: lval x: R|kotlin/String|"];
-            56 [label="Exit block"];
+            53 [label="Call arguments union" style="filled" fillcolor=yellow];
+            54 [label="Variable declaration: lval x: R|kotlin/String|"];
+            55 [label="Exit block"];
         }
-        57 [label="Exit function test_2" style="filled" fillcolor=red];
+        56 [label="Exit function test_2" style="filled" fillcolor=red];
     }
+    37 -> {38};
     38 -> {39};
     39 -> {40};
-    40 -> {41};
-    41 -> {57 48 42};
-    42 -> {43};
-    43 -> {58};
-    43 -> {44} [color=red];
+    40 -> {56 47 41};
+    41 -> {42};
+    42 -> {57};
+    42 -> {43} [color=red];
+    43 -> {44};
     44 -> {45};
     45 -> {46};
-    46 -> {47};
-    47 -> {53};
-    48 -> {57 49};
+    46 -> {52};
+    47 -> {56 48};
+    48 -> {49};
     49 -> {50};
     50 -> {51};
     51 -> {52};
@@ -186,56 +184,55 @@ digraph inplaceLambdaInControlFlowExpressions_kt {
     53 -> {54};
     54 -> {55};
     55 -> {56};
-    56 -> {57};
+    57 -> {58};
     58 -> {59};
     59 -> {60};
     60 -> {61};
-    61 -> {62};
-    62 -> {54} [color=red];
-    62 -> {44} [color=green];
+    61 -> {53} [color=red];
+    61 -> {43} [color=green];
 
     subgraph cluster_20 {
         color=red
-        63 [label="Enter function test_3" style="filled" fillcolor=red];
+        62 [label="Enter function test_3" style="filled" fillcolor=red];
         subgraph cluster_21 {
             color=blue
-            64 [label="Enter block"];
-            65 [label="Postponed enter to lambda"];
+            63 [label="Enter block"];
+            64 [label="Postponed enter to lambda"];
             subgraph cluster_22 {
                 color=blue
-                73 [label="Enter function anonymousFunction" style="filled" fillcolor=red];
+                72 [label="Enter function anonymousFunction" style="filled" fillcolor=red];
                 subgraph cluster_23 {
                     color=blue
-                    74 [label="Enter block"];
-                    75 [label="Function call: R|/materialize|<R|kotlin/String?|>()"];
-                    76 [label="Exit block"];
+                    73 [label="Enter block"];
+                    74 [label="Function call: R|/materialize|<R|kotlin/String?|>()"];
+                    75 [label="Exit block"];
                 }
-                77 [label="Exit function anonymousFunction" style="filled" fillcolor=red];
+                76 [label="Exit function anonymousFunction" style="filled" fillcolor=red];
             }
-            66 [label="Postponed exit from lambda"];
-            67 [label="Function call: R|kotlin/run|<R|kotlin/String?|>(...)"];
-            68 [label="Check not null: R|kotlin/run|<R|kotlin/String?|>(...)!!"];
-            69 [label="Call arguments union" style="filled" fillcolor=yellow];
-            70 [label="Variable declaration: lval x: R|kotlin/String|"];
-            71 [label="Exit block"];
+            65 [label="Postponed exit from lambda"];
+            66 [label="Function call: R|kotlin/run|<R|kotlin/String?|>(...)"];
+            67 [label="Check not null: R|kotlin/run|<R|kotlin/String?|>(...)!!"];
+            68 [label="Call arguments union" style="filled" fillcolor=yellow];
+            69 [label="Variable declaration: lval x: R|kotlin/String|"];
+            70 [label="Exit block"];
         }
-        72 [label="Exit function test_3" style="filled" fillcolor=red];
+        71 [label="Exit function test_3" style="filled" fillcolor=red];
     }
+    62 -> {63};
     63 -> {64};
-    64 -> {65};
-    65 -> {73};
-    65 -> {66} [color=red];
+    64 -> {72};
+    64 -> {65} [color=red];
+    65 -> {66};
     66 -> {67};
     67 -> {68};
     68 -> {69};
     69 -> {70};
     70 -> {71};
-    71 -> {72};
+    72 -> {73};
     73 -> {74};
     74 -> {75};
     75 -> {76};
-    76 -> {77};
-    77 -> {69} [color=red];
-    77 -> {66} [color=green];
+    76 -> {68} [color=red];
+    76 -> {65} [color=green];
 
 }

compiler/fir/analysis-tests/testData/resolve/delegatedSuperType.txt

@@ -13,8 +13,11 @@ FILE: delegatedSuperType.kt
 
     }
     public final class C : R|A| {
+        local final field $$delegate_0: R|A|
+
         public constructor(b: R|B|): R|C| {
             super<R|kotlin/Any|>()
+            this@R|/C|.R|<local>/$$delegate_0| = R|<local>/b|
         }
 
         public final val b: R|B| = R|<local>/b|

compiler/fir/analysis-tests/testData/resolve/delegates/delegateWithLambda.txt

@@ -24,15 +24,7 @@ FILE: delegateWithLambda.kt
         }
 
         public final val x: R|kotlin/String|by R|/lazy|<R|kotlin/String|>(<L> = lazy@fun <anonymous>(): R|kotlin/String| {
-            lval y: R|kotlin/String| = when (lval <elvis>: R|kotlin/String?| = (R|/getAny|() as? R|kotlin/String|)) {
-                ==($subj$, Null(null)) ->  {
-                    String()
-                }
-                else ->  {
-                    R|<local>/<elvis>|
-                }
-            }
-
+            lval y: R|kotlin/String| = (R|/getAny|() as? R|kotlin/String|) ?: String()
             ^ R|<local>/y|
         }
         )

compiler/fir/analysis-tests/testData/resolve/diagnostics/projectionsOnNonClassTypeArguments.kt

@@ -0,0 +1,8 @@
+class A<in T, out K>
+class B
+
+fun test() {
+    val a1 = A<<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>in Int<!>, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>out B<!>>()
+    val a2 = A<Int, B>()
+    val a3 = A<<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
+}

compiler/fir/analysis-tests/testData/resolve/diagnostics/projectionsOnNonClassTypeArguments.txt

@@ -0,0 +1,18 @@
+FILE: projectionsOnNonClassTypeArguments.kt
+    public final class A<in T, out K> : R|kotlin/Any| {
+        public constructor<in T, out K>(): R|A<T, K>| {
+            super<R|kotlin/Any|>()
+        }
+
+    }
+    public final class B : R|kotlin/Any| {
+        public constructor(): R|B| {
+            super<R|kotlin/Any|>()
+        }
+
+    }
+    public final fun test(): R|kotlin/Unit| {
+        lval a1: R|A<kotlin/Int, B>| = R|/A.A|<in R|kotlin/Int|, out R|B|>()
+        lval a2: R|A<kotlin/Int, B>| = R|/A.A|<R|kotlin/Int|, R|B|>()
+        lval a3: R|A<kotlin/Any?, kotlin/Any?>| = R|/A.A|<*, *>()
+    }

compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedSubClass.kt

@@ -0,0 +1,54 @@
+sealed class A
+
+sealed class B : A()
+class C : A()
+
+sealed class D : B()
+sealed class E : B()
+
+fun test_1(e: A) {
+    val a = when (e) {
+        is C -> 1
+        is D -> 2
+        is E -> 3
+    }.plus(0)
+
+    val b = when (e) {
+        is B -> 1
+        is C -> 2
+    }.plus(0)
+
+    val c = when (e) {
+        is B -> 1
+        is C -> 2
+        is E -> 3
+        is D -> 4
+    }.plus(0)
+
+    val d = when (e) {
+        is E -> 1
+        is A -> 2
+    }.plus(0)
+}
+
+fun test_2(e: A) {
+    val a = when (e) {
+        is D -> 1
+        is E -> 2
+    }.<!UNRESOLVED_REFERENCE!>plus<!>(0)
+
+    val b = when (e) {
+        is B -> 1
+        is D -> 2
+        is E -> 3
+    }.<!UNRESOLVED_REFERENCE!>plus<!>(0)
+
+    val c = when (e) {
+        is B -> 1
+        is D -> 2
+    }.<!UNRESOLVED_REFERENCE!>plus<!>(0)
+
+    val d = when (e) {
+        is C -> 1
+    }.<!UNRESOLVED_REFERENCE!>plus<!>(0)
+}

compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedSubClass.txt

@@ -0,0 +1,116 @@
+FILE: exhaustiveness_sealedSubClass.kt
+    public sealed class A : R|kotlin/Any| {
+        private constructor(): R|A| {
+            super<R|kotlin/Any|>()
+        }
+
+    }
+    public sealed class B : R|A| {
+        private constructor(): R|B| {
+            super<R|A|>()
+        }
+
+    }
+    public final class C : R|A| {
+        public constructor(): R|C| {
+            super<R|A|>()
+        }
+
+    }
+    public sealed class D : R|B| {
+        private constructor(): R|D| {
+            super<R|B|>()
+        }
+
+    }
+    public sealed class E : R|B| {
+        private constructor(): R|E| {
+            super<R|B|>()
+        }
+
+    }
+    public final fun test_1(e: R|A|): R|kotlin/Unit| {
+        lval a: R|kotlin/Int| = when (R|<local>/e|) {
+            ($subj$ is R|C|) ->  {
+                Int(1)
+            }
+            ($subj$ is R|D|) ->  {
+                Int(2)
+            }
+            ($subj$ is R|E|) ->  {
+                Int(3)
+            }
+        }
+        .R|kotlin/Int.plus|(Int(0))
+        lval b: R|kotlin/Int| = when (R|<local>/e|) {
+            ($subj$ is R|B|) ->  {
+                Int(1)
+            }
+            ($subj$ is R|C|) ->  {
+                Int(2)
+            }
+        }
+        .R|kotlin/Int.plus|(Int(0))
+        lval c: R|kotlin/Int| = when (R|<local>/e|) {
+            ($subj$ is R|B|) ->  {
+                Int(1)
+            }
+            ($subj$ is R|C|) ->  {
+                Int(2)
+            }
+            ($subj$ is R|E|) ->  {
+                Int(3)
+            }
+            ($subj$ is R|D|) ->  {
+                Int(4)
+            }
+        }
+        .R|kotlin/Int.plus|(Int(0))
+        lval d: R|kotlin/Int| = when (R|<local>/e|) {
+            ($subj$ is R|E|) ->  {
+                Int(1)
+            }
+            ($subj$ is R|A|) ->  {
+                Int(2)
+            }
+        }
+        .R|kotlin/Int.plus|(Int(0))
+    }
+    public final fun test_2(e: R|A|): R|kotlin/Unit| {
+        lval a: <ERROR TYPE REF: Unresolved name: plus> = when (R|<local>/e|) {
+            ($subj$ is R|D|) ->  {
+                Int(1)
+            }
+            ($subj$ is R|E|) ->  {
+                Int(2)
+            }
+        }
+        .<Unresolved name: plus>#(Int(0))
+        lval b: <ERROR TYPE REF: Unresolved name: plus> = when (R|<local>/e|) {
+            ($subj$ is R|B|) ->  {
+                Int(1)
+            }
+            ($subj$ is R|D|) ->  {
+                Int(2)
+            }
+            ($subj$ is R|E|) ->  {
+                Int(3)
+            }
+        }
+        .<Unresolved name: plus>#(Int(0))
+        lval c: <ERROR TYPE REF: Unresolved name: plus> = when (R|<local>/e|) {
+            ($subj$ is R|B|) ->  {
+                Int(1)
+            }
+            ($subj$ is R|D|) ->  {
+                Int(2)
+            }
+        }
+        .<Unresolved name: plus>#(Int(0))
+        lval d: <ERROR TYPE REF: Unresolved name: plus> = when (R|<local>/e|) {
+            ($subj$ is R|C|) ->  {
+                Int(1)
+            }
+        }
+        .<Unresolved name: plus>#(Int(0))
+    }

compiler/fir/analysis-tests/testData/resolve/expresssions/syntheticSmartCast.txt

@@ -16,27 +16,11 @@ FILE: test.kt
 
     }
     public final fun test1(x: R|AnotherClass?|): R|kotlin/Unit| {
-        lval bar: R|kotlin/CharSequence| = when (lval <elvis>: R|kotlin/CharSequence?| = R|<local>/x|?.{ $subj$.R|/AnotherClass.bar| }) {
-            ==($subj$, Null(null)) ->  {
-                ^test1 Unit
-            }
-            else ->  {
-                R|<local>/<elvis>|
-            }
-        }
-
+        lval bar: R|kotlin/CharSequence| = R|<local>/x|?.{ $subj$.R|/AnotherClass.bar| } ?: ^test1 Unit
         R|<local>/x|.R|/AnotherClass.bar|
     }
     public final fun test2(x: R|SomeClass?|): R|kotlin/Unit| {
-        lval bar: R|kotlin/CharSequence| = when (lval <elvis>: R|kotlin/CharSequence?| = R|<local>/x|?.{ $subj$.R|/SomeClass.bar| }) {
-            ==($subj$, Null(null)) ->  {
-                ^test2 Unit
-            }
-            else ->  {
-                R|<local>/<elvis>|
-            }
-        }
-
+        lval bar: R|kotlin/CharSequence| = R|<local>/x|?.{ $subj$.R|/SomeClass.bar| } ?: ^test2 Unit
         R|<local>/x|.R|/SomeClass.bar|
     }
     public final fun test3(x: R|AnotherClass?|): R|kotlin/Unit| {
@@ -58,62 +42,22 @@ FILE: test.kt
 
     }
     public final fun test5(x: R|AnotherClass?|): R|kotlin/Unit| {
-        lval bar: R|kotlin/String| = when (lval <elvis>: R|kotlin/String?| = (R|<local>/x|?.{ $subj$.R|/AnotherClass.bar| } as? R|kotlin/String|)) {
-            ==($subj$, Null(null)) ->  {
-                ^test5 Unit
-            }
-            else ->  {
-                R|<local>/<elvis>|
-            }
-        }
-
+        lval bar: R|kotlin/String| = (R|<local>/x|?.{ $subj$.R|/AnotherClass.bar| } as? R|kotlin/String|) ?: ^test5 Unit
         R|<local>/x|.R|/AnotherClass.foo|
     }
     public final fun test6(x: R|SomeClass?|): R|kotlin/Unit| {
-        lval bar: R|kotlin/String| = when (lval <elvis>: R|kotlin/String?| = (R|<local>/x|?.{ $subj$.R|/SomeClass.bar| } as? R|kotlin/String|)) {
-            ==($subj$, Null(null)) ->  {
-                ^test6 Unit
-            }
-            else ->  {
-                R|<local>/<elvis>|
-            }
-        }
-
+        lval bar: R|kotlin/String| = (R|<local>/x|?.{ $subj$.R|/SomeClass.bar| } as? R|kotlin/String|) ?: ^test6 Unit
         R|<local>/x|.R|/SomeClass.foo|
     }
     public final fun test7(x: R|AnotherClass?|): R|kotlin/Unit| {
-        lval baz: R|kotlin/Boolean| = when (lval <elvis>: R|kotlin/Boolean?| = (R|<local>/x|?.{ $subj$.R|/AnotherClass.baz|() } as? R|kotlin/Boolean|)) {
-            ==($subj$, Null(null)) ->  {
-                ^test7 Unit
-            }
-            else ->  {
-                R|<local>/<elvis>|
-            }
-        }
-
+        lval baz: R|kotlin/Boolean| = (R|<local>/x|?.{ $subj$.R|/AnotherClass.baz|() } as? R|kotlin/Boolean|) ?: ^test7 Unit
         R|<local>/x|.R|/AnotherClass.foo|
     }
     public final fun test8(x: R|AnotherClass?|): R|kotlin/Unit| {
-        lval bar: R|kotlin/CharSequence| = when (lval <elvis>: R|kotlin/CharSequence?| = R|<local>/x|?.{ $subj$.R|/AnotherClass.bar| }) {
-            ==($subj$, Null(null)) ->  {
-                ^test8 Unit
-            }
-            else ->  {
-                R|<local>/<elvis>|
-            }
-        }
-
+        lval bar: R|kotlin/CharSequence| = R|<local>/x|?.{ $subj$.R|/AnotherClass.bar| } ?: ^test8 Unit
         R|<local>/x|.R|/AnotherClass.foo|
     }
     public final fun test9(x: R|AnotherClass?|): R|kotlin/Unit| {
-        lval baz: R|kotlin/Any| = when (lval <elvis>: R|kotlin/Any?| = R|<local>/x|?.{ $subj$.R|/AnotherClass.baz|() }) {
-            ==($subj$, Null(null)) ->  {
-                ^test9 Unit
-            }
-            else ->  {
-                R|<local>/<elvis>|
-            }
-        }
-
+        lval baz: R|kotlin/Any| = R|<local>/x|?.{ $subj$.R|/AnotherClass.baz|() } ?: ^test9 Unit
         R|<local>/x|.R|/AnotherClass.foo|
     }

compiler/fir/analysis-tests/testData/resolve/inference/coercionToUnitWithEarlyReturn.kt

@@ -0,0 +1,19 @@
+// ISSUE: KT-39075
+
+class A {
+    fun unit() {}
+}
+
+fun foo(x: () -> Unit) {}
+
+fun main(x: A?) {
+
+    val lambda = l@{
+        if (x?.hashCode() == 0) return@l
+
+        x?.unit()
+    }
+
+    // lambda has a type (() -> Unit?)
+    foo(lambda)
+}

compiler/fir/analysis-tests/testData/resolve/inference/coercionToUnitWithEarlyReturn.txt

@@ -0,0 +1,25 @@
+FILE: coercionToUnitWithEarlyReturn.kt
+    public final class A : R|kotlin/Any| {
+        public constructor(): R|A| {
+            super<R|kotlin/Any|>()
+        }
+
+        public final fun unit(): R|kotlin/Unit| {
+        }
+
+    }
+    public final fun foo(x: R|() -> kotlin/Unit|): R|kotlin/Unit| {
+    }
+    public final fun main(x: R|A?|): R|kotlin/Unit| {
+        lval lambda: R|() -> kotlin/Unit| = l@fun <anonymous>(): R|kotlin/Unit| {
+            when () {
+                ==(R|<local>/x|?.{ $subj$.R|kotlin/Any.hashCode|() }, Int(0)) ->  {
+                    ^@l Unit
+                }
+            }
+
+            ^ R|<local>/x|?.{ $subj$.R|/A.unit|() }
+        }
+
+        R|/foo|(R|<local>/lambda|)
+    }

compiler/fir/analysis-tests/testData/resolve/inference/integerLiteralAsComparable.kt

@@ -0,0 +1,14 @@
+// ISSUE: KT-39048
+
+// FILE: JavaClass.java
+public class JavaClass<T extends Comparable<? super T>> {
+    public JavaClass(T from) {}
+}
+
+// FILE: main.kt
+
+class K<T : Comparable<T>>(t: T)
+fun main() {
+    K(0)
+    JavaClass(0)
+}

compiler/fir/analysis-tests/testData/resolve/inference/integerLiteralAsComparable.txt

@@ -0,0 +1,11 @@
+FILE: main.kt
+    public final class K<T : R|kotlin/Comparable<T>|> : R|kotlin/Any| {
+        public constructor<T : R|kotlin/Comparable<T>|>(t: R|T|): R|K<T>| {
+            super<R|kotlin/Any|>()
+        }
+
+    }
+    public final fun main(): R|kotlin/Unit| {
+        R|/K.K|<R|kotlin/Int|>(Int(0))
+        R|/JavaClass.JavaClass|<R|ft<ILT: 0, ILT: 0?>!|>(Int(0))
+    }

compiler/fir/analysis-tests/testData/resolve/inference/lambdaInElvis.kt

@@ -0,0 +1,18 @@
+// ISSUE: KT-39012
+
+interface A
+
+fun <T> foo(f: (MutableList<T>) -> Unit): List<T>? = TODO()
+fun <T> listOf(): List<T> = TODO()
+
+fun bar1(w: List<CharSequence>): List<CharSequence>? {
+    return foo { container ->
+        container.add("")
+    } ?: w
+}
+
+fun bar2(): List<CharSequence>? {
+    return foo { container ->
+        container.add("")
+    } ?: listOf()
+}

compiler/fir/analysis-tests/testData/resolve/inference/lambdaInElvis.txt

@@ -0,0 +1,21 @@
+FILE: lambdaInElvis.kt
+    public abstract interface A : R|kotlin/Any| {
+    }
+    public final fun <T> foo(f: R|(kotlin/collections/MutableList<T>) -> kotlin/Unit|): R|kotlin/collections/List<T>?| {
+        ^foo R|kotlin/TODO|()
+    }
+    public final fun <T> listOf(): R|kotlin/collections/List<T>| {
+        ^listOf R|kotlin/TODO|()
+    }
+    public final fun bar1(w: R|kotlin/collections/List<kotlin/CharSequence>|): R|kotlin/collections/List<kotlin/CharSequence>?| {
+        ^bar1 R|/foo|<R|kotlin/CharSequence|>(<L> = foo@fun <anonymous>(container: R|kotlin/collections/MutableList<kotlin/CharSequence>|): R|kotlin/Unit| {
+            ^ R|<local>/container|.R|FakeOverride<kotlin/collections/MutableList.add: R|kotlin/Boolean|>|(String())
+        }
+        ) ?: R|<local>/w|
+    }
+    public final fun bar2(): R|kotlin/collections/List<kotlin/CharSequence>?| {
+        ^bar2 R|/foo|<R|kotlin/CharSequence|>(<L> = foo@fun <anonymous>(container: R|kotlin/collections/MutableList<kotlin/CharSequence>|): R|kotlin/Unit| {
+            ^ R|<local>/container|.R|FakeOverride<kotlin/collections/MutableList.add: R|kotlin/Boolean|>|(String())
+        }
+        ) ?: R|/listOf|<R|kotlin/CharSequence|>()
+    }

compiler/fir/analysis-tests/testData/resolve/inference/nestedExtensionFunctionType.kt

@@ -0,0 +1,19 @@
+// ISSUE: KT-39034
+
+interface A
+
+fun test_0(a: A, f: A.() -> Unit) {
+    a.f()
+}
+
+fun test_1(a: A, ys: List<A.() -> Unit>) {
+    for (y in ys) {
+        a.y()
+    }
+}
+
+fun test_2(a: A, vararg zs: A.() -> Unit) {
+    for (z in zs) {
+        a.z()
+    }
+}

compiler/fir/analysis-tests/testData/resolve/inference/nestedExtensionFunctionType.txt

@@ -0,0 +1,22 @@
+FILE: nestedExtensionFunctionType.kt
+    public abstract interface A : R|kotlin/Any| {
+    }
+    public final fun test_0(a: R|A|, f: R|A.() -> kotlin/Unit|): R|kotlin/Unit| {
+        R|<local>/f|.R|FakeOverride<kotlin/Function1.invoke: R|kotlin/Unit|>|(R|<local>/a|)
+    }
+    public final fun test_1(a: R|A|, ys: R|kotlin/collections/List<kotlin/Function1<A, kotlin/Unit>>|): R|kotlin/Unit| {
+        lval <iterator>: R|kotlin/collections/Iterator<kotlin/Function1<A, kotlin/Unit>>| = R|<local>/ys|.R|FakeOverride<kotlin/collections/List.iterator: R|kotlin/collections/Iterator<kotlin/Function1<A, kotlin/Unit>>|>|()
+        while(R|<local>/<iterator>|.R|kotlin/collections/Iterator.hasNext|()) {
+            lval y: R|(A) -> kotlin/Unit| = R|<local>/<iterator>|.R|FakeOverride<kotlin/collections/Iterator.next: R|(A) -> kotlin/Unit|>|()
+            R|<local>/y|.R|FakeOverride<kotlin/Function1.invoke: R|kotlin/Unit|>|(R|<local>/a|)
+        }
+
+    }
+    public final fun test_2(a: R|A|, vararg zs: @R|kotlin/ExtensionFunctionType|() R|kotlin/Array<out kotlin/Function1<A, kotlin/Unit>>|): R|kotlin/Unit| {
+        lval <iterator>: R|kotlin/collections/Iterator<kotlin/Function1<A, kotlin/Unit>>| = R|<local>/zs|.R|FakeOverride<kotlin/Array.iterator: R|kotlin/collections/Iterator<kotlin/Function1<A, kotlin/Unit>>|>|()
+        while(R|<local>/<iterator>|.R|kotlin/collections/Iterator.hasNext|()) {
+            lval z: R|(A) -> kotlin/Unit| = R|<local>/<iterator>|.R|FakeOverride<kotlin/collections/Iterator.next: R|(A) -> kotlin/Unit|>|()
+            R|<local>/z|.R|FakeOverride<kotlin/Function1.invoke: R|kotlin/Unit|>|(R|<local>/a|)
+        }
+
+    }

compiler/fir/analysis-tests/testData/resolve/invokeInWhenSubjectVariableInitializer.txt

@@ -1,12 +1,4 @@
 FILE: invokeInWhenSubjectVariableInitializer.kt
     public final fun test(func: R|() -> kotlin/String?|): R|kotlin/Unit| {
-        lval x: R|kotlin/String| = when (lval <elvis>: R|kotlin/String?| = R|<local>/func|.R|FakeOverride<kotlin/Function0.invoke: R|kotlin/String?|>|()) {
-            ==($subj$, Null(null)) ->  {
-                String()
-            }
-            else ->  {
-                R|<local>/<elvis>|
-            }
-        }
-
+        lval x: R|kotlin/String| = R|<local>/func|.R|FakeOverride<kotlin/Function0.invoke: R|kotlin/String?|>|() ?: String()
     }

compiler/fir/analysis-tests/testData/resolve/lambdaInLhsOfTypeOperatorCall.kt

@@ -0,0 +1,17 @@
+// ISSUE: KT-39046
+
+fun foo(b: B<Int, Int>) {}
+
+fun test_1(b: B<String, Number>) {
+    foo(b.myMap {
+        it.k.length // implicits
+    } as B<Int, Int>)
+}
+
+fun test_2(s: String) {
+    val func = { s.length } as B<Int, Int>
+}
+
+class B<out K, V>(val k: K, val v: V)
+
+fun <X, R, V> B<X, V>.myMap(transform: (B<X, V>) -> R): B<R, V> = TODO()

compiler/fir/analysis-tests/testData/resolve/lambdaInLhsOfTypeOperatorCall.txt

@@ -0,0 +1,30 @@
+FILE: lambdaInLhsOfTypeOperatorCall.kt
+    public final fun foo(b: R|B<kotlin/Int, kotlin/Int>|): R|kotlin/Unit| {
+    }
+    public final fun test_1(b: R|B<kotlin/String, kotlin/Number>|): R|kotlin/Unit| {
+        R|/foo|((R|<local>/b|.R|/myMap|<R|kotlin/String|, R|kotlin/Int|, R|kotlin/Number|>(<L> = myMap@fun <anonymous>(it: R|B<kotlin/String, kotlin/Number>|): R|kotlin/Int| {
+            ^ R|<local>/it|.R|FakeOverride</B.k: R|kotlin/String|>|.R|kotlin/String.length|
+        }
+        ) as R|B<kotlin/Int, kotlin/Int>|))
+    }
+    public final fun test_2(s: R|kotlin/String|): R|kotlin/Unit| {
+        lval func: R|B<kotlin/Int, kotlin/Int>| = (fun <anonymous>(): R|kotlin/Int| {
+            ^ R|<local>/s|.R|kotlin/String.length|
+        }
+         as R|B<kotlin/Int, kotlin/Int>|)
+    }
+    public final class B<out K, V> : R|kotlin/Any| {
+        public constructor<out K, V>(k: R|K|, v: R|V|): R|B<K, V>| {
+            super<R|kotlin/Any|>()
+        }
+
+        public final val k: R|K| = R|<local>/k|
+            public get(): R|K|
+
+        public final val v: R|V| = R|<local>/v|
+            public get(): R|V|
+
+    }
+    public final fun <X, R, V> R|B<X, V>|.myMap(transform: R|(B<X, V>) -> R|): R|B<R, V>| {
+        ^myMap R|kotlin/TODO|()
+    }