Use GPG agent for signing in PublishedKotlinModule

Update to maven-gpg-plugin 1.6 and add workaround for https://issues.apache.org/jira/browse/MGPG-59

.gitignore

@@ -58,5 +58,4 @@ kotlin-ultimate/
 node_modules/
 .rpt2_cache/
 libraries/tools/kotlin-test-js-runner/lib/
-libraries/tools/kotlin-source-map-loader/lib/
 local.properties

.idea/codeStyles/Project.xml

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

.idea/runConfigurations/Test__stdlib_js_public_kotlin_api_test__overwrite_results.xml

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

.idea/scopes/Apply_copyright.xml

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

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

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

build.gradle.kts

@@ -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"
 }
 
 val intellijUltimateEnabled by extra(project.kotlinBuildProperties.intellijUltimateEnabled)
@@ -200,7 +200,11 @@ extra["intellijSeparateSdks"] = intellijSeparateSdks
 
 extra["IntellijCoreDependencies"] =
     listOf(
-        if (Platform[191].orHigher()) "asm-all-7.0.1" else "asm-all",
+        when {
+            Platform[202].orHigher() -> "asm-all-8.0.1"
+            Platform[191].orHigher() -> "asm-all-7.0.1"
+            else -> "asm-all"
+        },
         "guava",
         "jdom",
         "jna",

buildSrc/build.gradle.kts

@@ -105,7 +105,7 @@ dependencies {
 
     implementation("com.github.jengelman.gradle.plugins:shadow:${rootProject.extra["versions.shadow"]}")
     implementation("net.sf.proguard:proguard-gradle:6.2.2")
-    implementation("org.jetbrains.intellij.deps:asm-all:7.0.1")
+    implementation("org.jetbrains.intellij.deps:asm-all:8.0.1")
 
     implementation("gradle.plugin.org.jetbrains.gradle.plugin.idea-ext:gradle-idea-ext:0.5")
 }

buildSrc/src/main/kotlin/dependencies.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.
+ */
+
 @file:Suppress("unused")
 
 // usages in build scripts are not tracked properly
@@ -97,9 +102,11 @@ fun Project.kotlinStdlib(suffix: String? = null, classifier: String? = null): An
         dependencies.project(listOfNotNull(":kotlin-stdlib", suffix).joinToString("-"), classifier)
 }
 
-fun Project.kotlinBuiltins(): Any =
+fun Project.kotlinBuiltins(): Any = kotlinBuiltins(forJvm = false)
+
+fun Project.kotlinBuiltins(forJvm: Boolean): Any =
     if (kotlinBuildProperties.useBootstrapStdlib) "org.jetbrains.kotlin:builtins:$bootstrapKotlinVersion"
-    else dependencies.project(":core:builtins")
+    else dependencies.project(":core:builtins", configuration = "runtimeElementsJvm".takeIf { forJvm })
 
 fun DependencyHandler.projectTests(name: String): ProjectDependency = project(name, configuration = "tests-jar")
 fun DependencyHandler.projectRuntimeJar(name: String): ProjectDependency = project(name, configuration = "runtimeJar")

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

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

