Export transitively underlying test framework modules

Otherwise "This class does not have a constructor" happens when using
an aliased annotation, e.g. kotlin.test.Test aliased to org.junit.test

.bunch

@@ -2,7 +2,6 @@
 202
 203_202
 193
-192_193
-as36_192_193
 as40_193
-as41
+as41
+as42_as41

benchmarks/build.gradle.kts

@@ -8,10 +8,8 @@ buildscript {
         val cacheRedirectorEnabled = findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() == true
         if (cacheRedirectorEnabled) {
             maven("https://cache-redirector.jetbrains.com/dl.bintray.com/kotlin/kotlinx")
-            maven("https://cache-redirector.jetbrains.com/dl.bintray.com/kotlin/kotlin-dev")
         } else {
             maven("https://dl.bintray.com/kotlin/kotlinx")
-            maven("https://dl.bintray.com/kotlin/kotlin-dev")
         }
     }
     dependencies {
@@ -30,10 +28,8 @@ repositories {
     val cacheRedirectorEnabled = findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() == true
     if (cacheRedirectorEnabled) {
         maven("https://cache-redirector.jetbrains.com/dl.bintray.com/kotlin/kotlinx")
-        maven("https://cache-redirector.jetbrains.com/dl.bintray.com/kotlin/kotlin-dev")
-    } else {
+   } else {
         maven("https://dl.bintray.com/kotlin/kotlinx")
-        maven("https://dl.bintray.com/kotlin/kotlin-dev")
     }
 }
 
@@ -74,6 +70,7 @@ benchmark {
             param("size", 1000)
 
             include("CommonCallsBenchmark")
+            include("ControlFlowAnalysisBenchmark")
             //include("InferenceBaselineCallsBenchmark")
         }
 

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

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

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

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

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

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

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

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

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

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

build.gradle.kts

@@ -178,7 +178,7 @@ extra["versions.jflex"] = "1.7.0"
 extra["versions.markdown"] = "0.1.25"
 extra["versions.trove4j"] = "1.0.20181211"
 extra["versions.completion-ranking-kotlin"] = "0.1.2"
-extra["versions.r8"] = "1.5.70"
+extra["versions.r8"] = "2.0.88"
 val immutablesVersion = "0.3.1"
 extra["versions.kotlinx-collections-immutable"] = immutablesVersion
 extra["versions.kotlinx-collections-immutable-jvm"] = immutablesVersion
@@ -187,7 +187,7 @@ extra["versions.kotlinx-collections-immutable-jvm"] = immutablesVersion
 extra["versions.ktor-network"] = "1.0.1"
 
 if (!project.hasProperty("versions.kotlin-native")) {
-    extra["versions.kotlin-native"] = "1.4-M3-dev-15627"
+    extra["versions.kotlin-native"] = "1.4.20-dev-16314"
 }
 
 val intellijUltimateEnabled by extra(project.kotlinBuildProperties.intellijUltimateEnabled)
@@ -221,6 +221,7 @@ extra["compilerModules"] = arrayOf(
     ":compiler:config",
     ":compiler:config.jvm",
     ":compiler:container",
+    ":compiler:resolution.common",
     ":compiler:resolution",
     ":compiler:serialization",
     ":compiler:psi",
@@ -229,6 +230,8 @@ extra["compilerModules"] = arrayOf(
     ":compiler:frontend.java",
     ":compiler:cli-common",
     ":compiler:ir.tree",
+    ":compiler:ir.tree.impl",
+    ":compiler:ir.tree.persistent",
     ":compiler:ir.psi2ir",
     ":compiler:ir.backend.common",
     ":compiler:backend.jvm",
@@ -263,17 +266,17 @@ extra["compilerModules"] = arrayOf(
     ":kotlin-build-common",
     ":core:metadata",
     ":core:metadata.jvm",
+    ":core:compiler.common",
     ":core:descriptors",
     ":core:descriptors.jvm",
     ":core:descriptors.runtime",
     ":core:deserialization",
     ":core:util.runtime",
-    ":core:type-system",
     ":compiler:fir:cones",
     ":compiler:fir:resolve",
     ":compiler:fir:fir-serialization",
     ":compiler:fir:tree",
-    ":compiler:fir:raw-fir:fir-common",
+    ":compiler:fir:raw-fir:raw-fir.common",
     ":compiler:fir:raw-fir:psi2fir",
     ":compiler:fir:raw-fir:light-tree2fir",
     ":compiler:fir:fir2ir",
@@ -285,7 +288,6 @@ extra["compilerModules"] = arrayOf(
 )
 
 extra["compilerModulesForJps"] = listOf(
-    ":core:type-system",
     ":kotlin-build-common",
     ":kotlin-util-io",
     ":kotlin-util-klib",
@@ -294,6 +296,7 @@ extra["compilerModulesForJps"] = listOf(
     ":kotlin-compiler-runner",
     ":daemon-common",
     ":daemon-common-new",
+    ":core:compiler.common",
     ":core:descriptors",
     ":core:descriptors.jvm",
     ":idea:idea-jps-common",
@@ -455,6 +458,16 @@ allprojects {
         outputs.doNotCacheIf("https://youtrack.jetbrains.com/issue/KT-37089") { true }
     }
 
+    tasks.withType<SourceTask>().configureEach {
+        doFirst {
+            source.visit {
+                if (file.isDirectory && file.listFiles()?.isEmpty() == true) {
+                    logger.warn("Empty source directories may cause build cache misses: " + file.absolutePath)
+                }
+            }
+        }
+    }
+
     normalization {
         runtimeClasspath {
             ignore("META-INF/MANIFEST.MF")

buildSrc/src/main/kotlin/IdeCompatibilityDsl.kt

@@ -53,7 +53,8 @@ enum class Ide(val platform: Platform) : CompatibilityPredicate {
     AS35(Platform.P183),
     AS36(Platform.P192),
     AS40(Platform.P193),
-    AS41(Platform.P201);
+    AS41(Platform.P201),
+    AS42(Platform.P201);
 
     val kind = Kind.values().first { it.shortName == name.take(2) }
     val version = name.dropWhile { !it.isDigit() }.toInt()

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

@@ -52,6 +52,7 @@ open class PublishedKotlinModule : Plugin<Project> {
                 configure<SigningExtension> {
                     isRequired = signingRequired
                     sign(configurations["archives"])
+                    useGpgCmd()
                 }
 
                 tasks.named<Sign>("signArchives").configure {

buildSrc/src/main/kotlin/tasks.kt

@@ -54,6 +54,7 @@ fun Task.dependsOnKotlinPluginInstall() {
         ":kotlin-test:kotlin-test-annotations-common:install",
         ":kotlin-test:kotlin-test-jvm:install",
         ":kotlin-test:kotlin-test-js:install",
+        ":kotlin-test:kotlin-test-junit:install",
         ":kotlin-gradle-subplugin-example:install",
         ":kotlin-stdlib-common:install",
         ":kotlin-stdlib:install",
@@ -65,7 +66,8 @@ fun Task.dependsOnKotlinPluginInstall() {
         ":kotlin-scripting-jvm:install",
         ":kotlin-scripting-compiler-embeddable:install",
         ":kotlin-scripting-compiler-impl-embeddable:install",
-        ":kotlin-test-js-runner:install"
+        ":kotlin-test-js-runner:install",
+        ":native:kotlin-klib-commonizer-embeddable:install"
     )
 }
 

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

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

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

@@ -120,7 +120,7 @@ public abstract class AnnotationCodegen {
             @Nullable Type returnType,
             @Nullable KotlinType typeForTypeAnnotations,
             @Nullable DeclarationDescriptorWithVisibility parameterContainer,
-            @NotNull List<Class<?>> additionalAnnotations
+            @NotNull List<String> additionalVisibleAnnotations
     ) {
         if (annotated == null) return;
 
@@ -155,9 +155,9 @@ public abstract class AnnotationCodegen {
             }
         }
 
-        for (Class<?> annotation : additionalAnnotations) {
-            String descriptor = generateAnnotationIfNotPresent(annotationDescriptorsAlreadyPresent, annotation);
-            annotationDescriptorsAlreadyPresent.add(descriptor);
+        for (String annotation : additionalVisibleAnnotations) {
+            generateAnnotationIfNotPresent(annotationDescriptorsAlreadyPresent, annotation, true);
+            annotationDescriptorsAlreadyPresent.add(annotation);
         }
 
         generateAdditionalAnnotations(annotated, returnType, annotationDescriptorsAlreadyPresent, parameterContainer);
@@ -248,17 +248,17 @@ public abstract class AnnotationCodegen {
             if (!TypeUtils.isNullableType(flexibleType.getLowerBound()) && TypeUtils.isNullableType(flexibleType.getUpperBound())) {
                 AnnotationDescriptor notNull = type.getAnnotations().findAnnotation(JvmAnnotationNames.JETBRAINS_NOT_NULL_ANNOTATION);
                 if (notNull != null) {
-                    generateAnnotationIfNotPresent(annotationDescriptorsAlreadyPresent, NotNull.class);
+                    generateAnnotationIfNotPresent(annotationDescriptorsAlreadyPresent, Type.getType(NotNull.class).getDescriptor(), false);
                 }
                 return;
             }
         }
 
-        boolean isNullableType = TypeUtils.isNullableType(type);
-
-        Class<?> annotationClass = isNullableType ? Nullable.class : NotNull.class;
-
-        generateAnnotationIfNotPresent(annotationDescriptorsAlreadyPresent, annotationClass);
+        generateAnnotationIfNotPresent(
+                annotationDescriptorsAlreadyPresent,
+                TypeUtils.isNullableType(type) ? Type.getType(Nullable.class).getDescriptor() : Type.getType(NotNull.class).getDescriptor(),
+                false
+        );
     }
 
     private static final Map<JvmTarget, Map<KotlinTarget, ElementType>> annotationTargetMaps = new EnumMap<>(JvmTarget.class);
@@ -338,13 +338,14 @@ public abstract class AnnotationCodegen {
         visitor.visitEnd();
     }
 
-    @NotNull
-    private String generateAnnotationIfNotPresent(Set<String> annotationDescriptorsAlreadyPresent, Class<?> annotationClass) {
-        String descriptor = Type.getType(annotationClass).getDescriptor();
-        if (!annotationDescriptorsAlreadyPresent.contains(descriptor)) {
-            visitAnnotation(descriptor, false).visitEnd();
+    private void generateAnnotationIfNotPresent(
+            Set<String> annotationDescriptorsAlreadyPresent,
+            String annotationDescriptor,
+            boolean visible
+    ) {
+        if (!annotationDescriptorsAlreadyPresent.contains(annotationDescriptor)) {
+            visitAnnotation(annotationDescriptor, visible).visitEnd();
         }
-        return descriptor;
     }
 
     private static boolean isBareTypeParameterWithNullableUpperBound(@NotNull KotlinType type) {

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

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

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

@@ -173,7 +173,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         return null;
     }
 
-    static class BlockStackElement {
+    public static class BlockStackElement {
     }
 
     static class LoopBlockStackElement extends BlockStackElement {
@@ -2224,8 +2224,9 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
 
             if (!skipPropertyAccessors) {
                 if (isBackingFieldMovedFromCompanion && context.getContextDescriptor() instanceof AccessorForPropertyBackingField) {
-                    propertyDescriptor = (PropertyDescriptor) backingFieldContext.getParentContext()
-                            .getAccessor(propertyDescriptor, AccessorKind.IN_CLASS_COMPANION, delegateType, superCallTarget);
+                    CodegenContext<?> parentContext = backingFieldContext.getParentContext();
+                    propertyDescriptor =
+                            parentContext.getAccessor(propertyDescriptor, AccessorKind.IN_CLASS_COMPANION, delegateType, superCallTarget);
                 }
                 else {
                     propertyDescriptor =
@@ -2835,7 +2836,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             TypeApproximator approximator = new TypeApproximator(state.getModule().getBuiltIns());
 
             KotlinType approximatedType =
-                    CapturedTypeConstructorKt.isCaptured(type) ?
+                    TypeUtils.contains(type, (containedType) -> CapturedTypeConstructorKt.isCaptured(containedType)) ?
                     (KotlinType) approximator.approximateToSuperType(
                             type, TypeApproximatorConfiguration.InternalTypesApproximation.INSTANCE
                     ) : null;
@@ -4103,15 +4104,14 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         TypeAndNullability right754Type = calcTypeForIeee754ArithmeticIfNeeded(right, getRightOperandType(primitiveNumericComparisonInfo));
         boolean isSame754ArithmeticTypes = left754Type != null && right754Type != null && left754Type.type.equals(right754Type.type);
         boolean properIeee754Comparisons = shouldUseProperIeee754Comparisons();
+        boolean isStandardCompareTo = primitiveNumericComparisonInfo != null;
 
-        if (properIeee754Comparisons && left754Type != null && right754Type != null) {
+        if (properIeee754Comparisons && isStandardCompareTo && left754Type != null && right754Type != null) {
             type = comparisonOperandType(left754Type.type, right754Type.type);
-            //type = comparisonOperandType(leftType, rightType);
             leftValue = gen(left);
             rightValue = gen(right);
         }
-        else if (!properIeee754Comparisons &&
-                 state.getIntrinsics().getIntrinsic((FunctionDescriptor) resolvedCall.getResultingDescriptor()) instanceof CompareTo &&
+        else if (!properIeee754Comparisons && isStandardCompareTo &&
                  ((isPrimitive(leftType) && isPrimitive(rightType)) || isSame754ArithmeticTypes)) {
             type = isSame754ArithmeticTypes ? left754Type.type : comparisonOperandType(leftType, rightType);
             leftValue = gen(left);

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

@@ -73,7 +73,7 @@ import static org.jetbrains.kotlin.codegen.serialization.JvmSerializationBinding
 import static org.jetbrains.kotlin.codegen.state.KotlinTypeMapper.isAccessor;
 import static org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.DECLARATION;
 import static org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.DELEGATION;
-import static org.jetbrains.kotlin.descriptors.ModalityKt.isOverridable;
+import static org.jetbrains.kotlin.descriptors.ModalityUtilsKt.isOverridable;
 import static org.jetbrains.kotlin.resolve.DescriptorToSourceUtils.getSourceFromDescriptor;
 import static org.jetbrains.kotlin.resolve.DescriptorUtils.*;
 import static org.jetbrains.kotlin.resolve.inline.InlineOnlyKt.isInlineOnlyPrivateInBytecode;
@@ -83,6 +83,8 @@ import static org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils.*;
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
 
 public class FunctionCodegen {
+    private static final String JAVA_LANG_DEPRECATED = Type.getType(Deprecated.class).getDescriptor();
+
     public final GenerationState state;
     private final KotlinTypeMapper typeMapper;
     private final BindingContext bindingContext;
@@ -221,7 +223,7 @@ public class FunctionCodegen {
                 InlineClassDescriptorResolver.isSpecializedEqualsMethod(functionDescriptor);
         generateMethodAnnotationsIfRequired(
                 functionDescriptor, asmMethod, jvmSignature, mv,
-                isCompatibilityStubInDefaultImpls ? Collections.singletonList(Deprecated.class) : Collections.emptyList(),
+                isCompatibilityStubInDefaultImpls ? Collections.singletonList(JAVA_LANG_DEPRECATED) : Collections.emptyList(),
                 skipNullabilityAnnotations
         );
         GenerateJava8ParameterNamesKt.generateParameterNames(functionDescriptor, mv, jvmSignature, state, (flags & ACC_SYNTHETIC) != 0);
@@ -285,7 +287,7 @@ public class FunctionCodegen {
             @NotNull Method asmMethod,
             @NotNull JvmMethodGenericSignature jvmSignature,
             @NotNull MethodVisitor mv,
-            @NotNull List<Class<?>> additionalNoArgAnnotations,
+            @NotNull List<String> additionalVisibleAnnotations,
             boolean skipNullabilityAnnotations
     ) {
         FunctionDescriptor annotationsOwner;
@@ -302,7 +304,7 @@ public class FunctionCodegen {
         }
 
         AnnotationCodegen.forMethod(mv, memberCodegen, state, skipNullabilityAnnotations)
-                .genAnnotations(annotationsOwner, asmMethod.getReturnType(), functionDescriptor.getReturnType(), null, additionalNoArgAnnotations);
+                .genAnnotations(annotationsOwner, asmMethod.getReturnType(), functionDescriptor.getReturnType(), null, additionalVisibleAnnotations);
 
         generateParameterAnnotations(
                 annotationsOwner, mv, jvmSignature,

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

@@ -62,6 +62,8 @@ import org.jetbrains.org.objectweb.asm.commons.Method;
 
 import java.util.*;
 
+import static org.jetbrains.kotlin.builtins.StandardNames.ENUM_VALUES;
+import static org.jetbrains.kotlin.builtins.StandardNames.ENUM_VALUE_OF;
 import static org.jetbrains.kotlin.codegen.AsmUtil.*;
 import static org.jetbrains.kotlin.codegen.CodegenUtilKt.isGenericToArray;
 import static org.jetbrains.kotlin.codegen.CodegenUtilKt.isNonGenericToArray;

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

@@ -12,6 +12,7 @@ import kotlin.text.StringsKt;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.backend.common.CodegenUtil;
+import org.jetbrains.kotlin.builtins.StandardNames;
 import org.jetbrains.kotlin.builtins.functions.FunctionInvokeDescriptor;
 import org.jetbrains.kotlin.codegen.binding.CalculatedClosure;
 import org.jetbrains.kotlin.codegen.context.CodegenContext;
@@ -404,7 +405,7 @@ public class JvmCodegenUtil {
         // The Result class is the only inline class in the standard library without special rules for equality.
         // We only call Result.equals-impl0 if we are compiling for Kotlin 1.4 or later. Otherwise, the code
         // might well be running against an older version of the standard library.
-        if (DescriptorUtils.getFqNameSafe(classDescriptor).equals(DescriptorUtils.RESULT_FQ_NAME)) {
+        if (DescriptorUtils.getFqNameSafe(classDescriptor).equals(StandardNames.RESULT_FQ_NAME)) {
             return state.getLanguageVersionSettings().getApiVersion().compareTo(ApiVersion.KOTLIN_1_4) >= 0;
         } else {
             return ((DeserializedClassDescriptor) descriptor).getMetadataVersion().isAtLeast(1, 1, 16);

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

@@ -1543,7 +1543,7 @@ public abstract class StackValue {
 
                 //TODO: try to don't generate defaults at all in CollectionElementReceiver
 
-                List<ResolvedValueArgument> getterArguments = new ArrayList(collectionElementReceiver.valueArguments);
+                List<ResolvedValueArgument> getterArguments = new ArrayList<>(collectionElementReceiver.valueArguments);
                 List<ResolvedValueArgument> getterDefaults = CollectionsKt.takeLastWhile(getterArguments,
                                                                                          argument -> argument instanceof DefaultValueArgument);
 

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

@@ -821,20 +821,17 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
 
         Map<ValueParameterDescriptor, ResolvedValueArgument> arguments = newResolvedCall.getValueArguments();
         for (ValueParameterDescriptor valueParameter : arguments.keySet()) {
-            SamType samType = SamType.createByValueParameter(valueParameter);
-            if (samType == null) continue;
-
             ResolvedValueArgument argument = arguments.get(valueParameter);
             if (argument instanceof ExpressionValueArgument) {
                 ValueArgument valueArgument = ((ExpressionValueArgument) argument).getValueArgument();
                 if (valueArgument != null && newResolvedCall.getExpectedTypeForSamConvertedArgument(valueArgument) != null) {
-                    recordSamTypeOnArgumentExpression(samType, valueArgument);
+                    recordSamTypeOnArgumentExpression(valueParameter, valueArgument);
                 }
             } else if (argument instanceof VarargValueArgument) {
                 VarargValueArgument varargValueArgument = (VarargValueArgument) argument;
                 for (ValueArgument valueArgument : varargValueArgument.getArguments()) {
                     if (valueArgument != null && newResolvedCall.getExpectedTypeForSamConvertedArgument(valueArgument) != null) {
-                        recordSamTypeOnArgumentExpression(samType, valueArgument);
+                        recordSamTypeOnArgumentExpression(valueParameter, valueArgument);
                     }
                 }
             }
@@ -872,6 +869,13 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         }
     }
 
+    private void recordSamTypeOnArgumentExpression(ValueParameterDescriptor valueParameter, ValueArgument valueArgument) {
+        SamType samType = SamType.createByValueParameter(valueParameter);
+        if (samType == null) return;
+
+        recordSamTypeOnArgumentExpression(samType, valueArgument);
+    }
+
     private void recordSamTypeOnArgumentExpression(SamType samType, ValueArgument valueArgument) {
         KtExpression argumentExpression = valueArgument.getArgumentExpression();
         assert argumentExpression != null : valueArgument.asElement().getText();

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

@@ -43,7 +43,6 @@ import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
 import org.jetbrains.kotlin.serialization.DescriptorSerializer
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.typeUtil.makeNullable
-import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 import org.jetbrains.kotlin.utils.sure
 import org.jetbrains.org.objectweb.asm.Label
 import org.jetbrains.org.objectweb.asm.MethodVisitor
@@ -104,9 +103,9 @@ abstract class AbstractCoroutineCodegen(
         ValueParameterDescriptorImpl(
             this, null, index, Annotations.EMPTY, name,
             type,
-            false, false,
-            false,
-            null, SourceElement.NO_SOURCE
+            declaresDefaultValue = false, isCrossinline = false,
+            isNoinline = false,
+            varargElementType = null, source = SourceElement.NO_SOURCE
         )
 
     override fun generateConstructor(): Method {
@@ -157,7 +156,7 @@ abstract class AbstractCoroutineCodegen(
         return constructor
     }
 
-    abstract protected val passArityToSuperClass: Boolean
+    protected abstract val passArityToSuperClass: Boolean
 }
 
 class CoroutineCodegenForLambda private constructor(
@@ -187,6 +186,23 @@ class CoroutineCodegenForLambda private constructor(
 
     private val endLabel = Label()
 
+    private val varsCountByType = hashMapOf<Type, Int>()
+
+    private val fieldsForParameters: Map<ParameterDescriptor, FieldInfo> = createFieldsForParameters()
+
+    private fun createFieldsForParameters(): Map<ParameterDescriptor, FieldInfo> {
+        val result = hashMapOf<ParameterDescriptor, FieldInfo>()
+        for (parameter in allFunctionParameters()) {
+            if (parameter.isUnused()) continue
+            val type = state.typeMapper.mapType(parameter.type)
+            val normalizedType = type.normalize()
+            val index = varsCountByType[normalizedType]?.plus(1) ?: 0
+            varsCountByType[normalizedType] = index
+            result[parameter] = createHiddenFieldInfo(parameter.type, "${normalizedType.descriptor[0]}$$index")
+        }
+        return result
+    }
+
     private fun getCreateFunction(): SimpleFunctionDescriptor = SimpleFunctionDescriptorImpl.create(
         funDescriptor.containingDeclaration,
         Annotations.EMPTY,
@@ -232,8 +248,7 @@ class CoroutineCodegenForLambda private constructor(
 
     override fun generateClosureBody() {
         for (parameter in allFunctionParameters()) {
-            if (parameter.isUnused()) continue
-            val fieldInfo = parameter.getFieldInfoForCoroutineLambdaParameter()
+            val fieldInfo = fieldsForParameters[parameter] ?: continue
             v.newField(
                 OtherOrigin(parameter),
                 Opcodes.ACC_PRIVATE + Opcodes.ACC_SYNTHETIC,
@@ -257,7 +272,7 @@ class CoroutineCodegenForLambda private constructor(
         super.generateBody()
 
         if (doNotGenerateInvokeBridge) {
-            v.serializationBindings.put<FunctionDescriptor, Method>(
+            v.serializationBindings.put(
                 METHOD_FOR_FUNCTION,
                 originalSuspendFunctionDescriptor,
                 typeMapper.mapAsmMethod(erasedInvokeFunction)
@@ -320,7 +335,7 @@ class CoroutineCodegenForLambda private constructor(
             newarray(AsmTypes.OBJECT_TYPE)
             // 0 - this
             // 1..22 - parameters
-            // 23 - first empy slot
+            // 23 - first empty slot
             val arraySlot = 23
             store(arraySlot, AsmTypes.OBJECT_TYPE)
             for ((varIndex, type) in parameterTypes.withVariableIndices()) {
@@ -405,8 +420,8 @@ class CoroutineCodegenForLambda private constructor(
             // Pass lambda parameters to 'invoke' call on newly constructed object
             var index = 1
             for (parameter in allFunctionParameters()) {
-                val fieldInfoForCoroutineLambdaParameter = parameter.getFieldInfoForCoroutineLambdaParameter()
-                if (!parameter.isUnused()) {
+                val fieldInfoForCoroutineLambdaParameter = fieldsForParameters[parameter]
+                if (fieldInfoForCoroutineLambdaParameter != null) {
                     if (isBigArity) {
                         load(cloneIndex, fieldInfoForCoroutineLambdaParameter.ownerType)
                         load(1, AsmTypes.OBJECT_TYPE)
@@ -442,7 +457,7 @@ class CoroutineCodegenForLambda private constructor(
                         )
                     }
                 }
-                index += if (isBigArity || generateErasedCreate) 1 else fieldInfoForCoroutineLambdaParameter.fieldType.size
+                index += if (isBigArity || generateErasedCreate) 1 else state.typeMapper.mapType(parameter.type).size
             }
 
             load(cloneIndex, AsmTypes.OBJECT_TYPE)
@@ -452,17 +467,22 @@ class CoroutineCodegenForLambda private constructor(
 
     private fun ExpressionCodegen.initializeCoroutineParameters() {
         for (parameter in allFunctionParameters()) {
-            if (parameter.isUnused()) continue
-            val fieldStackValue =
-                StackValue.field(
-                    parameter.getFieldInfoForCoroutineLambdaParameter(), generateThisOrOuter(context.thisDescriptor, false)
-                )
+            val fieldForParameter = fieldsForParameters[parameter] ?: continue
+            val fieldStackValue = StackValue.field(fieldForParameter, generateThisOrOuter(context.thisDescriptor, false))
 
-            val mappedType = typeMapper.mapType(parameter.type)
-            fieldStackValue.put(mappedType, v)
+            val originalType = typeMapper.mapType(parameter.type)
+            // If a parameter has reference type, it has prefix L$,
+            // however, when the type is primitive, its prefix is ${type.descriptor}$.
+            // In other words, it the type is Boolean, the prefix is Z$.
+            // This is different from spilled variables, where all int-like primitives have prefix I$.
+            // This is not a problem, since we do not clean spilled primitives up
+            // and we do not coerce Int to Boolean, which takes quite a bit of bytecode (see coerceInt).
+            val normalizedType = originalType.normalize()
+            fieldStackValue.put(normalizedType, v)
 
-            val newIndex = myFrameMap.enter(parameter, mappedType)
-            v.store(newIndex, mappedType)
+            val newIndex = myFrameMap.enter(parameter, originalType)
+            StackValue.coerce(normalizedType, originalType, v)
+            v.store(newIndex, originalType)
 
             val name =
                 if (parameter is ReceiverParameterDescriptor)
@@ -471,7 +491,7 @@ class CoroutineCodegenForLambda private constructor(
                     (getNameForDestructuredParameterOrNull(parameter as ValueParameterDescriptor) ?: parameter.name.asString())
             val label = Label()
             v.mark(label)
-            v.visitLocalVariable(name, mappedType.descriptor, null, label, endLabel, newIndex)
+            v.visitLocalVariable(name, originalType.descriptor, null, label, endLabel, newIndex)
         }
 
         initializeVariablesForDestructuredLambdaParameters(
@@ -485,13 +505,10 @@ class CoroutineCodegenForLambda private constructor(
         originalSuspendFunctionDescriptor.extensionReceiverParameter.let(::listOfNotNull) +
                 originalSuspendFunctionDescriptor.valueParameters
 
-    private fun ParameterDescriptor.getFieldInfoForCoroutineLambdaParameter() =
-        createHiddenFieldInfo(type, COROUTINE_LAMBDA_PARAMETER_PREFIX + (this.safeAs<ValueParameterDescriptor>()?.index ?: ""))
-
     private fun createHiddenFieldInfo(type: KotlinType, name: String) =
         FieldInfo.createForHiddenField(
             typeMapper.mapClass(closureContext.thisDescriptor),
-            typeMapper.mapType(type),
+            typeMapper.mapType(type).normalize(),
             type,
             name
         )
@@ -514,7 +531,8 @@ class CoroutineCodegenForLambda private constructor(
                         isForNamedFunction = false,
                         languageVersionSettings = languageVersionSettings,
                         disableTailCallOptimizationForFunctionReturningUnit = false,
-                        useOldSpilledVarTypeAnalysis = state.configuration.getBoolean(JVMConfigurationKeys.USE_OLD_SPILLED_VAR_TYPE_ANALYSIS)
+                        useOldSpilledVarTypeAnalysis = state.configuration.getBoolean(JVMConfigurationKeys.USE_OLD_SPILLED_VAR_TYPE_ANALYSIS),
+                        initialVarsCountByType = varsCountByType
                     )
                     val maybeWithForInline = if (forInline)
                         SuspendForInlineCopyingMethodVisitor(stateMachineBuilder, access, name, desc, functionCodegen::newMethod)
@@ -758,16 +776,11 @@ class CoroutineCodegenForNamedFunction private constructor(
             declaration: KtFunction
         ): CoroutineCodegenForNamedFunction {
             val bindingContext = expressionCodegen.state.bindingContext
-            val closure =
-                bindingContext[
-                        CodegenBinding.CLOSURE,
-                        bindingContext[CodegenBinding.CLASS_FOR_CALLABLE, originalSuspendDescriptor]
-                ].sure { "There must be a closure defined for $originalSuspendDescriptor" }
+            val closure = bindingContext[CLOSURE, bindingContext[CodegenBinding.CLASS_FOR_CALLABLE, originalSuspendDescriptor]]
+                .sure { "There must be a closure defined for $originalSuspendDescriptor" }
 
-            val suspendFunctionView =
-                bindingContext[
-                        CodegenBinding.SUSPEND_FUNCTION_TO_JVM_VIEW, originalSuspendDescriptor
-                ].sure { "There must be a jvm view defined for $originalSuspendDescriptor" }
+            val suspendFunctionView = bindingContext[CodegenBinding.SUSPEND_FUNCTION_TO_JVM_VIEW, originalSuspendDescriptor]
+                .sure { "There must be a jvm view defined for $originalSuspendDescriptor" }
 
             if (suspendFunctionView.dispatchReceiverParameter != null) {
                 closure.setNeedsCaptureOuterClass()
@@ -785,10 +798,8 @@ class CoroutineCodegenForNamedFunction private constructor(
     }
 }
 
-private const val COROUTINE_LAMBDA_PARAMETER_PREFIX = "p$"
-
 private object FailingFunctionGenerationStrategy : FunctionGenerationStrategy() {
-    override fun skipNotNullAssertionsForParameters(): kotlin.Boolean {
+    override fun skipNotNullAssertionsForParameters(): Boolean {
         error("This functions must not be called")
     }
 

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

@@ -20,6 +20,7 @@ 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 kotlin.math.max
 
 private const val COROUTINES_DEBUG_METADATA_VERSION = 1
@@ -63,7 +64,9 @@ class CoroutineTransformerMethodVisitor(
     // JVM_IR backend generates $completion, while old backend does not
     private val putContinuationParameterToLvt: Boolean = true,
     // New SourceInterpreter-less analyser can be somewhat unstable, disable it
-    private val useOldSpilledVarTypeAnalysis: Boolean = false
+    private val useOldSpilledVarTypeAnalysis: Boolean = false,
+    // Parameters of suspend lambda are put to the same fields as spilled variables
+    private val initialVarsCountByType: Map<Type, Int> = emptyMap()
 ) : TransformationMethodVisitor(delegate, access, name, desc, signature, exceptions) {
 
     private val classBuilderForCoroutineState: ClassBuilder by lazy(obtainClassBuilderForCoroutineState)
@@ -132,15 +135,19 @@ class CoroutineTransformerMethodVisitor(
 
         UninitializedStoresProcessor(methodNode, shouldPreserveClassInitialization).run()
 
+        updateLvtAccordingToLiveness(methodNode, isForNamedFunction)
+
         val spilledToVariableMapping = spillVariables(suspensionPoints, methodNode)
 
         val suspendMarkerVarIndex = methodNode.maxLocals++
 
         val suspensionPointLineNumbers = suspensionPoints.map { findSuspensionPointLineNumber(it) }
 
-        val continuationLabels = suspensionPoints.withIndex().map {
-            transformCallAndReturnContinuationLabel(
-                it.index + 1, it.value, methodNode, suspendMarkerVarIndex, suspensionPointLineNumbers[it.index])
+        // Create states in state-machine, to which state-machine can jump
+        val stateLabels = suspensionPoints.withIndex().map {
+            transformCallAndReturnStateLabel(
+                it.index + 1, it.value, methodNode, suspendMarkerVarIndex, suspensionPointLineNumbers[it.index]
+            )
         }
 
         methodNode.instructions.apply {
@@ -163,7 +170,7 @@ class CoroutineTransformerMethodVisitor(
                         0,
                         suspensionPoints.size,
                         defaultLabel,
-                        firstStateLabel, *continuationLabels.toTypedArray()
+                        firstStateLabel, *stateLabels.toTypedArray()
                     ),
                     firstStateLabel
                 )
@@ -180,25 +187,38 @@ class CoroutineTransformerMethodVisitor(
             })
         }
 
+        initializeFakeInlinerVariables(methodNode, stateLabels)
+
         dropSuspensionMarkers(methodNode)
         methodNode.removeEmptyCatchBlocks()
 
-        // The parameters (and 'this') shall live throughout the method, otherwise, d8 emits warning about invalid debug info
-        val startLabel = LabelNode()
-        val endLabel = LabelNode()
-        methodNode.instructions.insertBefore(methodNode.instructions.first, startLabel)
-        methodNode.instructions.insert(methodNode.instructions.last, endLabel)
-
-        fixLvtForParameters(methodNode, startLabel, endLabel)
-
         if (languageVersionSettings.isReleaseCoroutines()) {
             writeDebugMetadata(methodNode, suspensionPointLineNumbers, spilledToVariableMapping)
         }
     }
 
+    // When suspension point is inlined, it is in range of fake inliner variables.
+    // Path from TABLESWITCH into unspilling goes to latter part of the range.
+    // In this case the variables are uninitialized, initialize them
+    private fun initializeFakeInlinerVariables(methodNode: MethodNode, stateLabels: List<LabelNode>) {
+        for (stateLabel in stateLabels) {
+            for (record in methodNode.localVariables) {
+                if (isFakeLocalVariableForInline(record.name) &&
+                    methodNode.instructions.indexOf(record.start) < methodNode.instructions.indexOf(stateLabel) &&
+                    methodNode.instructions.indexOf(stateLabel) < methodNode.instructions.indexOf(record.end)
+                ) {
+                    methodNode.instructions.insert(stateLabel, withInstructionAdapter {
+                        iconst(0)
+                        store(record.index, Type.INT_TYPE)
+                    })
+                }
+            }
+        }
+    }
+
     private fun addCompletionParameterToLVT(methodNode: MethodNode) {
         val index =
-                /*  all args */ Type.getMethodType(methodNode.desc).argumentTypes.fold(0) { a, b -> a + b.size } +
+            /*  all args */ Type.getMethodType(methodNode.desc).argumentTypes.fold(0) { a, b -> a + b.size } +
                 /* this */ (if (isStatic(methodNode.access)) 0 else 1) -
                 /* only last */ 1
         val startLabel = with(methodNode.instructions) {
@@ -311,31 +331,10 @@ class CoroutineTransformerMethodVisitor(
         }
     }
 
-    private fun fixLvtForParameters(methodNode: MethodNode, startLabel: LabelNode, endLabel: LabelNode) {
-        val paramsNum =
-                /* this */ (if (isStatic(methodNode.access)) 0 else 1) +
-                /* real params */ Type.getArgumentTypes(methodNode.desc).fold(0) { a, b -> a + b.size }
-
-        for (i in 0 until paramsNum) {
-            fixRangeOfLvtRecord(methodNode, i, startLabel, endLabel)
-        }
-    }
-
-    private fun fixRangeOfLvtRecord(methodNode: MethodNode, index: Int, startLabel: LabelNode, endLabel: LabelNode) {
-        val vars = methodNode.localVariables.filter { it.index == index }
-        assert(vars.size <= 1) {
-            "Someone else occupies parameter's slot at $index"
-        }
-        vars.firstOrNull()?.let {
-            it.start = startLabel
-            it.end = endLabel
-        }
-    }
-
     private fun writeDebugMetadata(
         methodNode: MethodNode,
         suspensionPointLineNumbers: List<LineNumberNode?>,
-        spilledToLocalMapping: List<List<SpilledVariableDescriptor>>
+        spilledToLocalMapping: List<List<SpilledVariableAndField>>
     ) {
         val lines = suspensionPointLineNumbers.map { it?.line ?: -1 }
         val metadata = classBuilderForCoroutineState.newAnnotation(DEBUG_METADATA_ANNOTATION_ASM_TYPE.descriptor, true)
@@ -590,7 +589,7 @@ class CoroutineTransformerMethodVisitor(
         }
     }
 
-    private fun spillVariables(suspensionPoints: List<SuspensionPoint>, methodNode: MethodNode): List<List<SpilledVariableDescriptor>> {
+    private fun spillVariables(suspensionPoints: List<SuspensionPoint>, methodNode: MethodNode): List<List<SpilledVariableAndField>> {
         val instructions = methodNode.instructions
         val frames =
             if (useOldSpilledVarTypeAnalysis) performRefinedTypeAnalysis(methodNode, containingClassInternalName)
@@ -598,11 +597,23 @@ class CoroutineTransformerMethodVisitor(
 
         fun AbstractInsnNode.index() = instructions.indexOf(this)
 
-        // We postpone these actions because they change instruction indices that we use when obtaining frames
-        val postponedActions = mutableListOf<() -> Unit>()
         val maxVarsCountByType = mutableMapOf<Type, Int>()
+        var initialSpilledVariablesCount = 0
+        for ((type, count) in initialVarsCountByType) {
+            if (type == AsmTypes.OBJECT_TYPE) {
+                initialSpilledVariablesCount = count
+            }
+            maxVarsCountByType[type] = count
+        }
+
         val livenessFrames = analyzeLiveness(methodNode)
-        val spilledToVariableMapping = arrayListOf<List<SpilledVariableDescriptor>>()
+
+        // References shall be cleaned up after uspill (during spill in next suspension point) to prevent memory leaks,
+        val referencesToSpillBySuspensionPointIndex = arrayListOf<List<ReferenceToSpill>>()
+        // while primitives shall not
+        val primitivesToSpillBySuspensionPointIndex = arrayListOf<List<PrimitiveToSpill>>()
+
+        // Collect information about spillable variables, that we use to determine which variables we need to cleanup
 
         for (suspension in suspensionPoints) {
             val suspensionCallBegin = suspension.suspensionCallBegin
@@ -629,7 +640,8 @@ class CoroutineTransformerMethodVisitor(
             // NB: it's also rather useful for sake of optimization
             val livenessFrame = livenessFrames[suspensionCallBegin.index()]
 
-            val spilledToVariable = arrayListOf<SpilledVariableDescriptor>()
+            val referencesToSpill = arrayListOf<ReferenceToSpill>()
+            val primitivesToSpill = arrayListOf<PrimitiveToSpill>()
 
             // 0 - this
             // 1 - parameter
@@ -637,77 +649,181 @@ class CoroutineTransformerMethodVisitor(
             // k - continuation
             // k + 1 - data
             // k + 2 - exception
-            val variablesToSpill =
-                (0 until localsCount)
-                    .filterNot { it in setOf(continuationIndex, dataIndex, exceptionIndex) }
-                    .map { Pair(it, frame.getLocal(it)) }
-                    .filter { (index, value) ->
-                        (index == 0 && needDispatchReceiver && isForNamedFunction) ||
-                                (value.type != null && livenessFrame.isAlive(index))
-                    }
+            for (slot in 0 until localsCount) {
+                if (slot == continuationIndex || slot == dataIndex || slot == exceptionIndex) continue
+                val value = frame.getLocal(slot)
+                if (value.type == null || !livenessFrame.isAlive(slot)) continue
 
-            for ((index, basicValue) in variablesToSpill) {
-                if (basicValue == StrictBasicValue.NULL_VALUE) {
-                    postponedActions.add {
-                        with(instructions) {
-                            insert(suspension.tryCatchBlockEndLabelAfterSuspensionCall, withInstructionAdapter {
-                                aconst(null)
-                                store(index, AsmTypes.OBJECT_TYPE)
-                            })
-                        }
-                    }
+                if (value == StrictBasicValue.NULL_VALUE) {
+                    referencesToSpill += slot to null
                     continue
                 }
 
-                val type = basicValue.type!!
+                val type = value.type!!
                 val normalizedType = type.normalize()
 
                 val indexBySort = varsCountByType[normalizedType]?.plus(1) ?: 0
                 varsCountByType[normalizedType] = indexBySort
 
                 val fieldName = normalizedType.fieldNameForVar(indexBySort)
-                localVariableName(methodNode, index, suspension.suspensionCallEnd.next.index())
-                    ?.let { spilledToVariable.add(SpilledVariableDescriptor(fieldName, it)) }
-
-                postponedActions.add {
-                    with(instructions) {
-                        // store variable before suspension call
-                        insertBefore(suspension.suspensionCallBegin, withInstructionAdapter {
-                            load(continuationIndex, AsmTypes.OBJECT_TYPE)
-                            load(index, type)
-                            StackValue.coerce(type, normalizedType, this)
-                            putfield(classBuilderForCoroutineState.thisName, fieldName, normalizedType.descriptor)
-                        })
-
-                        // restore variable after suspension call
-                        insert(suspension.tryCatchBlockEndLabelAfterSuspensionCall, withInstructionAdapter {
-                            load(continuationIndex, AsmTypes.OBJECT_TYPE)
-                            getfield(classBuilderForCoroutineState.thisName, fieldName, normalizedType.descriptor)
-                            StackValue.coerce(normalizedType, type, this)
-                            store(index, type)
-                        })
-                    }
+                if (normalizedType == AsmTypes.OBJECT_TYPE) {
+                    referencesToSpill += slot to SpillableVariable(value, type, normalizedType, fieldName)
+                } else {
+                    primitivesToSpill += slot to SpillableVariable(value, type, normalizedType, fieldName)
                 }
             }
 
-            spilledToVariableMapping.add(spilledToVariable)
+            referencesToSpillBySuspensionPointIndex += referencesToSpill
+            primitivesToSpillBySuspensionPointIndex += primitivesToSpill
 
-            varsCountByType.forEach {
-                maxVarsCountByType[it.key] = max(maxVarsCountByType[it.key] ?: 0, it.value)
+            for ((type, index) in varsCountByType) {
+                maxVarsCountByType[type] = max(maxVarsCountByType[type] ?: 0, index)
             }
         }
 
-        postponedActions.forEach(Function0<Unit>::invoke)
+        // Calculate variables to cleanup
 
-        maxVarsCountByType.forEach { entry ->
+        // Use CFG to calculate amount of spilled variables in previous suspension point (P) and current one (C).
+        // All fields from L$C to L$P should be cleaned. I.e. we should spill ACONST_NULL to them.
+        val cfg = ControlFlowGraph.build(methodNode)
+
+        // Collect all immediately preceding suspension points. I.e. suspension points, from which there is a path
+        // into current one, that does not cross other suspension points.
+        val suspensionPointEnds = suspensionPoints.associateBy { it.suspensionCallEnd }
+        fun findSuspensionPointPredecessors(suspension: SuspensionPoint): List<SuspensionPoint> {
+            val visited = mutableSetOf<AbstractInsnNode>()
+            fun dfs(current: AbstractInsnNode): List<SuspensionPoint> {
+                if (!visited.add(current)) return emptyList()
+                suspensionPointEnds[current]?.let { return listOf(it) }
+                return cfg.getPredecessorsIndices(current).flatMap { dfs(instructions[it]) }
+            }
+            return dfs(suspension.suspensionCallBegin)
+        }
+
+        val predSuspensionPoints = suspensionPoints.associateWith { findSuspensionPointPredecessors(it) }
+
+        // Calculate all pairs SuspensionPoint -> C and P, where P is minimum of all preds' Cs
+        fun countVariablesToSpill(index: Int): Int =
+            referencesToSpillBySuspensionPointIndex[index].count { (_, variable) -> variable != null }
+
+        val referencesToCleanBySuspensionPointIndex = arrayListOf<Pair<Int, Int>>() // current to pred
+        for (suspensionPointIndex in suspensionPoints.indices) {
+            val suspensionPoint = suspensionPoints[suspensionPointIndex]
+            val currentSpilledReferencesCount = countVariablesToSpill(suspensionPointIndex)
+            val preds = predSuspensionPoints[suspensionPoint]
+            val predSpilledReferencesCount =
+                if (preds.isNullOrEmpty()) initialSpilledVariablesCount
+                else preds.maxOf { countVariablesToSpill(suspensionPoints.indexOf(it)) }
+            referencesToCleanBySuspensionPointIndex += currentSpilledReferencesCount to predSpilledReferencesCount
+        }
+
+        // Mutate method node
+
+        fun generateSpillAndUnspill(suspension: SuspensionPoint, slot: Int, spillableVariable: SpillableVariable?) {
+            if (spillableVariable == null) {
+                with(instructions) {
+                    insert(suspension.tryCatchBlockEndLabelAfterSuspensionCall, withInstructionAdapter {
+                        aconst(null)
+                        store(slot, AsmTypes.OBJECT_TYPE)
+                    })
+                }
+                return
+            }
+
+            with(instructions) {
+                // store variable before suspension call
+                insertBefore(suspension.suspensionCallBegin, withInstructionAdapter {
+                    load(continuationIndex, AsmTypes.OBJECT_TYPE)
+                    load(slot, spillableVariable.type)
+                    StackValue.coerce(spillableVariable.type, spillableVariable.normalizedType, this)
+                    putfield(
+                        classBuilderForCoroutineState.thisName,
+                        spillableVariable.fieldName,
+                        spillableVariable.normalizedType.descriptor
+                    )
+                })
+
+                // restore variable after suspension call
+                insert(suspension.tryCatchBlockEndLabelAfterSuspensionCall, withInstructionAdapter {
+                    load(continuationIndex, AsmTypes.OBJECT_TYPE)
+                    getfield(
+                        classBuilderForCoroutineState.thisName,
+                        spillableVariable.fieldName,
+                        spillableVariable.normalizedType.descriptor
+                    )
+                    StackValue.coerce(spillableVariable.normalizedType, spillableVariable.type, this)
+                    store(slot, spillableVariable.type)
+                })
+            }
+        }
+
+        fun cleanUpField(suspension: SuspensionPoint, fieldIndex: Int) {
+            with(instructions) {
+                insertBefore(suspension.suspensionCallBegin, withInstructionAdapter {
+                    load(continuationIndex, AsmTypes.OBJECT_TYPE)
+                    aconst(null)
+                    putfield(
+                        classBuilderForCoroutineState.thisName,
+                        "L\$$fieldIndex",
+                        AsmTypes.OBJECT_TYPE.descriptor
+                    )
+                })
+            }
+        }
+
+        for (suspensionPointIndex in suspensionPoints.indices) {
+            val suspension = suspensionPoints[suspensionPointIndex]
+            for ((slot, referenceToSpill) in referencesToSpillBySuspensionPointIndex[suspensionPointIndex]) {
+                generateSpillAndUnspill(suspension, slot, referenceToSpill)
+            }
+            val (currentSpilledCount, predSpilledCount) = referencesToCleanBySuspensionPointIndex[suspensionPointIndex]
+            if (predSpilledCount > currentSpilledCount) {
+                for (fieldIndex in currentSpilledCount until predSpilledCount) {
+                    cleanUpField(suspension, fieldIndex)
+                }
+            }
+            for ((slot, primitiveToSpill) in primitivesToSpillBySuspensionPointIndex[suspensionPointIndex]) {
+                generateSpillAndUnspill(suspension, slot, primitiveToSpill)
+            }
+        }
+
+        for (entry in maxVarsCountByType) {
             val (type, maxIndex) = entry
-            for (index in 0..maxIndex) {
+            for (index in (initialVarsCountByType[type]?.plus(1) ?: 0)..maxIndex) {
                 classBuilderForCoroutineState.newField(
                     JvmDeclarationOrigin.NO_ORIGIN, AsmUtil.NO_FLAG_PACKAGE_PRIVATE,
                     type.fieldNameForVar(index), type.descriptor, null, null
                 )
             }
         }
+
+        // Calculate debug metadata mapping
+
+        fun calculateSpilledVariableAndField(
+            suspension: SuspensionPoint,
+            slot: Int,
+            spillableVariable: SpillableVariable?
+        ): SpilledVariableAndField? {
+            if (spillableVariable == null) return null
+            val name = localVariableName(methodNode, slot, suspension.suspensionCallEnd.next.index()) ?: return null
+            return SpilledVariableAndField(spillableVariable.fieldName, name)
+        }
+
+        val spilledToVariableMapping = arrayListOf<List<SpilledVariableAndField>>()
+        for (suspensionPointIndex in suspensionPoints.indices) {
+            val suspension = suspensionPoints[suspensionPointIndex]
+
+            val spilledToVariable = arrayListOf<SpilledVariableAndField>()
+
+            referencesToSpillBySuspensionPointIndex[suspensionPointIndex].mapNotNullTo(spilledToVariable) { (slot, spillableVariable) ->
+                calculateSpilledVariableAndField(suspension, slot, spillableVariable)
+            }
+            primitivesToSpillBySuspensionPointIndex[suspensionPointIndex].mapNotNullTo(spilledToVariable) { (slot, spillableVariable) ->
+                calculateSpilledVariableAndField(suspension, slot, spillableVariable)
+            }
+
+            spilledToVariableMapping += spilledToVariable
+        }
         return spilledToVariableMapping
     }
 
@@ -729,21 +845,21 @@ class CoroutineTransformerMethodVisitor(
     private val SuspensionPoint.tryCatchBlockEndLabelAfterSuspensionCall: LabelNode
         get() {
             assert(suspensionCallEnd.next is LabelNode) {
-                "Next instruction after ${this} should be a label, but " +
+                "Next instruction after $this should be a label, but " +
                         "${suspensionCallEnd.next::class.java}/${suspensionCallEnd.next.opcode} was found"
             }
 
             return suspensionCallEnd.next as LabelNode
         }
 
-    private fun transformCallAndReturnContinuationLabel(
+    private fun transformCallAndReturnStateLabel(
         id: Int,
         suspension: SuspensionPoint,
         methodNode: MethodNode,
         suspendMarkerVarIndex: Int,
         suspendPointLineNumber: LineNumberNode?
     ): LabelNode {
-        val continuationLabel = LabelNode().linkWithLabel()
+        val stateLabel = LabelNode().linkWithLabel()
         val continuationLabelAfterLoadedResult = LabelNode()
         val suspendElementLineNumber = lineNumber
         var nextLineNumberNode = nextDefinitelyHitLineNumber(suspension)
@@ -771,7 +887,7 @@ class CoroutineTransformerMethodVisitor(
                 load(suspendMarkerVarIndex, AsmTypes.OBJECT_TYPE)
                 areturn(AsmTypes.OBJECT_TYPE)
                 // Mark place for continuation
-                visitLabel(continuationLabel.label)
+                visitLabel(stateLabel.label)
             })
 
             // After suspension point there is always three nodes: L1, NOP, L2
@@ -822,7 +938,7 @@ class CoroutineTransformerMethodVisitor(
             }
         }
 
-        return continuationLabel
+        return stateLabel
     }
 
     // Find the next line number instruction that is defintely hit. That is, a line number
@@ -830,9 +946,11 @@ class CoroutineTransformerMethodVisitor(
     private fun nextDefinitelyHitLineNumber(suspension: SuspensionPoint): LineNumberNode? {
         var next = suspension.suspensionCallEnd.next
         while (next != null) {
-            if (next.isBranchOrCall) return null
-            else if (next is LineNumberNode) return next
-            else next = next.next
+            when {
+                next.isBranchOrCall -> return null
+                next is LineNumberNode -> return next
+                else -> next = next.next
+            }
         }
         return next
     }
@@ -888,9 +1006,19 @@ class CoroutineTransformerMethodVisitor(
         return
     }
 
-    private data class SpilledVariableDescriptor(val fieldName: String, val variableName: String)
+    private data class SpilledVariableAndField(val fieldName: String, val variableName: String)
 }
 
+private class SpillableVariable(
+    val value: BasicValue,
+    val type: Type,
+    val normalizedType: Type,
+    val fieldName: String
+)
+
+private typealias ReferenceToSpill = Pair<Int, SpillableVariable?>
+private typealias PrimitiveToSpill = Pair<Int, SpillableVariable>
+
 internal fun InstructionAdapter.generateContinuationConstructorCall(
     objectTypeForState: Type?,
     methodNode: MethodNode,
@@ -956,7 +1084,7 @@ inline fun withInstructionAdapter(block: InstructionAdapter.() -> Unit): InsnLis
     return tmpMethodNode.instructions
 }
 
-private fun Type.normalize() =
+internal fun Type.normalize() =
     when (sort) {
         Type.ARRAY, Type.OBJECT -> AsmTypes.OBJECT_TYPE
         else -> this
@@ -1027,3 +1155,72 @@ internal fun replaceFakeContinuationsWithRealOnes(methodNode: MethodNode, contin
         methodNode.instructions.set(fakeContinuation, VarInsnNode(Opcodes.ALOAD, continuationIndex))
     }
 }
+
+/* We do not want to spill dead variables, thus, we shrink its LVT record to region, where the variable is alive,
+ * so, the variable will not be visible in debugger. User can still prolong life span of the variable by using it.
+ *
+ * This means, that function parameters do not longer span the whole function, including `this`.
+ * This might and will break some bytecode processors, including old versions of R8. See KT-24510.
+ */
+private fun updateLvtAccordingToLiveness(method: MethodNode, isForNamedFunction: Boolean) {
+    val liveness = analyzeLiveness(method)
+
+    fun List<LocalVariableNode>.findRecord(insnIndex: Int, variableIndex: Int): LocalVariableNode? {
+        for (variable in this) {
+            if (variable.index == variableIndex &&
+                method.instructions.indexOf(variable.start) <= insnIndex &&
+                insnIndex < method.instructions.indexOf(variable.end)
+            ) return variable
+        }
+        return null
+    }
+
+    fun isAlive(insnIndex: Int, variableIndex: Int): Boolean =
+        liveness[insnIndex].isAlive(variableIndex)
+
+    val oldLvt = arrayListOf<LocalVariableNode>()
+    for (record in method.localVariables) {
+        oldLvt += record
+    }
+    method.localVariables.clear()
+    // Skip `this` for suspend lamdba
+    val start = if (isForNamedFunction) 0 else 1
+    for (variableIndex in start until method.maxLocals) {
+        if (oldLvt.none { it.index == variableIndex }) continue
+        var startLabel: LabelNode? = null
+        for (insnIndex in 0 until (method.instructions.size() - 1)) {
+            val insn = method.instructions[insnIndex]
+            if (!isAlive(insnIndex, variableIndex) && isAlive(insnIndex + 1, variableIndex)) {
+                startLabel = insn as? LabelNode ?: insn.findNextOrNull { it is LabelNode } as? LabelNode
+            }
+            if (isAlive(insnIndex, variableIndex) && !isAlive(insnIndex + 1, variableIndex)) {
+                // No variable in LVT -> do not add one
+                val lvtRecord = oldLvt.findRecord(insnIndex, variableIndex) ?: continue
+                if (lvtRecord.name == CONTINUATION_VARIABLE_NAME) continue
+                val endLabel = insn as? LabelNode ?: insn.findNextOrNull { it is LabelNode } as? LabelNode ?: continue
+                // startLabel can be null in case of parameters
+                @Suppress("NAME_SHADOWING") val startLabel = startLabel ?: lvtRecord.start
+                // No LINENUMBER in range -> no way to put a breakpoint -> do not bother adding a record
+                if (InsnSequence(startLabel, endLabel).none { it is LineNumberNode }) continue
+                method.localVariables.add(
+                    LocalVariableNode(lvtRecord.name, lvtRecord.desc, lvtRecord.signature, startLabel, endLabel, lvtRecord.index)
+                )
+            }
+        }
+    }
+
+    for (variable in oldLvt) {
+        // $continuation and $result are dead, but they are used by debugger, as well as fake inliner variables
+        // For example, $continuation is used to create async stack trace
+        if (variable.name == CONTINUATION_VARIABLE_NAME ||
+            variable.name == SUSPEND_CALL_RESULT_NAME ||
+            isFakeLocalVariableForInline(variable.name)
+        ) {
+            method.localVariables.add(variable)
+        }
+        // this acts like $continuation for lambdas. For example, it is used by debugger to create async stack trace. Keep it.
+        if (variable.name == "this" && !isForNamedFunction) {
+            method.localVariables.add(variable)
+        }
+    }
+}

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

@@ -1,11 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.codegen.coroutines
-
-import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
-import org.jetbrains.org.objectweb.asm.tree.analysis.SourceValue
-
-typealias SourceFrames = Array<Frame<SourceValue>?>

compiler/backend/src/org/jetbrains/kotlin/codegen/coroutines/SourceFrames.kt.202

@@ -1,11 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.codegen.coroutines
-
-import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
-import org.jetbrains.org.objectweb.asm.tree.analysis.SourceValue
-
-typealias SourceFrames = Array<Frame<SourceValue>>

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

@@ -26,7 +26,6 @@ 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
 
-// TODO Use this in variable liveness analysis
 internal class MethodNodeExaminer(
     val languageVersionSettings: LanguageVersionSettings,
     containingClassInternalName: String,

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

@@ -8,8 +8,8 @@ package org.jetbrains.kotlin.codegen.coroutines
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.backend.common.COROUTINE_SUSPENDED_NAME
 import org.jetbrains.kotlin.backend.common.isBuiltInSuspendCoroutineUninterceptedOrReturn
+import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.builtins.isBuiltinFunctionalClassDescriptor
-import org.jetbrains.kotlin.builtins.isBuiltinFunctionalType
 import org.jetbrains.kotlin.codegen.*
 import org.jetbrains.kotlin.codegen.binding.CodegenBinding
 import org.jetbrains.kotlin.codegen.inline.addFakeContinuationMarker
@@ -312,7 +312,7 @@ private fun FunctionDescriptor.getContinuationParameterTypeOfSuspendFunction(isR
 
 fun ModuleDescriptor.getResult(kotlinType: KotlinType) =
     module.resolveTopLevelClass(
-        DescriptorUtils.RESULT_FQ_NAME,
+        StandardNames.RESULT_FQ_NAME,
         NoLookupLocation.FROM_BACKEND
     )?.defaultType?.let {
         KotlinTypeFactory.simpleType(
@@ -501,7 +501,7 @@ fun FunctionDescriptor.isSuspendLambdaOrLocalFunction() = this.isSuspend && when
 fun FunctionDescriptor.isLocalSuspendFunctionNotSuspendLambda() = isSuspendLambdaOrLocalFunction() && this !is AnonymousFunctionDescriptor
 
 @JvmField
-val EXPERIMENTAL_CONTINUATION_ASM_TYPE = DescriptorUtils.CONTINUATION_INTERFACE_FQ_NAME_EXPERIMENTAL.topLevelClassAsmType()
+val EXPERIMENTAL_CONTINUATION_ASM_TYPE = StandardNames.CONTINUATION_INTERFACE_FQ_NAME_EXPERIMENTAL.topLevelClassAsmType()
 
 @JvmField
-val RELEASE_CONTINUATION_ASM_TYPE = DescriptorUtils.CONTINUATION_INTERFACE_FQ_NAME_RELEASE.topLevelClassAsmType()
+val RELEASE_CONTINUATION_ASM_TYPE = StandardNames.CONTINUATION_INTERFACE_FQ_NAME_RELEASE.topLevelClassAsmType()

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

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.codegen.inline
 
 import com.intellij.psi.PsiElement
 import com.intellij.util.ArrayUtil
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.codegen.*
 import org.jetbrains.kotlin.codegen.AsmUtil.isPrimitive
 import org.jetbrains.kotlin.codegen.context.ClosureContext
@@ -658,6 +658,10 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
                 if (nameWithoutManglingSuffix != null) {
                     methodNode = getMethodNode(bytes, nameWithoutManglingSuffix, asmMethod.descriptor, classType)
                 }
+                if (methodNode == null) {
+                    val nameWithImplSuffix = "$nameWithoutManglingSuffix-impl"
+                    methodNode = getMethodNode(bytes, nameWithImplSuffix, asmMethod.descriptor, classType)
+                }
             }
             return methodNode
         }
@@ -671,7 +675,7 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
             if (callableDescriptor is FictitiousArrayConstructor) return true
             val name = callableDescriptor.name.asString()
             return (name == "arrayOf" || name == "emptyArray") && callableDescriptor.containingDeclaration.let { container ->
-                container is PackageFragmentDescriptor && container.fqName == KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME
+                container is PackageFragmentDescriptor && container.fqName == StandardNames.BUILT_INS_PACKAGE_FQ_NAME
             }
         }
 

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InternalFinallyBlockInliner.java

@@ -171,7 +171,7 @@ public class InternalFinallyBlockInliner extends CoveringTryCatchNodeProcessor {
             checkClusterInvariant(clustersFromInnermost);
 
             int originalDepthIndex = 0;
-            List<TryCatchBlockNodeInfo> nestedUnsplitBlocksWithoutFinally = new ArrayList();
+            List<TryCatchBlockNodeInfo> nestedUnsplitBlocksWithoutFinally = new ArrayList<>();
             while (tryCatchBlockIterator.hasNext()) {
                 TryBlockCluster<TryCatchBlockNodeInfo> clusterToFindFinally = tryCatchBlockIterator.next();
                 List<TryCatchBlockNodeInfo> clusterBlocks = clusterToFindFinally.getBlocks();

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

@@ -91,7 +91,7 @@ class ParametersBuilder private constructor() {
     }
 
     fun buildParameters(): Parameters {
-        var nextDeclarationIndex = (params.maxBy { it.declarationIndex }?.declarationIndex ?: -1) + 1
+        var nextDeclarationIndex = (params.maxOfOrNull { it.declarationIndex } ?: -1) + 1
 
         return Parameters(params.map { param ->
             if (param is CapturedParamInfo) {

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

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen.inline
 import org.jetbrains.kotlin.backend.common.isBuiltInIntercepted
 import org.jetbrains.kotlin.backend.common.isBuiltInSuspendCoroutineUninterceptedOrReturn
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.codegen.AsmUtil
 import org.jetbrains.kotlin.codegen.coroutines.createMethodNodeForCoroutineContext
 import org.jetbrains.kotlin.codegen.coroutines.createMethodNodeForIntercepted
@@ -54,7 +55,7 @@ internal fun generateInlineIntrinsic(
 
 private fun isSpecialEnumMethod(descriptor: FunctionDescriptor): Boolean {
     val containingDeclaration = descriptor.containingDeclaration as? PackageFragmentDescriptor ?: return false
-    if (containingDeclaration.fqName != KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME) {
+    if (containingDeclaration.fqName != StandardNames.BUILT_INS_PACKAGE_FQ_NAME) {
         return false
     }
     if (descriptor.typeParameters.size != 1) {

compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/IntrinsicMethods.java

@@ -20,7 +20,7 @@ import com.google.common.collect.ImmutableList;
 import kotlin.text.StringsKt;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
+import org.jetbrains.kotlin.builtins.StandardNames;
 import org.jetbrains.kotlin.builtins.PrimitiveType;
 import org.jetbrains.kotlin.codegen.AsmUtil;
 import org.jetbrains.kotlin.config.JvmTarget;
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType;
 import org.jetbrains.kotlin.types.expressions.OperatorConventions;
 import org.jetbrains.org.objectweb.asm.Type;
 
-import static org.jetbrains.kotlin.builtins.KotlinBuiltIns.*;
+import static org.jetbrains.kotlin.builtins.StandardNames.*;
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
 
 public class IntrinsicMethods {
@@ -70,15 +70,15 @@ public class IntrinsicMethods {
 
     public IntrinsicMethods(JvmTarget jvmTarget, boolean canReplaceStdlibRuntimeApiBehavior, boolean shouldThrowNpeOnExplicitEqualsForBoxedNull) {
         intrinsicsMap.registerIntrinsic(KOTLIN_JVM, RECEIVER_PARAMETER_FQ_NAME, "javaClass", -1, JavaClassProperty.INSTANCE);
-        intrinsicsMap.registerIntrinsic(KOTLIN_JVM, KotlinBuiltIns.FQ_NAMES.kClass, "java", -1, new KClassJavaProperty());
-        intrinsicsMap.registerIntrinsic(KOTLIN_JVM, KotlinBuiltIns.FQ_NAMES.kClass, "javaObjectType", -1, new KClassJavaObjectTypeProperty());
-        intrinsicsMap.registerIntrinsic(KOTLIN_JVM, KotlinBuiltIns.FQ_NAMES.kClass, "javaPrimitiveType", -1, new KClassJavaPrimitiveTypeProperty());
-        intrinsicsMap.registerIntrinsic(KotlinBuiltIns.FQ_NAMES.kCallable.toSafe(), null, "name", -1, new KCallableNameProperty());
+        intrinsicsMap.registerIntrinsic(KOTLIN_JVM, StandardNames.FqNames.kClass, "java", -1, new KClassJavaProperty());
+        intrinsicsMap.registerIntrinsic(KOTLIN_JVM, StandardNames.FqNames.kClass, "javaObjectType", -1, new KClassJavaObjectTypeProperty());
+        intrinsicsMap.registerIntrinsic(KOTLIN_JVM, StandardNames.FqNames.kClass, "javaPrimitiveType", -1, new KClassJavaPrimitiveTypeProperty());
+        intrinsicsMap.registerIntrinsic(StandardNames.FqNames.kCallable.toSafe(), null, "name", -1, new KCallableNameProperty());
         intrinsicsMap.registerIntrinsic(new FqName("kotlin.jvm.internal.unsafe"), null, "monitorEnter", 1, MonitorInstruction.MONITOR_ENTER);
         intrinsicsMap.registerIntrinsic(new FqName("kotlin.jvm.internal.unsafe"), null, "monitorExit", 1, MonitorInstruction.MONITOR_EXIT);
-        intrinsicsMap.registerIntrinsic(KOTLIN_JVM, KotlinBuiltIns.FQ_NAMES.array, "isArrayOf", 0, new IsArrayOf());
+        intrinsicsMap.registerIntrinsic(KOTLIN_JVM, StandardNames.FqNames.array, "isArrayOf", 0, new IsArrayOf());
 
-        intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, KotlinBuiltIns.FQ_NAMES.kProperty0, "isInitialized", -1, LateinitIsInitialized.INSTANCE);
+        intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, StandardNames.FqNames.kProperty0, "isInitialized", -1, LateinitIsInitialized.INSTANCE);
 
         intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, null, "arrayOf", 1, new ArrayOf());
 
@@ -87,7 +87,7 @@ public class IntrinsicMethods {
         ImmutableList<Name> primitiveCastMethods = OperatorConventions.NUMBER_CONVERSIONS.asList();
         for (Name method : primitiveCastMethods) {
             String methodName = method.asString();
-            declareIntrinsicFunction(FQ_NAMES.number, methodName, 0, NUMBER_CAST);
+            declareIntrinsicFunction(StandardNames.FqNames.number, methodName, 0, NUMBER_CAST);
             for (PrimitiveType type : PrimitiveType.NUMBER_TYPES) {
                 declareIntrinsicFunction(type.getTypeFqName(), methodName, 0, NUMBER_CAST);
             }
@@ -139,20 +139,20 @@ public class IntrinsicMethods {
         declareBinaryOp("or", IOR);
         declareBinaryOp("xor", IXOR);
 
-        declareIntrinsicFunction(FQ_NAMES._boolean, "not", 0, new Not());
+        declareIntrinsicFunction(StandardNames.FqNames._boolean, "not", 0, new Not());
 
-        declareIntrinsicFunction(FQ_NAMES.string, "plus", 1, new Concat());
-        declareIntrinsicFunction(FQ_NAMES.string, "get", 1, new StringGetChar());
+        declareIntrinsicFunction(StandardNames.FqNames.string, "plus", 1, new Concat());
+        declareIntrinsicFunction(StandardNames.FqNames.string, "get", 1, new StringGetChar());
 
         if (canReplaceStdlibRuntimeApiBehavior) {
-            intrinsicsMap.registerIntrinsic(TEXT_PACKAGE_FQ_NAME, FQ_NAMES.string, "trimMargin", 1, new TrimMargin());
-            intrinsicsMap.registerIntrinsic(TEXT_PACKAGE_FQ_NAME, FQ_NAMES.string, "trimIndent", 0, new TrimIndent());
+            intrinsicsMap.registerIntrinsic(TEXT_PACKAGE_FQ_NAME, StandardNames.FqNames.string, "trimMargin", 1, new TrimMargin());
+            intrinsicsMap.registerIntrinsic(TEXT_PACKAGE_FQ_NAME, StandardNames.FqNames.string, "trimIndent", 0, new TrimIndent());
         }
 
-        declareIntrinsicFunction(FQ_NAMES.cloneable, "clone", 0, CLONE);
+        declareIntrinsicFunction(StandardNames.FqNames.cloneable, "clone", 0, CLONE);
 
-        intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, KotlinBuiltIns.FQ_NAMES.any, "toString", 0, TO_STRING);
-        intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, KotlinBuiltIns.FQ_NAMES.string, "plus", 1, STRING_PLUS);
+        intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, StandardNames.FqNames.any, "toString", 0, TO_STRING);
+        intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, StandardNames.FqNames.string, "plus", 1, STRING_PLUS);
         intrinsicsMap.registerIntrinsic(BUILT_INS_PACKAGE_FQ_NAME, null, "arrayOfNulls", 1, new NewArray());
 
         for (PrimitiveType type : PrimitiveType.values()) {
@@ -197,7 +197,7 @@ public class IntrinsicMethods {
         for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) {
             declareArrayMethods(jvmPrimitiveType.getPrimitiveType().getArrayTypeFqName());
         }
-        declareArrayMethods(FQ_NAMES.array.toSafe());
+        declareArrayMethods(FqNames.array.toSafe());
     }
 
     private void declareArrayMethods(@NotNull FqName arrayTypeFqName) {

compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/IteratorNext.kt

@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.codegen.intrinsics
 
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns.COLLECTIONS_PACKAGE_FQ_NAME
+import org.jetbrains.kotlin.builtins.StandardNames.COLLECTIONS_PACKAGE_FQ_NAME
 import org.jetbrains.kotlin.codegen.AsmUtil
 import org.jetbrains.kotlin.codegen.Callable
 import org.jetbrains.kotlin.codegen.CallableMethod

compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/TypeIntrinsics.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.codegen.intrinsics
 
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns.FQ_NAMES
+import org.jetbrains.kotlin.builtins.StandardNames.FqNames
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
@@ -16,7 +16,6 @@ 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 kotlin.text.Regex
 
 object TypeIntrinsics {
     @JvmStatic
@@ -134,20 +133,20 @@ object TypeIntrinsics {
 
 
     private val MUTABLE_COLLECTION_TYPE_FQ_NAMES = setOf(
-            FQ_NAMES.mutableIterator,
-            FQ_NAMES.mutableIterable,
-            FQ_NAMES.mutableCollection,
-            FQ_NAMES.mutableList,
-            FQ_NAMES.mutableListIterator,
-            FQ_NAMES.mutableMap,
-            FQ_NAMES.mutableSet,
-            FQ_NAMES.mutableMapEntry
+        FqNames.mutableIterator,
+        FqNames.mutableIterable,
+        FqNames.mutableCollection,
+        FqNames.mutableList,
+        FqNames.mutableListIterator,
+        FqNames.mutableMap,
+        FqNames.mutableSet,
+        FqNames.mutableMapEntry
     )
 
     private fun getMutableCollectionMethodName(prefix: String, jetType: KotlinType): String? {
         val fqName = getClassFqName(jetType)
         if (fqName == null || fqName !in MUTABLE_COLLECTION_TYPE_FQ_NAMES) return null
-        val baseName = if (fqName == FQ_NAMES.mutableMapEntry) "MutableMapEntry" else fqName.shortName().asString()
+        val baseName = if (fqName == FqNames.mutableMapEntry) "MutableMapEntry" else fqName.shortName().asString()
         return prefix + baseName
     }
 
@@ -200,4 +199,4 @@ object TypeIntrinsics {
 
     private val BEFORE_CHECKCAST_TO_FUNCTION_OF_ARITY_DESCRIPTOR =
             Type.getMethodDescriptor(OBJECT_TYPE, OBJECT_TYPE, Type.INT_TYPE)
-}
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/common/variableLiveness.kt

@@ -5,16 +5,10 @@
 
 package org.jetbrains.kotlin.codegen.optimization.common
 
-import org.jetbrains.kotlin.codegen.coroutines.SUSPEND_FUNCTION_COMPLETION_PARAMETER_NAME
-import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
-import org.jetbrains.kotlin.load.java.JvmAbi
-import org.jetbrains.org.objectweb.asm.Type
 import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode
 import org.jetbrains.org.objectweb.asm.tree.IincInsnNode
 import org.jetbrains.org.objectweb.asm.tree.MethodNode
 import org.jetbrains.org.objectweb.asm.tree.VarInsnNode
-import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
-import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
 import java.util.*
 
 
@@ -29,10 +23,6 @@ class VariableLivenessFrame(val maxLocals: Int) : VarFrame<VariableLivenessFrame
         bitSet.set(varIndex, true)
     }
 
-    fun markAllAlive(bitSet: BitSet) {
-        this.bitSet.or(bitSet)
-    }
-
     fun markDead(varIndex: Int) {
         bitSet.set(varIndex, false)
     }
@@ -45,34 +35,17 @@ class VariableLivenessFrame(val maxLocals: Int) : VarFrame<VariableLivenessFrame
     }
 
     override fun hashCode() = bitSet.hashCode()
+
+    override fun toString(): String = (0 until maxLocals).map { if (bitSet[it]) '@' else '_' }.joinToString(separator = "")
 }
 
-fun analyzeLiveness(node: MethodNode): List<VariableLivenessFrame> {
-    val typeAnnotatedFrames = MethodTransformer.analyze("fake", node, OptimizationBasicInterpreter())
-    val visibleByDebuggerVariables = analyzeVisibleByDebuggerVariables(node, typeAnnotatedFrames)
-    return analyze(node, object : BackwardAnalysisInterpreter<VariableLivenessFrame> {
+fun analyzeLiveness(method: MethodNode): List<VariableLivenessFrame> =
+    analyze(method, object : BackwardAnalysisInterpreter<VariableLivenessFrame> {
         override fun newFrame(maxLocals: Int) = VariableLivenessFrame(maxLocals)
         override fun def(frame: VariableLivenessFrame, insn: AbstractInsnNode) = defVar(frame, insn)
         override fun use(frame: VariableLivenessFrame, insn: AbstractInsnNode) =
-            useVar(frame, insn, node, visibleByDebuggerVariables[node.instructions.indexOf(insn)])
+            useVar(frame, insn)
     })
-}
-
-private fun analyzeVisibleByDebuggerVariables(
-    node: MethodNode,
-    typeAnnotatedFrames: TypeAnnotatedFrames
-): Array<BitSet> {
-    val res = Array(node.instructions.size()) { BitSet(node.maxLocals) }
-    for (local in node.localVariables) {
-        if (local.name.isInvisibleDebuggerVariable()) continue
-        for (index in node.instructions.indexOf(local.start) until node.instructions.indexOf(local.end)) {
-            if (Type.getType(local.desc).sort == typeAnnotatedFrames[index]?.getLocal(local.index)?.type?.sort) {
-                res[index].set(local.index)
-            }
-        }
-    }
-    return res
-}
 
 private fun defVar(frame: VariableLivenessFrame, insn: AbstractInsnNode) {
     if (insn is VarInsnNode && insn.isStoreOperation()) {
@@ -80,22 +53,10 @@ private fun defVar(frame: VariableLivenessFrame, insn: AbstractInsnNode) {
     }
 }
 
-private fun useVar(
-    frame: VariableLivenessFrame,
-    insn: AbstractInsnNode,
-    node: MethodNode,
-    visibleByDebuggerVariables: BitSet
-) {
-    frame.markAllAlive(visibleByDebuggerVariables)
-
+private fun useVar(frame: VariableLivenessFrame, insn: AbstractInsnNode) {
     if (insn is VarInsnNode && insn.isLoadOperation()) {
         frame.markAlive(insn.`var`)
     } else if (insn is IincInsnNode) {
         frame.markAlive(insn.`var`)
     }
-}
-
-private fun String.isInvisibleDebuggerVariable(): Boolean =
-    startsWith(JvmAbi.LOCAL_VARIABLE_NAME_PREFIX_INLINE_ARGUMENT) ||
-            startsWith(JvmAbi.LOCAL_VARIABLE_NAME_PREFIX_INLINE_FUNCTION) ||
-            this == SUSPEND_FUNCTION_COMPLETION_PARAMETER_NAME
+}

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

@@ -69,9 +69,10 @@ abstract class PrimitiveNumberRangeIntrinsicRangeValue(
                     ?: throw AssertionError("Floating point intrinsic range value should be a range literal")
                 InFloatingPointRangeLiteralExpressionGenerator(operatorReference, rangeLiteral, comparisonGenerator, codegen.frameMap)
             }
-            else -> InIntegralContinuousRangeExpressionGenerator(
-                operatorReference, rangeContainsTypeInfo, getBoundedValue(codegen), comparisonGenerator, codegen.frameMap
-            )
+            else ->
+                InIntegralContinuousRangeExpressionGenerator(
+                    operatorReference, rangeContainsTypeInfo, getBoundedValue(codegen), comparisonGenerator, codegen.frameMap
+                )
         }
     }
 

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

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.codegen.range
 
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.builtins.UnsignedTypes
 import org.jetbrains.kotlin.codegen.AsmUtil.isPrimitiveNumberClassDescriptor
 import org.jetbrains.kotlin.descriptors.*
@@ -83,10 +84,10 @@ fun getRangeOrProgressionElementType(rangeType: KotlinType): KotlinType? {
         COMPARABLE_RANGE_FQN -> rangeType.arguments.singleOrNull()?.type
 
         UINT_RANGE_FQN, UINT_PROGRESSION_FQN ->
-            rangeClassDescriptor.findTypeInModuleByTopLevelClassFqName(KotlinBuiltIns.FQ_NAMES.uIntFqName)
+            rangeClassDescriptor.findTypeInModuleByTopLevelClassFqName(StandardNames.FqNames.uIntFqName)
 
         ULONG_RANGE_FQN, ULONG_PROGRESSION_FQN ->
-            rangeClassDescriptor.findTypeInModuleByTopLevelClassFqName(KotlinBuiltIns.FQ_NAMES.uLongFqName)
+            rangeClassDescriptor.findTypeInModuleByTopLevelClassFqName(StandardNames.FqNames.uLongFqName)
 
         else -> null
     }
@@ -208,17 +209,25 @@ fun isPrimitiveRangeContains(descriptor: CallableDescriptor): Boolean {
 }
 
 fun isUnsignedIntegerRangeContains(descriptor: CallableDescriptor): Boolean {
-    if (descriptor.name.asString() != "contains") return false
-
     val dispatchReceiverType = descriptor.dispatchReceiverParameter?.type
     val extensionReceiverType = descriptor.extensionReceiverParameter?.type
 
-    return (dispatchReceiverType != null && isUnsignedRange(dispatchReceiverType)) ||
-            (extensionReceiverType != null && isUnsignedRange(extensionReceiverType))
+    when {
+        dispatchReceiverType != null && extensionReceiverType == null -> {
+            if (descriptor.name.asString() != "contains") return false
+            return isUnsignedRange(dispatchReceiverType)
+        }
+        extensionReceiverType != null && dispatchReceiverType == null -> {
+            if (!descriptor.isTopLevelInPackage("contains", "kotlin.ranges")) return false
+            return isUnsignedRange(extensionReceiverType)
+        }
+        else ->
+            return false
+    }
 }
 
 fun isPrimitiveNumberRangeExtensionContainsPrimitiveNumber(descriptor: CallableDescriptor): Boolean {
-    if (descriptor.name.asString() != "contains") return false
+    if (!descriptor.isTopLevelInPackage("contains", "kotlin.ranges")) return false
 
     val extensionReceiverType = descriptor.extensionReceiverParameter?.type ?: return false
 

compiler/backend/src/org/jetbrains/kotlin/codegen/range/comparison/ComparisonGenerator.kt

@@ -87,7 +87,10 @@ fun getComparisonGeneratorForRangeContainsCall(
             getComparisonGeneratorForKotlinType(elementType)
 
         KotlinBuiltIns.isUInt(elementType) ->
-            UIntComparisonGenerator
+            if (KotlinBuiltIns.isULong(valueParameterType))
+                null
+            else
+                UIntComparisonGenerator
 
         KotlinBuiltIns.isULong(elementType) ->
             ULongComparisonGenerator

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

@@ -51,14 +51,12 @@ class BuilderFactoryForDuplicateSignatureDiagnostics(
     moduleName: String,
     languageVersionSettings: LanguageVersionSettings,
     shouldGenerate: (JvmDeclarationOrigin) -> Boolean,
-    mapAsmMethod: ((FunctionDescriptor) -> Method)?
 ) : SignatureCollectingClassBuilderFactory(builderFactory, shouldGenerate) {
 
-    private val mapAsmMethod = mapAsmMethod
-        ?: KotlinTypeMapper(
-            // Avoid errors when some classes are not loaded for some reason
-            bindingContext, ClassBuilderMode.LIGHT_CLASSES, moduleName, languageVersionSettings, isIrBackend = false
-        )::mapAsmMethod
+    private val mapAsmMethod: (FunctionDescriptor) -> Method = KotlinTypeMapper(
+        // Avoid errors when some classes are not loaded for some reason
+        bindingContext, ClassBuilderMode.LIGHT_CLASSES, moduleName, languageVersionSettings, isIrBackend = false
+    )::mapAsmMethod
 
     private val reportDiagnosticsTasks = ArrayList<() -> Unit>()
 

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

@@ -21,7 +21,6 @@ import org.jetbrains.kotlin.codegen.optimization.OptimizationClassBuilderFactory
 import org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.ScriptDescriptor
 import org.jetbrains.kotlin.diagnostics.Diagnostic
@@ -48,7 +47,6 @@ import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.TypeApproximator
 import org.jetbrains.org.objectweb.asm.Type
-import org.jetbrains.org.objectweb.asm.commons.Method
 import java.io.File
 
 class GenerationState private constructor(
@@ -283,7 +281,6 @@ class GenerationState private constructor(
     val isIrWithStableAbi = configuration.getBoolean(JVMConfigurationKeys.IS_IR_WITH_STABLE_ABI)
 
     val globalSerializationBindings = JvmSerializationBindings()
-    lateinit var irBasedMapAsmMethod: (FunctionDescriptor) -> Method
     var mapInlineClass: (ClassDescriptor) -> Type = { descriptor -> typeMapper.mapType(descriptor.defaultType) }
 
     val typeApproximator: TypeApproximator? =
@@ -310,7 +307,6 @@ class GenerationState private constructor(
                         BuilderFactoryForDuplicateSignatureDiagnostics(
                             it, this.bindingContext, diagnostics, this.moduleName, this.languageVersionSettings,
                             shouldGenerate = { origin -> !shouldOnlyCollectSignatures(origin) },
-                            mapAsmMethod = if (isIrBackend) { descriptor: FunctionDescriptor -> irBasedMapAsmMethod(descriptor) } else null
                         ).apply { duplicateSignatureFactory = this }
                 },
                 { BuilderFactoryForDuplicateClassNameDiagnostics(it, diagnostics) },

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

@@ -8,7 +8,9 @@ package org.jetbrains.kotlin.codegen.state
 import com.intellij.openapi.util.text.StringUtil
 import org.jetbrains.kotlin.builtins.BuiltInsPackageFragment
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.builtins.StandardNames.RESULT_FQ_NAME
 import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
+import org.jetbrains.kotlin.builtins.functions.FunctionClassKind
 import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 import org.jetbrains.kotlin.codegen.*
 import org.jetbrains.kotlin.codegen.AsmUtil.isStaticMethod
@@ -52,10 +54,7 @@ import org.jetbrains.kotlin.resolve.bindingContextUtil.isUsedAsExpression
 import org.jetbrains.kotlin.resolve.calls.model.DefaultValueArgument
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.calls.model.VarargValueArgument
-import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
-import org.jetbrains.kotlin.resolve.descriptorUtil.classId
-import org.jetbrains.kotlin.resolve.descriptorUtil.isPublishedApi
-import org.jetbrains.kotlin.resolve.descriptorUtil.module
+import org.jetbrains.kotlin.resolve.descriptorUtil.*
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes.DEFAULT_CONSTRUCTOR_MARKER
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes.OBJECT_TYPE
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName
@@ -330,8 +329,8 @@ class KotlinTypeMapper @JvmOverloads constructor(
 
         if (classDescriptor is FunctionClassDescriptor) {
             if (classDescriptor.hasBigArity ||
-                classDescriptor.functionKind == FunctionClassDescriptor.Kind.KFunction ||
-                classDescriptor.functionKind == FunctionClassDescriptor.Kind.KSuspendFunction
+                classDescriptor.functionKind == FunctionClassKind.KFunction ||
+                classDescriptor.functionKind == FunctionClassKind.KSuspendFunction
             ) {
                 // kotlin.reflect.KFunction{n}<P1, ..., Pn, R> is mapped to kotlin.reflect.KFunction<R> (for all n), and
                 // kotlin.Function{n}<P1, ..., Pn, R> is mapped to kotlin.jvm.functions.FunctionN<R> (for n > 22).
@@ -385,6 +384,11 @@ class KotlinTypeMapper @JvmOverloads constructor(
             return functionDescriptor.builtIns.nullableAnyType
         }
 
+        // Force boxing for Result type, otherwise, the coroutines machinery will break
+        if (originalReturnType.constructor.declarationDescriptor?.fqNameSafe == RESULT_FQ_NAME) {
+            return functionDescriptor.builtIns.nullableAnyType
+        }
+
         // Don't box other inline classes
         return originalReturnType
     }

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

@@ -18,6 +18,7 @@
 
 package org.jetbrains.kotlin.codegen.state
 
+import org.jetbrains.kotlin.builtins.StandardNames.FqNames
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
@@ -37,7 +38,6 @@ import org.jetbrains.kotlin.types.checker.convertVariance
 import org.jetbrains.kotlin.types.getEffectiveVariance
 import org.jetbrains.kotlin.types.model.KotlinTypeMarker
 import org.jetbrains.kotlin.types.model.TypeParameterMarker
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns.FQ_NAMES as BUILTIN_NAMES
 
 // TODO: probably class upper bound should be used
 @Suppress("UNUSED_PARAMETER")
@@ -81,9 +81,9 @@ val FqName?.isMethodWithDeclarationSiteWildcardsFqName: Boolean
 
 private fun FqName.child(name: String): FqName = child(Name.identifier(name))
 private val METHODS_WITH_DECLARATION_SITE_WILDCARDS = setOf(
-    BUILTIN_NAMES.mutableCollection.child("addAll"),
-    BUILTIN_NAMES.mutableList.child("addAll"),
-    BUILTIN_NAMES.mutableMap.child("putAll")
+    FqNames.mutableCollection.child("addAll"),
+    FqNames.mutableList.child("addAll"),
+    FqNames.mutableMap.child("putAll")
 )
 
 fun TypeMappingMode.updateArgumentModeFromAnnotations(

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

@@ -35,7 +35,7 @@ private class State<T>(val path: MutableList<String>) {
         path.add(step)
     }
 
-    fun removeStep(step: String) {
+    fun removeStep() {
         path.removeAt(path.lastIndex)
     }
 
@@ -93,7 +93,7 @@ abstract class TypeAnnotationCollector<T>(val context: TypeSystemCommonBackendCo
     fun KotlinTypeMarker.process(step: String) {
         state.addStep(step)
         this.gatherTypeAnnotations()
-        state.removeStep(step)
+        state.removeStep()
     }
 
 

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

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.serialization.builtins
 
 import com.intellij.openapi.util.Disposer
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.builtins.jvm.JvmBuiltInClassDescriptorFactory
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.config.addKotlinSourceRoots
@@ -100,9 +100,9 @@ class BuiltInsSerializer(dependOnOldBuiltIns: Boolean) : MetadataSerializer(Buil
     // Since Kotlin 1.1, we always discard this class during deserialization (see ClassDeserializer.kt).
     private fun createCloneable(module: ModuleDescriptor): ClassDescriptor {
         val factory = JvmBuiltInClassDescriptorFactory(LockBasedStorageManager.NO_LOCKS, module) {
-            EmptyPackageFragmentDescriptor(module, KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME)
+            EmptyPackageFragmentDescriptor(module, StandardNames.BUILT_INS_PACKAGE_FQ_NAME)
         }
-        return factory.createClass(ClassId.topLevel(KotlinBuiltIns.FQ_NAMES.cloneable.toSafe()))
+        return factory.createClass(ClassId.topLevel(StandardNames.FqNames.cloneable.toSafe()))
                ?: error("Could not create kotlin.Cloneable in $module")
     }
 }

compiler/cli/build.gradle.kts

@@ -31,6 +31,9 @@ dependencies {
     compile(project(":kotlin-util-io"))
     compile(project(":compiler:ir.serialization.common"))
 
+    // TODO: as soon as cli-jvm is extracted out of this module, move this dependency there
+    compileOnly(project(":compiler:ir.tree.impl"))
+
     compileOnly(toolsJarApi())
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
     compileOnly(intellijDep()) { includeIntellijCoreJarDependencies(project) }

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

@@ -317,6 +317,12 @@ abstract class CommonCompilerArguments : CommonToolArguments() {
     )
     var useFir: Boolean by FreezableVar(false)
 
+    @Argument(
+        value = "-Xuse-fir-extended-checkers",
+        description = "Use extended analysis mode based on Front-end IR. Warning: this feature is far from being production-ready"
+    )
+    var useFirExtendedCheckers: Boolean by FreezableVar(false)
+
     @Argument(
         value = "-Xuse-mixed-named-arguments",
         description = "Enable Support named arguments in their own position even if the result appears as mixed"

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/messages/OutputMessageUtil.java

@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.cli.common.messages;
 
 import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -25,6 +24,7 @@ import java.io.File;
 import java.io.PrintWriter;
 import java.io.Serializable;
 import java.io.StringWriter;
+import java.util.ArrayList;
 import java.util.Collection;
 
 public class OutputMessageUtil {
@@ -69,7 +69,7 @@ public class OutputMessageUtil {
     }
 
     private static Collection<File> parseSourceFiles(String[] strings, int start) {
-        Collection<File> sourceFiles = ContainerUtil.newArrayList();
+        Collection<File> sourceFiles = new ArrayList<>();
         for (int i = start; i < strings.length; i++) {
             sourceFiles.add(new File(strings[i]));
         }

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/repl/GenericReplEvaluator.kt

@@ -89,6 +89,9 @@ open class GenericReplEvaluator(
 
             historyActor.addPlaceholder(compileResult.lineId, EvalClassWithInstanceAndLoader(scriptClass.kotlin, null, classLoader, invokeWrapper))
 
+            val savedClassLoader = Thread.currentThread().contextClassLoader
+            Thread.currentThread().contextClassLoader = classLoader
+
             val scriptInstance =
                     try {
                         if (invokeWrapper != null) invokeWrapper.invoke { scriptInstanceConstructor.newInstance(*constructorArgs) }
@@ -104,6 +107,7 @@ open class GenericReplEvaluator(
                     }
                     finally {
                         historyActor.removePlaceholder(compileResult.lineId)
+                        Thread.currentThread().contextClassLoader = savedClassLoader
                     }
 
             historyActor.addFinal(compileResult.lineId, EvalClassWithInstanceAndLoader(scriptClass.kotlin, scriptInstance, classLoader, invokeWrapper))

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/repl/replUtil.kt

@@ -34,12 +34,12 @@ fun String.replUnescapeLineBreaks() = StringUtil.replace(this, XML_REPLACEMENTS,
 fun String.replEscapeLineBreaks() = StringUtil.replace(this, SOURCE_CHARS, XML_REPLACEMENTS)
 
 fun String.replOutputAsXml(escapeType: ReplEscapeType): String {
-    val escapedXml = StringUtil.escapeXml(replEscapeLineBreaks())
+    val escapedXml = StringUtil.escapeXmlEntities(replEscapeLineBreaks())
     return "$XML_PREAMBLE<output type=\"$escapeType\">$escapedXml</output>"
 }
 
 fun String.replInputAsXml(): String {
-    val escapedXml = StringUtil.escapeXml(replEscapeLineBreaks())
+    val escapedXml = StringUtil.escapeXmlEntities(replEscapeLineBreaks())
     return "$XML_PREAMBLE<input>$escapedXml</input>"
 }
 
@@ -86,4 +86,4 @@ internal fun URLClassLoader.listLocalUrlsAsFiles(): List<File> {
 internal fun <T : Any> List<T>.ensureNotEmpty(error: String): List<T> {
     if (this.isEmpty()) throw IllegalStateException(error)
     return this
-}
+}

compiler/cli/cli-js-klib/build.gradle.kts

@@ -6,6 +6,7 @@ plugins {
 dependencies {
     compile(project(":compiler:cli"))
     compile(project(":compiler:ir.serialization.js"))
+    compileOnly(project(":compiler:ir.tree.persistent"))
     runtimeOnly(project(":kotlin-reflect"))
     if (Platform[193].orLower()) {
         compile(intellijDep()) { includeJars("picocontainer", rootProject = rootProject) }

compiler/cli/cli-js-klib/src/GenerateJsIrKlib.kt

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.cli.common.messages.*
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.config.*
+import org.jetbrains.kotlin.ir.declarations.persistent.PersistentIrFactory
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
 import org.jetbrains.kotlin.library.resolver.KotlinLibraryResolveResult
 import org.jetbrains.kotlin.psi.KtFile
@@ -87,6 +88,7 @@ fun buildKLib(
         configuration = configuration,
         allDependencies = allDependencies,
         friendDependencies = emptyList(),
+        irFactory = PersistentIrFactory,
         outputKlibPath = outputPath,
         nopack = true
     )

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

@@ -24,13 +24,17 @@ import org.jetbrains.kotlin.cli.common.messages.MessageUtil
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.plugins.PluginCliParser
-import org.jetbrains.kotlin.config.*
+import org.jetbrains.kotlin.config.CommonConfigurationKeys
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.IncrementalCompilation
+import org.jetbrains.kotlin.config.Services
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.incremental.js.IncrementalDataProvider
 import org.jetbrains.kotlin.incremental.js.IncrementalNextRoundChecker
 import org.jetbrains.kotlin.incremental.js.IncrementalResultsConsumer
 import org.jetbrains.kotlin.ir.backend.js.*
+import org.jetbrains.kotlin.ir.declarations.persistent.PersistentIrFactory
 import org.jetbrains.kotlin.js.config.EcmaVersion
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
 import org.jetbrains.kotlin.js.config.JsConfig
@@ -193,6 +197,7 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
                     configuration = config.configuration,
                     allDependencies = resolvedLibraries,
                     friendDependencies = friendDependencies,
+                    irFactory = PersistentIrFactory,
                     outputKlibPath = outputKlibPath,
                     nopack = arguments.irProduceKlibDir
                 )

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

@@ -127,10 +127,10 @@ object Main {
             classpath.addPath(".")
         }
 
-        classpath.addPath(KOTLIN_HOME.toString() + "/lib/kotlin-stdlib.jar")
+        classpath.addPath("$KOTLIN_HOME/lib/kotlin-stdlib.jar")
 
         if (!noReflect) {
-            classpath.addPath(KOTLIN_HOME.toString() + "/lib/kotlin-reflect.jar")
+            classpath.addPath("$KOTLIN_HOME/lib/kotlin-reflect.jar")
         }
 
         if (expression != null) {

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

@@ -89,8 +89,10 @@ abstract class CLICompiler<A : CommonCompilerArguments> : CLITool<A>() {
 
                 performanceManager.notifyCompilationFinished()
                 if (arguments.reportPerf) {
-                    performanceManager.getMeasurementResults()
-                        .forEach { it -> configuration.get(MESSAGE_COLLECTOR_KEY)!!.report(INFO, "PERF: " + it.render(), null) }
+                    collector.report(INFO, "PERF: " + performanceManager.getTargetInfo())
+                    for (measurement in performanceManager.getMeasurementResults()) {
+                        collector.report(INFO, "PERF: " + measurement.render(), null)
+                    }
                 }
 
                 if (arguments.dumpPerf != null) {

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

@@ -24,6 +24,13 @@ abstract class CommonCompilerPerformanceManager(private val presentableName: Str
     private var irTranslationStart: Long = 0
     private var irGenerationStart: Long = 0
 
+    private var targetDescription: String? = null
+    protected var files: Int? = null
+    protected var lines: Int? = null
+
+    fun getTargetInfo(): String =
+        "$targetDescription, $files files ($lines lines)"
+
     fun getMeasurementResults(): List<PerformanceMeasurement> = measurements
 
     fun enableCollectingPerformanceStatistics() {
@@ -34,9 +41,13 @@ abstract class CommonCompilerPerformanceManager(private val presentableName: Str
 
     private fun deltaTime(start: Long): Long = PerformanceCounter.currentTime() - start
 
-    open fun notifyCompilerInitialized() {
+    open fun notifyCompilerInitialized(files: Int, lines: Int, targetDescription: String) {
         if (!isEnabled) return
         recordInitializationTime()
+
+        this.files = files
+        this.lines = lines
+        this.targetDescription = targetDescription
     }
 
     open fun notifyCompilationFinished() {
@@ -50,32 +61,30 @@ abstract class CommonCompilerPerformanceManager(private val presentableName: Str
         analysisStart = PerformanceCounter.currentTime()
     }
 
-    open fun notifyAnalysisFinished(files: Int, lines: Int, additionalDescription: String?) {
+    open fun notifyAnalysisFinished() {
         val time = PerformanceCounter.currentTime() - analysisStart
-        measurements += CodeAnalysisMeasurement(files, lines, TimeUnit.NANOSECONDS.toMillis(time), additionalDescription)
+        measurements += CodeAnalysisMeasurement(lines, TimeUnit.NANOSECONDS.toMillis(time))
     }
 
     open fun notifyGenerationStarted() {
         generationStart = PerformanceCounter.currentTime()
     }
 
-    open fun notifyGenerationFinished(files: Int, lines: Int, additionalDescription: String) {
+    open fun notifyGenerationFinished() {
         val time = PerformanceCounter.currentTime() - generationStart
-        measurements += CodeGenerationMeasurement(files, lines, TimeUnit.NANOSECONDS.toMillis(time), additionalDescription)
+        measurements += CodeGenerationMeasurement(lines, TimeUnit.NANOSECONDS.toMillis(time))
     }
 
     open fun notifyIRTranslationStarted() {
         irTranslationStart = PerformanceCounter.currentTime()
     }
 
-    open fun notifyIRTranslationFinished(files: Int, lines: Int, additionalDescription: String?) {
+    open fun notifyIRTranslationFinished() {
         val time = deltaTime(irTranslationStart)
         measurements += IRMeasurement(
-            files,
             lines,
             TimeUnit.NANOSECONDS.toMillis(time),
-            additionalDescription,
-            IRMeasurement.Kind.Translation
+            IRMeasurement.Kind.TRANSLATION
         )
     }
 
@@ -83,14 +92,12 @@ abstract class CommonCompilerPerformanceManager(private val presentableName: Str
         irGenerationStart = PerformanceCounter.currentTime()
     }
 
-    open fun notifyIRGenerationFinished(files: Int, lines: Int, additionalDescription: String) {
+    open fun notifyIRGenerationFinished() {
         val time = deltaTime(irGenerationStart)
         measurements += IRMeasurement(
-            files,
             lines,
             TimeUnit.NANOSECONDS.toMillis(time),
-            additionalDescription,
-            IRMeasurement.Kind.Generation
+            IRMeasurement.Kind.GENERATION
         )
     }
 

compiler/cli/src/org/jetbrains/kotlin/cli/common/Usage.java

@@ -102,6 +102,6 @@ public class Usage {
 
     private static void appendln(@NotNull StringBuilder sb, @NotNull String string) {
         sb.append(string);
-        StringsKt.appendln(sb);
+        sb.append('\n');
     }
 }

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

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

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

@@ -9,54 +9,41 @@ interface PerformanceMeasurement {
     fun render(): String
 }
 
-
 class JitCompilationMeasurement(private val milliseconds: Long) : PerformanceMeasurement {
     override fun render(): String = "JIT time is $milliseconds ms"
 }
 
-
 class CompilerInitializationMeasurement(private val milliseconds: Long) : PerformanceMeasurement {
     override fun render(): String = "INIT: Compiler initialized in $milliseconds ms"
 }
 
-
-class CodeAnalysisMeasurement(val files: Int, val lines: Int, val milliseconds: Long, private val description: String?) :
-    PerformanceMeasurement {
-
-    val lps: Double = lines.toDouble() * 1000 / milliseconds
-
-    override fun render(): String =
-        "ANALYZE: $files files ($lines lines) ${description ?: ""}in $milliseconds ms - ${"%.3f".format(lps)} loc/s"
+class CodeAnalysisMeasurement(private val lines: Int?, val milliseconds: Long) : PerformanceMeasurement {
+    override fun render(): String = formatMeasurement("ANALYZE", milliseconds, lines)
 }
 
-
-class CodeGenerationMeasurement(private val files: Int, val lines: Int, private val milliseconds: Long, private val description: String?) :
-    PerformanceMeasurement {
-
-    private val speed: Double = lines.toDouble() * 1000 / milliseconds
-
-    override fun render(): String =
-        "GENERATE: $files files ($lines lines) ${description}in $milliseconds ms - ${"%.3f".format(speed)} loc/s"
+class CodeGenerationMeasurement(private val lines: Int?, private val milliseconds: Long) : PerformanceMeasurement {
+    override fun render(): String = formatMeasurement("GENERATE", milliseconds, lines)
 }
 
-
 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"
+class IRMeasurement(val lines: Int?, val milliseconds: Long, val kind: Kind) : PerformanceMeasurement {
+    override fun render(): String = formatMeasurement("IR $kind", milliseconds, lines)
 
     enum class Kind {
-        Generation, Translation
+        TRANSLATION, GENERATION
     }
 }
+
+private fun formatMeasurement(name: String, time: Long, lines: Int?): String =
+    "%15s%8s ms".format(name, time) +
+            (lines?.let {
+                val lps = it.toDouble() * 1000 / time
+                "%12.3f loc/s".format(lps)
+            } ?: "")

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

@@ -147,9 +147,14 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
                 ModuleChunk(listOf(module))
             }
 
-            KotlinToJVMBytecodeCompiler.configureSourceRoots(configuration, moduleChunk.modules, buildFile)
-            val environment = createCoreEnvironment(rootDisposable, configuration, messageCollector)
-                ?: return COMPILATION_ERROR
+            val chunk = moduleChunk.modules
+            KotlinToJVMBytecodeCompiler.configureSourceRoots(configuration, chunk, buildFile)
+            val environment = createCoreEnvironment(
+                rootDisposable, configuration, messageCollector,
+                chunk.map { input -> input.getModuleName() + "-" + input.getModuleType() }.let { names ->
+                    names.singleOrNull() ?: names.joinToString()
+                }
+            ) ?: return COMPILATION_ERROR
             environment.registerJavacIfNeeded(arguments).let {
                 if (!it) return COMPILATION_ERROR
             }
@@ -161,7 +166,7 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
                 return COMPILATION_ERROR
             }
 
-            KotlinToJVMBytecodeCompiler.compileModules(environment, buildFile, moduleChunk.modules)
+            KotlinToJVMBytecodeCompiler.compileModules(environment, buildFile, chunk)
             return OK
         } catch (e: CompilationException) {
             messageCollector.report(
@@ -213,13 +218,17 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
     private fun createCoreEnvironment(
         rootDisposable: Disposable,
         configuration: CompilerConfiguration,
-        messageCollector: MessageCollector
+        messageCollector: MessageCollector,
+        targetDescription: String
     ): KotlinCoreEnvironment? {
         if (messageCollector.hasErrors()) return null
 
         val environment = KotlinCoreEnvironment.createForProduction(rootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
 
-        configuration[CLIConfigurationKeys.PERF_MANAGER]?.notifyCompilerInitialized()
+        val sourceFiles = environment.getSourceFiles()
+        configuration[CLIConfigurationKeys.PERF_MANAGER]?.notifyCompilerInitialized(
+            sourceFiles.size, environment.countLinesOfCode(sourceFiles), targetDescription
+        )
 
         return if (messageCollector.hasErrors()) null else environment
     }

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

@@ -38,7 +38,7 @@ class CliKotlinAsJavaSupport(
     override fun getFacadeClassesInPackage(packageFqName: FqName, scope: GlobalSearchScope): Collection<PsiClass> {
         return findFacadeFilesInPackage(packageFqName, scope)
             .groupBy { it.javaFileFacadeFqName }
-            .mapNotNull { (facadeClassFqName, files) ->
+            .mapNotNull { (facadeClassFqName, _) ->
                 KtLightClassForFacade.createForFacade(psiManager, facadeClassFqName, scope)
             }
     }

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

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

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

@@ -608,7 +608,10 @@ class KotlinCoreEnvironment private constructor(
         // made public for Upsource
         @JvmStatic
         @Deprecated("Use registerProjectServices(project) instead.", ReplaceWith("registerProjectServices(projectEnvironment.project)"))
-        fun registerProjectServices(projectEnvironment: JavaCoreProjectEnvironment, messageCollector: MessageCollector?) {
+        fun registerProjectServices(
+            projectEnvironment: JavaCoreProjectEnvironment,
+            @Suppress("UNUSED_PARAMETER") messageCollector: MessageCollector?
+        ) {
             registerProjectServices(projectEnvironment.project)
         }
 

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

@@ -52,12 +52,18 @@ import org.jetbrains.kotlin.codegen.KotlinCodegenFacade
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.codegen.state.GenerationStateEventCallback
 import org.jetbrains.kotlin.config.*
+import org.jetbrains.kotlin.diagnostics.*
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
+import org.jetbrains.kotlin.fir.FirPsiSourceElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.analysis.collectors.FirDiagnosticsCollector
+import org.jetbrains.kotlin.fir.analysis.diagnostics.*
+import org.jetbrains.kotlin.fir.analysis.registerExtendedCheckersComponent
 import org.jetbrains.kotlin.fir.backend.Fir2IrConverter
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendClassResolver
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmClassCodegen
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmKotlinMangler
+import org.jetbrains.kotlin.fir.backend.jvm.FirJvmVisibilityConverter
 import org.jetbrains.kotlin.fir.builder.RawFirBuilder
 import org.jetbrains.kotlin.fir.extensions.BunchOfRegisteredExtensions
 import org.jetbrains.kotlin.fir.extensions.extensionService
@@ -71,6 +77,7 @@ import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveProcessor
 import org.jetbrains.kotlin.idea.MainFunctionDetector
 import org.jetbrains.kotlin.ir.backend.jvm.jvmResolveLibraries
 import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmManglerDesc
+import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.javac.JavacWrapper
 import org.jetbrains.kotlin.load.kotlin.ModuleVisibilityManager
 import org.jetbrains.kotlin.modules.Module
@@ -82,6 +89,7 @@ import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.PlatformDependentAnalyzerServices
+import org.jetbrains.kotlin.resolve.diagnostics.SimpleDiagnostics
 import org.jetbrains.kotlin.resolve.jvm.KotlinJavaPsiFacade
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformAnalyzerServices
 import org.jetbrains.kotlin.utils.newLinkedHashMapWithExpectedSize
@@ -192,12 +200,11 @@ object KotlinToJVMBytecodeCompiler {
 
         val projectConfiguration = environment.configuration
         if (projectConfiguration.getBoolean(CommonConfigurationKeys.USE_FIR)) {
-            return compileModulesUsingFrontendIR(environment, buildFile, chunk)
+            val extendedAnalysisMode = projectConfiguration.getBoolean(CommonConfigurationKeys.USE_FIR_EXTENDED_CHECKERS)
+            return compileModulesUsingFrontendIR(environment, buildFile, chunk, extendedAnalysisMode)
         }
 
-        val targetDescription = "in targets [" + chunk.joinToString { input -> input.getModuleName() + "-" + input.getModuleType() } + "]"
-
-        val result = repeatAnalysisIfNeeded(analyze(environment, targetDescription), environment, targetDescription)
+        val result = repeatAnalysisIfNeeded(analyze(environment), environment)
         if (result == null || !result.shouldGenerateCode) return false
 
         ProgressIndicatorAndCompilationCanceledStatus.checkCanceled()
@@ -302,7 +309,12 @@ object KotlinToJVMBytecodeCompiler {
         configuration.addAll(JVMConfigurationKeys.MODULES, chunk)
     }
 
-    private fun compileModulesUsingFrontendIR(environment: KotlinCoreEnvironment, buildFile: File?, chunk: List<Module>): Boolean {
+    private fun compileModulesUsingFrontendIR(
+        environment: KotlinCoreEnvironment,
+        buildFile: File?,
+        chunk: List<Module>,
+        extendedAnalysisMode: Boolean
+    ): Boolean {
         val project = environment.project
         val performanceManager = environment.configuration.get(CLIConfigurationKeys.PERF_MANAGER)
 
@@ -351,25 +363,40 @@ object KotlinToJVMBytecodeCompiler {
                     project, environment.createPackagePartProvider(librariesScope)
                 )
                 it.extensionService.registerExtensions(BunchOfRegisteredExtensions.empty())
+                if (extendedAnalysisMode) {
+                    it.registerExtendedCheckersComponent()
+                }
             }
             val firProvider = (session.firProvider as FirProviderImpl)
             val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider, stubMode = false)
             val resolveTransformer = FirTotalResolveProcessor(session)
+            val collector = FirDiagnosticsCollector.create(session)
+            val firDiagnostics = mutableListOf<FirDiagnostic<*>>()
             val firFiles = ktFiles.map {
                 val firFile = builder.buildFirFile(it)
                 firProvider.recordFile(firFile)
                 firFile
-            }.also {
+            }.also { firFiles ->
                 try {
-                    resolveTransformer.process(it)
+                    resolveTransformer.process(firFiles)
+                    firFiles.forEach {
+                        firDiagnostics += collector.collectDiagnostics(it)
+                    }
                 } catch (e: Exception) {
                     throw e
                 }
             }
+            AnalyzerWithCompilerReport.reportDiagnostics(
+                SimpleDiagnostics(
+                    firDiagnostics.map { it.toRegularDiagnostic() }
+                ),
+                environment.messageCollector
+            )
+            performanceManager?.notifyAnalysisFinished()
 
-            val debugTargetDescription = "target " + module.getModuleName() + "-" + module.getModuleType() + " "
-            val codeLines = environment.countLinesOfCode(ktFiles)
-            performanceManager?.notifyAnalysisFinished(ktFiles.size, codeLines, debugTargetDescription)
+            if (firDiagnostics.any { it.severity == Severity.ERROR }) {
+                return false
+            }
 
             performanceManager?.notifyGenerationStarted()
             val signaturer = IdSignatureDescriptor(JvmManglerDesc())
@@ -378,12 +405,12 @@ object KotlinToJVMBytecodeCompiler {
             val (moduleFragment, symbolTable, sourceManager, components) =
                 Fir2IrConverter.createModuleFragment(
                     session, resolveTransformer.scopeSession, firFiles,
-                    moduleConfiguration.languageVersionSettings, signaturer = signaturer,
-                    generatorExtensions = JvmGeneratorExtensions(),
-                    mangler = FirJvmKotlinMangler(session)
+                    moduleConfiguration.languageVersionSettings, signaturer,
+                    JvmGeneratorExtensions(), FirJvmKotlinMangler(session), IrFactoryImpl,
+                    FirJvmVisibilityConverter
                 )
 
-            performanceManager?.notifyIRTranslationFinished(ktFiles.size, codeLines, debugTargetDescription)
+            performanceManager?.notifyIRTranslationFinished()
 
             val dummyBindingContext = NoScopeRecordCliBindingTrace().bindingContext
 
@@ -415,11 +442,6 @@ object KotlinToJVMBytecodeCompiler {
             }
             CodegenFactory.doCheckCancelled(generationState)
             generationState.factory.done()
-            performanceManager?.notifyGenerationFinished(
-                ktFiles.size,
-                codeLines,
-                additionalDescription = debugTargetDescription
-            )
 
             ProgressIndicatorAndCompilationCanceledStatus.checkCanceled()
 
@@ -435,13 +457,37 @@ object KotlinToJVMBytecodeCompiler {
                 generationState.extraJvmDiagnosticsTrace.bindingContext, environment.messageCollector
             )
 
-            performanceManager?.notifyIRGenerationFinished(ktFiles.size, codeLines, additionalDescription = debugTargetDescription)
+            performanceManager?.notifyIRGenerationFinished()
+            performanceManager?.notifyGenerationFinished()
             ProgressIndicatorAndCompilationCanceledStatus.checkCanceled()
             outputs[module] = generationState
         }
         return writeOutputs(environment, projectConfiguration, chunk, outputs)
     }
 
+    private fun FirDiagnostic<*>.toRegularDiagnostic(): Diagnostic {
+        val psiSource = element as FirPsiSourceElement<*>
+        @Suppress("TYPE_MISMATCH")
+        when (this) {
+            is FirSimpleDiagnostic ->
+                return SimpleDiagnostic(
+                    psiSource.psi, factory.psiDiagnosticFactory, severity
+                )
+            is FirDiagnosticWithParameters1<*, *> ->
+                return DiagnosticWithParameters1(
+                    psiSource.psi, this.a, factory.psiDiagnosticFactory, severity
+                )
+            is FirDiagnosticWithParameters2<*, *, *> ->
+                return DiagnosticWithParameters2(
+                    psiSource.psi, this.a, this.b, factory.psiDiagnosticFactory, severity
+                )
+            is FirDiagnosticWithParameters3<*, *, *, *> ->
+                return DiagnosticWithParameters3(
+                    psiSource.psi, this.a, this.b, this.c, factory.psiDiagnosticFactory, severity
+                )
+        }
+    }
+
     private fun getBuildFilePaths(buildFile: File?, sourceFilePaths: List<String>): List<String> =
         if (buildFile == null) sourceFilePaths
         else sourceFilePaths.map { path ->
@@ -484,11 +530,7 @@ object KotlinToJVMBytecodeCompiler {
         }
     }
 
-    private fun repeatAnalysisIfNeeded(
-        result: AnalysisResult?,
-        environment: KotlinCoreEnvironment,
-        targetDescription: String?
-    ): AnalysisResult? {
+    private fun repeatAnalysisIfNeeded(result: AnalysisResult?, environment: KotlinCoreEnvironment): AnalysisResult? {
         if (result is AnalysisResult.RetryWithAdditionalRoots) {
             val configuration = environment.configuration
 
@@ -511,7 +553,7 @@ object KotlinToJVMBytecodeCompiler {
             configuration[CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY]?.clear()
 
             // Repeat analysis with additional Java roots (kapt generated sources)
-            return analyze(environment, targetDescription)
+            return analyze(environment)
         }
 
         return result
@@ -519,7 +561,7 @@ object KotlinToJVMBytecodeCompiler {
 
     @Suppress("MemberVisibilityCanBePrivate") // Used in ExecuteKotlinScriptMojo
     fun analyzeAndGenerate(environment: KotlinCoreEnvironment): GenerationState? {
-        val result = repeatAnalysisIfNeeded(analyze(environment, null), environment, null) ?: return null
+        val result = repeatAnalysisIfNeeded(analyze(environment), environment) ?: return null
 
         if (!result.shouldGenerateCode) return null
 
@@ -528,7 +570,7 @@ object KotlinToJVMBytecodeCompiler {
         return generate(environment, environment.configuration, result, environment.getSourceFiles(), null)
     }
 
-    fun analyze(environment: KotlinCoreEnvironment, targetDescription: String?): AnalysisResult? {
+    fun analyze(environment: KotlinCoreEnvironment): AnalysisResult? {
         val sourceFiles = environment.getSourceFiles()
         val collector = environment.messageCollector
 
@@ -561,7 +603,7 @@ object KotlinToJVMBytecodeCompiler {
             )
         }
 
-        performanceManager?.notifyAnalysisFinished(sourceFiles.size, environment.countLinesOfCode(sourceFiles), targetDescription)
+        performanceManager?.notifyAnalysisFinished()
 
         val analysisResult = analyzerWithCompilerReport.analysisResult
 
@@ -642,11 +684,7 @@ object KotlinToJVMBytecodeCompiler {
 
         KotlinCodegenFacade.compileCorrectFiles(generationState)
 
-        performanceManager?.notifyGenerationFinished(
-            sourceFiles.size,
-            environment.countLinesOfCode(sourceFiles),
-            additionalDescription = if (module != null) "target " + module.getModuleName() + "-" + module.getModuleType() + " " else ""
-        )
+        performanceManager?.notifyGenerationFinished()
 
         ProgressIndicatorAndCompilationCanceledStatus.checkCanceled()
 

compiler/compiler-runner/src/org/jetbrains/kotlin/compilerRunner/KotlinCompilerRunnerUtils.kt

@@ -49,7 +49,7 @@ object KotlinCompilerRunnerUtils {
         additionalJvmParams: Array<String> = arrayOf()
     ): CompileServiceSession? {
         val daemonJVMOptions = configureDaemonJVMOptions(
-            additionalParams = *additionalJvmParams,
+            additionalParams = additionalJvmParams,
             inheritMemoryLimits = true,
             inheritOtherJvmOptions = false,
             inheritAdditionalProperties = true

compiler/config/build.gradle.kts

@@ -4,7 +4,8 @@ plugins {
 }
 
 dependencies {
-    api(project(":core:deserialization"))
+    api(project(":core:metadata"))
+    api(project(":core:compiler.common"))
     api(project(":compiler:util"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
 }

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

@@ -50,6 +50,9 @@ object CommonConfigurationKeys {
 
     @JvmField
     val DESERIALIZE_FAKE_OVERRIDES = CompilerConfigurationKey.create<Boolean>("Deserialize fake overrides")
+
+    @JvmField
+    val USE_FIR_EXTENDED_CHECKERS = CompilerConfigurationKey.create<Boolean>("fir extended checkers")
 }
 
 var CompilerConfiguration.languageVersionSettings: LanguageVersionSettings

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

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.config
 
+import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.DescriptorUtils
 
 fun LanguageVersionSettings.coroutinesPackageFqName(): FqName {
     return coroutinesPackageFqName(isReleaseCoroutines())
@@ -17,9 +17,9 @@ fun LanguageVersionSettings.isReleaseCoroutines() = supportsFeature(LanguageFeat
 
 private fun coroutinesPackageFqName(isReleaseCoroutines: Boolean): FqName {
     return if (isReleaseCoroutines)
-        DescriptorUtils.COROUTINES_PACKAGE_FQ_NAME_RELEASE
+        StandardNames.COROUTINES_PACKAGE_FQ_NAME_RELEASE
     else
-        DescriptorUtils.COROUTINES_PACKAGE_FQ_NAME_EXPERIMENTAL
+        StandardNames.COROUTINES_PACKAGE_FQ_NAME_EXPERIMENTAL
 }
 
 fun LanguageVersionSettings.coroutinesIntrinsicsPackageFqName() =
@@ -33,7 +33,7 @@ fun LanguageVersionSettings.restrictsSuspensionFqName() =
 
 fun FqName.isBuiltInCoroutineContext(languageVersionSettings: LanguageVersionSettings) =
     if (languageVersionSettings.supportsFeature(LanguageFeature.ReleaseCoroutines))
-        this == DescriptorUtils.COROUTINES_PACKAGE_FQ_NAME_RELEASE.child(Name.identifier("coroutineContext"))
+        this == StandardNames.COROUTINES_PACKAGE_FQ_NAME_RELEASE.child(Name.identifier("coroutineContext"))
     else
-        this == DescriptorUtils.COROUTINES_PACKAGE_FQ_NAME_EXPERIMENTAL.child(Name.identifier("coroutineContext")) ||
-                this == DescriptorUtils.COROUTINES_INTRINSICS_PACKAGE_FQ_NAME_EXPERIMENTAL.child(Name.identifier("coroutineContext"))
+        this == StandardNames.COROUTINES_PACKAGE_FQ_NAME_EXPERIMENTAL.child(Name.identifier("coroutineContext")) ||
+                this == StandardNames.COROUTINES_INTRINSICS_PACKAGE_FQ_NAME_EXPERIMENTAL.child(Name.identifier("coroutineContext"))

compiler/container/src/org/jetbrains/kotlin/container/Registry.kt

@@ -79,6 +79,7 @@ internal class ComponentRegistry {
         By mimicking the usual descriptors we get lazy evaluation and consistency checks for free.
          */
         for (resolver in clashResolvers) {
+            @Suppress("UNCHECKED_CAST")
             val clashedComponents = registrationMap[resolver.applicableTo] as? Collection<ComponentDescriptor> ?: continue
             if (clashedComponents.size <= 1) continue
 
@@ -86,4 +87,4 @@ internal class ComponentRegistry {
             registrationMap[resolver.applicableTo] = substituteDescriptor
         }
     }
-}
+}

compiler/container/src/org/jetbrains/kotlin/container/Singletons.kt

@@ -153,6 +153,7 @@ internal class ClashResolutionDescriptor<E : PlatformSpecificExtension<E>>(
 
     override fun createInstance(context: ValueResolveContext): Any {
         state = ComponentState.Initializing
+        @Suppress("UNCHECKED_CAST")
         val extensions = computeArguments(clashedComponents) as List<E>
         val resolution = resolver.resolveExtensionsClash(extensions)
         state = ComponentState.Initialized

compiler/daemon/daemon-client-new/build.gradle.kts

@@ -1,5 +1,3 @@
-import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
-
 description = "Kotlin Daemon Client New"
 
 plugins {
@@ -49,6 +47,12 @@ dependencies {
     }
 }
 
+tasks.withType<org.jetbrains.kotlin.gradle.dsl.KotlinCompile<*>> {
+    kotlinOptions {
+        apiVersion = "1.3"
+    }
+}
+
 sourceSets {
     "main" { projectDefault() }
     "test" {}

compiler/daemon/daemon-client-new/src/org/jetbrains/kotlin/daemon/client/experimental/KotlinCompilerClient.kt

@@ -297,13 +297,13 @@ class KotlinCompilerClient : KotlinCompilerDaemonClient {
                     log.info("Executing daemon compilation with args: " + filteredArgs.joinToString(" "))
                     val servicesFacade =
                         CompilerCallbackServicesFacadeServerServerSide()
-                    val serverRun = servicesFacade.runServer()
+                    servicesFacade.runServer()
                     try {
                         val memBefore = daemon.getUsedMemory().get() / 1024
                         val startTime = System.nanoTime()
 
                         val compResults = createCompResults()
-                        val compResultsServerRun = compResults.runServer()
+                        compResults.runServer()
                         val res = daemon.compile(
                             CompileService.NO_SESSION,
                             filteredArgs.toList().toTypedArray(),
@@ -373,7 +373,6 @@ class KotlinCompilerClient : KotlinCompilerDaemonClient {
 
     // --- Implementation ---------------------------------------
 
-    @Synchronized
     private inline fun <R> connectLoop(reportingTargets: DaemonReportingTargets, autostart: Boolean, body: (Boolean) -> R?): R? {
         try {
             var attempts = 1
@@ -544,6 +543,7 @@ class KotlinCompilerClient : KotlinCompilerDaemonClient {
             // assuming that all important output is already done, the rest should be routed to the log by the daemon itself
             if (stdoutThread.isAlive) {
                 // TODO: find better method to stop the thread, but seems it will require asynchronous consuming of the stream
+                @Suppress("DEPRECATION")
                 stdoutThread.stop()
             }
             reportingTargets.out?.flush()

compiler/daemon/daemon-client/build.gradle.kts

@@ -38,6 +38,13 @@ dependencies {
     }
 }
 
+tasks.withType<org.jetbrains.kotlin.gradle.dsl.KotlinCompile<*>> {
+    kotlinOptions {
+        // This module is being run from within Gradle, older versions of which only have kotlin-stdlib 1.3 in the runtime classpath.
+        apiVersion = "1.3"
+    }
+}
+
 sourceSets {
     "main" { projectDefault() }
     "test" {}

compiler/daemon/daemon-client/src/org/jetbrains/kotlin/daemon/client/CompilerCallbackServicesFacadeServer.kt

@@ -31,7 +31,6 @@ import org.jetbrains.kotlin.utils.isProcessCanceledException
 import java.io.File
 import java.rmi.server.UnicastRemoteObject
 
-
 open class CompilerCallbackServicesFacadeServer(
     val incrementalCompilationComponents: IncrementalCompilationComponents? = null,
     val lookupTracker: LookupTracker? = null,
@@ -40,7 +39,7 @@ open class CompilerCallbackServicesFacadeServer(
     val incrementalResultsConsumer: IncrementalResultsConsumer? = null,
     val incrementalDataProvider: IncrementalDataProvider? = null,
     port: Int = SOCKET_ANY_FREE_PORT
-) : CompilerCallbackServicesFacade,
+) : @Suppress("DEPRECATION") CompilerCallbackServicesFacade,
     UnicastRemoteObject(
         port,
         LoopbackNetworkInterface.clientLoopbackSocketFactory,

compiler/daemon/daemon-client/src/org/jetbrains/kotlin/daemon/client/KotlinCompilerClient.kt

@@ -63,7 +63,7 @@ object KotlinCompilerClient {
                                 daemonOptions: DaemonOptions,
                                 reportingTargets: DaemonReportingTargets,
                                 autostart: Boolean = true,
-                                checkId: Boolean = true
+                                @Suppress("UNUSED_PARAMETER") checkId: Boolean = true
     ): CompileService? {
         val flagFile = getOrCreateClientFlagFile(daemonOptions)
         return connectToCompileService(compilerId, flagFile, daemonJVMOptions, daemonOptions, reportingTargets, autostart)
@@ -142,6 +142,7 @@ object KotlinCompilerClient {
         compilerService.releaseCompileSession(sessionId)
     }
 
+    @Suppress("DEPRECATION")
     @Deprecated("Use other compile method", ReplaceWith("compile"))
     fun compile(compilerService: CompileService,
                 sessionId: Int,
@@ -156,6 +157,7 @@ object KotlinCompilerClient {
     }
 
 
+    @Suppress("DEPRECATION")
     @Deprecated("Use non-deprecated compile method", ReplaceWith("compile"))
     fun incrementalCompile(compileService: CompileService,
                            sessionId: Int,
@@ -277,6 +279,7 @@ object KotlinCompilerClient {
                     val memBefore = daemon.getUsedMemory().get() / 1024
                     val startTime = System.nanoTime()
 
+                    @Suppress("DEPRECATION")
                     val res = daemon.remoteCompile(CompileService.NO_SESSION, CompileService.TargetPlatform.JVM, filteredArgs.toList().toTypedArray(), servicesFacade, outStrm, CompileService.OutputFormat.PLAIN, outStrm, null)
 
                     val endTime = System.nanoTime()
@@ -308,8 +311,9 @@ object KotlinCompilerClient {
 
     // --- Implementation ---------------------------------------
 
-    @Synchronized
-    private inline fun <R> connectLoop(reportingTargets: DaemonReportingTargets, autostart: Boolean, body: (Boolean) -> R?): R? {
+    private inline fun <R> connectLoop(
+        reportingTargets: DaemonReportingTargets, autostart: Boolean, body: (Boolean) -> R?
+    ): R? = synchronized(this) {
         try {
             var attempts = 1
             while (true) {

compiler/daemon/daemon-common-new/src/org/jetbrains/kotlin/daemon/common/experimental/CompileServiceClientSideImpl.kt

@@ -43,11 +43,12 @@ class CompileServiceClientSideImpl(
             } ?: false
 
         override suspend fun clientHandshake(input: ByteReadChannelWrapper, output: ByteWriteChannelWrapper, log: Logger): Boolean {
-            return trySendHandshakeMessage(output, log) && tryAcquireHandshakeMessage(input, log)
+            return trySendHandshakeMessage(output) && tryAcquireHandshakeMessage(input)
         }
 
         override fun startKeepAlives() {
             val keepAliveMessage = Server.KeepAliveMessage<CompileServiceServerSide>()
+            @OptIn(ObsoleteCoroutinesApi::class)
             GlobalScope.async(newSingleThreadContext("keepAliveThread")) {
                 delay(KEEPALIVE_PERIOD * 4)
                 while (true) {
@@ -185,7 +186,7 @@ class CompileServiceClientSideImpl(
     }
 
     override suspend fun clearJarCache() {
-        val id = sendMessage(ClearJarCacheMessage())
+        sendMessage(ClearJarCacheMessage())
     }
 
     override suspend fun releaseReplSession(sessionId: Int): CompileService.CallResult<Nothing> {

compiler/daemon/daemon-common-new/src/org/jetbrains/kotlin/daemon/common/experimental/CompileServiceRMIWrapper.kt

@@ -8,10 +8,8 @@ package org.jetbrains.kotlin.daemon.common.experimental
 import kotlinx.coroutines.runBlocking
 import org.jetbrains.kotlin.cli.common.repl.ReplCodeLine
 import org.jetbrains.kotlin.daemon.common.*
-import org.jetbrains.kotlin.daemon.common.LoopbackNetworkInterface
 import org.jetbrains.kotlin.daemon.common.experimental.socketInfrastructure.Client
 import org.jetbrains.kotlin.daemon.common.experimental.socketInfrastructure.DefaultClientRMIWrapper
-import org.jetbrains.kotlin.daemon.common.*
 import java.io.File
 import java.io.Serializable
 import java.rmi.NoSuchObjectException
@@ -74,6 +72,7 @@ class CompileServiceRMIWrapper(val server: CompileServiceServerSide, daemonOptio
         server.scheduleShutdown(graceful)
     }
 
+    @Suppress("OverridingDeprecatedMember", "DEPRECATION")
     override fun remoteCompile(
         sessionId: Int,
         targetPlatform: CompileService.TargetPlatform,
@@ -85,6 +84,7 @@ class CompileServiceRMIWrapper(val server: CompileServiceServerSide, daemonOptio
         operationsTracer: RemoteOperationsTracer?
     ) = deprecated()
 
+    @Suppress("OverridingDeprecatedMember", "DEPRECATION")
     override fun remoteIncrementalCompile(
         sessionId: Int,
         targetPlatform: CompileService.TargetPlatform,
@@ -123,6 +123,7 @@ class CompileServiceRMIWrapper(val server: CompileServiceServerSide, daemonOptio
         server.clearJarCache()
     }
 
+    @Suppress("OverridingDeprecatedMember", "DEPRECATION")
     override fun leaseReplSession(
         aliveFlagPath: String?,
         targetPlatform: CompileService.TargetPlatform,

compiler/daemon/daemon-common-new/src/org/jetbrains/kotlin/daemon/common/experimental/NetworkUtils.kt

@@ -5,24 +5,25 @@
 
 package org.jetbrains.kotlin.daemon.common.experimental
 
-import io.ktor.network.selector.ActorSelectorManager
-import io.ktor.network.sockets.aSocket
-import kotlinx.coroutines.*
+import io.ktor.network.selector.*
+import io.ktor.network.sockets.*
+import io.ktor.util.*
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runBlocking
+import org.jetbrains.kotlin.daemon.common.LoopbackNetworkInterface
 import org.jetbrains.kotlin.daemon.common.experimental.socketInfrastructure.ServerSocketWrapper
-import org.jetbrains.kotlin.daemon.common.*
 import java.io.IOException
 import java.io.Serializable
-import java.net.*
-import java.rmi.server.RMIClientSocketFactory
-import java.rmi.server.RMIServerSocketFactory
+import java.net.InetAddress
+import java.net.InetSocketAddress
 import java.util.*
 
-
 object LoopbackNetworkInterfaceKtor {
 
     val serverLoopbackSocketFactoryKtor by lazy { ServerLoopbackSocketFactoryKtor() }
     val clientLoopbackSocketFactoryKtor by lazy { ClientLoopbackSocketFactoryKtor() }
 
+    @KtorExperimentalAPI
     val selectorMgr = ActorSelectorManager(Dispatchers.IO)
 
     class ServerLoopbackSocketFactoryKtor : Serializable {
@@ -30,6 +31,7 @@ object LoopbackNetworkInterfaceKtor {
         override fun hashCode(): Int = super.hashCode()
 
         @Throws(IOException::class)
+        @OptIn(KtorExperimentalAPI::class)
         fun createServerSocket(port: Int) =
             aSocket(selectorMgr)
                 .tcp()
@@ -37,6 +39,7 @@ object LoopbackNetworkInterfaceKtor {
     }
 
     class ClientLoopbackSocketFactoryKtor : LoopbackNetworkInterface.AbstractClientLoopbackSocketFactory<io.ktor.network.sockets.Socket>() {
+        @OptIn(KtorExperimentalAPI::class)
         override fun socketCreate(host: String, port: Int): io.ktor.network.sockets.Socket =
             runBlocking { aSocket(selectorMgr).tcp().connect(InetSocketAddress(host, port)) }
     }
@@ -63,4 +66,4 @@ fun findPortForSocket(attempts: Int, portRangeStart: Int, portRangeEnd: Int): Se
         }
     }
     throw IllegalStateException("Cannot find free socketPort in $attempts attempts", lastException)
-}
+}

compiler/daemon/daemon-common-new/src/org/jetbrains/kotlin/daemon/common/experimental/socketInfrastructure/Client.kt

@@ -1,3 +1,8 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
 package org.jetbrains.kotlin.daemon.common.experimental.socketInfrastructure
 
 import io.ktor.network.sockets.Socket
@@ -114,6 +119,7 @@ abstract class DefaultAuthorizableClient<ServerType : ServerBase>(
         return actualResult as T
     }
 
+    @OptIn(ObsoleteCoroutinesApi::class, ExperimentalCoroutinesApi::class)
     override suspend fun connectToServer() {
 
         writeActor = GlobalScope.actor(capacity = Channel.UNLIMITED) {
@@ -242,7 +248,7 @@ class DefaultClient<ServerType : ServerBase>(
     serverHost: String = LoopbackNetworkInterface.loopbackInetAddressName
 ) : DefaultAuthorizableClient<ServerType>(serverPort, serverHost) {
     override suspend fun clientHandshake(input: ByteReadChannelWrapper, output: ByteWriteChannelWrapper, log: Logger) = true
-    override suspend fun authorizeOnServer(output: ByteWriteChannelWrapper): Boolean = true
+    override suspend fun authorizeOnServer(serverOutputChannel: ByteWriteChannelWrapper): Boolean = true
     override fun startKeepAlives() {}
     override fun delayKeepAlives() {}
 }

compiler/daemon/daemon-common-new/src/org/jetbrains/kotlin/daemon/common/experimental/socketInfrastructure/Server.kt

@@ -1,3 +1,8 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
 package org.jetbrains.kotlin.daemon.common.experimental.socketInfrastructure
 
 import io.ktor.network.sockets.ServerSocket
@@ -188,7 +193,7 @@ suspend fun <T> runWithTimeout(
 ): T? = withTimeoutOrNull(unit.toMillis(timeout)) { block() }
 
 //@Throws(ConnectionResetException::class)
-suspend fun tryAcquireHandshakeMessage(input: ByteReadChannelWrapper, log: Logger): Boolean {
+suspend fun tryAcquireHandshakeMessage(input: ByteReadChannelWrapper): Boolean {
     val bytes = runWithTimeout {
         input.nextBytes()
     } ?: return false
@@ -200,7 +205,7 @@ suspend fun tryAcquireHandshakeMessage(input: ByteReadChannelWrapper, log: Logge
 
 
 //@Throws(ConnectionResetException::class)
-suspend fun trySendHandshakeMessage(output: ByteWriteChannelWrapper, log: Logger): Boolean {
+suspend fun trySendHandshakeMessage(output: ByteWriteChannelWrapper): Boolean {
     runWithTimeout {
         output.writeBytesAndLength(FIRST_HANDSHAKE_BYTE_TOKEN.size, FIRST_HANDSHAKE_BYTE_TOKEN)
     } ?: return false

compiler/daemon/daemon-common-new/src/org/jetbrains/kotlin/daemon/common/experimental/socketInfrastructure/StreamWrappers.kt

@@ -1,9 +1,15 @@
+/*
+ * 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.daemon.common.experimental.socketInfrastructure
 
-import io.ktor.network.sockets.Socket
-import io.ktor.network.sockets.openReadChannel
-import io.ktor.network.sockets.openWriteChannel
-import kotlinx.coroutines.*
+import io.ktor.network.sockets.*
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.ObsoleteCoroutinesApi
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.channels.actor
 import kotlinx.coroutines.channels.consumeEach
@@ -45,6 +51,7 @@ class ByteReadChannelWrapper(readChannel: ByteReadChannel, private val log: Logg
         }
 
     // TODO : replace GlobalScope with something more explicit here and below.
+    @OptIn(ObsoleteCoroutinesApi::class, ExperimentalCoroutinesApi::class)
     private val readActor = GlobalScope.actor<ReadQuery>(capacity = Channel.UNLIMITED) {
         consumeEach { message ->
             if (!readChannel.isClosedForRead) {
@@ -145,6 +152,7 @@ class ByteWriteChannelWrapper(writeChannel: ByteWriteChannel, private val log: L
         }
     }
 
+    @OptIn(ObsoleteCoroutinesApi::class, ExperimentalCoroutinesApi::class)
     private val writeActor = GlobalScope.actor<WriteActorQuery>(capacity = Channel.UNLIMITED) {
         consumeEach { message ->
             if (!writeChannel.isClosedForWrite) {

compiler/daemon/daemon-common/src/org/jetbrains/kotlin/daemon/common/CompileService.kt

@@ -105,6 +105,7 @@ interface CompileService : Remote {
 
     // TODO: consider adding async version of shutdown and release
 
+    @Suppress("DEPRECATION")
     @Deprecated("The usages should be replaced with `compile` method", ReplaceWith("compile"))
     @Throws(RemoteException::class)
     fun remoteCompile(
@@ -118,6 +119,7 @@ interface CompileService : Remote {
             operationsTracer: RemoteOperationsTracer?
     ): CallResult<Int>
 
+    @Suppress("DEPRECATION")
     @Deprecated("The usages should be replaced with `compile` method", ReplaceWith("compile"))
     @Throws(RemoteException::class)
     fun remoteIncrementalCompile(
@@ -149,6 +151,7 @@ interface CompileService : Remote {
     @Throws(RemoteException::class)
     fun clearJarCache()
 
+    @Suppress("DEPRECATION")
     @Deprecated("The usages should be replaced with other `leaseReplSession` method", ReplaceWith("leaseReplSession"))
     @Throws(RemoteException::class)
     fun leaseReplSession(

compiler/daemon/daemon-common/src/org/jetbrains/kotlin/daemon/common/CompileServiceRMIWrapper.kt

@@ -23,6 +23,7 @@ class CompileServiceClientRMIWrapper(
     private fun reportNotImplemented(): Nothing = throw IllegalStateException("Unexpected call to deprecated method")
 
     // deprecated methods :
+    @Suppress("OverridingDeprecatedMember", "DEPRECATION")
     override fun remoteCompile(
         sessionId: Int,
         targetPlatform: CompileService.TargetPlatform,
@@ -36,6 +37,7 @@ class CompileServiceClientRMIWrapper(
         reportNotImplemented()
     }
 
+    @Suppress("OverridingDeprecatedMember", "DEPRECATION")
     override fun remoteIncrementalCompile(
         sessionId: Int,
         targetPlatform: CompileService.TargetPlatform,
@@ -49,6 +51,7 @@ class CompileServiceClientRMIWrapper(
         reportNotImplemented()
     }
 
+    @Suppress("OverridingDeprecatedMember", "DEPRECATION")
     override fun leaseReplSession(
         aliveFlagPath: String?,
         targetPlatform: CompileService.TargetPlatform,
@@ -66,10 +69,12 @@ class CompileServiceClientRMIWrapper(
         reportNotImplemented()
     }
 
+    @Suppress("OverridingDeprecatedMember")
     override fun remoteReplLineCheck(sessionId: Int, codeLine: ReplCodeLine): CompileService.CallResult<ReplCheckResult> {
         reportNotImplemented()
     }
 
+    @Suppress("OverridingDeprecatedMember")
     override fun remoteReplLineCompile(
         sessionId: Int,
         codeLine: ReplCodeLine,
@@ -78,6 +83,7 @@ class CompileServiceClientRMIWrapper(
         reportNotImplemented()
     }
 
+    @Suppress("OverridingDeprecatedMember")
     override fun remoteReplLineEval(
         sessionId: Int,
         codeLine: ReplCodeLine,

compiler/daemon/daemon-common/src/org/jetbrains/kotlin/daemon/common/DaemonParams.kt

@@ -329,7 +329,7 @@ fun configureDaemonJVMOptions(vararg additionalParams: String,
                               inheritAdditionalProperties: Boolean
 ): DaemonJVMOptions =
         configureDaemonJVMOptions(DaemonJVMOptions(),
-                                  additionalParams = *additionalParams,
+                                  additionalParams = additionalParams,
                                   inheritMemoryLimits = inheritMemoryLimits,
                                   inheritOtherJvmOptions = inheritOtherJvmOptions,
                                   inheritAdditionalProperties = inheritAdditionalProperties)

compiler/daemon/daemon-common/src/org/jetbrains/kotlin/daemon/common/JpsCompilerServicesFacade.kt

@@ -16,4 +16,5 @@
 
 package org.jetbrains.kotlin.daemon.common
 
-interface JpsCompilerServicesFacade : CompilerServicesFacadeBase, CompilerCallbackServicesFacade
+@Suppress("DEPRECATION")
+interface JpsCompilerServicesFacade : CompilerServicesFacadeBase, CompilerCallbackServicesFacade

compiler/daemon/daemon-common/src/org/jetbrains/kotlin/daemon/common/PerfUtils.kt

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+@file:Suppress("NOTHING_TO_INLINE")
+
 package org.jetbrains.kotlin.daemon.common
 
 import java.lang.management.ManagementFactory
@@ -101,7 +103,7 @@ inline fun endMeasureWallTime(perfCounters: PerfCounters, startState: List<Long>
 }
 
 
-inline fun beginMeasureWallAndThreadTimes(perfCounters: PerfCounters, threadMXBean: ThreadMXBean): List<Long> {
+inline fun beginMeasureWallAndThreadTimes(threadMXBean: ThreadMXBean): List<Long> {
     val startTime = System.nanoTime()
     val startThreadTime = threadMXBean.threadCpuTime()
     val startThreadUserTime = threadMXBean.threadUserTime()
@@ -117,12 +119,7 @@ inline fun endMeasureWallAndThreadTimes(perfCounters: PerfCounters, threadMXBean
                                 threadUser = threadMXBean.threadUserTime() - startThreadUserTime)
 }
 
-inline fun beginMeasureWallAndThreadTimes(perfCounters: PerfCounters) =
-    beginMeasureWallAndThreadTimes(perfCounters, ManagementFactory.getThreadMXBean())
-inline fun endMeasureWallAndThreadTimes(perfCounters: PerfCounters, startState: List<Long>) =
-    endMeasureWallAndThreadTimes(perfCounters, ManagementFactory.getThreadMXBean(), startState)
-
-inline fun beginMeasureWallAndThreadTimesAndMemory(perfCounters: PerfCounters, withGC: Boolean = false, threadMXBean: ThreadMXBean): List<Long> {
+inline fun beginMeasureWallAndThreadTimesAndMemory(withGC: Boolean = false, threadMXBean: ThreadMXBean): List<Long> {
     val startMem = usedMemory(withGC)
     val startTime = System.nanoTime()
     val startThreadTime = threadMXBean.threadCpuTime()
@@ -141,13 +138,6 @@ inline fun endMeasureWallAndThreadTimesAndMemory(perfCounters: PerfCounters, wit
                                 memory = usedMemory(withGC) - startMem)
 }
 
-inline fun<R> beginMeasureWallAndThreadTimesAndMemory(perfCounters: PerfCounters, withGC: Boolean) =
-    beginMeasureWallAndThreadTimesAndMemory(perfCounters, withGC, ManagementFactory.getThreadMXBean())
-
-inline fun<R> endMeasureWallAndThreadTimesAndMemory(perfCounters: PerfCounters, withGC: Boolean, startState: List<Long>) =
-    endMeasureWallAndThreadTimesAndMemory(perfCounters, withGC, ManagementFactory.getThreadMXBean(), startState)
-
-
 class DummyProfiler : Profiler {
     override fun getCounters(): Map<Any?, PerfCounters> = mapOf(null to SimplePerfCounters())
     override fun getTotalCounters(): PerfCounters = SimplePerfCounters()
@@ -174,7 +164,7 @@ class WallTotalProfiler : TotalProfiler() {
 
 class WallAndThreadTotalProfiler : TotalProfiler() {
     @Suppress("OVERRIDE_BY_INLINE")
-    override inline fun beginMeasure(obj: Any?) = beginMeasureWallAndThreadTimes(total, threadMXBean)
+    override inline fun beginMeasure(obj: Any?) = beginMeasureWallAndThreadTimes(threadMXBean)
     @Suppress("OVERRIDE_BY_INLINE")
     override inline fun endMeasure(obj: Any?, startState: List<Long>) = endMeasureWallAndThreadTimes(total, threadMXBean, startState)
 }
@@ -183,7 +173,7 @@ class WallAndThreadTotalProfiler : TotalProfiler() {
 class WallAndThreadAndMemoryTotalProfiler(val withGC: Boolean) : TotalProfiler() {
     @Suppress("OVERRIDE_BY_INLINE")
     override inline fun beginMeasure(obj: Any?) =
-        beginMeasureWallAndThreadTimesAndMemory(total, withGC, threadMXBean)
+        beginMeasureWallAndThreadTimesAndMemory(withGC, threadMXBean)
     @Suppress("OVERRIDE_BY_INLINE")
     override inline fun endMeasure(obj: Any?, startState: List<Long>) =
         endMeasureWallAndThreadTimesAndMemory(total, withGC, threadMXBean, startState)
@@ -198,7 +188,7 @@ class WallAndThreadByClassProfiler() : TotalProfiler() {
 
     @Suppress("OVERRIDE_BY_INLINE")
     override inline fun beginMeasure(obj: Any?) =
-        beginMeasureWallAndThreadTimes(counters.getOrPut(obj?.javaClass?.name, { SimplePerfCountersWithTotal(total) }), threadMXBean)
+        beginMeasureWallAndThreadTimes(threadMXBean)
     @Suppress("OVERRIDE_BY_INLINE")
     override inline fun endMeasure(obj: Any?, startState: List<Long>) =
         endMeasureWallAndThreadTimes(counters.getOrPut(obj?.javaClass?.name, { SimplePerfCountersWithTotal(total) }), threadMXBean, startState)

compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/CompilerDaemonTest.kt

@@ -170,7 +170,7 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() {
             val opts2 = configureDaemonJVMOptions(inheritMemoryLimits = false, inheritAdditionalProperties = false, inheritOtherJvmOptions = false)
             assertEquals("300m", opts2.maxMemory)
             assertEquals( -1, DaemonJVMOptionsMemoryComparator().compare(opts, opts2))
-            assertEquals("300m", listOf(opts, opts2).maxWith(DaemonJVMOptionsMemoryComparator())?.maxMemory)
+            assertEquals("300m", listOf(opts, opts2).maxWithOrNull(DaemonJVMOptionsMemoryComparator())?.maxMemory)
 
             val myXmxParam = ManagementFactory.getRuntimeMXBean().inputArguments.first { it.startsWith("-Xmx") }
             TestCase.assertNotNull(myXmxParam)

compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/experimental/integration/CompilerDaemonTest.kt

@@ -244,7 +244,7 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() {
                 configureDaemonJVMOptions(inheritMemoryLimits = false, inheritAdditionalProperties = false, inheritOtherJvmOptions = false)
             assertEquals("300m", opts2.maxMemory)
             assertEquals(-1, DaemonJVMOptionsMemoryComparator().compare(opts, opts2))
-            assertEquals("300m", listOf(opts, opts2).maxWith(DaemonJVMOptionsMemoryComparator())?.maxMemory)
+            assertEquals("300m", listOf(opts, opts2).maxWithOrNull(DaemonJVMOptionsMemoryComparator())?.maxMemory)
 
             val myXmxParam = ManagementFactory.getRuntimeMXBean().inputArguments.first { it.startsWith("-Xmx") }
             TestCase.assertNotNull(myXmxParam)

compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/experimental/unit/ClientSerializationTest.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.daemon.experimental.unit
 
 import io.ktor.network.sockets.aSocket
+import io.ktor.util.*
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.async
 import kotlinx.coroutines.runBlocking
@@ -24,6 +25,7 @@ import java.io.ObjectOutputStream
 import java.net.InetSocketAddress
 import java.util.logging.Logger
 
+@OptIn(KtorExperimentalAPI::class)
 class TestServer(val serverPort: Int = 6999) {
     private val serverSocket = aSocket(selectorMgr).tcp().bind(InetSocketAddress(serverPort))
     private val log = Logger.getLogger("TestServer")

compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/experimental/unit/ConnectionsTest.kt

@@ -229,7 +229,7 @@ class ConnectionsTest : KotlinIntegrationTestBase() {
 
     private fun expectNewDaemon(serverType: ServerType, extraAction: (CompileServiceAsync) -> Unit = {}) = expectDaemon(
         getDaemons = ::getNewDaemonsOrAsyncWrappers,
-        chooseDaemon = { daemons -> daemons.maxWith(comparator)!!.daemon },
+        chooseDaemon = { daemons -> daemons.maxWithOrNull(comparator)!!.daemon },
         getInfo = { d -> runBlocking { d.getDaemonInfo() } },
         registerClient = { d -> runBlocking { d.registerClient(generateClient()) } },
         port = { d -> d.serverPort },

compiler/daemon/src/org/jetbrains/kotlin/daemon/CompileServiceImpl.kt

@@ -309,6 +309,7 @@ abstract class CompileServiceImplBase(
             CompileService.CallResult.Good(ExitCode.COMPILATION_ERROR.code)
         } else when (compilationOptions.compilerMode) {
             CompilerMode.JPS_COMPILER -> {
+                @Suppress("UNCHECKED_CAST")
                 servicesFacade as JpsServicesFacadeT
                 withIC(enabled = servicesFacade.hasIncrementalCaches()) {
                     doCompile(sessionId, daemonReporter, tracer = null) { eventManger, profiler ->
@@ -609,6 +610,7 @@ abstract class CompileServiceImplBase(
         body: KotlinJvmReplServiceT.() -> CompileService.CallResult<R>
     ): CompileService.CallResult<R> =
         withValidClientOrSessionProxy(sessionId) { session ->
+            @Suppress("UNCHECKED_CAST")
             (session?.data as? KotlinJvmReplServiceT?)?.body() ?: CompileService.CallResult.Error("Not a REPL session $sessionId")
         }
 
@@ -703,6 +705,7 @@ class CompileServiceImpl(
         CompileService.CallResult.Good(res)
     }
 
+    @Suppress("OverridingDeprecatedMember", "DEPRECATION")
     override fun remoteCompile(
         sessionId: Int,
         targetPlatform: CompileService.TargetPlatform,
@@ -728,6 +731,7 @@ class CompileServiceImpl(
             }
         }
 
+    @Suppress("OverridingDeprecatedMember", "DEPRECATION")
     override fun remoteIncrementalCompile(
         sessionId: Int,
         targetPlatform: CompileService.TargetPlatform,
@@ -784,7 +788,7 @@ class CompileServiceImpl(
     override fun leaseReplSession(
         aliveFlagPath: String?,
         targetPlatform: CompileService.TargetPlatform,
-        servicesFacade: CompilerCallbackServicesFacade,
+        @Suppress("DEPRECATION") servicesFacade: CompilerCallbackServicesFacade,
         templateClasspath: List<File>,
         templateClassName: String,
         scriptArgs: Array<out Any?>?,
@@ -819,15 +823,17 @@ class CompileServiceImpl(
     // TODO: add more checks (e.g. is it a repl session)
     override fun releaseReplSession(sessionId: Int): CompileService.CallResult<Nothing> = releaseCompileSession(sessionId)
 
+    @Suppress("OverridingDeprecatedMember")
     override fun remoteReplLineCheck(sessionId: Int, codeLine: ReplCodeLine): CompileService.CallResult<ReplCheckResult> =
         ifAlive(minAliveness = Aliveness.Alive) {
             withValidRepl(sessionId) {
+                @Suppress("DEPRECATION")
                 CompileService.CallResult.Good(check(codeLine))
             }
         }
 
     private fun createCompileServices(
-        facade: CompilerCallbackServicesFacade,
+        @Suppress("DEPRECATION") facade: CompilerCallbackServicesFacade,
         eventManager: EventManager,
         rpcProfiler: Profiler
     ): Services {
@@ -835,7 +841,7 @@ class CompileServiceImpl(
         if (facade.hasIncrementalCaches()) {
             builder.register(
                 IncrementalCompilationComponents::class.java,
-                RemoteIncrementalCompilationComponentsClient(facade, eventManager, rpcProfiler)
+                RemoteIncrementalCompilationComponentsClient(facade, rpcProfiler)
             )
         }
         if (facade.hasLookupTracker()) {
@@ -857,6 +863,7 @@ class CompileServiceImpl(
         return builder.build()
     }
 
+    @Suppress("OverridingDeprecatedMember")
     override fun remoteReplLineCompile(
         sessionId: Int,
         codeLine: ReplCodeLine,
@@ -864,10 +871,12 @@ class CompileServiceImpl(
     ): CompileService.CallResult<ReplCompileResult> =
         ifAlive(minAliveness = Aliveness.Alive) {
             withValidRepl(sessionId) {
+                @Suppress("DEPRECATION")
                 CompileService.CallResult.Good(compile(codeLine, history))
             }
         }
 
+    @Suppress("OverridingDeprecatedMember")
     override fun remoteReplLineEval(
         sessionId: Int,
         codeLine: ReplCodeLine,
@@ -997,7 +1006,7 @@ class CompileServiceImpl(
             val comparator =
                 compareByDescending<DaemonWithMetadata, DaemonJVMOptions>(DaemonJVMOptionsMemoryComparator(), { it.jvmOptions })
                     .thenBy(FileAgeComparator()) { it.runFile }
-            aliveWithOpts.maxWith(comparator)?.let { bestDaemonWithMetadata ->
+            aliveWithOpts.maxWithOrNull(comparator)?.let { bestDaemonWithMetadata ->
                 val fattestOpts = bestDaemonWithMetadata.jvmOptions
                 if (fattestOpts memorywiseFitsInto daemonJVMOptions && FileAgeComparator().compare(
                         bestDaemonWithMetadata.runFile,

compiler/daemon/src/org/jetbrains/kotlin/daemon/KotlinRemoteReplService.kt

@@ -126,7 +126,7 @@ open class KotlinJvmReplService(
     templateClasspath: List<File>,
     templateClassName: String,
     messageCollector: MessageCollector,
-    @Deprecated("drop it")
+    // TODO: drop it
     protected val operationsTracer: RemoteOperationsTracer?
 ) : KotlinJvmReplServiceBase(disposable, compilerId, templateClasspath, templateClassName, messageCollector) {
 
@@ -142,9 +142,11 @@ open class KotlinJvmReplService(
     @Deprecated("remove after removal state-less check/compile/eval methods")
     protected val defaultStateFacade: RemoteReplStateFacadeServer by lazy { createRemoteState() }
 
+    @Suppress("DEPRECATION")
     @Deprecated("Use check(state, line) instead")
     fun check(codeLine: ReplCodeLine): ReplCheckResult = check(defaultStateFacade.state, codeLine)
 
+    @Suppress("DEPRECATION", "UNUSED_PARAMETER")
     @Deprecated("Use compile(state, line) instead")
     fun compile(codeLine: ReplCodeLine, verifyHistory: List<ReplCodeLine>?): ReplCompileResult = compile(defaultStateFacade.state, codeLine)
 

compiler/daemon/src/org/jetbrains/kotlin/daemon/RemoteCompilationCanceledStatusClient.kt

@@ -17,14 +17,17 @@
 package org.jetbrains.kotlin.daemon
 
 import org.jetbrains.kotlin.daemon.common.*
-import org.jetbrains.kotlin.progress.CompilationCanceledStatus
 import org.jetbrains.kotlin.progress.CompilationCanceledException
+import org.jetbrains.kotlin.progress.CompilationCanceledStatus
 import java.util.concurrent.TimeUnit
 import java.util.logging.Logger
 
 val CANCELED_STATUS_CHECK_THRESHOLD_NS = TimeUnit.MILLISECONDS.toNanos(100)
 
-class RemoteCompilationCanceledStatusClient(val facade: CompilerCallbackServicesFacade, val profiler: Profiler = DummyProfiler()): CompilationCanceledStatus {
+class RemoteCompilationCanceledStatusClient(
+    @Suppress("DEPRECATION") val facade: CompilerCallbackServicesFacade,
+    val profiler: Profiler = DummyProfiler()
+): CompilationCanceledStatus {
 
     private val log by lazy { Logger.getLogger("compiler") }
 

compiler/daemon/src/org/jetbrains/kotlin/daemon/RemoteExpectActualTracker.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.daemon
 
-import org.jetbrains.kotlin.daemon.common.CompilerCallbackServicesFacade
 import org.jetbrains.kotlin.daemon.common.DummyProfiler
 import org.jetbrains.kotlin.daemon.common.Profiler
 import org.jetbrains.kotlin.daemon.common.withMeasure
@@ -13,7 +12,7 @@ import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
 import java.io.File
 
 class RemoteExpectActualTracker(
-    val facade: CompilerCallbackServicesFacade,
+    @Suppress("DEPRECATION") val facade: org.jetbrains.kotlin.daemon.common.CompilerCallbackServicesFacade,
     val profiler: Profiler = DummyProfiler()
 ): ExpectActualTracker {
     override fun report(expectedFile: File, actualFile: File) {

compiler/daemon/src/org/jetbrains/kotlin/daemon/RemoteIncrementalCacheClient.kt

@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.daemon
 
-import org.jetbrains.kotlin.daemon.common.CompilerCallbackServicesFacade
 import org.jetbrains.kotlin.daemon.common.DummyProfiler
 import org.jetbrains.kotlin.daemon.common.Profiler
 import org.jetbrains.kotlin.daemon.common.withMeasure
@@ -24,8 +23,11 @@ import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache
 import org.jetbrains.kotlin.load.kotlin.incremental.components.JvmPackagePartProto
 import org.jetbrains.kotlin.modules.TargetId
 
-class RemoteIncrementalCacheClient(val facade: CompilerCallbackServicesFacade, val target: TargetId, val profiler: Profiler = DummyProfiler()): IncrementalCache {
-
+class RemoteIncrementalCacheClient(
+    @Suppress("DEPRECATION") val facade: org.jetbrains.kotlin.daemon.common.CompilerCallbackServicesFacade,
+    val target: TargetId,
+    val profiler: Profiler = DummyProfiler()
+): IncrementalCache {
     override fun getObsoletePackageParts(): Collection<String> = profiler.withMeasure(this) { facade.incrementalCache_getObsoletePackageParts(target) }
 
     override fun getObsoleteMultifileClasses(): Collection<String> = profiler.withMeasure(this) { facade.incrementalCache_getObsoleteMultifileClassFacades(target) }

compiler/daemon/src/org/jetbrains/kotlin/daemon/RemoteIncrementalCompilationComponentsClient.kt

@@ -16,13 +16,15 @@
 
 package org.jetbrains.kotlin.daemon
 
+import org.jetbrains.kotlin.daemon.common.DummyProfiler
+import org.jetbrains.kotlin.daemon.common.Profiler
 import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache
 import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents
 import org.jetbrains.kotlin.modules.TargetId
-import org.jetbrains.kotlin.daemon.common.CompilerCallbackServicesFacade
-import org.jetbrains.kotlin.daemon.common.DummyProfiler
-import org.jetbrains.kotlin.daemon.common.Profiler
 
-class RemoteIncrementalCompilationComponentsClient(val facade: CompilerCallbackServicesFacade, eventManager: EventManager, val profiler: Profiler = DummyProfiler()) : IncrementalCompilationComponents {
+class RemoteIncrementalCompilationComponentsClient(
+    @Suppress("DEPRECATION") val facade: org.jetbrains.kotlin.daemon.common.CompilerCallbackServicesFacade,
+    val profiler: Profiler = DummyProfiler()
+) : IncrementalCompilationComponents {
     override fun getIncrementalCache(target: TargetId): IncrementalCache = RemoteIncrementalCacheClient(facade, target, profiler)
 }

compiler/daemon/src/org/jetbrains/kotlin/daemon/RemoteIncrementalDataProvider.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.daemon
 
-import org.jetbrains.kotlin.daemon.common.CompilerCallbackServicesFacade
 import org.jetbrains.kotlin.daemon.common.Profiler
 import org.jetbrains.kotlin.daemon.common.withMeasure
 import org.jetbrains.kotlin.incremental.js.IncrementalDataProvider
@@ -13,8 +12,10 @@ import org.jetbrains.kotlin.incremental.js.IrTranslationResultValue
 import org.jetbrains.kotlin.incremental.js.TranslationResultValue
 import java.io.File
 
-class RemoteIncrementalDataProvider(val facade: CompilerCallbackServicesFacade, val rpcProfiler: Profiler) :
-    IncrementalDataProvider {
+class RemoteIncrementalDataProvider(
+    @Suppress("DEPRECATION") val facade: org.jetbrains.kotlin.daemon.common.CompilerCallbackServicesFacade,
+    val rpcProfiler: Profiler
+) : IncrementalDataProvider {
     override val serializedIrFiles: Map<File, IrTranslationResultValue>
         get() = TODO("not implemented") //To change initializer of created properties use File | Settings | File Templates.
 

compiler/daemon/src/org/jetbrains/kotlin/daemon/RemoteIncrementalResultsConsumer.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.daemon
 
-import org.jetbrains.kotlin.daemon.common.CompilerCallbackServicesFacade
 import org.jetbrains.kotlin.daemon.common.Profiler
 import org.jetbrains.kotlin.daemon.common.withMeasure
 import org.jetbrains.kotlin.incremental.js.FunctionWithSourceInfo
@@ -13,8 +12,11 @@ import org.jetbrains.kotlin.incremental.js.IncrementalResultsConsumer
 import org.jetbrains.kotlin.incremental.js.JsInlineFunctionHash
 import java.io.File
 
-class RemoteIncrementalResultsConsumer(val facade: CompilerCallbackServicesFacade, eventManager: EventManager, val rpcProfiler: Profiler) :
-    IncrementalResultsConsumer {
+class RemoteIncrementalResultsConsumer(
+    @Suppress("DEPRECATION") val facade: org.jetbrains.kotlin.daemon.common.CompilerCallbackServicesFacade,
+    eventManager: EventManager,
+    val rpcProfiler: Profiler
+) : IncrementalResultsConsumer {
     override fun processIrFile(
         sourceFile: File,
         fileData: ByteArray,

compiler/daemon/src/org/jetbrains/kotlin/daemon/RemoteLookupTrackerClient.kt

@@ -19,7 +19,6 @@ package org.jetbrains.kotlin.daemon
 import com.intellij.util.containers.StringInterner
 import gnu.trove.THashMap
 import gnu.trove.THashSet
-import org.jetbrains.kotlin.daemon.common.CompilerCallbackServicesFacade
 import org.jetbrains.kotlin.daemon.common.DummyProfiler
 import org.jetbrains.kotlin.daemon.common.Profiler
 import org.jetbrains.kotlin.daemon.common.withMeasure
@@ -28,9 +27,8 @@ import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.incremental.components.Position
 import org.jetbrains.kotlin.incremental.components.ScopeKind
 
-
 class RemoteLookupTrackerClient(
-    val facade: CompilerCallbackServicesFacade,
+    @Suppress("DEPRECATION") val facade: org.jetbrains.kotlin.daemon.common.CompilerCallbackServicesFacade,
     eventManager: EventManager,
     val profiler: Profiler = DummyProfiler()
 ) : LookupTracker {

compiler/daemon/src/org/jetbrains/kotlin/daemon/experimental/CompileServiceServerSideImpl.kt

@@ -10,15 +10,13 @@ package org.jetbrains.kotlin.daemon.experimental
 import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.vfs.impl.ZipHandler
 import com.intellij.openapi.vfs.impl.jar.CoreJarFileSystem
+import io.ktor.network.sockets.*
 import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.channels.actor
 import kotlinx.coroutines.channels.consumeEach
 import org.jetbrains.kotlin.cli.common.CLICompiler
-import org.jetbrains.kotlin.cli.common.ExitCode
-import org.jetbrains.kotlin.cli.common.arguments.K2JSCompilerArguments
-import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
-import org.jetbrains.kotlin.cli.common.messages.MessageCollector
+import org.jetbrains.kotlin.cli.common.KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY
 import org.jetbrains.kotlin.cli.common.repl.ReplCheckResult
 import org.jetbrains.kotlin.cli.common.repl.ReplCodeLine
 import org.jetbrains.kotlin.cli.common.repl.ReplCompileResult
@@ -29,7 +27,10 @@ import org.jetbrains.kotlin.cli.metadata.K2MetadataCompiler
 import org.jetbrains.kotlin.config.Services
 import org.jetbrains.kotlin.daemon.CompileServiceImplBase
 import org.jetbrains.kotlin.daemon.CompilerSelector
+import org.jetbrains.kotlin.daemon.EventManager
 import org.jetbrains.kotlin.daemon.common.*
+import org.jetbrains.kotlin.daemon.common.experimental.*
+import org.jetbrains.kotlin.daemon.common.experimental.socketInfrastructure.*
 import org.jetbrains.kotlin.daemon.experimental.CompileServiceTaskScheduler.*
 import org.jetbrains.kotlin.daemon.nowSeconds
 import org.jetbrains.kotlin.daemon.report.experimental.CompileServicesFacadeMessageCollector
@@ -45,12 +46,6 @@ import java.util.concurrent.TimeUnit
 import java.util.logging.Level
 import java.util.logging.Logger
 import kotlin.concurrent.schedule
-import org.jetbrains.kotlin.daemon.common.experimental.socketInfrastructure.*
-import org.jetbrains.kotlin.daemon.common.experimental.*
-import io.ktor.network.sockets.*
-import org.jetbrains.kotlin.cli.common.KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY
-import org.jetbrains.kotlin.daemon.EventManager
-import org.jetbrains.kotlin.daemon.report.DaemonMessageReporter
 
 // TODO: this classes should replace their non-experimental versions eventually.
 
@@ -79,6 +74,7 @@ private class CompileServiceTaskScheduler(log: Logger) {
 
     fun isShutdownActionInProgress() = shutdownActionInProgress
 
+    @OptIn(ObsoleteCoroutinesApi::class, ExperimentalCoroutinesApi::class)
     private val queriesActor = GlobalScope.actor<CompileServiceTask>(capacity = Channel.UNLIMITED) {
         var currentTaskId = 0
         var shutdownTask: ExclusiveTask? = null
@@ -179,10 +175,10 @@ class CompileServiceServerSideImpl(
     } ?: false
 
     override suspend fun serverHandshake(input: ByteReadChannelWrapper, output: ByteWriteChannelWrapper, log: Logger): Boolean {
-        return tryAcquireHandshakeMessage(input, log) && trySendHandshakeMessage(output, log)
+        return tryAcquireHandshakeMessage(input) && trySendHandshakeMessage(output)
     }
 
-    private lateinit var scheduler: CompileServiceTaskScheduler
+    private var scheduler: CompileServiceTaskScheduler
 
     constructor(
         serverSocket: ServerSocketWrapper,
@@ -500,7 +496,7 @@ class CompileServiceServerSideImpl(
                     }
                     .thenBy(FileAgeComparator()) { it.runFile }
                     .thenBy { it.daemon.serverPort }
-                aliveWithOpts.maxWith(comparator)?.let { bestDaemonWithMetadata ->
+                aliveWithOpts.maxWithOrNull(comparator)?.let { bestDaemonWithMetadata ->
                     val fattestOpts = bestDaemonWithMetadata.jvmOptions
                     if (fattestOpts memorywiseFitsInto daemonJVMOptions && FileAgeComparator().compare(
                             bestDaemonWithMetadata.runFile,
@@ -655,7 +651,7 @@ class CompileServiceServerSideImpl(
         if (facade.hasIncrementalCaches()) {
             builder.register(
                 IncrementalCompilationComponents::class.java,
-                RemoteIncrementalCompilationComponentsClient(facade, eventManager, rpcProfiler)
+                RemoteIncrementalCompilationComponentsClient(facade, rpcProfiler)
             )
         }
         if (facade.hasLookupTracker()) {