@@ -108,6 +108,10 @@ fun Project.projectTest(
     systemProperty("kotlin.ni", if (rootProject.hasProperty("newInferenceTests")) "true" else "false")
     systemProperty("org.jetbrains.kotlin.skip.muted.tests", if (rootProject.hasProperty("skipMutedTests")) "true" else "false")
 
+    if (Platform[202].orHigher()) {
+        systemProperty("idea.ignore.disabled.plugins", "true")
+    }
+
     var subProjectTempRoot: Path? = null
     doFirst {
         val teamcity = rootProject.findProperty("teamcity") as? Map<Any?, *>

compiler/android-tests/build.gradle.kts

@@ -29,7 +29,13 @@ dependencies {
         testCompile(intellijDep()) { includeJars("openapi", rootProject = rootProject) }
     }
 
-    testCompile(intellijDep()) { includeJars("util", "idea", "idea_rt", "groovy-all", rootProject = rootProject) }
+    testCompile(intellijDep()) { includeJars("util", "idea", "idea_rt", rootProject = rootProject) }
+    Platform[202].orHigher {
+        testCompile(intellijDep()) { includeJars("groovy", rootProject = rootProject) }
+    }
+    Platform[201].orLower {
+        testCompile(intellijDep()) { includeJars("groovy-all", rootProject = rootProject) }
+    }
     Platform[191].orLower {
         testCompile(intellijDep()) { includeJars("jps-builders") }
     }

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

@@ -294,7 +294,7 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
                     val kind = KotlinBaseTest.extractConfigurationKind(testFiles)
                     val jdkKind = KotlinBaseTest.getTestJdkKind(testFiles)
                     val keyConfiguration = CompilerConfiguration()
-                    CodegenTestCase.updateConfigurationByDirectivesInTestFiles(testFiles, keyConfiguration)
+                    KotlinBaseTest.updateConfigurationByDirectivesInTestFiles(testFiles, keyConfiguration)
 
                     val key = ConfigurationKey(kind, jdkKind, keyConfiguration.toString())
                     val compiler = if (isJvm8Target) {
@@ -303,7 +303,7 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
                     val filesHolder = holders.getOrPut(key) {
                         FilesWriter(compiler, KotlinTestUtils.newConfiguration(kind, jdkKind, KotlinTestUtils.getAnnotationsJar()).apply {
                             println("Creating new configuration by $key")
-                            CodegenTestCase.updateConfigurationByDirectivesInTestFiles(testFiles, this)
+                            KotlinBaseTest.updateConfigurationByDirectivesInTestFiles(testFiles, this)
                         })
                     }
 

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

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

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

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

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

@@ -105,6 +105,15 @@ public abstract class AnnotationCodegen {
             @Nullable Annotated annotated,
             @Nullable Type returnType,
             @Nullable KotlinType typeForTypeAnnotations
+    ) {
+        genAnnotations(annotated, returnType, typeForTypeAnnotations, null);
+    }
+
+    public void genAnnotations(
+            @Nullable Annotated annotated,
+            @Nullable Type returnType,
+            @Nullable KotlinType typeForTypeAnnotations,
+            @Nullable DeclarationDescriptorWithVisibility parameterContainer
     ) {
         if (annotated == null) return;
 
@@ -139,22 +148,23 @@ public abstract class AnnotationCodegen {
             }
         }
 
-        generateAdditionalAnnotations(annotated, returnType, annotationDescriptorsAlreadyPresent);
+        generateAdditionalAnnotations(annotated, returnType, annotationDescriptorsAlreadyPresent, parameterContainer);
         generateTypeAnnotations(annotated, typeForTypeAnnotations);
     }
 
     private void generateAdditionalAnnotations(
             @NotNull Annotated annotated,
             @Nullable Type returnType,
-            @NotNull Set<String> annotationDescriptorsAlreadyPresent
+            @NotNull Set<String> annotationDescriptorsAlreadyPresent,
+            @Nullable DeclarationDescriptorWithVisibility parameterContainer
     ) {
         if (annotated instanceof CallableDescriptor) {
-            generateAdditionalCallableAnnotations((CallableDescriptor) annotated, returnType, annotationDescriptorsAlreadyPresent);
+            generateAdditionalCallableAnnotations((CallableDescriptor) annotated, returnType, annotationDescriptorsAlreadyPresent, parameterContainer);
         }
         else if (annotated instanceof FieldDescriptor) {
             generateAdditionalCallableAnnotations(
-                    ((FieldDescriptor) annotated).getCorrespondingProperty(), returnType, annotationDescriptorsAlreadyPresent
-            );
+                    ((FieldDescriptor) annotated).getCorrespondingProperty(), returnType, annotationDescriptorsAlreadyPresent,
+                    parameterContainer);
         }
         else if (annotated instanceof ClassDescriptor) {
             generateAdditionalClassAnnotations(annotationDescriptorsAlreadyPresent, (ClassDescriptor) annotated);
@@ -164,11 +174,15 @@ public abstract class AnnotationCodegen {
     private void generateAdditionalCallableAnnotations(
             @NotNull CallableDescriptor descriptor,
             @Nullable Type returnType,
-            @NotNull Set<String> annotationDescriptorsAlreadyPresent
+            @NotNull Set<String> annotationDescriptorsAlreadyPresent,
+            @Nullable DeclarationDescriptorWithVisibility parameterContainer
     ) {
         // No need to annotate privates, synthetic accessors and their parameters
         if (isInvisibleFromTheOutside(descriptor)) return;
-        if (descriptor instanceof ValueParameterDescriptor && isInvisibleFromTheOutside(descriptor.getContainingDeclaration())) return;
+        if (descriptor instanceof ParameterDescriptor &&
+            isInvisibleFromTheOutside(parameterContainer != null ? parameterContainer : descriptor.getContainingDeclaration())) {
+            return;
+        }
 
         // No need to annotate annotation methods since they're always non-null
         if (descriptor instanceof PropertyGetterDescriptor &&

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

@@ -14,6 +14,7 @@ import org.jetbrains.kotlin.backend.common.bridges.ImplKt;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.codegen.context.ClassContext;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
+import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.psi.synthetics.SyntheticClassOrObjectDescriptor;
@@ -38,6 +39,8 @@ import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.enumEntryNeedS
 import static org.jetbrains.kotlin.resolve.DescriptorToSourceUtils.descriptorToDeclaration;
 import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.OBJECT_TYPE;
 import static org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKind.CLASS_MEMBER_DELEGATION_TO_DEFAULT_IMPL;
+import static org.jetbrains.kotlin.util.DeclarationUtilKt.findImplementationFromInterface;
+import static org.jetbrains.kotlin.util.DeclarationUtilKt.findInterfaceImplementation;
 
 public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject> {
     @NotNull
@@ -124,7 +127,7 @@ public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject
         for (DeclarationDescriptor memberDescriptor : DescriptorUtils.getAllDescriptors(descriptor.getDefaultType().getMemberScope())) {
             if (memberDescriptor instanceof CallableMemberDescriptor) {
                 CallableMemberDescriptor member = (CallableMemberDescriptor) memberDescriptor;
-                if (!member.getKind().isReal() && ImplKt.findInterfaceImplementation(member) == null) {
+                if (!member.getKind().isReal() && findInterfaceImplementation(member) == null) {
                     if (member instanceof FunctionDescriptor) {
                         functionCodegen.generateBridges((FunctionDescriptor) member);
                     }
@@ -219,21 +222,32 @@ public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject
     protected void generateDelegatesToDefaultImpl() {
         if (isJvmInterface(descriptor)) return;
 
+        boolean isErasedInlineClass = InlineClassesUtilsKt.isInlineClass(descriptor) && kind == OwnerKind.ERASED_INLINE_CLASS;
+        JvmKotlinType receiverType = new JvmKotlinType(typeMapper.mapType(descriptor), descriptor.getDefaultType());
+
         for (Map.Entry<FunctionDescriptor, FunctionDescriptor> entry : CodegenUtil.getNonPrivateTraitMethods(descriptor).entrySet()) {
-            FunctionDescriptor interfaceFun = entry.getKey();
-            //skip java 8 default methods
-            if (!CodegenUtilKt.isDefinitelyNotDefaultImplsMethod(interfaceFun) &&
-                !JvmAnnotationUtilKt.isCallableMemberCompiledToJvmDefault(
-                        DescriptorUtils.unwrapFakeOverrideToAnyDeclaration(interfaceFun), state.getJvmDefaultMode()
-                )
-            ) {
-                generateDelegationToDefaultImpl(interfaceFun, entry.getValue());
-            }
+            generateDelegationToDefaultImpl(entry.getKey(), entry.getValue(), receiverType, functionCodegen, state, isErasedInlineClass);
         }
     }
 
-    private void generateDelegationToDefaultImpl(@NotNull FunctionDescriptor interfaceFun, @NotNull FunctionDescriptor inheritedFun) {
+    public static void generateDelegationToDefaultImpl(
+            @NotNull FunctionDescriptor interfaceFun,
+            @NotNull FunctionDescriptor inheritedFun,
+            @NotNull JvmKotlinType receiverType,
+            @NotNull FunctionCodegen functionCodegen,
+            @NotNull GenerationState state,
+            boolean isErasedInlineClass
+    ) {
+        CallableMemberDescriptor actualImplementation =
+                interfaceFun.getKind().isReal() ? interfaceFun : findImplementationFromInterface(interfaceFun);
+        assert actualImplementation != null : "Can't find actual implementation for " + interfaceFun;
+        // Skip Java 8 default methods
+        if (CodegenUtilKt.isDefinitelyNotDefaultImplsMethod(actualImplementation) ||
+            JvmAnnotationUtilKt.isCallableMemberCompiledToJvmDefault(actualImplementation, state.getJvmDefaultMode())) {
+            return;
+        }
 
+        KotlinTypeMapper typeMapper = state.getTypeMapper();
         functionCodegen.generateMethod(
                 new JvmDeclarationOrigin(
                         CLASS_MEMBER_DELEGATION_TO_DEFAULT_IMPL, descriptorToDeclaration(interfaceFun), interfaceFun, null
@@ -248,7 +262,7 @@ public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject
                         DeclarationDescriptor declarationInheritedFun = inheritedFun.getContainingDeclaration();
                         PsiElement classForInheritedFun = descriptorToDeclaration(declarationInheritedFun);
                         if (classForInheritedFun instanceof KtDeclaration) {
-                            codegen.markLineNumber((KtElement) classForInheritedFun, false);
+                            codegen.markLineNumber(classForInheritedFun, false);
                         }
 
                         ClassDescriptor containingTrait = (ClassDescriptor) containingDeclaration;
@@ -282,18 +296,15 @@ public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject
                         InstructionAdapter iv = codegen.v;
                         Type[] myArgTypes = signature.getAsmMethod().getArgumentTypes();
                         Type[] toArgTypes = defaultImplsMethod.getArgumentTypes();
-                        boolean isErasedInlineClass =
-                                InlineClassesUtilsKt.isInlineClass(descriptor) && kind == OwnerKind.ERASED_INLINE_CLASS;
 
                         int myArgI = 0;
                         int argVar = 0;
 
-                        Type receiverType = typeMapper.mapType(descriptor);
                         KotlinType interfaceKotlinType = ((ClassDescriptor) inheritedFun.getContainingDeclaration()).getDefaultType();
-                        StackValue.local(argVar, receiverType, descriptor.getDefaultType())
+                        StackValue.local(argVar, receiverType.getType(), receiverType.getKotlinType())
                                 .put(OBJECT_TYPE, interfaceKotlinType, iv);
                         if (isErasedInlineClass) myArgI++;
-                        argVar += receiverType.getSize();
+                        argVar += receiverType.getType().getSize();
 
                         int toArgI = 1;
 

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

@@ -185,6 +185,12 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
         generateBridges();
         generateClosureBody();
 
+        if (samType != null) {
+            SamWrapperCodegen.generateDelegatesToDefaultImpl(
+                    asmType, classDescriptor, samType.getClassDescriptor(), functionCodegen, state
+            );
+        }
+
         this.constructor = generateConstructor();
 
         if (isConst(closure)) {

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

@@ -1585,7 +1585,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             assert topOfStack == tryWithFinallyBlockStackElement : "Top element of stack doesn't equals processing finally block";
 
             KtTryExpression jetTryExpression = tryWithFinallyBlockStackElement.expression;
-            Label finallyStart = new Label();
+            Label finallyStart = linkedLabel();
             v.mark(finallyStart);
             tryWithFinallyBlockStackElement.addGapLabel(finallyStart);
             addGapLabelsForNestedTryCatchWithoutFinally(state, nestedTryBlocksWithoutFinally, finallyStart);
@@ -2835,7 +2835,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;

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

@@ -70,7 +70,6 @@ import java.io.StringWriter;
 import java.util.*;
 import java.util.stream.Collectors;
 
-import static org.jetbrains.kotlin.builtins.KotlinBuiltIns.isNullableAny;
 import static org.jetbrains.kotlin.codegen.AsmUtil.*;
 import static org.jetbrains.kotlin.codegen.CodegenUtilKt.generateBridgeForMainFunctionIfNecessary;
 import static org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings.METHOD_FOR_FUNCTION;
@@ -493,11 +492,11 @@ public class FunctionCodegen {
             @NotNull FunctionDescriptor functionDescriptor,
             @NotNull MethodVisitor mv,
             @NotNull JvmMethodSignature jvmSignature,
-            @NotNull InnerClassConsumer innerClassConsumer,
+            @NotNull MemberCodegen<?> memberCodegen,
             @NotNull GenerationState state
     ) {
         generateParameterAnnotations(
-                functionDescriptor, mv, jvmSignature, functionDescriptor.getValueParameters(), innerClassConsumer, state
+                functionDescriptor, mv, jvmSignature, functionDescriptor.getValueParameters(), memberCodegen, state
         );
     }
 
@@ -506,7 +505,7 @@ public class FunctionCodegen {
             @NotNull MethodVisitor mv,
             @NotNull JvmMethodSignature jvmSignature,
             @NotNull List<ValueParameterDescriptor> valueParameters,
-            @NotNull InnerClassConsumer innerClassConsumer,
+            @NotNull MemberCodegen<?> memberCodegen,
             @NotNull GenerationState state
     ) {
         if (isAccessor(functionDescriptor)) return;
@@ -517,6 +516,7 @@ public class FunctionCodegen {
 
         Asm7UtilKt.visitAnnotableParameterCount(mv, kotlinParameterTypes.size() - syntheticParameterCount);
 
+        boolean isDefaultImpl = OwnerKind.DEFAULT_IMPLS == memberCodegen.context.getContextKind();
         for (int i = 0; i < kotlinParameterTypes.size(); i++) {
             JvmMethodParameterSignature parameterSignature = kotlinParameterTypes.get(i);
             JvmMethodParameterKind kind = parameterSignature.getKind();
@@ -529,13 +529,14 @@ public class FunctionCodegen {
                     ? iterator.next()
                     : kind == JvmMethodParameterKind.RECEIVER
                       ? JvmCodegenUtil.getDirectMember(functionDescriptor).getExtensionReceiverParameter()
-                      : null;
+                      : isDefaultImpl && kind == JvmMethodParameterKind.THIS ? JvmCodegenUtil.getDirectMember(functionDescriptor)
+                              .getDispatchReceiverParameter() : null;
 
             if (annotated != null) {
                 //noinspection ConstantConditions
                 int parameterIndex = i - syntheticParameterCount;
-                AnnotationCodegen.forParameter(parameterIndex, mv, innerClassConsumer, state)
-                        .genAnnotations(annotated, parameterSignature.getAsmType(), annotated.getReturnType());
+                AnnotationCodegen.forParameter(parameterIndex, mv, memberCodegen, state)
+                        .genAnnotations(annotated, parameterSignature.getAsmType(), annotated.getReturnType(), functionDescriptor);
             }
         }
     }
@@ -607,7 +608,7 @@ public class FunctionCodegen {
                     true, mv,
                     method.getAsmMethod(),
                     method.getOwner().getInternalName(),
-                    true);
+                    true, signature.getReturnType());
             methodEnd = new Label();
         }
         else {
@@ -711,8 +712,7 @@ public class FunctionCodegen {
             @NotNull JvmDefaultMode jvmDefaultMode
     ) {
         return OwnerKind.DEFAULT_IMPLS == context.getContextKind() &&
-               JvmAnnotationUtilKt
-                       .isCompiledToJvmDefault(DescriptorUtils.unwrapFakeOverrideToAnyDeclaration(functionDescriptor),
+               JvmAnnotationUtilKt.isCompiledToJvmDefault(DescriptorUtils.unwrapFakeOverrideToAnyDeclaration(functionDescriptor),
                                                jvmDefaultMode) &&
                jvmDefaultMode.isCompatibility();
     }
@@ -850,7 +850,8 @@ public class FunctionCodegen {
             @NotNull Method asmMethod,
             @NotNull String classToDelegateTo,
             int opcode,
-            boolean isInterface
+            boolean isInterface,
+            @NotNull Type returnType
     ) {
         InstructionAdapter iv = new InstructionAdapter(mv);
         Type[] argTypes = asmMethod.getArgumentTypes();
@@ -872,7 +873,8 @@ public class FunctionCodegen {
             paramIndex += argType.getSize();
         }
         iv.visitMethodInsn(opcode, classToDelegateTo, asmMethod.getName(), asmMethod.getDescriptor(), isInterface);
-        iv.areturn(asmMethod.getReturnType());
+        StackValue.onStack(asmMethod.getReturnType()).coerceTo(returnType, null, iv);
+        iv.areturn(returnType);
     }
 
     private static void generateDelegateToStaticErasedVersion(
@@ -911,7 +913,19 @@ public class FunctionCodegen {
             @NotNull String classToDelegateTo,
             boolean isInterfaceMethodCall
     ) {
-        generateDelegateToMethodBody(isStatic ? 0 : 1, mv, asmMethod, classToDelegateTo, Opcodes.INVOKESTATIC, isInterfaceMethodCall);
+        generateDelegateToStaticMethodBody(isStatic, mv, asmMethod, classToDelegateTo, isInterfaceMethodCall, asmMethod.getReturnType());
+    }
+
+
+    private static void generateDelegateToStaticMethodBody(
+            boolean isStatic,
+            @NotNull MethodVisitor mv,
+            @NotNull Method asmMethod,
+            @NotNull String classToDelegateTo,
+            boolean isInterfaceMethodCall,
+            @NotNull Type returnType
+    ) {
+        generateDelegateToMethodBody(isStatic ? 0 : 1, mv, asmMethod, classToDelegateTo, Opcodes.INVOKESTATIC, isInterfaceMethodCall, returnType);
     }
 
     private static boolean needIndexForVar(JvmMethodParameterKind kind) {
@@ -1064,18 +1078,6 @@ public class FunctionCodegen {
         );
     }
 
-    public static boolean isMethodOfAny(@NotNull FunctionDescriptor descriptor) {
-        String name = descriptor.getName().asString();
-        List<ValueParameterDescriptor> parameters = descriptor.getValueParameters();
-        if (parameters.isEmpty()) {
-            return name.equals("hashCode") || name.equals("toString");
-        }
-        else if (parameters.size() == 1 && name.equals("equals")) {
-            return isNullableAny(parameters.get(0).getType());
-        }
-        return false;
-    }
-
     @NotNull
     public static String[] getThrownExceptions(@NotNull FunctionDescriptor function, @NotNull KotlinTypeMapper typeMapper) {
         return ArrayUtil.toStringArray(CollectionsKt.map(
@@ -1669,7 +1671,9 @@ public class FunctionCodegen {
 
         if (JvmAnnotationUtilKt.isCompiledToJvmDefault(memberDescriptor, mode)) {
             return (kind != OwnerKind.DEFAULT_IMPLS && !isSynthetic) ||
-                   (kind == OwnerKind.DEFAULT_IMPLS && (isSynthetic || mode.isCompatibility()));
+                   (kind == OwnerKind.DEFAULT_IMPLS &&
+                    (isSynthetic || //TODO: move synthetic method generation into interface
+                     (mode.isCompatibility() && !JvmAnnotationUtilKt.hasJvmDefaultNoCompatibilityAnnotation(containingDeclaration))));
         } else {
             switch (kind) {
                 case DEFAULT_IMPLS: return true;

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

@@ -17,8 +17,7 @@
 package org.jetbrains.kotlin.codegen
 
 import com.intellij.util.ArrayUtil
-import org.jetbrains.kotlin.backend.common.bridges.findImplementationFromInterface
-import org.jetbrains.kotlin.backend.common.bridges.firstSuperMethodFromKotlin
+import org.jetbrains.kotlin.util.findImplementationFromInterface
 import org.jetbrains.kotlin.codegen.context.ClassContext
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.codegen.state.JvmMethodExceptionTypes
@@ -29,6 +28,7 @@ import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKind
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
+import org.jetbrains.kotlin.util.firstSuperMethodFromKotlin
 import org.jetbrains.org.objectweb.asm.MethodVisitor
 import org.jetbrains.org.objectweb.asm.Opcodes.*
 

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

@@ -16,6 +16,8 @@ import org.jetbrains.kotlin.load.java.descriptors.JavaForKotlinOverridePropertyD
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.jvm.annotations.isCompiledToJvmDefault
 import org.jetbrains.kotlin.resolve.jvm.annotations.hasPlatformDependentAnnotation
+import org.jetbrains.kotlin.util.findImplementationFromInterface
+import org.jetbrains.kotlin.util.findInterfaceImplementation
 
 class DescriptorBasedFunctionHandleForJvm(
     descriptor: FunctionDescriptor,

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

@@ -422,14 +422,6 @@ public class PropertyCodegen {
         }
         modifiers |= getVisibilityForBackingField(propertyDescriptor, isDelegate);
 
-        // If val is initialized in EXACTLY_ONCE closure, other class from the same package initializes it
-        // so, its visibility should be package private and not final
-        if (!propertyDescriptor.isVar() &&
-            bindingContext.get(BindingContext.FIELD_CAPTURED_IN_EXACLY_ONCE_CLOSURE, propertyDescriptor) != null
-        ) {
-            modifiers &= ~(ACC_PRIVATE | ACC_FINAL);
-        }
-
         if (AsmUtil.isPropertyWithBackingFieldCopyInOuterClass(propertyDescriptor)) {
             ImplementationBodyCodegen parentBodyCodegen = (ImplementationBodyCodegen) memberCodegen.getParentCodegen();
             parentBodyCodegen.addCompanionObjectPropertyToCopy(propertyDescriptor, defaultValue);

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

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.codegen;
 import kotlin.text.StringsKt;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.backend.common.CodegenUtil;
+import org.jetbrains.kotlin.codegen.context.ClassContext;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
 import org.jetbrains.kotlin.descriptors.*;
@@ -32,6 +33,7 @@ import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKt;
+import org.jetbrains.kotlin.resolve.scopes.MemberScope;
 import org.jetbrains.kotlin.storage.LockBasedStorageManager;
 import org.jetbrains.kotlin.types.KotlinType;
 import org.jetbrains.kotlin.util.OperatorNameConventions;
@@ -42,6 +44,7 @@ import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
 import org.jetbrains.org.objectweb.asm.commons.Method;
 
 import java.util.Collections;
+import java.util.Map;
 
 import static org.jetbrains.kotlin.codegen.AsmUtil.*;
 import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.*;
@@ -87,7 +90,7 @@ public class SamWrapperCodegen {
 
         boolean isKotlinFunInterface = !(samType.getClassDescriptor() instanceof JavaClassDescriptor);
 
-        ClassDescriptor classDescriptor = new ClassDescriptorImpl(
+        ClassDescriptorImpl classDescriptor = new ClassDescriptorImpl(
                 samType.getClassDescriptor().getContainingDeclaration(),
                 fqName.shortName(),
                 Modality.FINAL,
@@ -97,6 +100,8 @@ public class SamWrapperCodegen {
                 /* isExternal = */ false,
                 LockBasedStorageManager.NO_LOCKS
         );
+        classDescriptor.initialize(MemberScope.Empty.INSTANCE, Collections.emptySet(), null);
+
         // e.g. compare(T, T)
         SimpleFunctionDescriptor erasedInterfaceFunction = samType.getOriginalAbstractMethod().copy(
                 classDescriptor,
@@ -135,12 +140,17 @@ public class SamWrapperCodegen {
                     null);
 
         generateConstructor(asmType, functionAsmType, cv);
-        generateMethod(asmType, functionAsmType, cv, erasedInterfaceFunction, functionType);
+
+        ClassContext context = state.getRootContext().intoClass(classDescriptor, OwnerKind.IMPLEMENTATION, state);
+        FunctionCodegen functionCodegen = new FunctionCodegen(context, cv, state, parentCodegen);
+        generateMethod(asmType, functionAsmType, erasedInterfaceFunction, functionType, functionCodegen);
 
         if (isKotlinFunInterface) {
             generateGetFunctionDelegate(cv, asmType, functionAsmType);
             generateEquals(cv, asmType, functionAsmType, samAsmType);
             generateHashCode(cv, asmType, functionAsmType);
+
+            generateDelegatesToDefaultImpl(asmType, classDescriptor, samType.getClassDescriptor(), functionCodegen, state);
         }
 
         cv.done();
@@ -171,25 +181,22 @@ public class SamWrapperCodegen {
     }
 
     private void generateMethod(
-            Type ownerType,
-            Type functionType,
-            ClassBuilder cv,
-            SimpleFunctionDescriptor erasedInterfaceFunction,
-            KotlinType functionJetType
+            @NotNull Type ownerType,
+            @NotNull Type functionType,
+            @NotNull SimpleFunctionDescriptor erasedInterfaceFunction,
+            @NotNull KotlinType functionKotlinType,
+            @NotNull FunctionCodegen functionCodegen
     ) {
-        // using root context to avoid creating ClassDescriptor and everything else
-        FunctionCodegen codegen = new FunctionCodegen(state.getRootContext().intoClass(
-                (ClassDescriptor) erasedInterfaceFunction.getContainingDeclaration(), OwnerKind.IMPLEMENTATION, state), cv, state, parentCodegen);
-
-        FunctionDescriptor invokeFunction =
-                functionJetType.getMemberScope().getContributedFunctions(OperatorNameConventions.INVOKE, NoLookupLocation.FROM_BACKEND).iterator().next().getOriginal();
+        FunctionDescriptor invokeFunction = functionKotlinType.getMemberScope().getContributedFunctions(
+                OperatorNameConventions.INVOKE, NoLookupLocation.FROM_BACKEND
+        ).iterator().next().getOriginal();
         StackValue functionField = StackValue.field(functionType, ownerType, FUNCTION_FIELD_NAME, false, StackValue.none());
-        codegen.genSamDelegate(erasedInterfaceFunction, invokeFunction, functionField);
+        functionCodegen.genSamDelegate(erasedInterfaceFunction, invokeFunction, functionField);
 
         // generate sam bridges
         // TODO: erasedInterfaceFunction is actually not an interface function, but function in generated class
         SimpleFunctionDescriptor originalInterfaceErased = samType.getOriginalAbstractMethod();
-        ClosureCodegen.generateBridgesForSAM(originalInterfaceErased, erasedInterfaceFunction, codegen);
+        ClosureCodegen.generateBridgesForSAM(originalInterfaceErased, erasedInterfaceFunction, functionCodegen);
     }
 
     private static void generateEquals(
@@ -248,6 +255,31 @@ public class SamWrapperCodegen {
         FunctionCodegen.endVisit(iv, "getFunctionDelegate of SAM wrapper");
     }
 
+    public static void generateDelegatesToDefaultImpl(
+            @NotNull Type asmType,
+            @NotNull ClassDescriptor classDescriptor,
+            @NotNull ClassDescriptor funInterface,
+            @NotNull FunctionCodegen functionCodegen,
+            @NotNull GenerationState state
+    ) {
+        JvmKotlinType receiverType = new JvmKotlinType(asmType, classDescriptor.getDefaultType());
+
+        for (DeclarationDescriptor descriptor : DescriptorUtils.getAllDescriptors(funInterface.getDefaultType().getMemberScope())) {
+            if (!(descriptor instanceof CallableMemberDescriptor)) continue;
+            CallableMemberDescriptor member = (CallableMemberDescriptor) descriptor;
+            if (member.getModality() == Modality.ABSTRACT ||
+                Visibilities.isPrivate(member.getVisibility()) ||
+                member.getVisibility() == Visibilities.INVISIBLE_FAKE ||
+                DescriptorUtils.isMethodOfAny(member)) continue;
+
+            for (Map.Entry<FunctionDescriptor, FunctionDescriptor> entry : CodegenUtil.INSTANCE.copyFunctions(
+                    member, member, classDescriptor, Modality.OPEN, Visibilities.PUBLIC, CallableMemberDescriptor.Kind.DECLARATION, false
+            ).entrySet()) {
+                ClassBodyCodegen.generateDelegationToDefaultImpl(entry.getKey(), entry.getValue(), receiverType, functionCodegen, state, false);
+            }
+        }
+    }
+
     @NotNull
     private FqName getWrapperName(
             @NotNull KtFile containingFile,

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/codegenUtil.kt

@@ -60,6 +60,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.commons.Method
+import org.jetbrains.org.objectweb.asm.tree.LabelNode
 import java.util.*
 
 fun generateIsCheck(
@@ -666,3 +667,22 @@ private fun generateLambdaForRunSuspend(
     lambdaBuilder.done()
     return lambdaBuilder.thisName
 }
+
+internal fun LabelNode.linkWithLabel(): LabelNode {
+    // Remember labelNode in label and vise versa.
+    // Before ASM 8 there was JB patch in MethodNode that makes such linking in constructor of LabelNode.
+    //
+    // protected LabelNode getLabelNode(final Label label) {
+    //    if (!(label.info instanceof LabelNode)) {
+    //      //label.info = new LabelNode(label); //[JB: needed for Coverage agent]
+    //      label.info = new LabelNode(); //ASM 8
+    //    }
+    //    return (LabelNode) label.info;
+    //  }
+    if (label.info == null) {
+        label.info = this
+    }
+    return this
+}
+
+fun linkedLabel(): Label = LabelNode().linkWithLabel().label

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

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.codegen.optimization.common.*
 import org.jetbrains.kotlin.codegen.optimization.fixStack.FixStackMethodTransformer
 import org.jetbrains.kotlin.codegen.optimization.fixStack.top
 import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
+import org.jetbrains.kotlin.codegen.linkWithLabel
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.isReleaseCoroutines
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
@@ -750,7 +751,7 @@ class CoroutineTransformerMethodVisitor(
         suspendMarkerVarIndex: Int,
         suspendPointLineNumber: LineNumberNode?
     ): LabelNode {
-        val continuationLabel = LabelNode()
+        val continuationLabel = LabelNode().linkWithLabel()
         val continuationLabelAfterLoadedResult = LabelNode()
         val suspendElementLineNumber = lineNumber
         var nextLineNumberNode = nextDefinitelyHitLineNumber(suspension)

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

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.codegen.inline
 
 import org.jetbrains.kotlin.codegen.*
+import org.jetbrains.kotlin.codegen.linkWithLabel
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
@@ -15,6 +16,7 @@ import org.jetbrains.kotlin.resolve.inline.InlineUtil
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
 import org.jetbrains.org.objectweb.asm.Label
 import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.tree.LabelNode
 import org.jetbrains.org.objectweb.asm.tree.MethodNode
 
 class InlineCodegenForDefaultBody(
@@ -27,7 +29,7 @@ class InlineCodegenForDefaultBody(
 ) : CallGenerator {
     private val sourceMapper: SourceMapper = codegen.parentCodegen.orCreateSourceMapper
 
-    private val methodStartLabel = Label()
+    private val methodStartLabel = linkedLabel()
 
     init {
         assert(InlineUtil.isInline(function)) {

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

@@ -33,6 +33,7 @@ import java.io.PrintWriter;
 import java.io.StringWriter;
 import java.util.*;
 
+import static org.jetbrains.kotlin.codegen.CodegenUtilKt.linkedLabel;
 import static org.jetbrains.kotlin.codegen.inline.InlineCodegenUtilsKt.*;
 import static org.jetbrains.kotlin.codegen.inline.MethodInlinerUtilKt.getNextMeaningful;
 
@@ -198,7 +199,7 @@ public class InternalFinallyBlockInliner extends CoveringTryCatchNodeProcessor {
                 //Creating temp node for finally block copy with some additional instruction
                 MethodNode finallyBlockCopy = createEmptyMethodNode();
                 Label newFinallyStart = new Label();
-                Label insertedBlockEnd = new Label();
+                Label insertedBlockEnd = linkedLabel();
 
                 boolean generateAloadAstore = nonLocalReturnType != Type.VOID_TYPE && !finallyInfo.isEmpty();
                 if (generateAloadAstore) {

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

@@ -102,7 +102,7 @@ class MethodInliner(
         }
 
         //substitute returns with "goto end" instruction to keep non local returns in lambdas
-        val end = Label()
+        val end = linkedLabel()
         val isTransformingAnonymousObject = nodeRemapper is RegeneratedLambdaFieldRemapper
         transformedNode = doInline(transformedNode)
         if (!isTransformingAnonymousObject) {

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

@@ -66,16 +66,10 @@ class SourceMapCopier(val parent: SourceMapper, private val smap: SMAP, val call
             return mappedLineNumber
         }
 
-        val newLineNumber = if (lineNumber == 65100) {
-            // TODO This is a compatibility hack for reading bytecode generated by 1.4-M1. Once the bootstrap
-            //   compiler is updated to a newer version, it can be removed (as newer bytecode explicitly lists
-            //   this range in the SMAP).
-            parent.mapSyntheticLineNumber(InlineOnlySmapSkipper.LOCAL_VARIABLE_INLINE_ARGUMENT_SYNTHETIC_LINE_NUMBER)
-        } else {
-            val range = lastVisitedRange?.takeIf { lineNumber in it } ?: smap.findRange(lineNumber) ?: return -1
-            lastVisitedRange = range
-            parent.mapLineNumber(range.mapDestToSource(lineNumber), callSite ?: range.callSite)
-        }
+        val range = lastVisitedRange?.takeIf { lineNumber in it } ?: smap.findRange(lineNumber) ?: return -1
+        lastVisitedRange = range
+        val newLineNumber = parent.mapLineNumber(range.mapDestToSource(lineNumber), callSite ?: range.callSite)
+
         visitedLines.put(lineNumber, newLineNumber)
         return newLineNumber
     }

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

@@ -33,7 +33,11 @@ class TrimMargin : IntrinsicMethod() {
                 val marginPrefix = argument.valueArgument?.getArgumentExpression()
                     ?.let { codegen.getCompileTimeConstant(it) as? StringValue }
                     ?.value ?: return null
-                literalText.trimMargin(marginPrefix)
+                try {
+                    literalText.trimMargin(marginPrefix)
+                } catch (e: IllegalArgumentException) {
+                    return null
+                }
             }
             else -> error("Unknown value argument type ${argument::class}: $argument")
         }

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

@@ -30,7 +30,7 @@ class LabelNormalizationMethodTransformer : MethodTransformer() {
 
     private class TransformerForMethod(val methodNode: MethodNode) {
         val instructions = methodNode.instructions
-        val newLabelNodes = SmartIdentityTable<Label, LabelNode>()
+        val newLabelNodes = SmartIdentityTable<LabelNode, LabelNode>()
 
         fun transform() {
             if (rewriteLabelInstructions()) {
@@ -48,11 +48,11 @@ class LabelNormalizationMethodTransformer : MethodTransformer() {
                 if (thisNode is LabelNode) {
                     val prevNode = thisNode.previous
                     if (prevNode is LabelNode) {
-                        newLabelNodes[thisNode.label] = prevNode
+                        newLabelNodes[thisNode] = prevNode
                         removedAnyLabels = true
                         thisNode = instructions.removeNodeGetNext(thisNode)
                     } else {
-                        newLabelNodes[thisNode.label] = thisNode
+                        newLabelNodes[thisNode] = thisNode
                         thisNode = thisNode.next
                     }
                 } else {
@@ -145,12 +145,12 @@ class LabelNormalizationMethodTransformer : MethodTransformer() {
         }
 
         private fun getNew(oldLabelNode: LabelNode): LabelNode {
-            return newLabelNodes[oldLabelNode.label]
+            return newLabelNodes[oldLabelNode]
                 ?: throw IllegalStateException("Label wasn't found during iterating through instructions")
         }
 
         private fun getNewOrOld(oldLabelNode: LabelNode): LabelNode =
-            newLabelNodes[oldLabelNode.label] ?: oldLabelNode
+            newLabelNodes[oldLabelNode] ?: oldLabelNode
     }
 }
 

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/nullCheck/RedundantNullCheckMethodTransformer.kt

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.codegen.optimization.nullCheck
 import org.jetbrains.kotlin.codegen.coroutines.withInstructionAdapter
 import org.jetbrains.kotlin.codegen.inline.ReifiedTypeInliner
 import org.jetbrains.kotlin.codegen.intrinsics.IntrinsicMethods
+import org.jetbrains.kotlin.codegen.linkWithLabel
 import org.jetbrains.kotlin.codegen.optimization.common.StrictBasicValue
 import org.jetbrains.kotlin.codegen.optimization.common.debugText
 import org.jetbrains.kotlin.codegen.optimization.common.isInsn
@@ -269,7 +270,7 @@ class RedundantNullCheckMethodTransformer(private val generationState: Generatio
                 //  <...>   -- v is null here
 
                 val jumpsIfNull = insn.opcode == Opcodes.IFNULL
-                val originalLabel = insn.label
+                val originalLabel = insn.label.linkWithLabel()
                 originalLabels[insn] = originalLabel
                 insn.label = synthetic(LabelNode(Label()))
 
@@ -342,7 +343,7 @@ class RedundantNullCheckMethodTransformer(private val generationState: Generatio
                 val originalLabel: LabelNode?
                 val insertAfterNotNull: AbstractInsnNode
                 if (jumpsIfInstance) {
-                    originalLabel = next.label
+                    originalLabel = next.label.linkWithLabel()
                     originalLabels[next] = next.label
                     val newLabel = synthetic(LabelNode(Label()))
                     methodNode.instructions.add(newLabel)

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

@@ -32,6 +32,7 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.classId
 import org.jetbrains.kotlin.resolve.descriptorUtil.isEffectivelyPrivateApi
 import org.jetbrains.kotlin.resolve.descriptorUtil.nonSourceAnnotations
 import org.jetbrains.kotlin.resolve.jvm.annotations.hasJvmDefaultAnnotation
+import org.jetbrains.kotlin.resolve.jvm.requiresFunctionNameManglingForParameterTypes
 import org.jetbrains.kotlin.resolve.jvm.requiresFunctionNameManglingForReturnType
 import org.jetbrains.kotlin.serialization.DescriptorSerializer
 import org.jetbrains.kotlin.serialization.DescriptorSerializer.Companion.writeVersionRequirement
@@ -93,7 +94,13 @@ class JvmSerializerExtension @JvmOverloads constructor(
         writeVersionRequirementForJvmDefaultIfNeeded(descriptor, proto, versionRequirementTable)
 
         if (jvmDefaultMode.forAllMethodsWithBody && isInterface(descriptor)) {
-            proto.setExtension(JvmProtoBuf.jvmClassFlags, JvmFlags.getClassFlags(true))
+            proto.setExtension(
+                JvmProtoBuf.jvmClassFlags,
+                JvmFlags.getClassFlags(
+                    jvmDefaultMode.forAllMethodsWithBody,
+                    JvmDefaultMode.ALL_COMPATIBILITY == jvmDefaultMode
+                )
+            )
         }
     }
 
@@ -202,7 +209,10 @@ class JvmSerializerExtension @JvmOverloads constructor(
             versionRequirementTable?.writeInlineParameterNullCheckRequirement(proto::addVersionRequirement)
         }
 
-        if (requiresFunctionNameManglingForReturnType(descriptor)) {
+        if (requiresFunctionNameManglingForReturnType(descriptor) &&
+            !DescriptorUtils.hasJvmNameAnnotation(descriptor) &&
+            !requiresFunctionNameManglingForParameterTypes(descriptor)
+        ) {
             versionRequirementTable?.writeFunctionNameManglingForReturnTypeRequirement(proto::addVersionRequirement)
         }
     }
@@ -267,7 +277,7 @@ class JvmSerializerExtension @JvmOverloads constructor(
             versionRequirementTable?.writeInlineParameterNullCheckRequirement(proto::addVersionRequirement)
         }
 
-        if (requiresFunctionNameManglingForReturnType(descriptor)) {
+        if (!DescriptorUtils.hasJvmNameAnnotation(descriptor) && requiresFunctionNameManglingForReturnType(descriptor)) {
             versionRequirementTable?.writeFunctionNameManglingForReturnTypeRequirement(proto::addVersionRequirement)
         }
     }

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

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.codegen.state
 
 import org.jetbrains.kotlin.codegen.coroutines.unwrapInitialDescriptorForSuspendFunction
 import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.InlineClassDescriptorResolver
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe
 import org.jetbrains.kotlin.resolve.jvm.requiresFunctionNameManglingForParameterTypes
@@ -24,10 +25,13 @@ fun getManglingSuffixBasedOnKotlinSignature(
     if (descriptor is ConstructorDescriptor) return null
     if (InlineClassDescriptorResolver.isSynthesizedBoxOrUnboxMethod(descriptor)) return null
 
+    // Don't mangle functions with '@JvmName' annotation.
+    // Some stdlib functions ('Result.success', 'Result.failure') are annotated with '@JvmName' as a workaround for forward compatibility.
+    if (DescriptorUtils.hasJvmNameAnnotation(descriptor)) return null
+
     // If a function accepts inline class parameters, mangle its name.
-    val actualValueParameterTypes = listOfNotNull(descriptor.extensionReceiverParameter?.type) + descriptor.valueParameters.map { it.type }
-    if (requiresFunctionNameManglingForParameterTypes(actualValueParameterTypes)) {
-        return "-" + md5base64(collectSignatureForMangling(actualValueParameterTypes))
+    if (requiresFunctionNameManglingForParameterTypes(descriptor)) {
+        return "-" + md5base64(collectSignatureForMangling(descriptor))
     }
 
     // If a class member function returns inline class value, mangle its name.
@@ -42,8 +46,10 @@ fun getManglingSuffixBasedOnKotlinSignature(
     return null
 }
 
-private fun collectSignatureForMangling(types: List<KotlinType>) =
-    types.joinToString { getSignatureElementForMangling(it) }
+private fun collectSignatureForMangling(descriptor: CallableMemberDescriptor): String {
+    val types = listOfNotNull(descriptor.extensionReceiverParameter?.type) + descriptor.valueParameters.map { it.type }
+    return types.joinToString { getSignatureElementForMangling(it) }
+}
 
 private fun getSignatureElementForMangling(type: KotlinType): String = buildString {
     val descriptor = type.constructor.declarationDescriptor ?: return ""

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

@@ -67,7 +67,7 @@ class BuiltInsSerializer(dependOnOldBuiltIns: Boolean) : MetadataSerializer(Buil
             PrintingMessageCollector(System.err, MessageRenderer.PLAIN_RELATIVE_PATHS, false),
             false
     ) {
-        override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageLocation?) {
+        override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageSourceLocation?) {
             // Only report diagnostics without a particular location because there's plenty of errors in built-in sources
             // (functions without bodies, incorrect combination of modifiers, etc.)
             if (location == null) {

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

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.serialization.builtins
 import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.metadata.builtins.BuiltInsBinaryVersion
 import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion
+import org.jetbrains.kotlin.serialization.AnnotationSerializer
 import org.jetbrains.kotlin.serialization.KotlinSerializerExtensionBase
 import org.jetbrains.kotlin.serialization.deserialization.builtins.BuiltInSerializerProtocol
 import org.jetbrains.kotlin.types.KotlinType
@@ -31,20 +32,29 @@ class BuiltInsSerializerExtension : KotlinSerializerExtensionBase(BuiltInSeriali
         "CharRange" to "kotlin/ranges/CharRange"
     )
 
+    override fun createAnnotationSerializer(): AnnotationSerializer = object : AnnotationSerializer(stringTable) {
+        override fun ignoreAnnotation(type: KotlinType): Boolean =
+            type.presentableName == "JvmStatic" || type.presentableName == "JvmField" || super.ignoreAnnotation(type)
+    }
+
     override val metadataVersion: BinaryVersion
         get() = BuiltInsBinaryVersion.INSTANCE
 
     override fun shouldUseTypeTable(): Boolean = true
 
     override fun serializeErrorType(type: KotlinType, builder: ProtoBuf.Type.Builder) {
-        val unwrapped = type.unwrap()
-        if (unwrapped !is UnresolvedType) {
-            throw UnsupportedOperationException("Error types which are not UnresolvedType instances are not supported here: $unwrapped")
-        }
-
-        val className = shortNameToClassId[unwrapped.presentableName]
-                ?: throw UnsupportedOperationException("Unsupported unresolved type: $unwrapped")
+        val className = shortNameToClassId[type.presentableName]
+            ?: throw UnsupportedOperationException("Unsupported unresolved type: ${type.unwrap()}")
 
         builder.className = stringTable.getQualifiedClassNameIndex(className, false)
     }
+
+    private val KotlinType.presentableName: String
+        get() {
+            val unwrapped = unwrap()
+            if (unwrapped !is UnresolvedType) {
+                throw UnsupportedOperationException("Error types which are not UnresolvedType instances are not supported here: $unwrapped")
+            }
+            return unwrapped.presentableName
+        }
 }

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

@@ -340,6 +340,12 @@ abstract class CommonCompilerArguments : CommonToolArguments() {
     )
     var explicitApi: String by FreezableVar(ExplicitApiMode.DISABLED.state)
 
+    @Argument(
+        value = "-Xdeserialize-fake-overrides",
+        description = "Fallback to deserializing fake overrides"
+    )
+    var deserializeFakeOverrides: Boolean by FreezableVar(false)
+
     open fun configureAnalysisFlags(collector: MessageCollector): MutableMap<AnalysisFlag<*>, Any> {
         return HashMap<AnalysisFlag<*>, Any>().apply {
             put(AnalysisFlags.skipMetadataVersionCheck, skipMetadataVersionCheck)
@@ -382,6 +388,7 @@ abstract class CommonCompilerArguments : CommonToolArguments() {
                 put(LanguageFeature.NewInference, LanguageFeature.State.ENABLED)
                 put(LanguageFeature.SamConversionPerArgument, LanguageFeature.State.ENABLED)
                 put(LanguageFeature.FunctionReferenceWithDefaultValueAsOtherType, LanguageFeature.State.ENABLED)
+                put(LanguageFeature.DisableCompatibilityModeForNewInference, LanguageFeature.State.ENABLED)
             }
 
             if (inlineClasses) {
@@ -461,6 +468,8 @@ abstract class CommonCompilerArguments : CommonToolArguments() {
 
             if (!functionReferenceWithDefaultValueFeaturePassedExplicitly)
                 put(LanguageFeature.FunctionReferenceWithDefaultValueAsOtherType, LanguageFeature.State.ENABLED)
+
+            put(LanguageFeature.DisableCompatibilityModeForNewInference, LanguageFeature.State.ENABLED)
         }
 
         if (featuresThatForcePreReleaseBinaries.isNotEmpty()) {

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

@@ -169,6 +169,9 @@ class K2JSCompilerArguments : CommonCompilerArguments() {
     @Argument(value = "-Xenable-js-scripting", description = "Enable experimental support of .kts files using K/JS (with -Xir only)")
     var enableJsScripting: Boolean by FreezableVar(false)
 
+    @Argument(value = "-Xdisable-fake-override-validator", description = "Disable IR fake override validator")
+    var disableFakeOverrideValidator: Boolean by FreezableVar(false)
+
     override fun checkIrSupport(languageVersionSettings: LanguageVersionSettings, collector: MessageCollector) {
         if (!isIrBackendEnabled()) return
 

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/messages/CompilerMessageLocation.kt

@@ -18,24 +18,61 @@ package org.jetbrains.kotlin.cli.common.messages
 
 import java.io.Serializable
 
+interface CompilerMessageSourceLocation : Serializable {
+    val path: String
+    val line: Int
+    val column: Int
+    val lineEnd: Int get() = -1
+    val columnEnd: Int get() = -1
+    val lineContent: String?
+}
+
 data class CompilerMessageLocation private constructor(
-        val path: String,
-        val line: Int,
-        val column: Int,
-        val lineContent: String?
-) : Serializable {
+    override val path: String,
+    override val line: Int,
+    override val column: Int,
+    override val lineContent: String?
+) : CompilerMessageSourceLocation {
     override fun toString(): String =
-            path + (if (line != -1 || column != -1) " ($line:$column)" else "")
+        path + (if (line != -1 || column != -1) " ($line:$column)" else "")
 
     companion object {
         @JvmStatic
         fun create(path: String?): CompilerMessageLocation? =
-                create(path, -1, -1, null)
+            create(path, -1, -1, null)
 
         @JvmStatic
         fun create(path: String?, line: Int, column: Int, lineContent: String?): CompilerMessageLocation? =
-                if (path == null) null else CompilerMessageLocation(path, line, column, lineContent)
+            if (path == null) null else CompilerMessageLocation(path, line, column, lineContent)
 
         private val serialVersionUID: Long = 8228357578L
     }
 }
+
+data class CompilerMessageLocationWithRange private constructor(
+    override val path: String,
+    override val line: Int,
+    override val column: Int,
+    override val lineEnd: Int,
+    override val columnEnd: Int,
+    override val lineContent: String?
+) : CompilerMessageSourceLocation {
+    override fun toString(): String =
+        path + (if (line != -1 || column != -1) " ($line:$column)" else "")
+
+    companion object {
+        @JvmStatic
+        fun create(
+            path: String?,
+            lineStart: Int,
+            columnStart: Int,
+            lineEnd: Int?,
+            columnEnd: Int?,
+            lineContent: String?
+        ): CompilerMessageLocationWithRange? =
+            if (path == null) null else CompilerMessageLocationWithRange(path, lineStart, columnStart, lineEnd ?: -1, columnEnd ?: -1, lineContent)
+
+        private val serialVersionUID: Long = 8228357578L
+    }
+}
+

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

@@ -36,7 +36,7 @@ public class FilteringMessageCollector implements MessageCollector {
     }
 
     @Override
-    public void report(@NotNull CompilerMessageSeverity severity, @NotNull String message, @Nullable CompilerMessageLocation location) {
+    public void report(@NotNull CompilerMessageSeverity severity, @NotNull String message, @Nullable CompilerMessageSourceLocation location) {
         if (!decline.test(severity)) {
             messageCollector.report(severity, message, location);
         }

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

@@ -24,7 +24,6 @@ import org.jetbrains.annotations.Nullable;
 
 import java.util.Comparator;
 import java.util.List;
-import java.util.Map;
 import java.util.Objects;
 
 public class GroupingMessageCollector implements MessageCollector {
@@ -32,7 +31,7 @@ public class GroupingMessageCollector implements MessageCollector {
     private final boolean treatWarningsAsErrors;
 
     // Note that the key in this map can be null
-    private final Multimap<CompilerMessageLocation, Message> groupedMessages = LinkedHashMultimap.create();
+    private final Multimap<CompilerMessageSourceLocation, Message> groupedMessages = LinkedHashMultimap.create();
 
     public GroupingMessageCollector(@NotNull MessageCollector delegate, boolean treatWarningsAsErrors) {
         this.delegate = delegate;
@@ -48,7 +47,7 @@ public class GroupingMessageCollector implements MessageCollector {
     public void report(
             @NotNull CompilerMessageSeverity severity,
             @NotNull String message,
-            @Nullable CompilerMessageLocation location
+            @Nullable CompilerMessageSourceLocation location
     ) {
         if (CompilerMessageSeverity.VERBOSE.contains(severity)) {
             delegate.report(severity, message, location);
@@ -78,9 +77,9 @@ public class GroupingMessageCollector implements MessageCollector {
             report(CompilerMessageSeverity.ERROR, "warnings found and -Werror specified", null);
         }
 
-        List<CompilerMessageLocation> sortedKeys =
+        List<CompilerMessageSourceLocation> sortedKeys =
                 CollectionsKt.sortedWith(groupedMessages.keySet(), Comparator.nullsFirst(CompilerMessageLocationComparator.INSTANCE));
-        for (CompilerMessageLocation location : sortedKeys) {
+        for (CompilerMessageSourceLocation location : sortedKeys) {
             for (Message message : groupedMessages.get(location)) {
                 if (!hasExplicitErrors || message.severity.isError() || message.severity == CompilerMessageSeverity.STRONG_WARNING) {
                     delegate.report(message.severity, message.message, message.location);
@@ -91,7 +90,7 @@ public class GroupingMessageCollector implements MessageCollector {
         groupedMessages.clear();
     }
 
-    private static class CompilerMessageLocationComparator implements Comparator<CompilerMessageLocation> {
+    private static class CompilerMessageLocationComparator implements Comparator<CompilerMessageSourceLocation> {
         public static final CompilerMessageLocationComparator INSTANCE = new CompilerMessageLocationComparator();
 
         // First, output all messages without any location information. Then, only those with the file path.
@@ -104,7 +103,7 @@ public class GroupingMessageCollector implements MessageCollector {
         // foo.kt:42: error: bad line
         // foo.kt:42:43: error: bad character
         @Override
-        public int compare(CompilerMessageLocation o1, CompilerMessageLocation o2) {
+        public int compare(CompilerMessageSourceLocation o1, CompilerMessageSourceLocation o2) {
             if (o1.getColumn() == -1 && o2.getColumn() != -1) return -1;
             if (o1.getColumn() != -1 && o2.getColumn() == -1) return 1;
 
@@ -118,9 +117,9 @@ public class GroupingMessageCollector implements MessageCollector {
     private static class Message {
         private final CompilerMessageSeverity severity;
         private final String message;
-        private final CompilerMessageLocation location;
+        private final CompilerMessageSourceLocation location;
 
-        private Message(@NotNull CompilerMessageSeverity severity, @NotNull String message, @Nullable CompilerMessageLocation location) {
+        private Message(@NotNull CompilerMessageSeverity severity, @NotNull String message, @Nullable CompilerMessageSourceLocation location) {
             this.severity = severity;
             this.message = message;
             this.location = location;

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/messages/MessageCollector.kt

@@ -19,13 +19,13 @@ package org.jetbrains.kotlin.cli.common.messages
 interface MessageCollector {
     fun clear()
 
-    fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageLocation? = null)
+    fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageSourceLocation? = null)
 
     fun hasErrors(): Boolean
 
     companion object {
         val NONE: MessageCollector = object : MessageCollector {
-            override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageLocation?) {
+            override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageSourceLocation?) {
                 // Do nothing
             }
 

compiler/cli/cli-common/src/org/jetbrains/kotlin/utils/parametersMap.kt

@@ -63,8 +63,8 @@ private interface ArgsConverter<T> {
     }
 
     fun tryConvertSingle(parameter: KParameter, arg: NamedArgument<T>): Result
-    fun tryConvertVararg(parameter: KParameter, firstArg: NamedArgument<T>, restArgsIt: Iterator<NamedArgument<T>>): Result
-    fun tryConvertTail(parameter: KParameter, firstArg: NamedArgument<T>, restArgsIt: Iterator<NamedArgument<T>>): Result
+    fun tryConvertVararg(parameter: KParameter, firstArg: NamedArgument<T>, restArgs: Sequence<NamedArgument<T>>): Result
+    fun tryConvertTail(parameter: KParameter, firstArg: NamedArgument<T>, restArgs: Sequence<NamedArgument<T>>): Result
 }
 
 private enum class ArgsTraversalState { UNNAMED, NAMED, TAIL }
@@ -77,7 +77,7 @@ private fun <T> tryCreateCallableMapping(
     val res = mutableMapOf<KParameter, Any?>()
     var state = ArgsTraversalState.UNNAMED
     val unboundParams = callable.parameters.toMutableList()
-    val argIt = args.iterator()
+    val argIt = LookAheadIterator(args.iterator())
     while (argIt.hasNext()) {
         if (unboundParams.isEmpty()) return null // failed to match: no param left for the arg
         val arg = argIt.next()
@@ -102,7 +102,11 @@ private fun <T> tryCreateCallableMapping(
                     res[par] = cvtRes.v
                 } else if (par.type.jvmErasure.java.isArray) {
                     // try vararg
-                    val cvtVRes = converter.tryConvertVararg(par, arg, argIt)
+
+                    // Collect all the arguments that do not have a name
+                    val unnamed = argIt.sequenceUntil { it.name != null }
+
+                    val cvtVRes = converter.tryConvertVararg(par, arg, unnamed)
                     if (cvtVRes is ArgsConverter.Result.Success) {
                         res[par] = cvtVRes.v
                     } else return null // failed to match: no suitable param for unnamed arg
@@ -121,7 +125,7 @@ private fun <T> tryCreateCallableMapping(
             ArgsTraversalState.TAIL -> {
                 assert(arg.name == null)
                 val par = unboundParams.removeAt(unboundParams.lastIndex)
-                val cvtVRes = converter.tryConvertTail(par, arg, argIt)
+                val cvtVRes = converter.tryConvertTail(par, arg, argIt.asSequence())
                 if (cvtVRes is ArgsConverter.Result.Success) {
                     if (argIt.hasNext()) return null // failed to match: not all tail args are consumed
                     res[par] = cvtVRes.v
@@ -162,7 +166,7 @@ private class StringArgsConverter : ArgsConverter<String> {
     override fun tryConvertVararg(
         parameter: KParameter,
         firstArg: NamedArgument<String>,
-        restArgsIt: Iterator<NamedArgument<String>>
+        restArgs: Sequence<NamedArgument<String>>
     ): ArgsConverter.Result {
         fun convertPrimitivesArray(type: KType, args: Sequence<String?>): Any? =
             when (type.classifier) {
@@ -179,7 +183,7 @@ private class StringArgsConverter : ArgsConverter<String> {
 
         val parameterType = parameter.type
         if (parameterType.jvmErasure.java.isArray) {
-            val argsSequence = sequenceOf(firstArg.value) + restArgsIt.asSequence().map { it.value }
+            val argsSequence = sequenceOf(firstArg.value) + restArgs.map { it.value }
             val primArrayArgCandidate = convertPrimitivesArray(parameterType, argsSequence)
             if (primArrayArgCandidate != null)
                 return ArgsConverter.Result.Success(primArrayArgCandidate)
@@ -195,9 +199,9 @@ private class StringArgsConverter : ArgsConverter<String> {
     override fun tryConvertTail(
         parameter: KParameter,
         firstArg: NamedArgument<String>,
-        restArgsIt: Iterator<NamedArgument<String>>
+        restArgs: Sequence<NamedArgument<String>>
     ): ArgsConverter.Result =
-        tryConvertVararg(parameter, firstArg, restArgsIt)
+        tryConvertVararg(parameter, firstArg, restArgs)
 }
 
 private class AnyArgsConverter : ArgsConverter<Any> {
@@ -218,18 +222,33 @@ private class AnyArgsConverter : ArgsConverter<Any> {
                 else -> null
             }
 
-        if (value::class.isSubclassOf(parameter.type.jvmErasure)) return ArgsConverter.Result.Success(value)
+        fun evaluateValue(arg: Any): Any? {
+            if (arg::class.isSubclassOf(parameter.type.jvmErasure)) return arg
+            return convertPrimitivesArray(parameter.type, arg)
+        }
 
-        return convertPrimitivesArray(parameter.type, value)?.let { ArgsConverter.Result.Success(it) }
-            ?: ArgsConverter.Result.Failure
+        evaluateValue(value)?.let { return ArgsConverter.Result.Success(it) }
+
+        // Handle the scenario where [arg::class] is an Array<Any>
+        // but it's values could all still be valid
+        val parameterKClass = parameter.type.classifier as? KClass<*>
+        val arrayComponentType = parameterKClass?.java?.takeIf { it.isArray}?.componentType?.kotlin
+
+        if (value is Array<*> && arrayComponentType != null) {
+            // TODO: Idea! Maybe we should check if the values in the array are compatible with [arrayComponentType]
+            //  if they aren't perhaps we should fail silently
+            convertAnyArray(arrayComponentType, value.asSequence())?.let(::evaluateValue)?.let { return ArgsConverter.Result.Success(it) }
+        }
+
+        return ArgsConverter.Result.Failure
     }
 
     override fun tryConvertVararg(
-        parameter: KParameter, firstArg: NamedArgument<Any>, restArgsIt: Iterator<NamedArgument<Any>>
+        parameter: KParameter, firstArg: NamedArgument<Any>, restArgs: Sequence<NamedArgument<Any>>
     ): ArgsConverter.Result {
         val parameterType = parameter.type
         if (parameterType.jvmErasure.java.isArray) {
-            val argsSequence = sequenceOf(firstArg.value) + restArgsIt.asSequence().map { it.value }
+            val argsSequence = sequenceOf(firstArg.value) + restArgs.map { it.value }
             val arrayElementType = parameterType.arguments.firstOrNull()?.type
             val arrayArgCandidate = convertAnyArray(arrayElementType?.classifier, argsSequence)
             if (arrayArgCandidate != null)
@@ -242,7 +261,7 @@ private class AnyArgsConverter : ArgsConverter<Any> {
     override fun tryConvertTail(
         parameter: KParameter,
         firstArg: NamedArgument<Any>,
-        restArgsIt: Iterator<NamedArgument<Any>>
+        restArgs: Sequence<NamedArgument<Any>>
     ): ArgsConverter.Result =
         tryConvertSingle(parameter, firstArg)
 }
@@ -266,3 +285,38 @@ private fun <T> convertAnyArrayImpl(classifier: KClassifier?, args: Sequence<T?>
     }
     return result
 }
+
+/*
+ An iterator that allows us to read the next value without consuming it.
+ */
+private class LookAheadIterator<T>(private val iterator: Iterator<T>) : Iterator<T> {
+    private var currentLookAhead: T? = null
+
+    override fun hasNext(): Boolean {
+        return currentLookAhead != null || iterator.hasNext()
+    }
+
+    override fun next(): T {
+        currentLookAhead?.let { value ->
+            currentLookAhead = null
+            return value
+        }
+
+        return iterator.next()
+    }
+
+    fun nextWithoutConsuming(): T {
+        return currentLookAhead ?: iterator.next().also { currentLookAhead = it }
+    }
+}
+
+/*
+ Will return a sequence with the values of the iterator until the predicate evaluates to true.
+ */
+private fun <T> LookAheadIterator<T>.sequenceUntil(predicate: (T) -> Boolean): Sequence<T> = sequence {
+    while (hasNext()) {
+        if (predicate(nextWithoutConsuming()))
+            break
+        yield(next())
+    }
+}

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

@@ -322,6 +322,7 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
         }
 
         configuration.put(JSConfigurationKeys.PRINT_REACHABILITY_INFO, arguments.irDcePrintReachabilityInfo)
+        configuration.put(JSConfigurationKeys.DISABLE_FAKE_OVERRIDE_VALIDATOR, arguments.disableFakeOverrideValidator)
     }
 
     override fun executableScriptFileName(): String {

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

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

compiler/cli/src/org/jetbrains/kotlin/cli/common/messages/DefaultDiagnosticReporter.kt

@@ -31,6 +31,6 @@ interface MessageCollectorBasedReporter : DiagnosticMessageReporter {
     override fun report(diagnostic: Diagnostic, file: PsiFile, render: String) = messageCollector.report(
         AnalyzerWithCompilerReport.convertSeverity(diagnostic.severity),
         render,
-        MessageUtil.psiFileToMessageLocation(file, file.name, DiagnosticUtils.getLineAndColumn(diagnostic))
+        MessageUtil.psiFileToMessageLocation(file, file.name, DiagnosticUtils.getLineAndColumnRange(diagnostic))
     )
 }

compiler/cli/src/org/jetbrains/kotlin/cli/common/messages/DefaultDiagnosticReporter.kt.202

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.cli.common.messages
+
+import com.intellij.psi.PsiFile
+import org.jetbrains.kotlin.diagnostics.Diagnostic
+import org.jetbrains.kotlin.diagnostics.DiagnosticUtils
+
+/**
+ * This class behaviour is the same as [MessageCollector.report] in [AnalyzerWithCompilerReport.reportDiagnostic].
+ */
+class DefaultDiagnosticReporter(override val messageCollector: MessageCollector) : MessageCollectorBasedReporter
+
+interface MessageCollectorBasedReporter : DiagnosticMessageReporter {
+    val messageCollector: MessageCollector
+
+    override fun report(diagnostic: Diagnostic, file: PsiFile, render: String) = messageCollector.report(
+        AnalyzerWithCompilerReport.convertSeverity(diagnostic.severity),
+        render,
+        MessageUtil.psiFileToMessageLocation(file, file.name, DiagnosticUtils.getLineAndColumn(diagnostic))
+    )
+}

compiler/cli/src/org/jetbrains/kotlin/cli/common/messages/GradleStyleMessagerRenderer.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.cli.common.messages
 
 class GradleStyleMessageRenderer : MessageRenderer {
 
-    override fun render(severity: CompilerMessageSeverity, message: String, location: CompilerMessageLocation?): String {
+    override fun render(severity: CompilerMessageSeverity, message: String, location: CompilerMessageSourceLocation?): String {
         val prefix = when (severity) {
             CompilerMessageSeverity.WARNING, CompilerMessageSeverity.STRONG_WARNING -> "w"
             CompilerMessageSeverity.ERROR, CompilerMessageSeverity.EXCEPTION -> "e"

compiler/cli/src/org/jetbrains/kotlin/cli/common/messages/MessageRenderer.java

@@ -32,7 +32,7 @@ public interface MessageRenderer {
     MessageRenderer WITHOUT_PATHS = new PlainTextMessageRenderer() {
         @Nullable
         @Override
-        protected String getPath(@NotNull CompilerMessageLocation location) {
+        protected String getPath(@NotNull CompilerMessageSourceLocation location) {
             return null;
         }
 
@@ -45,7 +45,7 @@ public interface MessageRenderer {
     MessageRenderer PLAIN_FULL_PATHS = new PlainTextMessageRenderer() {
         @NotNull
         @Override
-        protected String getPath(@NotNull CompilerMessageLocation location) {
+        protected String getPath(@NotNull CompilerMessageSourceLocation location) {
             return location.getPath();
         }
 
@@ -60,7 +60,7 @@ public interface MessageRenderer {
 
         @NotNull
         @Override
-        protected String getPath(@NotNull CompilerMessageLocation location) {
+        protected String getPath(@NotNull CompilerMessageSourceLocation location) {
             return FileUtilsKt.descendantRelativeTo(new File(location.getPath()), cwd).getPath();
         }
 
@@ -75,7 +75,7 @@ public interface MessageRenderer {
 
         @Nullable
         @Override
-        protected String getPath(@NotNull CompilerMessageLocation location) {
+        protected String getPath(@NotNull CompilerMessageSourceLocation location) {
             return FileUtil.toSystemIndependentName(
                     FileUtilsKt.descendantRelativeTo(new File(location.getPath()), cwd).getPath()
             );
@@ -91,7 +91,7 @@ public interface MessageRenderer {
 
     String renderPreamble();
 
-    String render(@NotNull CompilerMessageSeverity severity, @NotNull String message, @Nullable CompilerMessageLocation location);
+    String render(@NotNull CompilerMessageSeverity severity, @NotNull String message, @Nullable CompilerMessageSourceLocation location);
 
     String renderUsage(@NotNull String usage);
 

compiler/cli/src/org/jetbrains/kotlin/cli/common/messages/MessageUtil.java

@@ -32,21 +32,23 @@ public class MessageUtil {
     private MessageUtil() {}
 
     @Nullable
-    public static CompilerMessageLocation psiElementToMessageLocation(@Nullable PsiElement element) {
+    public static CompilerMessageSourceLocation psiElementToMessageLocation(@Nullable PsiElement element) {
         if (element == null) return null;
         PsiFile file = element.getContainingFile();
-        return psiFileToMessageLocation(file, "<no path>", DiagnosticUtils.getLineAndColumnInPsiFile(file, element.getTextRange()));
+        return psiFileToMessageLocation(file, "<no path>", DiagnosticUtils.getLineAndColumnRangeInPsiFile(file, element.getTextRange()));
     }
 
     @Nullable
-    public static CompilerMessageLocation psiFileToMessageLocation(
+    public static CompilerMessageSourceLocation psiFileToMessageLocation(
             @NotNull PsiFile file,
             @Nullable String defaultValue,
-            @NotNull PsiDiagnosticUtils.LineAndColumn lineAndColumn
+            @NotNull PsiDiagnosticUtils.LineAndColumnRange range
     ) {
         VirtualFile virtualFile = file.getVirtualFile();
         String path = virtualFile != null ? virtualFileToPath(virtualFile) : defaultValue;
-        return CompilerMessageLocation.create(path, lineAndColumn.getLine(), lineAndColumn.getColumn(), lineAndColumn.getLineContent());
+        PsiDiagnosticUtils.LineAndColumn start = range.getStart();
+        PsiDiagnosticUtils.LineAndColumn end = range.getEnd();
+        return CompilerMessageLocationWithRange.create(path, start.getLine(), start.getColumn(), end.getLine(), end.getColumn(), start.getLineContent());
     }
 
     @NotNull

compiler/cli/src/org/jetbrains/kotlin/cli/common/messages/MessageUtil.java.202

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.cli.common.messages;
+
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.diagnostics.DiagnosticUtils;
+import org.jetbrains.kotlin.diagnostics.PsiDiagnosticUtils;
+
+import static com.intellij.openapi.util.io.FileUtil.toSystemDependentName;
+
+public class MessageUtil {
+    private MessageUtil() {}
+
+    @Nullable
+    public static CompilerMessageLocation psiElementToMessageLocation(@Nullable PsiElement element) {
+        if (element == null) return null;
+        PsiFile file = element.getContainingFile();
+        return psiFileToMessageLocation(file, "<no path>", DiagnosticUtils.getLineAndColumnInPsiFile(file, element.getTextRange()));
+    }
+
+    @Nullable
+    public static CompilerMessageLocation psiFileToMessageLocation(
+            @NotNull PsiFile file,
+            @Nullable String defaultValue,
+            @NotNull PsiDiagnosticUtils.LineAndColumn lineAndColumn
+    ) {
+        VirtualFile virtualFile = file.getVirtualFile();
+        String path = virtualFile != null ? virtualFileToPath(virtualFile) : defaultValue;
+        return CompilerMessageLocation.create(path, lineAndColumn.getLine(), lineAndColumn.getColumn(), lineAndColumn.getLineContent());
+    }
+
+    @NotNull
+    public static String virtualFileToPath(@NotNull VirtualFile virtualFile) {
+        return toSystemDependentName(virtualFile.getPath());
+    }
+}

compiler/cli/src/org/jetbrains/kotlin/cli/common/messages/PlainTextMessageRenderer.java

@@ -58,7 +58,7 @@ public abstract class PlainTextMessageRenderer implements MessageRenderer {
     }
 
     @Override
-    public String render(@NotNull CompilerMessageSeverity severity, @NotNull String message, @Nullable CompilerMessageLocation location) {
+    public String render(@NotNull CompilerMessageSeverity severity, @NotNull String message, @Nullable CompilerMessageSourceLocation location) {
         StringBuilder result = new StringBuilder();
 
         int line = location != null ? location.getLine() : -1;
@@ -156,7 +156,7 @@ public abstract class PlainTextMessageRenderer implements MessageRenderer {
     }
 
     @Nullable
-    protected abstract String getPath(@NotNull CompilerMessageLocation location);
+    protected abstract String getPath(@NotNull CompilerMessageSourceLocation location);
 
     @Override
     public String renderUsage(@NotNull String usage) {

compiler/cli/src/org/jetbrains/kotlin/cli/common/messages/PrintingMessageCollector.java

@@ -42,7 +42,7 @@ public class PrintingMessageCollector implements MessageCollector {
     public void report(
             @NotNull CompilerMessageSeverity severity,
             @NotNull String message,
-            @Nullable CompilerMessageLocation location
+            @Nullable CompilerMessageSourceLocation location
     ) {
         if (!verbose && CompilerMessageSeverity.VERBOSE.contains(severity)) return;
 

compiler/cli/src/org/jetbrains/kotlin/cli/common/messages/XmlMessageRenderer.java

@@ -27,7 +27,7 @@ public class XmlMessageRenderer implements MessageRenderer {
     }
 
     @Override
-    public String render(@NotNull CompilerMessageSeverity severity, @NotNull String message, @Nullable CompilerMessageLocation location) {
+    public String render(@NotNull CompilerMessageSeverity severity, @NotNull String message, @Nullable CompilerMessageSourceLocation location) {
         StringBuilder out = new StringBuilder();
         String tagName = severity.getPresentableName();
         out.append("<").append(tagName);

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

@@ -66,6 +66,7 @@ import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.*
+import org.jetbrains.kotlin.resolve.calls.tower.ImplicitsExtensionsResolutionFilter
 import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
 import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
 import org.jetbrains.kotlin.resolve.jvm.extensions.PackageFragmentProviderExtension
@@ -135,7 +136,8 @@ object TopDownAnalyzerFacadeForJVM {
         declarationProviderFactory: (StorageManager, Collection<KtFile>) -> DeclarationProviderFactory,
         targetEnvironment: TargetEnvironment = CompilerEnvironment,
         sourceModuleSearchScope: GlobalSearchScope = newModuleSearchScope(project, files),
-        klibList: List<KotlinLibrary> = emptyList()
+        klibList: List<KotlinLibrary> = emptyList(),
+        implicitsResolutionFilter: ImplicitsExtensionsResolutionFilter? = null
     ): ComponentProvider {
         val jvmTarget = configuration.get(JVMConfigurationKeys.JVM_TARGET, JvmTarget.DEFAULT)
         val languageVersionSettings = configuration.languageVersionSettings
@@ -186,7 +188,8 @@ object TopDownAnalyzerFacadeForJVM {
                 targetEnvironment, lookupTracker, expectActualTracker,
                 packagePartProvider(dependencyScope), languageVersionSettings,
                 useBuiltInsProvider = true,
-                configureJavaClassFinder = configureJavaClassFinder
+                configureJavaClassFinder = configureJavaClassFinder,
+                implicitsResolutionFilter = implicitsResolutionFilter
             )
 
             moduleClassResolver.compiledCodeResolver = dependenciesContainer.get()
@@ -220,7 +223,8 @@ object TopDownAnalyzerFacadeForJVM {
             partProvider, languageVersionSettings,
             useBuiltInsProvider = true,
             configureJavaClassFinder = configureJavaClassFinder,
-            javaClassTracker = configuration[JVMConfigurationKeys.JAVA_CLASSES_TRACKER]
+            javaClassTracker = configuration[JVMConfigurationKeys.JAVA_CLASSES_TRACKER],
+            implicitsResolutionFilter = implicitsResolutionFilter
         ).apply {
             initJvmBuiltInsForTopDownAnalysis()
             (partProvider as? IncrementalPackagePartProvider)?.deserializationConfiguration = get()

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

@@ -38,6 +38,17 @@ fun CompilerConfiguration.setupJvmSpecificArguments(arguments: K2JVMCompilerArgu
         }
     }
 
+    val jvmTarget = get(JVMConfigurationKeys.JVM_TARGET) ?: JvmTarget.DEFAULT
+    if (jvmTarget.bytecodeVersion < JvmTarget.JVM_1_8.bytecodeVersion) {
+        val jvmDefaultMode = languageVersionSettings.getFlag(JvmAnalysisFlags.jvmDefaultMode)
+        if (jvmDefaultMode.forAllMethodsWithBody) {
+            messageCollector.report(
+                ERROR,
+                "'-Xjvm-default=${jvmDefaultMode.description}' is only supported since JVM target 1.8. Recompile with '-jvm-target 1.8'"
+            )
+        }
+    }
+
     addAll(JVMConfigurationKeys.ADDITIONAL_JAVA_MODULES, arguments.additionalJavaModules?.asList())
 }
 

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/plugins/PluginCliParser.kt

@@ -26,7 +26,6 @@ import org.jetbrains.kotlin.compiler.plugin.*
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import java.io.File
 import java.net.URLClassLoader
-import java.util.*
 
 object PluginCliParser {
     @JvmStatic
@@ -78,44 +77,52 @@ object PluginCliParser {
         configuration: CompilerConfiguration,
         classLoader: URLClassLoader
     ) {
-        val optionValuesByPlugin = pluginOptions?.map(::parsePluginOption)?.groupBy {
-            if (it == null) throw CliOptionProcessingException("Wrong plugin option format: $it, should be ${CommonCompilerArguments.PLUGIN_OPTION_FORMAT}")
-            it.pluginId
-        } ?: mapOf()
-
         // TODO issue a warning on using deprecated command line processors when all official plugin migrate to the newer convention
         val commandLineProcessors = ServiceLoaderLite.loadImplementations(CommandLineProcessor::class.java, classLoader)
 
-        for (processor in commandLineProcessors) {
-            val declaredOptions = processor.pluginOptions.associateBy { it.optionName }
-            val optionsToValues = MultiMap<AbstractCliOption, CliOptionValue>()
+        processCompilerPluginsOptions(configuration, pluginOptions, commandLineProcessors)
+    }
+}
 
-            for (optionValue in optionValuesByPlugin[processor.pluginId].orEmpty()) {
-                val option = declaredOptions[optionValue!!.optionName]
-                    ?: throw CliOptionProcessingException("Unsupported plugin option: $optionValue")
-                optionsToValues.putValue(option, optionValue)
+fun processCompilerPluginsOptions(
+    configuration: CompilerConfiguration,
+    pluginOptions: Iterable<String>?,
+    commandLineProcessors: List<CommandLineProcessor>
+) {
+    val optionValuesByPlugin = pluginOptions?.map(::parsePluginOption)?.groupBy {
+        if (it == null) throw CliOptionProcessingException("Wrong plugin option format: $it, should be ${CommonCompilerArguments.PLUGIN_OPTION_FORMAT}")
+        it.pluginId
+    } ?: mapOf()
+
+    for (processor in commandLineProcessors) {
+        val declaredOptions = processor.pluginOptions.associateBy { it.optionName }
+        val optionsToValues = MultiMap<AbstractCliOption, CliOptionValue>()
+
+        for (optionValue in optionValuesByPlugin[processor.pluginId].orEmpty()) {
+            val option = declaredOptions[optionValue!!.optionName]
+                ?: throw CliOptionProcessingException("Unsupported plugin option: $optionValue")
+            optionsToValues.putValue(option, optionValue)
+        }
+
+        for (option in processor.pluginOptions) {
+            val values = optionsToValues[option]
+            if (option.required && values.isEmpty()) {
+                throw PluginCliOptionProcessingException(
+                    processor.pluginId,
+                    processor.pluginOptions,
+                    "Required plugin option not present: ${processor.pluginId}:${option.optionName}"
+                )
+            }
+            if (!option.allowMultipleOccurrences && values.size > 1) {
+                throw PluginCliOptionProcessingException(
+                    processor.pluginId,
+                    processor.pluginOptions,
+                    "Multiple values are not allowed for plugin option ${processor.pluginId}:${option.optionName}"
+                )
             }
 
-            for (option in processor.pluginOptions) {
-                val values = optionsToValues[option]
-                if (option.required && values.isEmpty()) {
-                    throw PluginCliOptionProcessingException(
-                        processor.pluginId,
-                        processor.pluginOptions,
-                        "Required plugin option not present: ${processor.pluginId}:${option.optionName}"
-                    )
-                }
-                if (!option.allowMultipleOccurrences && values.size > 1) {
-                    throw PluginCliOptionProcessingException(
-                        processor.pluginId,
-                        processor.pluginOptions,
-                        "Multiple values are not allowed for plugin option ${processor.pluginId}:${option.optionName}"
-                    )
-                }
-
-                for (value in values) {
-                    processor.processOption(option, value.value, configuration)
-                }
+            for (value in values) {
+                processor.processOption(option, value.value, configuration)
             }
         }
     }

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

@@ -27,7 +27,6 @@ import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.config.K2MetadataConfigurationKeys
 import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots
-import org.jetbrains.kotlin.cli.jvm.plugins.PluginCliParser
 import org.jetbrains.kotlin.codegen.CompilationException
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration

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

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

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

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

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

@@ -6,19 +6,21 @@
 package org.jetbrains.kotlin.daemon.client.experimental
 
 import io.ktor.network.sockets.Socket
-import kotlinx.coroutines.*
+import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.async
+import kotlinx.coroutines.runBlocking
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.daemon.client.CompileServiceSessionAsync
-import org.jetbrains.kotlin.daemon.client.KotlinCompilerDaemonClient
 import org.jetbrains.kotlin.daemon.client.DaemonReportMessage
 import org.jetbrains.kotlin.daemon.client.DaemonReportingTargets
+import org.jetbrains.kotlin.daemon.client.KotlinCompilerDaemonClient
+import org.jetbrains.kotlin.daemon.client.launchProcessWithFallback
 import org.jetbrains.kotlin.daemon.common.*
-import org.jetbrains.kotlin.daemon.common.Profiler
 import org.jetbrains.kotlin.daemon.common.experimental.*
 import org.jetbrains.kotlin.daemon.common.experimental.socketInfrastructure.Server
 import org.jetbrains.kotlin.daemon.common.experimental.socketInfrastructure.ServerSocketWrapper
-import org.jetbrains.kotlin.daemon.common.*
 import java.io.File
 import java.io.Serializable
 import java.net.SocketException
@@ -30,7 +32,6 @@ import java.util.concurrent.Semaphore
 import java.util.concurrent.TimeUnit
 import java.util.logging.Logger
 import kotlin.concurrent.thread
-import org.jetbrains.kotlin.daemon.client.launchProcessWithFallback
 
 
 class KotlinCompilerClient : KotlinCompilerDaemonClient {

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

@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.daemon.client
 
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.common.messages.OutputMessageUtil
@@ -66,7 +66,7 @@ fun MessageCollector.reportFromDaemon(outputsCollector: ((File, List<File>) -> U
                 else -> throw IllegalStateException("Unexpected compiler message report severity $severity")
             }
             if (message != null) {
-                report(compilerSeverity, message, attachment as? CompilerMessageLocation)
+                report(compilerSeverity, message, attachment as? CompilerMessageSourceLocation)
             }
             else {
                 reportUnexpected(category, severity, message, attachment)

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

@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.daemon
 
 import com.intellij.openapi.application.ApplicationManager
 import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.common.messages.OutputMessageUtil
@@ -181,7 +181,7 @@ class CompilerApiTest : KotlinIntegrationTestBase() {
 }
 
 class TestMessageCollector : MessageCollector {
-    data class Message(val severity: CompilerMessageSeverity, val message: String, val location: CompilerMessageLocation?)
+    data class Message(val severity: CompilerMessageSeverity, val message: String, val location: CompilerMessageSourceLocation?)
 
     val messages = arrayListOf<Message>()
 
@@ -189,7 +189,7 @@ class TestMessageCollector : MessageCollector {
         messages.clear()
     }
 
-    override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageLocation?) {
+    override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageSourceLocation?) {
         messages.add(Message(severity, message, location))
     }
 

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

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.daemon.experimental.integration
 import com.intellij.openapi.application.ApplicationManager
 import kotlinx.coroutines.runBlocking
 import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.common.messages.OutputMessageUtil
@@ -301,7 +301,7 @@ class CompilerApiTest : KotlinIntegrationTestBase() {
 }
 
 class TestMessageCollector : MessageCollector {
-    data class Message(val severity: CompilerMessageSeverity, val message: String, val location: CompilerMessageLocation?)
+    data class Message(val severity: CompilerMessageSeverity, val message: String, val location: CompilerMessageSourceLocation?)
 
     val messages = arrayListOf<Message>()
 
@@ -309,7 +309,7 @@ class TestMessageCollector : MessageCollector {
         messages.clear()
     }
 
-    override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageLocation?) {
+    override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageSourceLocation?) {
         messages.add(Message(severity, message, location))
     }
 

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

@@ -168,9 +168,9 @@ internal class KeepFirstErrorMessageCollector(compilerMessagesStream: PrintStrea
     private val innerCollector = PrintingMessageCollector(compilerMessagesStream, MessageRenderer.WITHOUT_PATHS, false)
 
     internal var firstErrorMessage: String? = null
-    internal var firstErrorLocation: CompilerMessageLocation? = null
+    internal var firstErrorLocation: CompilerMessageSourceLocation? = null
 
-    override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageLocation?) {
+    override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageSourceLocation?) {
         if (firstErrorMessage == null && severity.isError) {
             firstErrorMessage = message
             firstErrorLocation = location

compiler/daemon/src/org/jetbrains/kotlin/daemon/report/CompileServicesFacadeMessageCollector.kt

@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.daemon.report
 
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.common.messages.MessageRenderer
@@ -34,7 +34,7 @@ internal class CompileServicesFacadeMessageCollector(
         hasErrors = false
     }
 
-    override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageLocation?) {
+    override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageSourceLocation?) {
         log.info("Message: " + MessageRenderer.WITHOUT_PATHS.render(severity, message, location))
         when (severity) {
             CompilerMessageSeverity.OUTPUT -> {

compiler/daemon/src/org/jetbrains/kotlin/daemon/report/experimental/CompileServicesFacadeMessageCollector.kt

@@ -5,17 +5,14 @@
 
 package org.jetbrains.kotlin.daemon.report.experimental
 
-import kotlinx.coroutines.*
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.async
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.common.messages.MessageRenderer
 import org.jetbrains.kotlin.daemon.KotlinCompileDaemon.log
-import org.jetbrains.kotlin.daemon.common.CompilationOptions
-import org.jetbrains.kotlin.daemon.common.ReportCategory
-import org.jetbrains.kotlin.daemon.common.ReportSeverity
-import org.jetbrains.kotlin.daemon.common.CompilerServicesFacadeBaseAsync
-import org.jetbrains.kotlin.daemon.common.report
+import org.jetbrains.kotlin.daemon.common.*
 
 internal class CompileServicesFacadeMessageCollector(
     private val servicesFacade: CompilerServicesFacadeBaseAsync,
@@ -28,7 +25,7 @@ internal class CompileServicesFacadeMessageCollector(
         hasErrors = false
     }
 
-    override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageLocation?) {
+    override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageSourceLocation?) {
         GlobalScope.async {
             log.info("Message: " + MessageRenderer.WITHOUT_PATHS.render(severity, message, location))
             when (severity) {

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

@@ -358,6 +358,20 @@ public abstract interface Comparable<in T> : R|kotlin/Any| {
 
 }
 
+@R|kotlin/annotation/Target|() @R|kotlin/annotation/MustBeDocumented|() @R|kotlin/SinceKotlin|(version = String(1.4)) public final annotation class DeprecatedSinceKotlin : R|kotlin/Annotation| {
+    public final val errorSince: R|kotlin/String|
+        public get(): R|kotlin/String|
+
+    public final val hiddenSince: R|kotlin/String|
+        public get(): R|kotlin/String|
+
+    public final val warningSince: R|kotlin/String|
+        public get(): R|kotlin/String|
+
+    public constructor(warningSince: R|kotlin/String| = STUB, errorSince: R|kotlin/String| = STUB, hiddenSince: R|kotlin/String| = STUB): R|kotlin/DeprecatedSinceKotlin|
+
+}
+
 public final enum class DeprecationLevel : R|kotlin/Enum<kotlin/DeprecationLevel>| {
     private constructor(): R|kotlin/DeprecationLevel|
 

compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates/simpleDelegatedToMap.kt

@@ -1,6 +1,5 @@
 class C(val map: MutableMap<String, Any>) {
-    // NB: this does not work because of @LowPriorityInOverloadResolution not deserialized (KT-37228)
-    var foo by <!AMBIGUITY!>map<!>
+    var foo by map
 }
 
-var bar by <!AMBIGUITY!>hashMapOf<String, Any>()<!>
+var bar by hashMapOf<String, Any>()

compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates/simpleDelegatedToMap.txt

@@ -7,19 +7,19 @@ FILE: simpleDelegatedToMap.kt
         public final val map: R|kotlin/collections/MutableMap<kotlin/String, kotlin/Any>| = R|<local>/map|
             public get(): R|kotlin/collections/MutableMap<kotlin/String, kotlin/Any>|
 
-        public final var foo: <ERROR TYPE REF: Ambiguity: getValue, [kotlin/collections/getValue, kotlin/collections/getValue, kotlin/collections/getValue]>by R|<local>/map|
-            public get(): <ERROR TYPE REF: Ambiguity: getValue, [kotlin/collections/getValue, kotlin/collections/getValue, kotlin/collections/getValue]> {
-                ^ this@R|/C|.D|/C.foo|.<Ambiguity: getValue, [kotlin/collections/getValue, kotlin/collections/getValue, kotlin/collections/getValue]>#(this@R|/C|, ::R|/C.foo|)
+        public final var foo: R|kotlin/Any|by R|<local>/map|
+            public get(): R|kotlin/Any| {
+                ^ this@R|/C|.D|/C.foo|.R|kotlin/collections/getValue|<R|kotlin/Any|, R|kotlin/Any|>(this@R|/C|, ::R|/C.foo|)
             }
-            public set(<set-?>: <ERROR TYPE REF: Ambiguity: getValue, [kotlin/collections/getValue, kotlin/collections/getValue, kotlin/collections/getValue]>): R|kotlin/Unit| {
-                this@R|/C|.D|/C.foo|.<Inapplicable(INAPPLICABLE): [kotlin/collections/setValue]>#(this@R|/C|, ::R|/C.foo|, R|<local>/foo|)
+            public set(<set-?>: R|kotlin/Any|): R|kotlin/Unit| {
+                this@R|/C|.D|/C.foo|.R|kotlin/collections/setValue|<R|kotlin/Any|>(this@R|/C|, ::R|/C.foo|, R|<local>/foo|)
             }
 
     }
-    public final var bar: <ERROR TYPE REF: Ambiguity: getValue, [kotlin/collections/getValue, kotlin/collections/getValue, kotlin/collections/getValue]>by R|kotlin/collections/hashMapOf|<R|kotlin/String|, R|kotlin/Any|>()
-        public get(): <ERROR TYPE REF: Ambiguity: getValue, [kotlin/collections/getValue, kotlin/collections/getValue, kotlin/collections/getValue]> {
-            ^ D|/bar|.<Ambiguity: getValue, [kotlin/collections/getValue, kotlin/collections/getValue, kotlin/collections/getValue]>#(Null(null), ::R|/bar|)
+    public final var bar: R|ft<kotlin/Any, kotlin/Any?>!|by R|kotlin/collections/hashMapOf|<R|kotlin/String|, R|kotlin/Any|>()
+        public get(): R|ft<kotlin/Any, kotlin/Any?>!| {
+            ^ D|/bar|.R|kotlin/collections/getValue|<R|ft<kotlin/Any, kotlin/Any?>!|, R|ft<kotlin/Any, kotlin/Any?>!|>(Null(null), ::R|/bar|)
         }
-        public set(<set-?>: <ERROR TYPE REF: Ambiguity: getValue, [kotlin/collections/getValue, kotlin/collections/getValue, kotlin/collections/getValue]>): R|kotlin/Unit| {
-            D|/bar|.<Inapplicable(INAPPLICABLE): [kotlin/collections/setValue]>#(Null(null), ::R|/bar|, R|<local>/bar|)
+        public set(<set-?>: R|ft<kotlin/Any, kotlin/Any?>!|): R|kotlin/Unit| {
+            D|/bar|.R|kotlin/collections/setValue|<R|ft<kotlin/Any, kotlin/Any?>!|>(Null(null), ::R|/bar|, R|<local>/bar|)
         }

compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/FirOldFrontendDiagnosticsTestGenerated.java

@@ -1794,6 +1794,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/callableReference/classVsPackage.kt");
         }
 
+        @TestMetadata("compatibilityResolveWithVarargAndOperatorCall.kt")
+        public void testCompatibilityResolveWithVarargAndOperatorCall() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/callableReference/compatibilityResolveWithVarargAndOperatorCall.kt");
+        }
+
         @TestMetadata("constraintFromLHSWithCorrectDirection.kt")
         public void testConstraintFromLHSWithCorrectDirection() throws Exception {
             runTest("compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirection.kt");
@@ -1804,6 +1809,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirectionError.kt");
         }
 
+        @TestMetadata("correctCandidateWithCompatibilityForSeveralCandidates.kt")
+        public void testCorrectCandidateWithCompatibilityForSeveralCandidates() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/callableReference/correctCandidateWithCompatibilityForSeveralCandidates.kt");
+        }
+
         @TestMetadata("correctInfoAfterArrayLikeCall.kt")
         public void testCorrectInfoAfterArrayLikeCall() throws Exception {
             runTest("compiler/testData/diagnostics/tests/callableReference/correctInfoAfterArrayLikeCall.kt");
@@ -1914,6 +1924,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/callableReference/noAmbiguityWhenAllReferencesAreInapplicable.kt");
         }
 
+        @TestMetadata("noCompatibilityResolveWithProressiveModeForNI.kt")
+        public void testNoCompatibilityResolveWithProressiveModeForNI() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/callableReference/noCompatibilityResolveWithProressiveModeForNI.kt");
+        }
+
         @TestMetadata("noExceptionOnRedCodeWithArrayLikeCall.kt")
         public void testNoExceptionOnRedCodeWithArrayLikeCall() throws Exception {
             runTest("compiler/testData/diagnostics/tests/callableReference/noExceptionOnRedCodeWithArrayLikeCall.kt");
@@ -1939,6 +1954,21 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/callableReference/referenceAdaptationCompatibility.kt");
         }
 
+        @TestMetadata("referenceAdaptationHasDependencyOnApi14.kt")
+        public void testReferenceAdaptationHasDependencyOnApi14() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/callableReference/referenceAdaptationHasDependencyOnApi14.kt");
+        }
+
+        @TestMetadata("referenceToCompanionObjectMemberViaClassName.kt")
+        public void testReferenceToCompanionObjectMemberViaClassName() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/callableReference/referenceToCompanionObjectMemberViaClassName.kt");
+        }
+
+        @TestMetadata("referenceToCompanionObjectMemberViaClassNameCompatibility.kt")
+        public void testReferenceToCompanionObjectMemberViaClassNameCompatibility() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/callableReference/referenceToCompanionObjectMemberViaClassNameCompatibility.kt");
+        }
+
         @TestMetadata("rewriteAtSliceOnGetOperator.kt")
         public void testRewriteAtSliceOnGetOperator() throws Exception {
             runTest("compiler/testData/diagnostics/tests/callableReference/rewriteAtSliceOnGetOperator.kt");
@@ -1964,6 +1994,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/callableReference/typealiases.kt");
         }
 
+        @TestMetadata("unitAdaptationForReferenceCompatibility.kt")
+        public void testUnitAdaptationForReferenceCompatibility() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/callableReference/unitAdaptationForReferenceCompatibility.kt");
+        }
+
         @TestMetadata("unused.kt")
         public void testUnused() throws Exception {
             runTest("compiler/testData/diagnostics/tests/callableReference/unused.kt");
@@ -1974,6 +2009,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/callableReference/whitespacesInExpression.kt");
         }
 
+        @TestMetadata("withQuestionMarks.kt")
+        public void testWithQuestionMarks() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/callableReference/withQuestionMarks.kt");
+        }
+
         @TestMetadata("compiler/testData/diagnostics/tests/callableReference/bound")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
@@ -2559,6 +2599,16 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
             }
 
+            @TestMetadata("adaptedReferenceAgainstKCallable.kt")
+            public void testAdaptedReferenceAgainstKCallable() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/callableReference/resolve/adaptedReferenceAgainstKCallable.kt");
+            }
+
+            @TestMetadata("adaptedReferenceAgainstReflectionType.kt")
+            public void testAdaptedReferenceAgainstReflectionType() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/callableReference/resolve/adaptedReferenceAgainstReflectionType.kt");
+            }
+
             public void testAllFilesPresentInResolve() throws Exception {
                 KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/resolve"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true);
             }
@@ -2623,6 +2673,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 runTest("compiler/testData/diagnostics/tests/callableReference/resolve/commonSupertypeFromReturnTypesOfCallableReference.kt");
             }
 
+            @TestMetadata("compatibilityWarningOnReferenceAgainstReflectiveType.kt")
+            public void testCompatibilityWarningOnReferenceAgainstReflectiveType() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/callableReference/resolve/compatibilityWarningOnReferenceAgainstReflectiveType.kt");
+            }
+
             @TestMetadata("constructor.kt")
             public void testConstructor() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/callableReference/resolve/constructor.kt");
@@ -2708,6 +2763,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 runTest("compiler/testData/diagnostics/tests/callableReference/resolve/multipleOutersAndMultipleCallableReferences.kt");
             }
 
+            @TestMetadata("nestedReferenceCallAgainstExpectedType.kt")
+            public void testNestedReferenceCallAgainstExpectedType() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/callableReference/resolve/nestedReferenceCallAgainstExpectedType.kt");
+            }
+
             @TestMetadata("noAmbiguityBetweenTopLevelAndMemberProperty.kt")
             public void testNoAmbiguityBetweenTopLevelAndMemberProperty() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/callableReference/resolve/noAmbiguityBetweenTopLevelAndMemberProperty.kt");
@@ -2718,6 +2778,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 runTest("compiler/testData/diagnostics/tests/callableReference/resolve/noFakeDescriptorForObject.kt");
             }
 
+            @TestMetadata("overloadAmbiguityForSimpleLastExpressionOfBlock.kt")
+            public void testOverloadAmbiguityForSimpleLastExpressionOfBlock() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/callableReference/resolve/overloadAmbiguityForSimpleLastExpressionOfBlock.kt");
+            }
+
             @TestMetadata("overloads.kt")
             public void testOverloads() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/callableReference/resolve/overloads.kt");
@@ -2748,6 +2813,16 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 runTest("compiler/testData/diagnostics/tests/callableReference/resolve/resolveEqualsOperatorWithAnyExpectedType.kt");
             }
 
+            @TestMetadata("resolveReferenceAgainstKFunctionAndKPrpoerty.kt")
+            public void testResolveReferenceAgainstKFunctionAndKPrpoerty() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/callableReference/resolve/resolveReferenceAgainstKFunctionAndKPrpoerty.kt");
+            }
+
+            @TestMetadata("resolveTwoReferencesAgainstGenerics.kt")
+            public void testResolveTwoReferencesAgainstGenerics() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/callableReference/resolve/resolveTwoReferencesAgainstGenerics.kt");
+            }
+
             @TestMetadata("valVsFun.kt")
             public void testValVsFun() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/callableReference/resolve/valVsFun.kt");
@@ -3816,6 +3891,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldAsClassDelegate.kt");
         }
 
+        @TestMetadata("fieldInitialization.kt")
+        public void testFieldInitialization() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldInitialization.kt");
+        }
+
         @TestMetadata("infiniteLoops.kt")
         public void testInfiniteLoops() throws Exception {
             runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/infiniteLoops.kt");
@@ -4626,6 +4706,16 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/coroutines"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true);
         }
 
+        @TestMetadata("suspendInvokeInsideTry.kt")
+        public void testSuspendInvokeInsideTry() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/coroutines/suspendInvokeInsideTry.kt");
+        }
+
+        @TestMetadata("suspendInvokeInsideWhen.kt")
+        public void testSuspendInvokeInsideWhen() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/coroutines/suspendInvokeInsideWhen.kt");
+        }
+
         @TestMetadata("compiler/testData/diagnostics/tests/coroutines/callableReference")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
@@ -6131,6 +6221,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/overloadResolutionForSeveralProvideDelegates.kt");
             }
 
+            @TestMetadata("provideDelegateOnFunctionalTypeWithThis.kt")
+            public void testProvideDelegateOnFunctionalTypeWithThis() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/provideDelegateOnFunctionalTypeWithThis.kt");
+            }
+
             @TestMetadata("provideDelegateOperatorDeclaration.kt")
             public void testProvideDelegateOperatorDeclaration() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/provideDelegateOperatorDeclaration.kt");
@@ -6465,6 +6560,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedHidden.kt");
         }
 
+        @TestMetadata("deprecatedHiddenOnCallableReferenceArgument.kt")
+        public void testDeprecatedHiddenOnCallableReferenceArgument() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedHiddenOnCallableReferenceArgument.kt");
+        }
+
         @TestMetadata("deprecatedInheritance.kt")
         public void testDeprecatedInheritance() throws Exception {
             runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedInheritance.kt");
@@ -6584,6 +6684,64 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
         public void testWarningOnConstructorErrorOnClass() throws Exception {
             runTest("compiler/testData/diagnostics/tests/deprecated/warningOnConstructorErrorOnClass.kt");
         }
+
+        @TestMetadata("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class DeprecatedSinceKotlin extends AbstractFirOldFrontendDiagnosticsTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInDeprecatedSinceKotlin() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true);
+            }
+
+            @TestMetadata("checkValuesAreParseableAsVersion.kt")
+            public void testCheckValuesAreParseableAsVersion() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/checkValuesAreParseableAsVersion.kt");
+            }
+
+            @TestMetadata("deprecatedSinceKotlinDeclaration.kt")
+            public void testDeprecatedSinceKotlinDeclaration() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/deprecatedSinceKotlinDeclaration.kt");
+            }
+
+            @TestMetadata("deprecatedSinceKotlinHiddenOnReferenceArgument.kt")
+            public void testDeprecatedSinceKotlinHiddenOnReferenceArgument() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/deprecatedSinceKotlinHiddenOnReferenceArgument.kt");
+            }
+
+            @TestMetadata("deprecatedSinceKotlinOutsideKotlinPackage.kt")
+            public void testDeprecatedSinceKotlinOutsideKotlinPackage() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/deprecatedSinceKotlinOutsideKotlinPackage.kt");
+            }
+
+            @TestMetadata("deprecatedSinceKotlinWithoutArguments.kt")
+            public void testDeprecatedSinceKotlinWithoutArguments() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/deprecatedSinceKotlinWithoutArguments.kt");
+            }
+
+            @TestMetadata("error.kt")
+            public void testError() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/error.kt");
+            }
+
+            @TestMetadata("hidden.kt")
+            public void testHidden() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/hidden.kt");
+            }
+
+            @TestMetadata("messageFromDeprecatedAnnotation.kt")
+            public void testMessageFromDeprecatedAnnotation() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/messageFromDeprecatedAnnotation.kt");
+            }
+
+            @TestMetadata("warning.kt")
+            public void testWarning() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/warning.kt");
+            }
+        }
     }
 
     @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature")
@@ -7969,6 +8127,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/funInterface/noCompatibilityResolveForFunInterfaces.kt");
         }
 
+        @TestMetadata("prohibitFunInterfaceConstructorReferences.kt")
+        public void testProhibitFunInterfaceConstructorReferences() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/funInterface/prohibitFunInterfaceConstructorReferences.kt");
+        }
+
         @TestMetadata("resolveFunInterfaceWithoutMainMethod.kt")
         public void testResolveFunInterfaceWithoutMainMethod() throws Exception {
             runTest("compiler/testData/diagnostics/tests/funInterface/resolveFunInterfaceWithoutMainMethod.kt");
@@ -9931,6 +10094,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/inference/commonSuperTypeOfErrorTypes.kt");
         }
 
+        @TestMetadata("compatibilityResolveWhenVariableHasComplexIntersectionType.kt")
+        public void testCompatibilityResolveWhenVariableHasComplexIntersectionType() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/inference/compatibilityResolveWhenVariableHasComplexIntersectionType.kt");
+        }
+
         @TestMetadata("completeInferenceIfManyFailed.kt")
         public void testCompleteInferenceIfManyFailed() throws Exception {
             runTest("compiler/testData/diagnostics/tests/inference/completeInferenceIfManyFailed.kt");
@@ -9966,6 +10134,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/inference/dependantOnVarianceNullable.kt");
         }
 
+        @TestMetadata("equalitySubstitutionInsideNonInvariantType.kt")
+        public void testEqualitySubstitutionInsideNonInvariantType() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/inference/equalitySubstitutionInsideNonInvariantType.kt");
+        }
+
         @TestMetadata("expectedTypeAdditionalTest.kt")
         public void testExpectedTypeAdditionalTest() throws Exception {
             runTest("compiler/testData/diagnostics/tests/inference/expectedTypeAdditionalTest.kt");
@@ -10076,6 +10249,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/inference/intersectionTypeMultipleBoundsAsReceiver.kt");
         }
 
+        @TestMetadata("intersectionTypesWithContravariantTypes.kt")
+        public void testIntersectionTypesWithContravariantTypes() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/inference/intersectionTypesWithContravariantTypes.kt");
+        }
+
         @TestMetadata("intersectionWithEnum.kt")
         public void testIntersectionWithEnum() throws Exception {
             runTest("compiler/testData/diagnostics/tests/inference/intersectionWithEnum.kt");
@@ -10261,6 +10439,21 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/inference/resolveWithUnknownLambdaParameterType.kt");
         }
 
+        @TestMetadata("returningLambdaInSuspendContext.kt")
+        public void testReturningLambdaInSuspendContext() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/inference/returningLambdaInSuspendContext.kt");
+        }
+
+        @TestMetadata("simpleLambdaInCallWithAnotherLambdaWithBuilderInference.kt")
+        public void testSimpleLambdaInCallWithAnotherLambdaWithBuilderInference() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/inference/simpleLambdaInCallWithAnotherLambdaWithBuilderInference.kt");
+        }
+
+        @TestMetadata("skipedUnresolvedInBuilderInferenceWithStubReceiverType.kt")
+        public void testSkipedUnresolvedInBuilderInferenceWithStubReceiverType() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/inference/skipedUnresolvedInBuilderInferenceWithStubReceiverType.kt");
+        }
+
         @TestMetadata("starApproximation.kt")
         public void testStarApproximation() throws Exception {
             runTest("compiler/testData/diagnostics/tests/inference/starApproximation.kt");
@@ -10398,6 +10591,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/capturedTypeWithTypeVariableSubtyping.kt");
             }
 
+            @TestMetadata("capturingFromArgumentOfFlexibleType.kt")
+            public void testCapturingFromArgumentOfFlexibleType() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/capturingFromArgumentOfFlexibleType.kt");
+            }
+
             @TestMetadata("expectedTypeMismatchWithInVariance.kt")
             public void testExpectedTypeMismatchWithInVariance() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/expectedTypeMismatchWithInVariance.kt");
@@ -10491,6 +10689,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionToUnitReference.kt");
             }
 
+            @TestMetadata("coercionToUnitWithNothingType.kt")
+            public void testCoercionToUnitWithNothingType() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionToUnitWithNothingType.kt");
+            }
+
             @TestMetadata("coercionWithExpectedType.kt")
             public void testCoercionWithExpectedType() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExpectedType.kt");
@@ -10511,6 +10714,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithoutExpectedType.kt");
             }
 
+            @TestMetadata("coerctionToUnitForATypeWithUpperBound.kt")
+            public void testCoerctionToUnitForATypeWithUpperBound() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coerctionToUnitForATypeWithUpperBound.kt");
+            }
+
             @TestMetadata("coersionWithAnonymousFunctionsAndUnresolved.kt")
             public void testCoersionWithAnonymousFunctionsAndUnresolved() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coersionWithAnonymousFunctionsAndUnresolved.kt");
@@ -10818,6 +11026,16 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 public void testTakingExtensibilityFromDeclarationOfAnonymousFunction() throws Exception {
                     runTest("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/takingExtensibilityFromDeclarationOfAnonymousFunction.kt");
                 }
+
+                @TestMetadata("wrongVariableFixationOrder.kt")
+                public void testWrongVariableFixationOrder() throws Exception {
+                    runTest("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/wrongVariableFixationOrder.kt");
+                }
+
+                @TestMetadata("wrongVariableFixationOrder2.kt")
+                public void testWrongVariableFixationOrder2() throws Exception {
+                    runTest("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/wrongVariableFixationOrder2.kt");
+                }
             }
         }
 
@@ -11164,6 +11382,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 runTest("compiler/testData/diagnostics/tests/inference/nothingType/nothingWithCallableReference.kt");
             }
 
+            @TestMetadata("nullableExpectedTypeFromVariable.kt")
+            public void testNullableExpectedTypeFromVariable() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/nothingType/nullableExpectedTypeFromVariable.kt");
+            }
+
             @TestMetadata("platformNothingAsUsefulConstraint.kt")
             public void testPlatformNothingAsUsefulConstraint() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/inference/nothingType/platformNothingAsUsefulConstraint.kt");
@@ -11173,6 +11396,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             public void testReifiedParameterWithRecursiveBound() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/inference/nothingType/reifiedParameterWithRecursiveBound.kt");
             }
+
+            @TestMetadata("specialCallWithMaterializeAndExpectedType.kt")
+            public void testSpecialCallWithMaterializeAndExpectedType() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/nothingType/specialCallWithMaterializeAndExpectedType.kt");
+            }
         }
 
         @TestMetadata("compiler/testData/diagnostics/tests/inference/publicApproximation")
@@ -13631,6 +13859,16 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 runTest("compiler/testData/diagnostics/tests/j+k/sam/compatibilityResolveToOuterScopeForKotlinFunctions.kt");
             }
 
+            @TestMetadata("conversionForDerivedGenericClass.kt")
+            public void testConversionForDerivedGenericClass() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/j+k/sam/conversionForDerivedGenericClass.kt");
+            }
+
+            @TestMetadata("conversionsWithNestedGenerics.kt")
+            public void testConversionsWithNestedGenerics() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/j+k/sam/conversionsWithNestedGenerics.kt");
+            }
+
             @TestMetadata("enhancedSamConstructor.kt")
             public void testEnhancedSamConstructor() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/j+k/sam/enhancedSamConstructor.kt");
@@ -13651,6 +13889,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 runTest("compiler/testData/diagnostics/tests/j+k/sam/kt37920.kt");
             }
 
+            @TestMetadata("kt39630.kt")
+            public void testKt39630() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/j+k/sam/kt39630.kt");
+            }
+
             @TestMetadata("privateCandidatesWithWrongArguments.kt")
             public void testPrivateCandidatesWithWrongArguments() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/j+k/sam/privateCandidatesWithWrongArguments.kt");
@@ -13661,6 +13904,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 runTest("compiler/testData/diagnostics/tests/j+k/sam/recursiveSamsAndInvoke.kt");
             }
 
+            @TestMetadata("referenceToSamFunctionAgainstExpectedType.kt")
+            public void testReferenceToSamFunctionAgainstExpectedType() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/j+k/sam/referenceToSamFunctionAgainstExpectedType.kt");
+            }
+
             @TestMetadata("samOnTypeParameter.kt")
             public void testSamOnTypeParameter() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/j+k/sam/samOnTypeParameter.kt");
@@ -15241,6 +15489,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 runTest("compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/oldInference.kt");
             }
 
+            @TestMetadata("secondNamed.kt")
+            public void testSecondNamed() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/secondNamed.kt");
+            }
+
             @TestMetadata("simple.kt")
             public void testSimple() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/simple.kt");
@@ -19523,6 +19776,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/samConversions/checkSamConversionsAreDisabledByDefault.kt");
         }
 
+        @TestMetadata("conversionOnLambdaAsLastExpression.kt")
+        public void testConversionOnLambdaAsLastExpression() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/samConversions/conversionOnLambdaAsLastExpression.kt");
+        }
+
         @TestMetadata("DisabledForKTSimple.kt")
         public void testDisabledForKTSimple() throws Exception {
             runTest("compiler/testData/diagnostics/tests/samConversions/DisabledForKTSimple.kt");
@@ -19538,6 +19796,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/samConversions/GenericSubstitutionKT.kt");
         }
 
+        @TestMetadata("javaMemberAgainstExtension.kt")
+        public void testJavaMemberAgainstExtension() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/samConversions/javaMemberAgainstExtension.kt");
+        }
+
         @TestMetadata("OverloadPriority.kt")
         public void testOverloadPriority() throws Exception {
             runTest("compiler/testData/diagnostics/tests/samConversions/OverloadPriority.kt");
@@ -21362,6 +21625,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/smartCasts/smartcastOnSameFieldOfDifferentInstances.kt");
         }
 
+        @TestMetadata("smartcastToNothingAfterCheckingForNull.kt")
+        public void testSmartcastToNothingAfterCheckingForNull() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/smartCasts/smartcastToNothingAfterCheckingForNull.kt");
+        }
+
         @TestMetadata("thisWithLabel.kt")
         public void testThisWithLabel() throws Exception {
             runTest("compiler/testData/diagnostics/tests/smartCasts/thisWithLabel.kt");
@@ -24429,6 +24697,64 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
         }
     }
 
+    @TestMetadata("compiler/testData/diagnostics/tests/unitConversion")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class UnitConversion extends AbstractFirOldFrontendDiagnosticsTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInUnitConversion() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/unitConversion"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true);
+        }
+
+        @TestMetadata("chainedFunSuspendUnitConversion.kt")
+        public void testChainedFunSuspendUnitConversion() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/unitConversion/chainedFunSuspendUnitConversion.kt");
+        }
+
+        @TestMetadata("chainedFunUnitConversion.kt")
+        public void testChainedFunUnitConversion() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/unitConversion/chainedFunUnitConversion.kt");
+        }
+
+        @TestMetadata("chainedUnitSuspendConversion.kt")
+        public void testChainedUnitSuspendConversion() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/unitConversion/chainedUnitSuspendConversion.kt");
+        }
+
+        @TestMetadata("noUnitConversionForGenericTypeFromArrow.kt")
+        public void testNoUnitConversionForGenericTypeFromArrow() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/unitConversion/noUnitConversionForGenericTypeFromArrow.kt");
+        }
+
+        @TestMetadata("noUnitConversionOnReturningGenericFunctionalType.kt")
+        public void testNoUnitConversionOnReturningGenericFunctionalType() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/unitConversion/noUnitConversionOnReturningGenericFunctionalType.kt");
+        }
+
+        @TestMetadata("unitConversionCompatibility.kt")
+        public void testUnitConversionCompatibility() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/unitConversion/unitConversionCompatibility.kt");
+        }
+
+        @TestMetadata("unitConversionDisabledForSimpleArguments.kt")
+        public void testUnitConversionDisabledForSimpleArguments() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/unitConversion/unitConversionDisabledForSimpleArguments.kt");
+        }
+
+        @TestMetadata("unitConversionForAllKinds.kt")
+        public void testUnitConversionForAllKinds() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/unitConversion/unitConversionForAllKinds.kt");
+        }
+
+        @TestMetadata("unitConversionForSubtypes.kt")
+        public void testUnitConversionForSubtypes() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/unitConversion/unitConversionForSubtypes.kt");
+        }
+    }
+
     @TestMetadata("compiler/testData/diagnostics/tests/varargs")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
@@ -24491,6 +24817,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_before.kt");
         }
 
+        @TestMetadata("inferredNullableArrayAsVararg.kt")
+        public void testInferredNullableArrayAsVararg() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/varargs/inferredNullableArrayAsVararg.kt");
+        }
+
         @TestMetadata("kt1781.kt")
         public void testKt1781() throws Exception {
             runTest("compiler/testData/diagnostics/tests/varargs/kt1781.kt");

compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/FirOldFrontendDiagnosticsTestWithStdlibGenerated.java

@@ -561,6 +561,52 @@ public class FirOldFrontendDiagnosticsTestWithStdlibGenerated extends AbstractFi
             public void testTarget8() throws Exception {
                 runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/target8.kt");
             }
+
+            @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/allCompatibility")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class AllCompatibility extends AbstractFirOldFrontendDiagnosticsTestWithStdlib {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInAllCompatibility() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true);
+                }
+
+                @TestMetadata("specialization.kt")
+                public void testSpecialization() throws Exception {
+                    runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/allCompatibility/specialization.kt");
+                }
+            }
+
+            @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultWithoutCompatibility")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class JvmDefaultWithoutCompatibility extends AbstractFirOldFrontendDiagnosticsTestWithStdlib {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInJvmDefaultWithoutCompatibility() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultWithoutCompatibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true);
+                }
+
+                @TestMetadata("target6.kt")
+                public void testTarget6() throws Exception {
+                    runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultWithoutCompatibility/target6.kt");
+                }
+
+                @TestMetadata("target8.kt")
+                public void testTarget8() throws Exception {
+                    runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultWithoutCompatibility/target8.kt");
+                }
+
+                @TestMetadata("target8Disabled.kt")
+                public void testTarget8Disabled() throws Exception {
+                    runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultWithoutCompatibility/target8Disabled.kt");
+                }
+            }
         }
 
         @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField")
@@ -1835,6 +1881,11 @@ public class FirOldFrontendDiagnosticsTestWithStdlibGenerated extends AbstractFi
             runTest("compiler/testData/diagnostics/testsWithStdLib/factoryPattern/overloadByLambdaReturnType_enabled_no_annotation.kt");
         }
 
+        @TestMetadata("referenceWithTheSameNameAsContainingProperty.kt")
+        public void testReferenceWithTheSameNameAsContainingProperty() throws Exception {
+            runTest("compiler/testData/diagnostics/testsWithStdLib/factoryPattern/referenceWithTheSameNameAsContainingProperty.kt");
+        }
+
         @TestMetadata("resolutionInOldInference.kt")
         public void testResolutionInOldInference() throws Exception {
             runTest("compiler/testData/diagnostics/testsWithStdLib/factoryPattern/resolutionInOldInference.kt");

compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmSerializerExtension.kt

@@ -93,7 +93,13 @@ class FirJvmSerializerExtension @JvmOverloads constructor(
         writeVersionRequirementForJvmDefaultIfNeeded(klass, proto, versionRequirementTable)
 
         if (jvmDefaultMode.forAllMethodsWithBody && klass is FirRegularClass && klass.classKind == ClassKind.INTERFACE) {
-            proto.setExtension(JvmProtoBuf.jvmClassFlags, JvmFlags.getClassFlags(true))
+            proto.setExtension(
+                JvmProtoBuf.jvmClassFlags,
+                JvmFlags.getClassFlags(
+                    jvmDefaultMode.forAllMethodsWithBody,
+                    JvmDefaultMode.ALL_COMPATIBILITY == jvmDefaultMode
+                )
+            )
         }
     }
 

compiler/fir/fir2ir/tests/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java

@@ -1284,9 +1284,9 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
             runTest("compiler/testData/codegen/box/boxingOptimization/kt6842.kt");
         }
 
-        @TestMetadata("maxMinBy.kt")
-        public void testMaxMinBy() throws Exception {
-            runTest("compiler/testData/codegen/box/boxingOptimization/maxMinBy.kt");
+        @TestMetadata("maxMinByOrNull.kt")
+        public void testMaxMinByOrNull() throws Exception {
+            runTest("compiler/testData/codegen/box/boxingOptimization/maxMinByOrNull.kt");
         }
 
         @TestMetadata("nullCheck.kt")
@@ -1707,6 +1707,16 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
         public void testLackOfNullCheckOnNullableInsideBuild() throws Exception {
             runTest("compiler/testData/codegen/box/builderInference/lackOfNullCheckOnNullableInsideBuild.kt");
         }
+
+        @TestMetadata("substituteStubTypeIntoCR.kt")
+        public void testSubstituteStubTypeIntoCR() throws Exception {
+            runTest("compiler/testData/codegen/box/builderInference/substituteStubTypeIntoCR.kt");
+        }
+
+        @TestMetadata("substituteStubTypeIntolambdaParameterDescriptor.kt")
+        public void testSubstituteStubTypeIntolambdaParameterDescriptor() throws Exception {
+            runTest("compiler/testData/codegen/box/builderInference/substituteStubTypeIntolambdaParameterDescriptor.kt");
+        }
     }
 
     @TestMetadata("compiler/testData/codegen/box/builtinStubMethods")
@@ -2090,6 +2100,11 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
                 runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/noReflectionForAdaptedCallableReferencesWithSuspendConversion.kt");
             }
 
+            @TestMetadata("referenceToVarargWithDefaults.kt")
+            public void testReferenceToVarargWithDefaults() throws Exception {
+                runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/referenceToVarargWithDefaults.kt");
+            }
+
             @TestMetadata("reflectionForVarargAsArray.kt")
             public void testReflectionForVarargAsArray() throws Exception {
                 runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/reflectionForVarargAsArray.kt");
@@ -2685,6 +2700,11 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
                 runTest("compiler/testData/codegen/box/callableReference/function/privateClassMember.kt");
             }
 
+            @TestMetadata("referenceToCompanionMember.kt")
+            public void testReferenceToCompanionMember() throws Exception {
+                runTest("compiler/testData/codegen/box/callableReference/function/referenceToCompanionMember.kt");
+            }
+
             @TestMetadata("sortListOfStrings.kt")
             public void testSortListOfStrings() throws Exception {
                 runTest("compiler/testData/codegen/box/callableReference/function/sortListOfStrings.kt");
@@ -5097,9 +5117,9 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
             runTest("compiler/testData/codegen/box/contracts/exception.kt");
         }
 
-        @TestMetadata("field.kt")
-        public void testField() throws Exception {
-            runTest("compiler/testData/codegen/box/contracts/field.kt");
+        @TestMetadata("fieldReadInConstructor.kt")
+        public void testFieldReadInConstructor() throws Exception {
+            runTest("compiler/testData/codegen/box/contracts/fieldReadInConstructor.kt");
         }
 
         @TestMetadata("forLoop.kt")
@@ -5117,6 +5137,11 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
             runTest("compiler/testData/codegen/box/contracts/lambdaParameter.kt");
         }
 
+        @TestMetadata("listAppend.kt")
+        public void testListAppend() throws Exception {
+            runTest("compiler/testData/codegen/box/contracts/listAppend.kt");
+        }
+
         @TestMetadata("valInWhen.kt")
         public void testValInWhen() throws Exception {
             runTest("compiler/testData/codegen/box/contracts/valInWhen.kt");
@@ -9567,6 +9592,11 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
                 runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/genericDelegateWithNoAdditionalInfo.kt");
             }
 
+            @TestMetadata("genericProvideDelegateOnNumberLiteral.kt")
+            public void testGenericProvideDelegateOnNumberLiteral() throws Exception {
+                runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/genericProvideDelegateOnNumberLiteral.kt");
+            }
+
             @TestMetadata("hostCheck.kt")
             public void testHostCheck() throws Exception {
                 runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/hostCheck.kt");
@@ -10366,6 +10396,11 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
             runTest("compiler/testData/codegen/box/enum/kt2350.kt");
         }
 
+        @TestMetadata("kt38996.kt")
+        public void testKt38996() throws Exception {
+            runTest("compiler/testData/codegen/box/enum/kt38996.kt");
+        }
+
         @TestMetadata("kt7257.kt")
         public void testKt7257() throws Exception {
             runTest("compiler/testData/codegen/box/enum/kt7257.kt");
@@ -11200,6 +11235,11 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
             runTest("compiler/testData/codegen/box/funInterface/basicFunInterfaceConversion.kt");
         }
 
+        @TestMetadata("basicFunInterfaceConversionClash.kt")
+        public void testBasicFunInterfaceConversionClash() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/basicFunInterfaceConversionClash.kt");
+        }
+
         @TestMetadata("castFromAny.kt")
         public void testCastFromAny() throws Exception {
             runTest("compiler/testData/codegen/box/funInterface/castFromAny.kt");
@@ -11235,6 +11275,11 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
             runTest("compiler/testData/codegen/box/funInterface/multimodule.kt");
         }
 
+        @TestMetadata("nonAbstractMethod.kt")
+        public void testNonAbstractMethod() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/nonAbstractMethod.kt");
+        }
+
         @TestMetadata("nullableSam.kt")
         public void testNullableSam() throws Exception {
             runTest("compiler/testData/codegen/box/funInterface/nullableSam.kt");
@@ -12325,6 +12370,11 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
             KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
         }
 
+        @TestMetadata("approximateNonTopLevelCapturedTypes.kt")
+        public void testApproximateNonTopLevelCapturedTypes() throws Exception {
+            runTest("compiler/testData/codegen/box/inference/approximateNonTopLevelCapturedTypes.kt");
+        }
+
         @TestMetadata("builderInference.kt")
         public void testBuilderInference() throws Exception {
             runTest("compiler/testData/codegen/box/inference/builderInference.kt");
@@ -12385,6 +12435,16 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
             runTest("compiler/testData/codegen/box/inference/lastExpressionOfLambdaWithNothingConstraint.kt");
         }
 
+        @TestMetadata("noNothingValueInsideSpecialCall.kt")
+        public void testNoNothingValueInsideSpecialCall() throws Exception {
+            runTest("compiler/testData/codegen/box/inference/noNothingValueInsideSpecialCall.kt");
+        }
+
+        @TestMetadata("plusAssignInsideLambda.kt")
+        public void testPlusAssignInsideLambda() throws Exception {
+            runTest("compiler/testData/codegen/box/inference/plusAssignInsideLambda.kt");
+        }
+
         @TestMetadata("unsafeVarianceCodegen.kt")
         public void testUnsafeVarianceCodegen() throws Exception {
             runTest("compiler/testData/codegen/box/inference/unsafeVarianceCodegen.kt");
@@ -13023,6 +13083,11 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
             runTest("compiler/testData/codegen/box/inlineClasses/noReturnTypeMangling.kt");
         }
 
+        @TestMetadata("noReturnTypeManglingJvmName.kt")
+        public void testNoReturnTypeManglingJvmName() throws Exception {
+            runTest("compiler/testData/codegen/box/inlineClasses/noReturnTypeManglingJvmName.kt");
+        }
+
         @TestMetadata("nullableEqeqNonNull.kt")
         public void testNullableEqeqNonNull() throws Exception {
             runTest("compiler/testData/codegen/box/inlineClasses/nullableEqeqNonNull.kt");
@@ -14487,6 +14552,11 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
         public void testTostring() throws Exception {
             runTest("compiler/testData/codegen/box/intrinsics/tostring.kt");
         }
+
+        @TestMetadata("trimMarginWithBlankString.kt")
+        public void testTrimMarginWithBlankString() throws Exception {
+            runTest("compiler/testData/codegen/box/intrinsics/trimMarginWithBlankString.kt");
+        }
     }
 
     @TestMetadata("compiler/testData/codegen/box/ir")
@@ -14501,6 +14571,11 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
             KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
         }
 
+        @TestMetadata("anonymousClassLeak.kt")
+        public void testAnonymousClassLeak() throws Exception {
+            runTest("compiler/testData/codegen/box/ir/anonymousClassLeak.kt");
+        }
+
         @TestMetadata("anonymousObjectInForLoopIteratorAndBody.kt")
         public void testAnonymousObjectInForLoopIteratorAndBody() throws Exception {
             runTest("compiler/testData/codegen/box/ir/anonymousObjectInForLoopIteratorAndBody.kt");
@@ -14551,6 +14626,11 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
             runTest("compiler/testData/codegen/box/ir/kt29833.kt");
         }
 
+        @TestMetadata("kt40083.kt")
+        public void testKt40083() throws Exception {
+            runTest("compiler/testData/codegen/box/ir/kt40083.kt");
+        }
+
         @TestMetadata("objectClass.kt")
         public void testObjectClass() throws Exception {
             runTest("compiler/testData/codegen/box/ir/objectClass.kt");
@@ -15268,6 +15348,11 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
                 runTest("compiler/testData/codegen/box/jvm8/defaults/kt14243_prop.kt");
             }
 
+            @TestMetadata("kt40920.kt")
+            public void testKt40920() throws Exception {
+                runTest("compiler/testData/codegen/box/jvm8/defaults/kt40920.kt");
+            }
+
             @TestMetadata("oneImplementation.kt")
             public void testOneImplementation() throws Exception {
                 runTest("compiler/testData/codegen/box/jvm8/defaults/oneImplementation.kt");
@@ -15400,6 +15485,11 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
                     runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/defaultArgsViaAnonymousObject.kt");
                 }
 
+                @TestMetadata("funInterface.kt")
+                public void testFunInterface() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/funInterface.kt");
+                }
+
                 @TestMetadata("inheritedFunctionWithDefaultParameters.kt")
                 public void testInheritedFunctionWithDefaultParameters() throws Exception {
                     runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/inheritedFunctionWithDefaultParameters.kt");
@@ -15657,6 +15747,11 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
                     runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/defaultArgsViaAnonymousObject.kt");
                 }
 
+                @TestMetadata("funInterface.kt")
+                public void testFunInterface() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/funInterface.kt");
+                }
+
                 @TestMetadata("inheritedFunctionWithDefaultParameters.kt")
                 public void testInheritedFunctionWithDefaultParameters() throws Exception {
                     runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/inheritedFunctionWithDefaultParameters.kt");
@@ -15682,6 +15777,11 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
                     runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/kt14243_2.kt");
                 }
 
+                @TestMetadata("kt40920.kt")
+                public void testKt40920() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/kt40920.kt");
+                }
+
                 @TestMetadata("privateFunInInterface.kt")
                 public void testPrivateFunInInterface() throws Exception {
                     runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/privateFunInInterface.kt");
@@ -15719,6 +15819,24 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
                         runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/delegationBy/simpleProperty.kt");
                     }
                 }
+
+                @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/specialization")
+                @TestDataPath("$PROJECT_ROOT")
+                @RunWith(JUnit3RunnerWithInners.class)
+                public static class Specialization extends AbstractFirBlackBoxCodegenTest {
+                    private void runTest(String testDataFilePath) throws Exception {
+                        KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_IR, testDataFilePath, "// IGNORE_BACKEND_FIR: ");
+                    }
+
+                    public void testAllFilesPresentInSpecialization() throws Exception {
+                        KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/specialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
+                    }
+
+                    @TestMetadata("basic.kt")
+                    public void testBasic() throws Exception {
+                        runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/specialization/basic.kt");
+                    }
+                }
             }
 
             @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/noDelegation")
@@ -15843,6 +15961,26 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
                 runTest("compiler/testData/codegen/box/jvm8/javaDefaults/invokeDefaultViaSuper.kt");
             }
 
+            @TestMetadata("kt40920.kt")
+            public void testKt40920() throws Exception {
+                runTest("compiler/testData/codegen/box/jvm8/javaDefaults/kt40920.kt");
+            }
+
+            @TestMetadata("kt40920_java.kt")
+            public void testKt40920_java() throws Exception {
+                runTest("compiler/testData/codegen/box/jvm8/javaDefaults/kt40920_java.kt");
+            }
+
+            @TestMetadata("kt40920_java2.kt")
+            public void testKt40920_java2() throws Exception {
+                runTest("compiler/testData/codegen/box/jvm8/javaDefaults/kt40920_java2.kt");
+            }
+
+            @TestMetadata("kt40920_map.kt")
+            public void testKt40920_map() throws Exception {
+                runTest("compiler/testData/codegen/box/jvm8/javaDefaults/kt40920_map.kt");
+            }
+
             @TestMetadata("longChainOfKotlinExtendsFromJavaWithDefault.kt")
             public void testLongChainOfKotlinExtendsFromJavaWithDefault() throws Exception {
                 runTest("compiler/testData/codegen/box/jvm8/javaDefaults/longChainOfKotlinExtendsFromJavaWithDefault.kt");
@@ -26033,6 +26171,11 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
                     KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
                 }
 
+                @TestMetadata("allSupertypes.kt")
+                public void testAllSupertypes() throws Exception {
+                    runTest("compiler/testData/codegen/box/reflection/mapping/types/allSupertypes.kt");
+                }
+
                 @TestMetadata("annotationConstructorParameters.kt")
                 public void testAnnotationConstructorParameters() throws Exception {
                     runTest("compiler/testData/codegen/box/reflection/mapping/types/annotationConstructorParameters.kt");
@@ -26048,6 +26191,11 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
                     runTest("compiler/testData/codegen/box/reflection/mapping/types/constructors.kt");
                 }
 
+                @TestMetadata("createType.kt")
+                public void testCreateType() throws Exception {
+                    runTest("compiler/testData/codegen/box/reflection/mapping/types/createType.kt");
+                }
+
                 @TestMetadata("genericArrayElementType.kt")
                 public void testGenericArrayElementType() throws Exception {
                     runTest("compiler/testData/codegen/box/reflection/mapping/types/genericArrayElementType.kt");

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaConstructor.kt

@@ -113,6 +113,10 @@ class FirJavaConstructor @FirImplementationDetail constructor(
         return this
     }
 
+    override fun <D> transformBody(transformer: FirTransformer<D>, data: D): FirConstructor {
+        return this
+    }
+
     override var containerSource: DeserializedContainerSource? = null
 
     override fun replaceReturnTypeRef(newReturnTypeRef: FirTypeRef) {

compiler/fir/modularized-tests/tests/org/jetbrains/kotlin/fir/NonFirResolveModularizedTotalKotlinTest.kt

@@ -6,10 +6,8 @@
 package org.jetbrains.kotlin.fir
 
 import com.intellij.openapi.util.Disposer
-import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys.CONTENT_ROOTS
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY
-import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
@@ -17,9 +15,6 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinToJVMBytecodeCompiler
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
-import org.jetbrains.kotlin.test.ConfigurationKind
-import org.jetbrains.kotlin.test.KotlinTestUtils
-import org.jetbrains.kotlin.test.TestJdkKind
 import java.io.FileOutputStream
 import java.io.PrintStream
 import kotlin.system.measureNanoTime
@@ -87,7 +82,7 @@ class NonFirResolveModularizedTotalKotlinTest : AbstractModularizedTest() {
 
             }
 
-            override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageLocation?) {
+            override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageSourceLocation?) {
                 if (location != null)
                     print(location.toString())
                 print(":")

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

@@ -84,7 +84,6 @@ private class FirCallArgumentsProcessor(private val function: FirFunction<*>) {
                 if (state == State.VARARG_POSITION) {
                     completeVarargPositionArguments()
                 }
-                state = State.NAMED_ONLY_ARGUMENTS
 
                 processNamedArgument(argument, argumentName)
             }
@@ -125,6 +124,8 @@ private class FirCallArgumentsProcessor(private val function: FirFunction<*>) {
             addDiagnostic(NamedArgumentNotAllowed(argument, function))
         }
 
+        val stateAllowsMixedNamedAndPositionArguments = state != State.NAMED_ONLY_ARGUMENTS
+        state = State.NAMED_ONLY_ARGUMENTS
         val parameter = findParameterByName(argument, name) ?: return
 
         result[parameter]?.let {
@@ -134,7 +135,7 @@ private class FirCallArgumentsProcessor(private val function: FirFunction<*>) {
 
         result[parameter] = ResolvedCallArgument.SimpleArgument(argument)
 
-        if (parameters.getOrNull(currentPositionedParameterIndex) == parameter) {
+        if (stateAllowsMixedNamedAndPositionArguments && parameters.getOrNull(currentPositionedParameterIndex) == parameter) {
             state = State.POSITION_ARGUMENTS
             currentPositionedParameterIndex++
         }

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

@@ -99,7 +99,13 @@ class FirCallCompletionResultsWriterTransformer(
         data: ExpectedArgumentType?,
     ): CompositeTransformResult<FirStatement> {
         val calleeReference = qualifiedAccessExpression.calleeReference as? FirNamedReferenceWithCandidate
-            ?: return qualifiedAccessExpression.compose()
+            ?: return run {
+                if (mode == Mode.DelegatedPropertyCompletion) {
+                    val typeUpdater = TypeUpdaterForDelegateArguments()
+                    qualifiedAccessExpression.transformSingle(typeUpdater, null)
+                }
+                qualifiedAccessExpression.compose()
+            }
         val result = prepareQualifiedTransform(qualifiedAccessExpression, calleeReference)
             .transformExplicitReceiver(integerApproximator, null)
         val typeRef = result.typeRef as FirResolvedTypeRef

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt

@@ -18,7 +18,6 @@ import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.transformers.*
-import org.jetbrains.kotlin.fir.resolve.transformers.TransformImplicitType
 import org.jetbrains.kotlin.fir.resolve.transformers.contracts.runContractResolveForLocalClass
 import org.jetbrains.kotlin.fir.symbols.impl.FirAccessorSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
@@ -86,9 +85,9 @@ fun <F : FirClass<F>> F.runContractAndBodiesResolutionForLocalClass(
         components.session, components.scopeSession,
         implicitBodyResolveComputationSession,
         FirResolvePhase.BODY_RESOLVE,
-        outerBodyResolveContext = newContext,
         implicitTypeOnly = false,
-        returnTypeCalculator
+        returnTypeCalculator,
+        outerBodyResolveContext = newContext
     )
 
     val graphBuilder = components.context.dataFlowAnalyzerContext.graphBuilder

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirIntegerLiteralTypeScope.kt

@@ -108,7 +108,6 @@ class FirIntegerOperator @FirImplementationDetail constructor(
     FirDeclarationOrigin.Synthetic,
     returnTypeRef,
     receiverTypeRef,
-    typeParameters = mutableListOf(),
     valueParameters = mutableListOf(),
     body = null,
     status,
@@ -117,6 +116,7 @@ class FirIntegerOperator @FirImplementationDetail constructor(
     kind.operatorName,
     symbol,
     annotations = mutableListOf(),
+    typeParameters = mutableListOf(),
 ) {
     enum class Kind(val unary: Boolean, val operatorName: Name) {
         PLUS(false, OperatorNameConventions.PLUS),

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirAnonymousFunction.kt

@@ -64,4 +64,6 @@ abstract class FirAnonymousFunction : FirFunction<FirAnonymousFunction>, FirExpr
     abstract override fun <D> transformControlFlowGraphReference(transformer: FirTransformer<D>, data: D): FirAnonymousFunction
 
     abstract override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirAnonymousFunction
+
+    abstract override fun <D> transformBody(transformer: FirTransformer<D>, data: D): FirAnonymousFunction
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirConstructor.kt

@@ -64,4 +64,6 @@ abstract class FirConstructor : FirPureAbstractElement(), FirFunction<FirConstru
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirConstructor
 
     abstract fun <D> transformDelegatedConstructor(transformer: FirTransformer<D>, data: D): FirConstructor
+
+    abstract override fun <D> transformBody(transformer: FirTransformer<D>, data: D): FirConstructor
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirErrorFunction.kt

@@ -57,4 +57,6 @@ abstract class FirErrorFunction : FirPureAbstractElement(), FirFunction<FirError
     abstract override fun <D> transformControlFlowGraphReference(transformer: FirTransformer<D>, data: D): FirErrorFunction
 
     abstract override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirErrorFunction
+
+    abstract override fun <D> transformBody(transformer: FirTransformer<D>, data: D): FirErrorFunction
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirFunction.kt

@@ -55,4 +55,6 @@ interface FirFunction<F : FirFunction<F>> : FirCallableDeclaration<F>, FirTarget
     fun <D> transformControlFlowGraphReference(transformer: FirTransformer<D>, data: D): FirFunction<F>
 
     fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirFunction<F>
+
+    fun <D> transformBody(transformer: FirTransformer<D>, data: D): FirFunction<F>
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirPropertyAccessor.kt

@@ -60,6 +60,8 @@ abstract class FirPropertyAccessor : FirPureAbstractElement(), FirFunction<FirPr
 
     abstract override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirPropertyAccessor
 
+    abstract override fun <D> transformBody(transformer: FirTransformer<D>, data: D): FirPropertyAccessor
+
     abstract override fun <D> transformContractDescription(transformer: FirTransformer<D>, data: D): FirPropertyAccessor
 
     abstract fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirPropertyAccessor

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirSimpleFunction.kt

@@ -62,6 +62,8 @@ abstract class FirSimpleFunction : FirPureAbstractElement(), FirFunction<FirSimp
 
     abstract override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirSimpleFunction
 
+    abstract override fun <D> transformBody(transformer: FirTransformer<D>, data: D): FirSimpleFunction
+
     abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirSimpleFunction
 
     abstract override fun <D> transformContractDescription(transformer: FirTransformer<D>, data: D): FirSimpleFunction

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousFunctionImpl.kt

@@ -69,7 +69,7 @@ internal class FirAnonymousFunctionImpl(
         transformReceiverTypeRef(transformer, data)
         transformControlFlowGraphReference(transformer, data)
         transformValueParameters(transformer, data)
-        body = body?.transformSingle(transformer, data)
+        transformBody(transformer, data)
         typeRef = typeRef.transformSingle(transformer, data)
         label = label?.transformSingle(transformer, data)
         typeParameters.transformInplace(transformer, data)
@@ -101,6 +101,11 @@ internal class FirAnonymousFunctionImpl(
         return this
     }
 
+    override fun <D> transformBody(transformer: FirTransformer<D>, data: D): FirAnonymousFunctionImpl {
+        body = body?.transformSingle(transformer, data)
+        return this
+    }
+
     override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
         resolvePhase = newResolvePhase
     }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirConstructorImpl.kt

@@ -74,7 +74,7 @@ internal class FirConstructorImpl(
         transformStatus(transformer, data)
         transformAnnotations(transformer, data)
         transformDelegatedConstructor(transformer, data)
-        body = body?.transformSingle(transformer, data)
+        transformBody(transformer, data)
         return this
     }
 
@@ -113,6 +113,11 @@ internal class FirConstructorImpl(
         return this
     }
 
+    override fun <D> transformBody(transformer: FirTransformer<D>, data: D): FirConstructorImpl {
+        body = body?.transformSingle(transformer, data)
+        return this
+    }
+
     override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
         resolvePhase = newResolvePhase
     }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirErrorFunctionImpl.kt

@@ -90,6 +90,10 @@ internal class FirErrorFunctionImpl(
         return this
     }
 
+    override fun <D> transformBody(transformer: FirTransformer<D>, data: D): FirErrorFunctionImpl {
+        return this
+    }
+
     override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
         resolvePhase = newResolvePhase
     }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirPrimaryConstructor.kt

@@ -74,7 +74,7 @@ internal class FirPrimaryConstructor(
         transformStatus(transformer, data)
         transformAnnotations(transformer, data)
         transformDelegatedConstructor(transformer, data)
-        body = body?.transformSingle(transformer, data)
+        transformBody(transformer, data)
         return this
     }
 
@@ -113,6 +113,11 @@ internal class FirPrimaryConstructor(
         return this
     }
 
+    override fun <D> transformBody(transformer: FirTransformer<D>, data: D): FirPrimaryConstructor {
+        body = body?.transformSingle(transformer, data)
+        return this
+    }
+
     override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
         resolvePhase = newResolvePhase
     }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirPropertyAccessorImpl.kt

@@ -69,7 +69,7 @@ open class FirPropertyAccessorImpl @FirImplementationDetail constructor(
         transformReturnTypeRef(transformer, data)
         transformControlFlowGraphReference(transformer, data)
         transformValueParameters(transformer, data)
-        body = body?.transformSingle(transformer, data)
+        transformBody(transformer, data)
         transformContractDescription(transformer, data)
         transformStatus(transformer, data)
         transformAnnotations(transformer, data)
@@ -96,6 +96,11 @@ open class FirPropertyAccessorImpl @FirImplementationDetail constructor(
         return this
     }
 
+    override fun <D> transformBody(transformer: FirTransformer<D>, data: D): FirPropertyAccessorImpl {
+        body = body?.transformSingle(transformer, data)
+        return this
+    }
+
     override fun <D> transformContractDescription(transformer: FirTransformer<D>, data: D): FirPropertyAccessorImpl {
         contractDescription = contractDescription.transformSingle(transformer, data)
         return this

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirSimpleFunctionImpl.kt

@@ -72,7 +72,7 @@ open class FirSimpleFunctionImpl @FirImplementationDetail constructor(
         transformReceiverTypeRef(transformer, data)
         transformControlFlowGraphReference(transformer, data)
         transformValueParameters(transformer, data)
-        body = body?.transformSingle(transformer, data)
+        transformBody(transformer, data)
         transformStatus(transformer, data)
         transformContractDescription(transformer, data)
         transformAnnotations(transformer, data)
@@ -100,6 +100,11 @@ open class FirSimpleFunctionImpl @FirImplementationDetail constructor(
         return this
     }
 
+    override fun <D> transformBody(transformer: FirTransformer<D>, data: D): FirSimpleFunctionImpl {
+        body = body?.transformSingle(transformer, data)
+        return this
+    }
+
     override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirSimpleFunctionImpl {
         status = status.transformSingle(transformer, data)
         return this

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/synthetic/FirSyntheticPropertyAccessor.kt

@@ -109,6 +109,10 @@ class FirSyntheticPropertyAccessor(
         throw AssertionError("Transformation of synthetic property accessor isn't supported")
     }
 
+    override fun <D> transformBody(transformer: FirTransformer<D>, data: D): FirPropertyAccessor {
+        throw AssertionError("Transformation of synthetic property accessor isn't supported")
+    }
+
     override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
         throw AssertionError("Mutation of synthetic property accessor isn't supported")
     }

compiler/fir/tree/tree-generator/build.gradle.kts

@@ -27,7 +27,7 @@ dependencies {
     Platform[192].orHigher {
         runtimeOnly(intellijCoreDep()) { includeJars("jdom") }
     }
-    implementation(kotlin("reflect"))
+    implementation(project(":kotlin-reflect"))
 }
 
 val writeCopyright by task<WriteCopyrightToFile> {

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt

@@ -100,7 +100,7 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
             +controlFlowGraphReferenceField
             +symbol("FirFunctionSymbol", "F")
             +fieldList(valueParameter, withReplace = true).withTransform()
-            +body(nullable = true)
+            +body(nullable = true).withTransform()
         }
 
         errorFunction.configure {

compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt

@@ -42,6 +42,7 @@ import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
 import org.jetbrains.kotlin.load.kotlin.VirtualFileFinderFactory
 import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.resolve.*
+import org.jetbrains.kotlin.resolve.calls.tower.ImplicitsExtensionsResolutionFilter
 import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
 import org.jetbrains.kotlin.resolve.jvm.JvmDiagnosticComponents
 import org.jetbrains.kotlin.resolve.jvm.multiplatform.OptionalAnnotationPackageFragmentProvider
@@ -63,7 +64,8 @@ fun createContainerForLazyResolveWithJava(
     languageVersionSettings: LanguageVersionSettings,
     useBuiltInsProvider: Boolean,
     configureJavaClassFinder: (StorageComponentContainer.() -> Unit)? = null,
-    javaClassTracker: JavaClassesTracker? = null
+    javaClassTracker: JavaClassesTracker? = null,
+    implicitsResolutionFilter: ImplicitsExtensionsResolutionFilter? = null,
 ): StorageComponentContainer = createContainer("LazyResolveWithJava", JvmPlatformAnalyzerServices) {
     configureModule(moduleContext, jvmPlatform, JvmPlatformAnalyzerServices, bindingTrace, languageVersionSettings)
 
@@ -73,6 +75,7 @@ fun createContainerForLazyResolveWithJava(
     useInstance(moduleContentScope)
     useInstance(packagePartProvider)
     useInstance(declarationProviderFactory)
+    useInstanceIfNotNull(implicitsResolutionFilter)
 
     useInstance(VirtualFileFinderFactory.getInstance(moduleContext.project).create(moduleContentScope))
 

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmResolverForModuleFactory.kt

@@ -29,7 +29,6 @@ import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolverImpl
 import org.jetbrains.kotlin.load.java.structure.JavaClass
 import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
 import org.jetbrains.kotlin.platform.jvm.isJvm
-import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.resolve.CodeAnalyzerInitializer
 import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.resolve.TargetEnvironment
@@ -39,7 +38,9 @@ import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
 
 class JvmPlatformParameters(
     val packagePartProviderFactory: (ModuleContent<*>) -> PackagePartProvider,
-    val moduleByJavaClass: (JavaClass) -> ModuleInfo?
+    val moduleByJavaClass: (JavaClass) -> ModuleInfo?,
+    // params: referenced module info of target class, context module info of current resolver
+    val resolverForReferencedModule: ((ModuleInfo, ModuleInfo) -> ResolverForModule?)? = null,
 ) : PlatformAnalysisParameters
 
 
@@ -64,13 +65,22 @@ class JvmResolverForModuleFactory(
         )
 
         val moduleClassResolver = ModuleClassResolverImpl { javaClass ->
-            val referencedClassModule = (platformParameters as JvmPlatformParameters).moduleByJavaClass(javaClass)
-            // We don't have full control over idea resolve api so we allow for a situation which should not happen in Kotlin.
-            // For example, type in a java library can reference a class declared in a source root (is valid but rare case)
-            // Providing a fallback strategy in this case can hide future problems, so we should at least log to be able to diagnose those
+            val referencedClassModule = platformParameters.moduleByJavaClass(javaClass)
+            // A type in a java library can reference a class declared in a source root (is valid but rare case).
+            // Resolving such a class with Kotlin resolver for libraries is guaranteed to fail, as libraries can't
+            // have dependencies on the source roots. The chain of resolvers (sources -> libraries -> sdk) exists to prevent
+            // potentially slow repetitive analysis of the same libraries after modifications in sources. The only way to mitigate
+            // this restriction currently is to manually configure resolution anchors for known source-dependent libraries in a project.
+            // See also KT-24309
 
             @Suppress("UNCHECKED_CAST")
-            val resolverForReferencedModule = referencedClassModule?.let { resolverForProject.tryGetResolverForModule(it as M) }
+            val resolverForReferencedModule = referencedClassModule?.let { referencedModuleInfo ->
+                if (platformParameters.resolverForReferencedModule != null) {
+                    platformParameters.resolverForReferencedModule.invoke(referencedModuleInfo, moduleInfo)
+                } else {
+                    resolverForProject.tryGetResolverForModule(referencedModuleInfo as M)
+                }
+            }
 
             val resolverForModule = resolverForReferencedModule?.takeIf {
                 referencedClassModule.platform.isJvm() || referencedClassModule.platform == null
@@ -110,12 +120,12 @@ class JvmResolverForModuleFactory(
         )
 
         providersForModule +=
-                PackageFragmentProviderExtension.getInstances(project)
-                    .mapNotNull {
-                        it.getPackageFragmentProvider(
-                            project, moduleDescriptor, moduleContext.storageManager, trace, moduleInfo, lookupTracker
-                        )
-                    }
+            PackageFragmentProviderExtension.getInstances(project)
+                .mapNotNull {
+                    it.getPackageFragmentProvider(
+                        project, moduleDescriptor, moduleContext.storageManager, trace, moduleInfo, lookupTracker
+                    )
+                }
 
         return ResolverForModule(CompositePackageFragmentProvider(providersForModule), container)
     }

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/annotations/jvmAnnotationUtil.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.resolve.jvm.annotations
 
 import org.jetbrains.kotlin.config.JvmDefaultMode
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.Annotated
@@ -19,6 +20,7 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedClassDescriptor
 
 val JVM_DEFAULT_FQ_NAME = FqName("kotlin.jvm.JvmDefault")
+val JVM_DEFAULT_NO_COMPATIBILITY_FQ_NAME = FqName("kotlin.jvm.JvmDefaultWithoutCompatibility")
 val JVM_OVERLOADS_FQ_NAME = FqName("kotlin.jvm.JvmOverloads")
 val JVM_SYNTHETIC_ANNOTATION_FQ_NAME = FqName("kotlin.jvm.JvmSynthetic")
 
@@ -64,6 +66,10 @@ fun CallableMemberDescriptor.isCompiledToJvmDefault(jvmDefault: JvmDefaultMode):
 fun CallableMemberDescriptor.hasJvmDefaultAnnotation(): Boolean =
     DescriptorUtils.getDirectMember(this).annotations.hasAnnotation(JVM_DEFAULT_FQ_NAME)
 
+fun DeclarationDescriptor.hasJvmDefaultNoCompatibilityAnnotation(): Boolean =
+    this.annotations.hasAnnotation(JVM_DEFAULT_NO_COMPATIBILITY_FQ_NAME)
+
+
 fun CallableMemberDescriptor.hasPlatformDependentAnnotation(): Boolean =
     DescriptorUtils.getDirectMember(this).annotations.hasAnnotation(PLATFORM_DEPENDENT_ANNOTATION_FQ_NAME)