test2

#KT-36276 Fixed

build.gradle.kts

@@ -8,7 +8,7 @@ buildscript {
     extra["defaultSnapshotVersion"] = "1.4-SNAPSHOT"
     val cacheRedirectorEnabled = findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() == true
 
-    kotlinBootstrapFrom(BootstrapOption.BintrayBootstrap("1.4.0-dev-1075", cacheRedirectorEnabled))
+    kotlinBootstrapFrom(BootstrapOption.BintrayBootstrap("1.4.0-dev-1818", cacheRedirectorEnabled))
 
     repositories {
         bootstrapKotlinRepo?.let(::maven)
@@ -179,7 +179,7 @@ extra["versions.r8"] = "1.5.70"
 extra["versions.ktor-network"] = "1.0.1"
 
 if (!project.hasProperty("versions.kotlin-native")) {
-    extra["versions.kotlin-native"] = "1.4-dev-14287"
+    extra["versions.kotlin-native"] = "1.4-M1"
 }
 
 val intellijUltimateEnabled by extra(project.kotlinBuildProperties.intellijUltimateEnabled)

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

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

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

@@ -65,10 +65,14 @@ class CommonResolverForModuleFactory(
         override val name: Name,
         override val capabilities: Map<ModuleDescriptor.Capability<*>, Any?>,
         private val dependencies: Iterable<ModuleInfo>,
+        override val expectedBy: List<ModuleInfo>,
+        private val modulesWhoseInternalsAreVisible: Collection<ModuleInfo>,
         private val dependOnOldBuiltIns: Boolean
     ) : ModuleInfo {
         override fun dependencies() = listOf(this, *dependencies.toList().toTypedArray() )
 
+        override fun modulesWhoseInternalsAreVisible(): Collection<ModuleInfo> = modulesWhoseInternalsAreVisible
+
         override fun dependencyOnBuiltIns(): ModuleInfo.DependencyOnBuiltIns =
             if (dependOnOldBuiltIns) ModuleInfo.DependencyOnBuiltIns.LAST else ModuleInfo.DependencyOnBuiltIns.NONE
 
@@ -123,6 +127,8 @@ class CommonResolverForModuleFactory(
                 moduleName,
                 capabilities,
                 dependenciesContainer?.moduleInfos?.toList().orEmpty(),
+                dependenciesContainer?.refinesModuleInfos.orEmpty(),
+                dependenciesContainer?.friendModuleInfos.orEmpty(),
                 dependOnBuiltIns
             )
             val project = files.firstOrNull()?.project ?: throw AssertionError("No files to analyze")
@@ -150,7 +156,8 @@ class CommonResolverForModuleFactory(
                 GlobalSearchScope.allScope(project),
                 languageVersionSettings = multiplatformLanguageSettings,
                 syntheticFiles = files,
-                dependencyModules = dependenciesContainer?.moduleInfos ?: emptyList()
+                knownDependencyModuleDescriptors = dependenciesContainer?.moduleInfos
+                    ?.associateWith(dependenciesContainer::moduleDescriptorForModuleInfo).orEmpty()
             )
 
             val moduleDescriptor = resolver.descriptorForModule(moduleInfo)
@@ -167,7 +174,11 @@ class CommonResolverForModuleFactory(
 interface CommonDependenciesContainer {
     val moduleInfos: List<ModuleInfo>
 
+    fun moduleDescriptorForModuleInfo(moduleInfo: ModuleInfo): ModuleDescriptor
+
     fun packageFragmentProviderForModuleInfo(moduleInfo: ModuleInfo): PackageFragmentProvider?
+    val friendModuleInfos: List<ModuleInfo>
+    val refinesModuleInfos: List<ModuleInfo>
 }
 
 private fun createContainerToResolveCommonCode(

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

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

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

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

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

@@ -52,7 +52,9 @@ fun buildConfiguration(environment: KotlinCoreEnvironment, moduleName: String):
     return runtimeConfiguration
 }
 
-val environment = KotlinCoreEnvironment.createForTests(Disposable { }, CompilerConfiguration(), EnvironmentConfigFiles.JS_CONFIG_FILES)
+@Suppress("RedundantSamConstructor")
+private val environment =
+    KotlinCoreEnvironment.createForProduction(Disposable { }, CompilerConfiguration(), EnvironmentConfigFiles.JS_CONFIG_FILES)
 
 fun createPsiFile(fileName: String): KtFile {
     val psiManager = PsiManager.getInstance(environment.project)

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

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.cli.js
+
+import org.jetbrains.kotlin.config.*
+
+class JSLanguageVersionSettings(private val delegate: LanguageVersionSettings) : LanguageVersionSettings {
+    companion object {
+        private val disabledFeatures = setOf(
+            LanguageFeature.NewInference,
+            LanguageFeature.FunctionalInterfaceConversion,
+            LanguageFeature.SamConversionForKotlinFunctions,
+            LanguageFeature.SamConversionPerArgument,
+            LanguageFeature.FunctionReferenceWithDefaultValueAsOtherType,
+            LanguageFeature.NonStrictOnlyInputTypesChecks
+        )
+    }
+
+    override fun getFeatureSupport(feature: LanguageFeature): LanguageFeature.State {
+        return if (feature in disabledFeatures)
+            LanguageFeature.State.DISABLED
+        else
+            delegate.getFeatureSupport(feature)
+    }
+
+    override fun isPreRelease(): Boolean = delegate.isPreRelease()
+
+    override fun <T> getFlag(flag: AnalysisFlag<T>): T = delegate.getFlag(flag)
+
+    override val apiVersion: ApiVersion
+        get() = delegate.apiVersion
+
+    override val languageVersion: LanguageVersion
+        get() = delegate.languageVersion
+}

compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JSCompiler.java

@@ -246,6 +246,13 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
 
         configuration.put(CommonConfigurationKeys.MODULE_NAME, FileUtil.getNameWithoutExtension(outputFile));
 
+        if (!arguments.getNewInference()) {
+            CommonConfigurationKeysKt.setLanguageVersionSettings(
+                    configuration,
+                    new JSLanguageVersionSettings(CommonConfigurationKeysKt.getLanguageVersionSettings(configuration))
+            );
+        }
+
         JsConfig config = new JsConfig(project, configuration);
         JsConfig.Reporter reporter = new JsConfig.Reporter() {
             @Override

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

@@ -24,10 +24,7 @@ import org.jetbrains.kotlin.cli.common.messages.MessageUtil
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.plugins.PluginCliParser
-import org.jetbrains.kotlin.config.CommonConfigurationKeys
-import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.config.IncrementalCompilation
-import org.jetbrains.kotlin.config.Services
+import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.incremental.js.IncrementalDataProvider

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

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

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

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

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

@@ -421,6 +421,7 @@ class KotlinCoreEnvironment private constructor(
         fun createForProduction(
             parentDisposable: Disposable, configuration: CompilerConfiguration, configFiles: EnvironmentConfigFiles
         ): KotlinCoreEnvironment {
+            setupIdeaStandaloneExecution()
             val appEnv = getOrCreateApplicationEnvironmentForProduction(parentDisposable, configuration)
             val projectEnv = ProjectEnvironment(parentDisposable, appEnv)
             val environment = KotlinCoreEnvironment(projectEnv, configuration, configFiles)

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

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2010-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.cli.jvm.compiler
+
+import com.intellij.codeInsight.ExternalAnnotationsManager
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.psi.*
+
+class MockExternalAnnotationsManager : ExternalAnnotationsManager() {
+    override fun chooseAnnotationsPlace(element: PsiElement): AnnotationPlace = AnnotationPlace.NOWHERE
+    override fun chooseAnnotationsPlaceNoUi(element: PsiElement): AnnotationPlace = AnnotationPlace.NOWHERE
+
+    override fun isExternalAnnotationWritable(listOwner: PsiModifierListOwner, annotationFQN: String): Boolean = false
+    override fun isExternalAnnotation(annotation: PsiAnnotation): Boolean = false
+
+    override fun findExternalAnnotationsFiles(listOwner: PsiModifierListOwner): List<PsiFile>? = null
+    override fun findExternalAnnotation(listOwner: PsiModifierListOwner, annotationFQN: String): PsiAnnotation? = null
+    override fun findExternalAnnotations(listOwner: PsiModifierListOwner): Array<out PsiAnnotation>? = null
+
+    override fun annotateExternally(
+        listOwner: PsiModifierListOwner,
+        annotationFQName: String,
+        fromFile: PsiFile,
+        value: Array<out PsiNameValuePair>?
+    ) {
+        throw UnsupportedOperationException("not implemented")
+    }
+
+    override fun deannotate(listOwner: PsiModifierListOwner, annotationFQN: String): Boolean {
+        throw UnsupportedOperationException("not implemented")
+    }
+
+    override fun editExternalAnnotation(
+        listOwner: PsiModifierListOwner,
+        annotationFQN: String,
+        value: Array<out PsiNameValuePair>?
+    ): Boolean {
+        throw UnsupportedOperationException("not implemented")
+    }
+
+    override fun hasAnnotationRootsForFile(file: VirtualFile): Boolean = false
+
+    override fun findDefaultConstructorExternalAnnotations(aClass: PsiClass, annotationFQN: String): List<PsiAnnotation> = emptyList()
+
+    override fun findDefaultConstructorExternalAnnotations(aClass: PsiClass): List<PsiAnnotation> = emptyList()
+
+    override fun findExternalAnnotations(listOwner: PsiModifierListOwner, annotationFQN: String): List<PsiAnnotation> = emptyList()
+}

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

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

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

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

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

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

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

@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.cli.common.messages.MessageUtil
 import org.jetbrains.kotlin.cli.common.messages.OutputMessageUtil
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.config.K2MetadataConfigurationKeys
 import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots
 import org.jetbrains.kotlin.cli.jvm.plugins.PluginCliParser
 import org.jetbrains.kotlin.codegen.CompilationException
@@ -73,6 +74,10 @@ class K2MetadataCompiler : CLICompiler<K2MetadataCompilerArguments>() {
 
         configuration.put(CLIConfigurationKeys.ALLOW_KOTLIN_PACKAGE, arguments.allowKotlinPackage)
 
+        configuration.putIfNotNull(K2MetadataConfigurationKeys.FRIEND_PATHS, arguments.friendPaths?.toList())
+        configuration.putIfNotNull(K2MetadataConfigurationKeys.REFINES_PATHS, arguments.refinesPaths?.toList())
+
+
         val destination = arguments.destination
         if (destination != null) {
             if (destination.endsWith(".jar")) {

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

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.cli.metadata
 
-import org.jetbrains.kotlin.analyzer.ModuleInfo
+import org.jetbrains.kotlin.analyzer.*
 import org.jetbrains.kotlin.analyzer.common.CommonDependenciesContainer
 import org.jetbrains.kotlin.analyzer.common.CommonPlatformAnalyzerServices
 import org.jetbrains.kotlin.backend.common.serialization.metadata.KlibMetadataMonolithicSerializer
@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot
 import org.jetbrains.kotlin.cli.jvm.config.JvmContentRoot
+import org.jetbrains.kotlin.cli.jvm.config.K2MetadataConfigurationKeys
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.KotlinCompilerVersion
@@ -25,6 +26,7 @@ import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.descriptors.konan.DeserializedKlibModuleOrigin
 import org.jetbrains.kotlin.konan.util.KlibMetadataFactories
 import org.jetbrains.kotlin.library.*
+import org.jetbrains.kotlin.library.impl.BuiltInsPlatform
 import org.jetbrains.kotlin.library.impl.buildKoltinLibrary
 import org.jetbrains.kotlin.library.impl.createKotlinLibraryComponents
 import org.jetbrains.kotlin.library.metadata.parseModuleHeader
@@ -88,7 +90,8 @@ internal class K2MetadataKlibSerializer(private val metadataVersion: BuiltInsBin
             configuration[CommonConfigurationKeys.MODULE_NAME]!!,
             nopack = true,
             manifestProperties = null,
-            dataFlowGraph = null
+            dataFlowGraph = null,
+            builtInsPlatform = BuiltInsPlatform.COMMON
         )
     }
 }
@@ -109,6 +112,9 @@ private class KlibMetadataDependencyContainer(
         klibFiles.map { resolveSingleFileKlib(org.jetbrains.kotlin.konan.file.File(it.absolutePath)) }
     }
 
+    private val friendPaths = configuration.get(K2MetadataConfigurationKeys.FRIEND_PATHS).orEmpty().toSet()
+    private val refinesPaths = configuration.get(K2MetadataConfigurationKeys.REFINES_PATHS).orEmpty().toSet()
+
     private val builtIns
         get() = DefaultBuiltIns.Instance
 
@@ -144,7 +150,7 @@ private class KlibMetadataDependencyContainer(
             }
         }
 
-    override val moduleInfos: List<ModuleInfo> = mutableListOf<KlibModuleInfo>().apply {
+    private val moduleInfosImpl: List<KlibModuleInfo> = mutableListOf<KlibModuleInfo>().apply {
         addAll(
             moduleDescriptorsForKotlinLibraries.map { (kotlinLibrary, moduleDescriptor) ->
                 KlibModuleInfo(moduleDescriptor.name, kotlinLibrary, this@apply)
@@ -152,6 +158,28 @@ private class KlibMetadataDependencyContainer(
         )
     }
 
+    override val moduleInfos: List<ModuleInfo> get() = moduleInfosImpl
+
+    override val friendModuleInfos: List<ModuleInfo> = moduleInfosImpl.filter {
+        it.kotlinLibrary.libraryFile.absolutePath in friendPaths
+    }
+
+    override val refinesModuleInfos: List<ModuleInfo> = moduleInfosImpl.filter {
+        it.kotlinLibrary.libraryFile.absolutePath in refinesPaths
+    }
+
+    override fun moduleDescriptorForModuleInfo(moduleInfo: ModuleInfo): ModuleDescriptor {
+        if (moduleInfo !in moduleInfos)
+            error("Unknown module info $moduleInfo")
+        moduleInfo as KlibModuleInfo
+
+        // Ensure that the package fragment provider has been created and the module descriptor has been
+        // initialized with the package fragment provider:
+        packageFragmentProviderForModuleInfo(moduleInfo)
+
+        return moduleDescriptorsForKotlinLibraries.getValue(moduleInfo.kotlinLibrary)
+    }
+
     override fun packageFragmentProviderForModuleInfo(
         moduleInfo: ModuleInfo
     ): PackageFragmentProvider? {

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

@@ -1842,6 +1842,11 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest {
             runTest("compiler/testData/ir/irText/types/genericPropertyReferenceType.kt");
         }
 
+        @TestMetadata("inStarProjectionInReceiverType.kt")
+        public void testInStarProjectionInReceiverType() throws Exception {
+            runTest("compiler/testData/ir/irText/types/inStarProjectionInReceiverType.kt");
+        }
+
         @TestMetadata("intersectionType1_NI.kt")
         public void testIntersectionType1_NI() throws Exception {
             runTest("compiler/testData/ir/irText/types/intersectionType1_NI.kt");
@@ -1872,6 +1877,11 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest {
             runTest("compiler/testData/ir/irText/types/intersectionType3_OI.kt");
         }
 
+        @TestMetadata("kt36143.kt")
+        public void testKt36143() throws Exception {
+            runTest("compiler/testData/ir/irText/types/kt36143.kt");
+        }
+
         @TestMetadata("localVariableOfIntersectionType_NI.kt")
         public void testLocalVariableOfIntersectionType_NI() throws Exception {
             runTest("compiler/testData/ir/irText/types/localVariableOfIntersectionType_NI.kt");
@@ -1892,6 +1902,11 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest {
             runTest("compiler/testData/ir/irText/types/smartCastOnReceiverOfGenericType.kt");
         }
 
+        @TestMetadata("starProjection_OI.kt")
+        public void testStarProjection_OI() throws Exception {
+            runTest("compiler/testData/ir/irText/types/starProjection_OI.kt");
+        }
+
         @TestMetadata("compiler/testData/ir/irText/types/nullChecks")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)

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

@@ -9896,6 +9896,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/inference/conflictingSubstitutions.kt");
         }
 
+        @TestMetadata("cstFromErrorAndNonErrorTypes.kt")
+        public void testCstFromErrorAndNonErrorTypes() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/inference/cstFromErrorAndNonErrorTypes.kt");
+        }
+
         @TestMetadata("dependOnExpectedType.kt")
         public void testDependOnExpectedType() throws Exception {
             runTest("compiler/testData/diagnostics/tests/inference/dependOnExpectedType.kt");
@@ -10096,6 +10101,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/inference/kt35702.kt");
         }
 
+        @TestMetadata("kt36819.kt")
+        public void testKt36819() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/inference/kt36819.kt");
+        }
+
         @TestMetadata("kt6175.kt")
         public void testKt6175() throws Exception {
             runTest("compiler/testData/diagnostics/tests/inference/kt6175.kt");
@@ -21205,6 +21215,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             public void testSmartCastOnReceiver() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/smartCasts/inference/smartCastOnReceiver.kt");
             }
+
+            @TestMetadata("stabilityOfSmartcastsAgainstGenericFunctions.kt")
+            public void testStabilityOfSmartcastsAgainstGenericFunctions() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/smartCasts/inference/stabilityOfSmartcastsAgainstGenericFunctions.kt");
+            }
         }
 
         @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/intersectionScope")

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

@@ -1360,6 +1360,11 @@ public class FirOldFrontendDiagnosticsTestWithStdlibGenerated extends AbstractFi
                 runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/extensionReceiver_after.kt");
             }
 
+            @TestMetadata("externalArguments.kt")
+            public void testExternalArguments() throws Exception {
+                runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/externalArguments.kt");
+            }
+
             @TestMetadata("intersectingInfo.kt")
             public void testIntersectingInfo() throws Exception {
                 runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/intersectingInfo.kt");
@@ -1508,6 +1513,11 @@ public class FirOldFrontendDiagnosticsTestWithStdlibGenerated extends AbstractFi
                     KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/when"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true);
                 }
 
+                @TestMetadata("kt36818.kt")
+                public void testKt36818() throws Exception {
+                    runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/when/kt36818.kt");
+                }
+
                 @TestMetadata("withSubject.kt")
                 public void testWithSubject() throws Exception {
                     runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/when/withSubject.kt");
@@ -1908,6 +1918,11 @@ public class FirOldFrontendDiagnosticsTestWithStdlibGenerated extends AbstractFi
                 KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true);
             }
 
+            @TestMetadata("checkLowPriorityIsResolvedSuccessfully.kt")
+            public void testCheckLowPriorityIsResolvedSuccessfully() throws Exception {
+                runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/checkLowPriorityIsResolvedSuccessfully.kt");
+            }
+
             @TestMetadata("exactAnnotation.kt")
             public void testExactAnnotation() throws Exception {
                 runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/exactAnnotation.kt");

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

@@ -39,10 +39,11 @@ class RuntimeAssertionInfo(val needNotNullAssertion: Boolean, val message: Strin
     }
 
     companion object {
-        @JvmStatic fun create(
-                expectedType: KotlinType,
-                expressionType: KotlinType,
-                dataFlowExtras: DataFlowExtras
+        @JvmStatic
+        fun create(
+            expectedType: KotlinType,
+            expressionType: KotlinType,
+            dataFlowExtras: DataFlowExtras
         ): RuntimeAssertionInfo? {
             fun assertNotNull(): Boolean {
                 if (expectedType.isError || expressionType.isError) return false
@@ -81,9 +82,9 @@ private val KtExpression.textForRuntimeAssertionInfo
     get() = StringUtil.trimMiddle(text, 50)
 
 class RuntimeAssertionsDataFlowExtras(
-        private val c: ResolutionContext<*>,
-        private val expressionType: KotlinType,
-        private val expression: KtExpression
+    private val c: ResolutionContext<*>,
+    private val expressionType: KotlinType,
+    private val expression: KtExpression
 ) : RuntimeAssertionInfo.DataFlowExtras {
     private val dataFlowValue by lazy(LazyThreadSafetyMode.PUBLICATION) {
         c.dataFlowValueFactory.createDataFlowValue(expression, expressionType, c)
@@ -96,13 +97,18 @@ class RuntimeAssertionsDataFlowExtras(
 }
 
 object RuntimeAssertionsTypeChecker : AdditionalTypeChecker {
-    override fun checkType(expression: KtExpression, expressionType: KotlinType, expressionTypeWithSmartCast: KotlinType, c: ResolutionContext<*>) {
-        if (TypeUtils.noExpectedType(c.expectedType)) return
+    override fun checkType(
+        expression: KtExpression,
+        expressionType: KotlinType,
+        expressionTypeWithSmartCast: KotlinType,
+        c: ResolutionContext<*>
+    ) {
+        if (TypeUtils.noExpectedType(c.expectedType) || c.expectedType is StubType) return
 
         val assertionInfo = RuntimeAssertionInfo.create(
-                c.expectedType,
-                expressionType,
-                RuntimeAssertionsDataFlowExtras(c, expressionType, expression)
+            c.expectedType,
+            expressionType,
+            RuntimeAssertionsDataFlowExtras(c, expressionType, expression)
         )
 
         if (assertionInfo != null) {
@@ -127,9 +133,9 @@ object RuntimeAssertionsOnExtensionReceiverCallChecker : CallChecker {
         val c = context.resolutionContext
 
         val assertionInfo = RuntimeAssertionInfo.create(
-                receiverParameter.type,
-                receiverValue.type,
-                RuntimeAssertionsDataFlowExtras(c, receiverValue.type, receiverExpression)
+            receiverParameter.type,
+            receiverValue.type,
+            RuntimeAssertionsDataFlowExtras(c, receiverValue.type, receiverExpression)
         )
 
         if (assertionInfo != null) {
@@ -141,10 +147,10 @@ object RuntimeAssertionsOnExtensionReceiverCallChecker : CallChecker {
 object RuntimeAssertionsOnDeclarationBodyChecker {
     @JvmStatic
     fun check(
-            declaration: KtDeclaration,
-            descriptor: DeclarationDescriptor,
-            bindingTrace: BindingTrace,
-            languageVersionSettings: LanguageVersionSettings
+        declaration: KtDeclaration,
+        descriptor: DeclarationDescriptor,
+        bindingTrace: BindingTrace,
+        languageVersionSettings: LanguageVersionSettings
     ) {
         if (!languageVersionSettings.supportsFeature(LanguageFeature.StrictJavaNullabilityAssertions)) return
 
@@ -161,9 +167,9 @@ object RuntimeAssertionsOnDeclarationBodyChecker {
     }
 
     private fun checkLocalVariable(
-            declaration: KtProperty,
-            descriptor: VariableDescriptor,
-            bindingTrace: BindingTrace
+        declaration: KtProperty,
+        descriptor: VariableDescriptor,
+        bindingTrace: BindingTrace
     ) {
         if (declaration.typeReference != null) return
 
@@ -171,20 +177,23 @@ object RuntimeAssertionsOnDeclarationBodyChecker {
     }
 
     private fun checkFunction(
-            declaration: KtFunction,
-            descriptor: FunctionDescriptor,
-            bindingTrace: BindingTrace
+        declaration: KtFunction,
+        descriptor: FunctionDescriptor,
+        bindingTrace: BindingTrace
     ) {
         if (declaration.typeReference != null || declaration.hasBlockBody()) return
 
-        checkNullabilityAssertion(declaration.bodyExpression ?: return, descriptor.returnType ?: return,
-                                  bindingTrace)
+        checkNullabilityAssertion(
+            declaration.bodyExpression ?: return,
+            descriptor.returnType ?: return,
+            bindingTrace
+        )
     }
 
     private fun checkProperty(
-            declaration: KtProperty,
-            descriptor: PropertyDescriptor,
-            bindingTrace: BindingTrace
+        declaration: KtProperty,
+        descriptor: PropertyDescriptor,
+        bindingTrace: BindingTrace
     ) {
         if (declaration.typeReference != null) return
 
@@ -195,21 +204,24 @@ object RuntimeAssertionsOnDeclarationBodyChecker {
     }
 
     private fun checkPropertyAccessor(
-            declaration: KtPropertyAccessor,
-            descriptor: PropertyAccessorDescriptor,
-            bindingTrace: BindingTrace
+        declaration: KtPropertyAccessor,
+        descriptor: PropertyAccessorDescriptor,
+        bindingTrace: BindingTrace
     ) {
         if (declaration.property.typeReference != null || declaration.hasBlockBody()) return
 
-        checkNullabilityAssertion(declaration.bodyExpression ?: return, descriptor.correspondingProperty.type,
-                                  bindingTrace)
+        checkNullabilityAssertion(
+            declaration.bodyExpression ?: return,
+            descriptor.correspondingProperty.type,
+            bindingTrace
+        )
     }
 
 
     private fun checkNullabilityAssertion(
-            expression: KtExpression,
-            declarationType: KotlinType,
-            bindingTrace: BindingTrace
+        expression: KtExpression,
+        declarationType: KotlinType,
+        bindingTrace: BindingTrace
     ) {
         if (declarationType.unwrap().canContainNull()) return
 
@@ -219,9 +231,9 @@ object RuntimeAssertionsOnDeclarationBodyChecker {
         if (!expressionType.hasEnhancedNullability()) return
 
         bindingTrace.record(
-                JvmBindingContextSlices.BODY_RUNTIME_ASSERTION_INFO,
-                expression,
-                RuntimeAssertionInfo(true, expression.textForRuntimeAssertionInfo)
+            JvmBindingContextSlices.BODY_RUNTIME_ASSERTION_INFO,
+            expression,
+            RuntimeAssertionInfo(true, expression.textForRuntimeAssertionInfo)
         )
     }
 

compiler/frontend/src/org/jetbrains/kotlin/analyzer/AbstractResolverForProject.kt

@@ -19,12 +19,12 @@ abstract class AbstractResolverForProject<M : ModuleInfo>(
     private val debugName: String,
     protected val projectContext: ProjectContext,
     modules: Collection<M>,
-    private val fallbackModificationTracker: ModificationTracker? = null,
+    protected val fallbackModificationTracker: ModificationTracker? = null,
     private val delegateResolver: ResolverForProject<M> = EmptyResolverForProject(),
     private val packageOracleFactory: PackageOracleFactory = PackageOracleFactory.OptimisticFactory
 ) : ResolverForProject<M>() {
 
-    private class ModuleData(
+    protected class ModuleData(
         val moduleDescriptor: ModuleDescriptorImpl,
         val modificationTracker: ModificationTracker?
     ) {
@@ -37,7 +37,7 @@ abstract class AbstractResolverForProject<M : ModuleInfo>(
     }
 
     // Protected by ("projectContext.storageManager.lock")
-    private val descriptorByModule = mutableMapOf<M, ModuleData>()
+    protected val descriptorByModule = mutableMapOf<M, ModuleData>()
 
     // Protected by ("projectContext.storageManager.lock")
     private val moduleInfoByDescriptor = mutableMapOf<ModuleDescriptorImpl, M>()

compiler/frontend/src/org/jetbrains/kotlin/analyzer/ResolverForSingleModuleProject.kt

@@ -26,17 +26,26 @@ class ResolverForSingleModuleProject<M : ModuleInfo>(
     private val languageVersionSettings: LanguageVersionSettings = LanguageVersionSettingsImpl.DEFAULT,
     private val syntheticFiles: Collection<KtFile> = emptyList(),
     private val sdkDependency: M? = null,
-    dependencyModules: Iterable<M> = emptyList()
+    knownDependencyModuleDescriptors: Map<M, ModuleDescriptor> = emptyMap()
 ) : AbstractResolverForProject<M>(
     debugName,
     projectContext,
-    listOf(module) + dependencyModules,
+    listOf(module) + knownDependencyModuleDescriptors.keys,
     null,
     EmptyResolverForProject(),
     PackageOracleFactory.OptimisticFactory
 ) {
     override fun sdkDependency(module: M): M? = sdkDependency
 
+    init {
+        knownDependencyModuleDescriptors.forEach { (module, descriptor) ->
+            descriptorByModule[module] = ModuleData(
+                descriptor as ModuleDescriptorImpl,
+                (module as? TrackableModuleInfo)?.createModificationTracker() ?: fallbackModificationTracker
+            )
+        }
+    }
+
     override fun modulesContent(module: M): ModuleContent<M> = when (module) {
         this.module -> ModuleContent(module, syntheticFiles, searchScope)
         else -> ModuleContent(module, emptyList(), searchScope)

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/DiagnosticFactory.java

@@ -17,6 +17,8 @@
 package org.jetbrains.kotlin.diagnostics;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.diagnostics.rendering.DiagnosticRenderer;
 
 import java.util.Arrays;
 import java.util.Collection;
@@ -26,6 +28,8 @@ public abstract class DiagnosticFactory<D extends Diagnostic> {
     private String name = null;
     private final Severity severity;
 
+    private DiagnosticRenderer<D> defaultRenderer;
+
     protected DiagnosticFactory(@NotNull Severity severity) {
         this.severity = severity;
     }
@@ -49,6 +53,15 @@ public abstract class DiagnosticFactory<D extends Diagnostic> {
         return severity;
     }
 
+    @Nullable
+    public DiagnosticRenderer<D> getDefaultRenderer() {
+        return defaultRenderer;
+    }
+
+    void setDefaultRenderer(@Nullable DiagnosticRenderer<D> defaultRenderer) {
+        this.defaultRenderer = defaultRenderer;
+    }
+
     @NotNull
     @SuppressWarnings("unchecked")
     public D cast(@NotNull Diagnostic diagnostic) {

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java

@@ -16,6 +16,9 @@ import org.jetbrains.kotlin.config.LanguageVersion;
 import org.jetbrains.kotlin.config.LanguageVersionSettings;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.diagnostics.rendering.DeclarationWithDiagnosticComponents;
+import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages;
+import org.jetbrains.kotlin.diagnostics.rendering.DiagnosticFactoryToRendererMap;
+import org.jetbrains.kotlin.diagnostics.rendering.DiagnosticRenderer;
 import org.jetbrains.kotlin.lexer.KtKeywordToken;
 import org.jetbrains.kotlin.lexer.KtModifierKeywordToken;
 import org.jetbrains.kotlin.lexer.KtTokens;
@@ -1156,6 +1159,14 @@ public interface Errors {
         }
 
         public static void initializeFactoryNames(@NotNull Class<?> aClass) {
+            initializeFactoryNamesAndDefaultErrorMessages(aClass, DiagnosticFactoryToRendererMap::new);
+        }
+
+        public static void initializeFactoryNamesAndDefaultErrorMessages(
+                @NotNull Class<?> aClass,
+                @NotNull DefaultErrorMessages.Extension defaultErrorMessages
+        ) {
+            DiagnosticFactoryToRendererMap diagnosticToRendererMap = defaultErrorMessages.getMap();
             for (Field field : aClass.getFields()) {
                 if (Modifier.isStatic(field.getModifiers())) {
                     try {
@@ -1163,6 +1174,9 @@ public interface Errors {
                         if (value instanceof DiagnosticFactory) {
                             DiagnosticFactory<?> factory = (DiagnosticFactory<?>)value;
                             factory.setName(field.getName());
+
+                            //noinspection rawtypes, unchecked
+                            factory.setDefaultRenderer((DiagnosticRenderer) diagnosticToRendererMap.get(factory));
                         }
                     }
                     catch (IllegalAccessException e) {
@@ -1170,6 +1184,7 @@ public interface Errors {
                     }
                 }
             }
+
         }
 
         private static final Initializer INSTANCE = new Initializer();

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/diagnosticUtils.kt

@@ -167,10 +167,17 @@ inline fun <reified T : KtDeclaration> reportOnDeclarationAs(
     } ?: throw AssertionError("No declaration for $descriptor")
 }
 
+// this method should not be used in the project, but it is leaved for some time for compatibility with old compiler plugins
+@Deprecated(
+    "Please register DefaultErrorMessages.Extension in moment of DiagnosticFactory initialization by calling " +
+            "initializeFactoryNamesAndDefaultErrorMessages method instead of initializeFactoryNames",
+    ReplaceWith("report(diagnostic)"),
+    level = DeprecationLevel.ERROR
+)
 fun <D : Diagnostic> DiagnosticSink.reportFromPlugin(diagnostic: D, ext: DefaultErrorMessages.Extension) {
     @Suppress("UNCHECKED_CAST")
     val renderer = ext.map[diagnostic.factory] as? DiagnosticRenderer<D>
-            ?: error("Renderer not found for diagnostic ${diagnostic.factory.name}")
+        ?: error("Renderer not found for diagnostic ${diagnostic.factory.name}")
 
     val renderedDiagnostic = RenderedDiagnostic(diagnostic, renderer)
 

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java

@@ -56,7 +56,11 @@ public class DefaultErrorMessages {
 
     @Nullable
     public static DiagnosticRenderer getRendererForDiagnostic(@NotNull Diagnostic diagnostic) {
-        return AddToStdlibKt.firstNotNullResult(RENDERER_MAPS, map -> map.get(diagnostic.getFactory()));
+        DiagnosticRenderer<?> renderer = AddToStdlibKt.firstNotNullResult(RENDERER_MAPS, map -> map.get(diagnostic.getFactory()));
+        if (renderer != null)
+            return renderer;
+        else
+            return diagnostic.getFactory().getDefaultRenderer();
     }
 
     static {

compiler/frontend/src/org/jetbrains/kotlin/extensions/internal/CandidateInterceptor.kt

@@ -12,7 +12,9 @@ import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.calls.CallResolver
 import org.jetbrains.kotlin.resolve.calls.CandidateResolver
+import org.jetbrains.kotlin.resolve.calls.KotlinCallResolver
 import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
+import org.jetbrains.kotlin.resolve.calls.model.CallResolutionResult
 import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategy
 import org.jetbrains.kotlin.resolve.calls.tower.ImplicitScopeTower
 import org.jetbrains.kotlin.resolve.calls.tower.NewResolutionOldInference
@@ -30,10 +32,28 @@ class CandidateInterceptor(project: Project) {
         name: Name,
         kind: NewResolutionOldInference.ResolutionKind,
         tracing: TracingStrategy
-    ) = extensions.fold(candidates) { it, extension ->
+    ): Collection<NewResolutionOldInference.MyCandidate> = extensions.fold(candidates) { it, extension ->
         extension.interceptCandidates(it, context, candidateResolver, callResolver, name, kind, tracing)
     }
 
+    fun interceptResolvedCandidates(
+        callResolutionResult: CallResolutionResult,
+        context: BasicCallResolutionContext,
+        callResolver: KotlinCallResolver,
+        name: Name,
+        kind: NewResolutionOldInference.ResolutionKind,
+        tracing: TracingStrategy
+    ): CallResolutionResult {
+        var resolutionResult = callResolutionResult
+        for (extension in extensions) {
+            resolutionResult = extension.interceptCandidates(
+                resolutionResult, context, callResolver, name, kind, tracing
+            )
+        }
+
+        return resolutionResult
+    }
+
     fun interceptCandidates(
         candidates: Collection<FunctionDescriptor>,
         scopeTower: ImplicitScopeTower,

compiler/frontend/src/org/jetbrains/kotlin/extensions/internal/NonStableExtensionPoints.kt

@@ -13,7 +13,9 @@ import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtLambdaExpression
 import org.jetbrains.kotlin.resolve.calls.CallResolver
 import org.jetbrains.kotlin.resolve.calls.CandidateResolver
+import org.jetbrains.kotlin.resolve.calls.KotlinCallResolver
 import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
+import org.jetbrains.kotlin.resolve.calls.model.CallResolutionResult
 import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategy
 import org.jetbrains.kotlin.resolve.calls.tower.ImplicitScopeTower
 import org.jetbrains.kotlin.resolve.calls.tower.NewResolutionOldInference
@@ -58,6 +60,16 @@ interface CallResolutionInterceptorExtension {
         tracing: TracingStrategy
     ): Collection<NewResolutionOldInference.MyCandidate> = candidates
 
+    @JvmDefault
+    fun interceptCandidates(
+        callResolutionResult: CallResolutionResult,
+        context: BasicCallResolutionContext,
+        callResolver: KotlinCallResolver,
+        name: Name,
+        kind: NewResolutionOldInference.ResolutionKind,
+        tracing: TracingStrategy
+    ): CallResolutionResult = callResolutionResult
+
     fun interceptCandidates(
         candidates: Collection<FunctionDescriptor>,
         scopeTower: ImplicitScopeTower,

compiler/frontend/src/org/jetbrains/kotlin/idea/MainFunctionDetector.kt

@@ -125,9 +125,7 @@ class MainFunctionDetector {
             if (typeArguments.size != 1) return false
 
             val typeArgument = typeArguments[0].type
-            if (!(languageVersionSettings.supportsFeature(LanguageFeature.AllowNullableArrayArgsInMain) &&
-                        KotlinBuiltIns.isStringOrNullableString(typeArgument) || KotlinBuiltIns.isString(typeArgument))
-            ) {
+            if (!KotlinBuiltIns.isString(typeArgument)) {
                 return false
             }
             if (typeArguments[0].projectionKind === Variance.IN_VARIANCE) {

compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.resolve;
 
 import com.google.common.collect.Maps;
+import com.intellij.openapi.progress.ProgressManager;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiElement;
 import com.intellij.util.containers.Queue;
@@ -196,6 +197,8 @@ public class BodyResolver {
         Set<ConstructorDescriptor> visitedInCurrentChain = new HashSet<>();
         ConstructorDescriptor currentConstructorDescriptor = constructorDescriptor;
         while (true) {
+            ProgressManager.checkCanceled();
+
             visitedInCurrentChain.add(currentConstructorDescriptor);
             ConstructorDescriptor delegatedConstructorDescriptor = getDelegatedConstructor(currentConstructorDescriptor);
             if (delegatedConstructorDescriptor == null) break;
@@ -267,6 +270,8 @@ public class BodyResolver {
             @NotNull LexicalScope scopeForConstructorResolution,
             @NotNull LexicalScope scopeForMemberResolution
     ) {
+        ProgressManager.checkCanceled();
+
         LexicalScope scopeForConstructor =
                 primaryConstructor == null
                 ? null
@@ -399,6 +404,8 @@ public class BodyResolver {
         }
 
         for (KtSuperTypeListEntry delegationSpecifier : ktClass.getSuperTypeListEntries()) {
+            ProgressManager.checkCanceled();
+
             delegationSpecifier.accept(visitor);
         }
 
@@ -657,6 +664,8 @@ public class BodyResolver {
             @NotNull KtAnonymousInitializer anonymousInitializer,
             @NotNull ClassDescriptorWithResolutionScopes classDescriptor
     ) {
+        ProgressManager.checkCanceled();
+
         LexicalScope scopeForInitializers = classDescriptor.getScopeForInitializerResolution();
         KtExpression body = anonymousInitializer.getBody();
         if (body != null) {
@@ -935,6 +944,8 @@ public class BodyResolver {
             // Creates wrapper scope for header resolution if necessary (see resolveSecondaryConstructorBody)
             @Nullable Function1<LexicalScope, LexicalScope> headerScopeFactory
     ) {
+        ProgressManager.checkCanceled();
+
         PreliminaryDeclarationVisitor.Companion.createForDeclaration(function, trace, languageVersionSettings);
         LexicalScope innerScope = FunctionDescriptorUtil.getFunctionInnerScope(scope, functionDescriptor, trace, overloadChecker);
         List<KtParameter> valueParameters = function.getValueParameters();

compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.java

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.resolve;
 
+import com.intellij.openapi.progress.ProgressManager;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -270,6 +271,7 @@ public class ModifiersChecker {
                     missingSupertypesResolver
             );
             for (DeclarationChecker checker : declarationCheckers) {
+                ProgressManager.checkCanceled();
                 checker.check(declaration, descriptor, context);
             }
             OperatorModifierChecker.INSTANCE.check(declaration, descriptor, trace, languageVersionSettings);

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.kt

@@ -304,23 +304,31 @@ class CallExpressionResolver(
 
     private fun KtQualifiedExpression.elementChain(context: ExpressionTypingContext) =
         qualifiedExpressionResolver.resolveQualifierInExpressionAndUnroll(this, context) { nameExpression ->
-            val resolutionResult = resolveSimpleName(context, nameExpression)
+            val temporaryTraceAndCache =
+                TemporaryTraceAndCache.create(context, "trace to resolve as local variable or property", nameExpression)
+            val resolutionResult = resolveSimpleName(context, nameExpression, temporaryTraceAndCache)
 
             if (resolutionResult.isSingleResult && resolutionResult.resultingDescriptor is FakeCallableDescriptorForObject) {
                 false
             } else when (resolutionResult.resultCode) {
                 NAME_NOT_FOUND, CANDIDATES_WITH_WRONG_RECEIVER -> false
-                else -> !context.languageVersionSettings.supportsFeature(LanguageFeature.NewInference) || resolutionResult.isSuccess
+                else -> {
+                    val newInferenceEnabled = context.languageVersionSettings.supportsFeature(LanguageFeature.NewInference)
+                    val success = !newInferenceEnabled || resolutionResult.isSuccess
+                    if (newInferenceEnabled && success) {
+                        temporaryTraceAndCache.commit()
+                    }
+                    success
+                }
             }
         }
 
     private fun resolveSimpleName(
-        context: ExpressionTypingContext, expression: KtSimpleNameExpression
+        context: ExpressionTypingContext, expression: KtSimpleNameExpression, traceAndCache: TemporaryTraceAndCache
     ): OverloadResolutionResults<VariableDescriptor> {
-        val temporaryForVariable = TemporaryTraceAndCache.create(context, "trace to resolve as local variable or property", expression)
         val call = CallMaker.makePropertyCall(null, null, expression)
         val contextForVariable = BasicCallResolutionContext.create(
-            context.replaceTraceAndCache(temporaryForVariable), call, CheckArgumentTypesMode.CHECK_VALUE_ARGUMENTS
+            context.replaceTraceAndCache(traceAndCache), call, CheckArgumentTypesMode.CHECK_VALUE_ARGUMENTS
         )
         return callResolver.resolveSimpleProperty(contextForVariable)
     }

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/DiagnosticReporterByTrackingStrategy.kt

@@ -251,10 +251,12 @@ class DiagnosticReporterByTrackingStrategy(
                 )
                 val dataFlowValue = dataFlowValueFactory.createDataFlowValue(expressionArgument.receiver.receiverValue, context)
                 val call = if (call.callElement is KtBinaryExpression) null else call
-                smartCastManager.checkAndRecordPossibleCast(
-                    dataFlowValue, smartCastDiagnostic.smartCastType, argumentExpression, context, call,
-                    recordExpressionType = false
-                )
+                if (!expressionArgument.valueArgument.isExternal()) {
+                    smartCastManager.checkAndRecordPossibleCast(
+                        dataFlowValue, smartCastDiagnostic.smartCastType, argumentExpression, context, call,
+                        recordExpressionType = false
+                    )
+                } else null
             }
             is ReceiverExpressionKotlinCallArgument -> {
                 trace.markAsReported()

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/CoroutineInferenceSession.kt

@@ -28,6 +28,7 @@ import org.jetbrains.kotlin.resolve.deprecation.DeprecationResolver
 import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.expressions.DoubleColonExpressionResolver
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices
+import org.jetbrains.kotlin.types.typeUtil.contains
 import org.jetbrains.kotlin.utils.addToStdlib.cast
 
 class CoroutineInferenceSession(
@@ -52,9 +53,13 @@ class CoroutineInferenceSession(
 ) {
     private val commonCalls = arrayListOf<PSICompletedCallInfo>()
     private val diagnostics = arrayListOf<KotlinCallDiagnostic>()
+    private var hasInapplicableCall = false
 
     override fun shouldRunCompletion(candidate: KotlinResolutionCandidate): Boolean {
         val system = candidate.getSystem() as NewConstraintSystemImpl
+
+        if (system.hasContradiction) return true
+
         val storage = system.getBuilder().currentStorage()
         fun ResolvedAtom.hasPostponed(): Boolean {
             if (this is PostponedResolvedAtom && !analyzed) return true
@@ -75,26 +80,40 @@ class CoroutineInferenceSession(
 
         commonCalls.add(callInfo)
 
+        val resultingDescriptor = callInfo.resolvedCall.resultingDescriptor
+
+        // This check is similar to one for old inference, see getCoroutineInferenceData() function
+        val checkCall = resultingDescriptor is LocalVariableDescriptor || anyReceiverContainStubType(resultingDescriptor)
+
+        if (!checkCall) return
+
         val isApplicableCall =
             callComponents.statelessCallbacks.isApplicableCallForBuilderInference(
-                callInfo.resolvedCall.resultingDescriptor,
+                resultingDescriptor,
                 callComponents.languageVersionSettings
             )
 
         if (!isApplicableCall) {
-            diagnostics.add(NonApplicableCallForBuilderInferenceDiagnostic(callInfo.callResolutionResult.resultCallAtom.atom))
+            hasInapplicableCall = true
         }
     }
 
+    private fun anyReceiverContainStubType(descriptor: CallableDescriptor): Boolean {
+        return descriptor.dispatchReceiverParameter?.type?.contains { it is StubType } == true ||
+                descriptor.extensionReceiverParameter?.type?.contains { it is StubType } == true
+    }
+
+    fun hasInapplicableCall(): Boolean = hasInapplicableCall
+
     override fun writeOnlyStubs(callInfo: SingleCallResolutionResult): Boolean {
         return !skipCall(callInfo)
     }
 
     private fun skipCall(callInfo: SingleCallResolutionResult): Boolean {
-        // FakeCallableDescriptorForObject and LocalVariableDescriptor can't introduce new information for inference,
+        // FakeCallableDescriptorForObject can't introduce new information for inference,
         // so it's safe to complete it fully
         val descriptor = callInfo.resultCallAtom.candidateDescriptor
-        return descriptor is FakeCallableDescriptorForObject || descriptor is LocalVariableDescriptor
+        return descriptor is FakeCallableDescriptorForObject
     }
 
     override fun currentConstraintSystem(): ConstraintStorage {
@@ -105,8 +124,12 @@ class CoroutineInferenceSession(
         lambda: ResolvedLambdaAtom,
         initialStorage: ConstraintStorage,
         diagnosticsHolder: KotlinDiagnosticsHolder
-    ): Map<TypeConstructor, UnwrappedType> {
-        val commonSystem = buildCommonSystem(initialStorage)
+    ): Map<TypeConstructor, UnwrappedType>? {
+        val (commonSystem, effectivelyEmptyConstraintSystem) = buildCommonSystem(initialStorage)
+        if (effectivelyEmptyConstraintSystem) {
+            updateCalls(lambda, commonSystem)
+            return null
+        }
 
         val context = commonSystem.asConstraintSystemCompleterContext()
         kotlinConstraintSystemCompleter.completeConstraintSystem(
@@ -137,7 +160,7 @@ class CoroutineInferenceSession(
         storage: ConstraintStorage,
         nonFixedToVariablesSubstitutor: NewTypeSubstitutor,
         shouldIntegrateAllConstraints: Boolean
-    ) {
+    ): Boolean {
         storage.notFixedTypeVariables.values.forEach { commonSystem.registerVariable(it.typeVariable) }
 
         /*
@@ -149,12 +172,16 @@ class CoroutineInferenceSession(
         * */
         val callSubstitutor = storage.buildResultingSubstitutor(commonSystem, transformTypeVariablesToErrorTypes = false)
 
+        var introducedConstraint = false
+
         for (initialConstraint in storage.initialConstraints) {
             val lower = nonFixedToVariablesSubstitutor.safeSubstitute(callSubstitutor.safeSubstitute(initialConstraint.a as UnwrappedType)) // TODO: SUB
             val upper = nonFixedToVariablesSubstitutor.safeSubstitute(callSubstitutor.safeSubstitute(initialConstraint.b as UnwrappedType)) // TODO: SUB
 
             if (commonSystem.isProperType(lower) && commonSystem.isProperType(upper)) continue
 
+            introducedConstraint = true
+
             when (initialConstraint.constraintKind) {
                 ConstraintKind.LOWER -> error("LOWER constraint shouldn't be used, please use UPPER")
 
@@ -173,28 +200,38 @@ class CoroutineInferenceSession(
                 val typeVariable = storage.allTypeVariables.getValue(variableConstructor)
                 commonSystem.registerVariable(typeVariable)
                 commonSystem.addEqualityConstraint((typeVariable as NewTypeVariable).defaultType, type, CoroutinePosition())
+                introducedConstraint = true
             }
         }
+
+        return introducedConstraint
     }
 
-    private fun buildCommonSystem(initialStorage: ConstraintStorage): NewConstraintSystemImpl {
+    private fun buildCommonSystem(initialStorage: ConstraintStorage): Pair<NewConstraintSystemImpl, Boolean> {
         val commonSystem = NewConstraintSystemImpl(callComponents.constraintInjector, builtIns)
 
         val nonFixedToVariablesSubstitutor = createNonFixedTypeToVariableSubstitutor()
 
         integrateConstraints(commonSystem, initialStorage, nonFixedToVariablesSubstitutor, false)
 
+        var effectivelyEmptyCommonSystem = true
+
         for (call in commonCalls) {
-            integrateConstraints(commonSystem, call.callResolutionResult.constraintSystem, nonFixedToVariablesSubstitutor, false)
+            val hasConstraints =
+                integrateConstraints(commonSystem, call.callResolutionResult.constraintSystem, nonFixedToVariablesSubstitutor, false)
+            if (hasConstraints) effectivelyEmptyCommonSystem = false
         }
         for (call in partiallyResolvedCallsInfo) {
-            integrateConstraints(commonSystem, call.callResolutionResult.constraintSystem, nonFixedToVariablesSubstitutor, true)
+            val hasConstraints =
+                integrateConstraints(commonSystem, call.callResolutionResult.constraintSystem, nonFixedToVariablesSubstitutor, true)
+            if (hasConstraints) effectivelyEmptyCommonSystem = false
         }
+
         for (diagnostic in diagnostics) {
             commonSystem.addError(diagnostic)
         }
 
-        return commonSystem
+        return commonSystem to effectivelyEmptyCommonSystem
     }
 
     private fun updateCalls(lambda: ResolvedLambdaAtom, commonSystem: NewConstraintSystemImpl) {
@@ -281,9 +318,8 @@ class CoroutineInferenceSession(
 
 class ComposedSubstitutor(val left: NewTypeSubstitutor, val right: NewTypeSubstitutor) : NewTypeSubstitutor {
     override fun substituteNotNullTypeWithConstructor(constructor: TypeConstructor): UnwrappedType? {
-        return left.substituteNotNullTypeWithConstructor(
-            right.substituteNotNullTypeWithConstructor(constructor)?.constructor ?: constructor
-        )
+        val rightSubstitution = right.substituteNotNullTypeWithConstructor(constructor)
+        return left.substituteNotNullTypeWithConstructor(rightSubstitution?.constructor ?: constructor) ?: rightSubstitution
     }
 
     override val isEmpty: Boolean get() = left.isEmpty && right.isEmpty

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/KotlinResolutionCallbacksImpl.kt

@@ -130,7 +130,7 @@ class KotlinResolutionCallbacksImpl(
             return createSimplePSICallArgument(
                 trace.bindingContext, outerCallContext.statementFilter, outerCallContext.scope.ownerDescriptor,
                 CallMaker.makeExternalValueArgument(ktExpression), DataFlowInfo.EMPTY, typeInfo, languageVersionSettings,
-                dataFlowValueFactory
+                dataFlowValueFactory, outerCallContext.call
             )
         }
 
@@ -139,8 +139,6 @@ class KotlinResolutionCallbacksImpl(
             if (expectedReturnType == null) ContextDependency.DEPENDENT else ContextDependency.INDEPENDENT
         )
 
-        trace.record(BindingContext.NEW_INFERENCE_LAMBDA_INFO, psiCallArgument.ktFunction, lambdaInfo)
-
         val builtIns = outerCallContext.scope.ownerDescriptor.builtIns
 
         // We have to refine receiverType because resolve inside lambda needs proper scope from receiver,
@@ -179,8 +177,16 @@ class KotlinResolutionCallbacksImpl(
                 null
             }
 
+
+        val temporaryTrace = if (coroutineSession != null)
+            TemporaryBindingTrace.create(trace, "Trace to resolve coroutine $lambdaArgument")
+        else
+            null
+
+        (temporaryTrace ?: trace).record(BindingContext.NEW_INFERENCE_LAMBDA_INFO, psiCallArgument.ktFunction, lambdaInfo)
+
         val actualContext = outerCallContext
-            .replaceBindingTrace(trace)
+            .replaceBindingTrace(temporaryTrace ?: trace)
             .replaceContextDependency(lambdaInfo.contextDependency)
             .replaceExpectedType(approximatesExpectedType)
             .replaceDataFlowInfo(psiCallArgument.dataFlowInfoBeforeThisArgument).let {
@@ -188,7 +194,13 @@ class KotlinResolutionCallbacksImpl(
             }
 
         val functionTypeInfo = expressionTypingServices.getTypeInfo(psiCallArgument.expression, actualContext)
-        trace.record(BindingContext.NEW_INFERENCE_LAMBDA_INFO, psiCallArgument.ktFunction, LambdaInfo.STUB_EMPTY)
+        (temporaryTrace ?: trace).record(BindingContext.NEW_INFERENCE_LAMBDA_INFO, psiCallArgument.ktFunction, LambdaInfo.STUB_EMPTY)
+
+        if (coroutineSession?.hasInapplicableCall() == true) {
+            return ReturnArgumentsAnalysisResult(ReturnArgumentsInfo.empty, coroutineSession, hasInapplicableCallForBuilderInference = true)
+        } else {
+            temporaryTrace?.commit()
+        }
 
         var hasReturnWithoutExpression = false
         var returnArgumentFound = false

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/KotlinToResolvedCallTransformer.kt

@@ -318,13 +318,15 @@ class KotlinToResolvedCallTransformer(
                 )
             }
 
-            updateRecordedType(
-                argumentExpression,
-                parameter,
-                newContext,
-                constantConvertedArgument?.unknownIntegerType?.unwrap(),
-                resolvedCall.isReallySuccess()
-            )
+            if (!valueArgument.isExternal()) {
+                updateRecordedType(
+                    argumentExpression,
+                    parameter,
+                    newContext,
+                    constantConvertedArgument?.unknownIntegerType?.unwrap(),
+                    resolvedCall.isReallySuccess()
+                )
+            }
         }
     }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/NewCallArguments.kt

@@ -303,7 +303,8 @@ internal fun createSimplePSICallArgument(
     contextForArgument.scope.ownerDescriptor, valueArgument,
     contextForArgument.dataFlowInfo, typeInfoForArgument,
     contextForArgument.languageVersionSettings,
-    contextForArgument.dataFlowValueFactory
+    contextForArgument.dataFlowValueFactory,
+    contextForArgument.call,
 )
 
 internal fun createSimplePSICallArgument(
@@ -314,7 +315,8 @@ internal fun createSimplePSICallArgument(
     dataFlowInfoBeforeThisArgument: DataFlowInfo,
     typeInfoForArgument: KotlinTypeInfo,
     languageVersionSettings: LanguageVersionSettings,
-    dataFlowValueFactory: DataFlowValueFactory
+    dataFlowValueFactory: DataFlowValueFactory,
+    call: Call
 ): SimplePSIKotlinCallArgument? {
 
     val ktExpression = KtPsiUtil.getLastElementDeparenthesized(valueArgument.getArgumentExpression(), statementFilter) ?: return null
@@ -331,10 +333,10 @@ internal fun createSimplePSICallArgument(
             // so we use a fast-path here to avoid calling transformToReceiverWithSmartCastInfo function
             ReceiverValueWithSmartCastInfo(expressionReceiver, emptySet(), isStable = true)
         } else {
+            val useDataFlowInfoBeforeArgument = call.callType == Call.CallType.CONTAINS
             transformToReceiverWithSmartCastInfo(
                 ownerDescriptor, bindingContext,
-                // dataFlowInfoBeforeThisArgument cannot be used here, because of if() { if (x != null) return; x }
-                typeInfoForArgument.dataFlowInfo,
+                if (useDataFlowInfoBeforeArgument) dataFlowInfoBeforeThisArgument else typeInfoForArgument.dataFlowInfo,
                 expressionReceiver,
                 languageVersionSettings,
                 dataFlowValueFactory

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/PSICallResolver.kt

@@ -109,6 +109,10 @@ class PSICallResolver(
             return OverloadResolutionResultsImpl.nameNotFound()
         }
 
+        result = candidateInterceptor.interceptResolvedCandidates(
+            result, context, kotlinCallResolver, name, resolutionKind, tracingStrategy
+        )
+
         val overloadResolutionResults = convertToOverloadResolutionResults<D>(context, result, tracingStrategy)
         return overloadResolutionResults.also {
             clearCacheForApproximationResults()

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/ResolvedAtomCompleter.kt

@@ -77,6 +77,7 @@ class ResolvedAtomCompleter(
             is ResolvedCallableReferenceAtom -> completeCallableReference(resolvedAtom)
             is ResolvedLambdaAtom -> completeLambda(resolvedAtom)
             is ResolvedCallAtom -> completeResolvedCall(resolvedAtom, emptyList())
+            is ResolvedSubCallArgument -> completeSubCallArgument(resolvedAtom)
             is PartialCallResolutionResult -> completeResolvedCall(resolvedAtom.resultCallAtom, resolvedAtom.diagnostics)
         }
     }
@@ -90,6 +91,17 @@ class ResolvedAtomCompleter(
         complete(resolvedAtom)
     }
 
+    fun completeSubCallArgument(resolvedSubCallArgument: ResolvedSubCallArgument) {
+        val contextWithoutExpectedType = topLevelCallContext.replaceExpectedType(TypeUtils.NO_EXPECTED_TYPE)
+        kotlinToResolvedCallTransformer.updateRecordedType(
+            resolvedSubCallArgument.atom.psiExpression ?: return,
+            parameter = null,
+            context = contextWithoutExpectedType,
+            reportErrorForTypeMismatch = true,
+            convertedArgumentType = null
+        )
+    }
+
     fun completeResolvedCall(resolvedCallAtom: ResolvedCallAtom, diagnostics: Collection<KotlinCallDiagnostic>): ResolvedCall<*>? {
         clearPartiallyResolvedCall(resolvedCallAtom)
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ForceResolveUtil.java

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.resolve.lazy;
 
 import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.progress.ProgressManager;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
@@ -70,6 +71,8 @@ public class ForceResolveUtil {
     }
 
     private static void doForceResolveAllContents(Object object) {
+        ProgressManager.checkCanceled();
+
         if (object instanceof LazyEntity) {
             LazyEntity lazyEntity = (LazyEntity) object;
             lazyEntity.forceResolveAllContents();

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java

@@ -1402,9 +1402,14 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         ExpressionReceiver receiver = safeGetExpressionReceiver(facade, right, contextWithNoExpectedType);
         ExpressionTypingContext contextWithDataFlow = context.replaceDataFlowInfo(dataFlowInfo);
 
+        Call containsCall = CallMaker.makeCall(
+                callElement, receiver, null, operationSign,
+                Collections.singletonList(leftArgument), Call.CallType.CONTAINS
+        );
+
         OverloadResolutionResults<FunctionDescriptor> resolutionResult = components.callResolver.resolveCallWithGivenName(
                 contextWithDataFlow,
-                CallMaker.makeCall(callElement, receiver, null, operationSign, Collections.singletonList(leftArgument)),
+                containsCall,
                 operationSign,
                 OperatorNameConventions.CONTAINS);
         KotlinType containsType = OverloadResolutionResultsUtil.getResultingType(resolutionResult, context);

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.types.expressions;
 
+import com.intellij.openapi.progress.ProgressManager;
 import com.intellij.psi.tree.IElementType;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -303,6 +304,7 @@ public class ExpressionTypingServices {
 
         boolean isFirstStatement = true;
         for (Iterator<? extends KtElement> iterator = block.iterator(); iterator.hasNext(); ) {
+            ProgressManager.checkCanceled();
             // Use filtering trace to keep effect system cache only for one statement
             AbstractFilteringTrace traceForSingleStatement = new EffectsFilteringTrace(context.trace);
 

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorDispatcher.java

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.types.expressions;
 
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.progress.ProcessCanceledException;
+import com.intellij.openapi.progress.ProgressManager;
 import com.intellij.openapi.project.IndexNotReadyException;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -159,6 +160,7 @@ public abstract class ExpressionTypingVisitorDispatcher extends KtVisitor<Kotlin
 
     @NotNull
     private KotlinTypeInfo getTypeInfo(@NotNull KtExpression expression, ExpressionTypingContext context, KtVisitor<KotlinTypeInfo, ExpressionTypingContext> visitor) {
+        ProgressManager.checkCanceled();
         return typeInfoPerfCounter.time(() -> {
             try {
                 KotlinTypeInfo recordedTypeInfo = BindingContextUtils.getRecordedTypeInfo(expression, context.trace.getBindingContext());

compiler/incremental-compilation-impl/build.gradle.kts

@@ -26,7 +26,7 @@ dependencies {
     testCompile(intellijDep()) { includeJars("log4j", "jdom") }
 
     if (Platform.P192.orHigher()) {
-        testRuntime(intellijDep()) { includeJars("lz4-java-1.6.0") }
+        testRuntime(intellijDep()) { includeJars("lz4-java", rootProject = rootProject) }
     } else {
         testRuntime(intellijDep()) { includeJars("lz4-1.3.0") }
     }

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LateinitLowering.kt

@@ -81,7 +81,7 @@ class NullableFieldsDeclarationLowering(val backendContext: CommonBackendContext
         getter.body = IrBlockBodyImpl(startOffset, endOffset) {
             val irBuilder = backendContext.createIrBuilder(getter.symbol, startOffset, endOffset)
             irBuilder.run {
-                val resultVar = scope.createTemporaryVariable(
+                val resultVar = scope.createTmpVariable(
                     irGetField(getter.dispatchReceiverParameter?.let { irGet(it) }, backingField)
                 )
                 resultVar.parent = getter

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/ReturnableBlockLowering.kt

@@ -86,7 +86,7 @@ class ReturnableBlockTransformer(val context: CommonBackendContext, val containe
         val scopeSymbol = currentScope?.scope?.scopeOwnerSymbol ?: containerSymbol
         val builder = context.createIrBuilder(scopeSymbol!!)
         val variable by lazy {
-            builder.scope.createTemporaryVariableDeclaration(expression.type, "tmp\$ret\$${labelCnt++}", true)
+            builder.scope.createTmpVariable(expression.type, "tmp\$ret\$${labelCnt++}", true)
         }
 
         val loop by lazy {

compiler/ir/backend.common/src/org/jetbrains/kotlin/ir/builders/IrBuilders.kt

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.ir.builders
 
 import org.jetbrains.kotlin.ir.IrElement
+import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
 import org.jetbrains.kotlin.ir.declarations.IrVariable
 import org.jetbrains.kotlin.ir.declarations.impl.IrVariableImpl
@@ -56,6 +57,34 @@ fun <T : IrElement> IrStatementsBuilder<T>.createTmpVariable(
     return variable
 }
 
+fun Scope.createTmpVariable(
+    irType: IrType,
+    nameHint: String? = null,
+    isMutable: Boolean = false,
+    initializer: IrExpression? = null,
+    origin: IrDeclarationOrigin = IrDeclarationOrigin.IR_TEMPORARY_VARIABLE,
+    startOffset: Int = UNDEFINED_OFFSET,
+    endOffset: Int = UNDEFINED_OFFSET
+): IrVariable {
+    val descriptor = WrappedVariableDescriptor()
+    val symbol = IrVariableSymbolImpl(descriptor)
+    return IrVariableImpl(
+        startOffset,
+        endOffset,
+        origin,
+        symbol,
+        Name.identifier(nameHint ?: "tmp"),
+        irType,
+        isMutable,
+        isConst = false,
+        isLateinit = false
+    ).apply {
+        this.initializer = initializer
+        parent = getLocalDeclarationParent()
+        descriptor.bind(this)
+    }
+}
+
 fun Scope.createTmpVariable(
     irExpression: IrExpression,
     nameHint: String? = null,

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsIntrinsics.kt

@@ -96,7 +96,7 @@ class JsIntrinsics(private val irBuiltIns: IrBuiltIns, val context: JsIrBackendC
     // Type checks:
 
     val jsInstanceOf = binOpBool("jsInstanceOf")
-    val jsTypeOf = unOp("jsTypeOf", irBuiltIns.stringType)
+    val jsTypeOf = getInternalFunction("jsTypeOf")
 
     // Number conversions:
 

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/compiler.kt

@@ -57,10 +57,11 @@ fun compile(
         loadIr(project, mainModule, analyzer, configuration, allDependencies, friendDependencies)
 
     // TODO: not sure whether this check should be enabled by default. Add configuration key for it.
-    val mangleChecker = ManglerChecker(JsManglerIr, Ir2DescriptorManglerAdapter(JsManglerDesc))
-    moduleFragment.acceptVoid(mangleChecker)
-    irBuiltIns.knownBuiltins.forEach { it.acceptVoid(mangleChecker) }
-
+    if (mainModule is MainModule.SourceFiles) {
+        val mangleChecker = ManglerChecker(JsManglerIr, Ir2DescriptorManglerAdapter(JsManglerDesc))
+        moduleFragment.acceptVoid(mangleChecker)
+        irBuiltIns.knownBuiltins.forEach { it.acceptVoid(mangleChecker) }
+    }
 
     val moduleDescriptor = moduleFragment.descriptor
 

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/ClassReferenceLowering.kt

@@ -151,9 +151,10 @@ class ClassReferenceLowering(val context: JsIrBackendContext) : BodyLoweringPass
     private fun createSimpleKType(type: IrSimpleType): IrExpression {
         val classifier: IrClassifierSymbol = type.classifier
 
-        if (classifier is IrTypeParameterSymbol && classifier.owner.isReified) {
-            error("Fail")
-        }
+        // TODO: Check why do we have un-substituted reified parameters
+        // if (classifier is IrTypeParameterSymbol && classifier.owner.isReified) {
+        //     error("Fail")
+        // }
 
         val kClassifier = createKClassifier(classifier)
         // TODO: Use static array types
@@ -206,9 +207,11 @@ class ClassReferenceLowering(val context: JsIrBackendContext) : BodyLoweringPass
             Variance.IN_VARIANCE -> JsIrBuilder.buildString(context.irBuiltIns.stringType, "in")
             Variance.OUT_VARIANCE -> JsIrBuilder.buildString(context.irBuiltIns.stringType, "out")
         }
-        if (typeParameter.isReified) {
-            error("Reified parameter")
-        }
+
+        // TODO: Check why do we have non-inlined reified parameters
+        // if (typeParameter.isReified) {
+        //     error("Reified parameter")
+        // }
 
         return buildCall(
             context.intrinsics.createKTypeParameter!!,

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/EnumClassLowering.kt

@@ -343,8 +343,7 @@ class EnumEntryInstancesLowering(val context: JsIrBackendContext) : DeclarationT
             isStatic = true
         }.apply {
             parent = irClass
-            val builder = context.createIrBuilder(irClass.symbol)
-            initializer = builder.run { irExprBody(irImplicitCast(irNull(), type)) }
+            initializer = null
         }
 
         enumEntry.correspondingField = result
@@ -407,8 +406,7 @@ class EnumClassCreateInitializerLowering(val context: JsIrBackendContext) : Decl
         isStatic = true
     }.apply {
         parent = irClass
-        val builder = context.createIrBuilder(irClass.symbol)
-        initializer = builder.run { irExprBody(irBoolean(false)) }
+        initializer = null
     }
 
     private fun createInitEntryInstancesFun(irClass: IrClass, entryInstancesInitializedField: IrField): IrSimpleFunction =

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/IrElementToJsExpressionTransformer.kt

@@ -91,6 +91,14 @@ class IrElementToJsExpressionTransformer : BaseIrElementToJsNodeTransformer<JsEx
         val obj = expression.symbol.owner
         assert(obj.kind == ClassKind.OBJECT)
         assert(obj.isEffectivelyExternal()) { "Non external IrGetObjectValue must be lowered" }
+
+        // External interfaces cannot normally have companion objects.
+        // However, stdlib uses them to simulate string literal unions
+        // TODO: Stop abusing this tech
+        if (obj.isCompanion && obj.parentAsClass.isInterface) {
+            return JsNullLiteral()
+        }
+
         return context.getRefForExternalClass(obj)
     }
 

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/NameTables.kt

@@ -370,7 +370,7 @@ class NameTables(
             declaration !is IrDeclarationWithName ->
                 return
 
-            declaration.isEffectivelyExternal() ->
+            declaration.isEffectivelyExternal() && (declaration.getJsModule() == null || declaration.isJsNonModule()) ->
                 globalNames.declareStableName(declaration, declaration.getJsNameOrKotlinName().identifier)
 
             else ->

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/Psi2IrTranslator.kt

@@ -62,7 +62,7 @@ class Psi2IrTranslator(
         symbolTable: SymbolTable = SymbolTable(signaturer),
         extensions: GeneratorExtensions = GeneratorExtensions()
     ): GeneratorContext =
-        GeneratorContext(configuration, moduleDescriptor, bindingContext, languageVersionSettings, symbolTable, extensions, signaturer)
+        createGeneratorContext(configuration, moduleDescriptor, bindingContext, languageVersionSettings, symbolTable, extensions, signaturer)
 
     fun generateModuleFragment(
         context: GeneratorContext,
@@ -73,8 +73,8 @@ class Psi2IrTranslator(
         val moduleGenerator = ModuleGenerator(context)
         val irModule = moduleGenerator.generateModuleFragmentWithoutDependencies(ktFiles)
 
-        expectDescriptorToSymbol?.let { referenceExpectsForUsedActuals(it, context.symbolTable, irModule) }
         irModule.patchDeclarationParents()
+        expectDescriptorToSymbol?.let { referenceExpectsForUsedActuals(it, context.symbolTable, irModule) }
         postprocess(context, irModule)
         // do not generate unbound symbols before postprocessing,
         // since plugins must work with non-lazy IR

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ArgumentsGenerationUtils.kt

@@ -56,7 +56,13 @@ fun StatementGenerator.generateReceiver(ktDefaultElement: KtElement, receiver: R
     generateReceiver(ktDefaultElement.startOffsetSkippingComments, ktDefaultElement.endOffset, receiver)
 
 fun StatementGenerator.generateReceiver(defaultStartOffset: Int, defaultEndOffset: Int, receiver: ReceiverValue): IntermediateValue {
-    val irReceiverType = receiver.type.toIrType()
+    val irReceiverType =
+        when (receiver) {
+            is ExtensionReceiver ->
+                receiver.declarationDescriptor.extensionReceiverParameter!!.type.toIrType()
+            else ->
+                receiver.type.toIrType()
+        }
 
     if (receiver is TransientReceiver) return TransientReceiverValue(irReceiverType)
 

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/GeneratorContext.kt

@@ -1,17 +1,6 @@
 /*
- * Copyright 2010-2016 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
 package org.jetbrains.kotlin.psi2ir.generators
@@ -24,12 +13,41 @@ import org.jetbrains.kotlin.descriptors.NotFoundClasses
 import org.jetbrains.kotlin.ir.builders.IrGeneratorContext
 import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression
-import org.jetbrains.kotlin.ir.util.*
+import org.jetbrains.kotlin.ir.util.ConstantValueGenerator
+import org.jetbrains.kotlin.ir.util.IdSignatureComposer
+import org.jetbrains.kotlin.ir.util.SymbolTable
+import org.jetbrains.kotlin.ir.util.TypeTranslator
 import org.jetbrains.kotlin.psi2ir.Psi2IrConfiguration
 import org.jetbrains.kotlin.psi2ir.PsiSourceManager
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 
+fun createGeneratorContext(
+    configuration: Psi2IrConfiguration,
+    moduleDescriptor: ModuleDescriptor,
+    bindingContext: BindingContext,
+    languageVersionSettings: LanguageVersionSettings,
+    symbolTable: SymbolTable,
+    extensions: GeneratorExtensions,
+    signaturer: IdSignatureComposer
+): GeneratorContext {
+    val typeTranslator = TypeTranslator(symbolTable, languageVersionSettings, builtIns = moduleDescriptor.builtIns)
+    val constantValueGenerator = ConstantValueGenerator(moduleDescriptor, symbolTable)
+    typeTranslator.constantValueGenerator = constantValueGenerator
+    constantValueGenerator.typeTranslator = typeTranslator
+    return GeneratorContext(
+        configuration,
+        moduleDescriptor,
+        bindingContext,
+        languageVersionSettings,
+        symbolTable,
+        extensions,
+        typeTranslator,
+        constantValueGenerator,
+        IrBuiltIns(moduleDescriptor.builtIns, typeTranslator, signaturer, symbolTable)
+    )
+}
+
 class GeneratorContext(
     val configuration: Psi2IrConfiguration,
     val moduleDescriptor: ModuleDescriptor,
@@ -37,20 +55,13 @@ class GeneratorContext(
     val languageVersionSettings: LanguageVersionSettings,
     val symbolTable: SymbolTable,
     val extensions: GeneratorExtensions,
-    signaturer: IdSignatureComposer
+    val typeTranslator: TypeTranslator,
+    val constantValueGenerator: ConstantValueGenerator,
+    override val irBuiltIns: IrBuiltIns
 ) : IrGeneratorContext() {
 
-    val constantValueGenerator: ConstantValueGenerator = ConstantValueGenerator(moduleDescriptor, symbolTable)
-    val typeTranslator: TypeTranslator = TypeTranslator(symbolTable, languageVersionSettings, builtIns = moduleDescriptor.builtIns)
     val callToSubstitutedDescriptorMap = mutableMapOf<IrMemberAccessExpression, CallableDescriptor>()
 
-    init {
-        typeTranslator.constantValueGenerator = constantValueGenerator
-        constantValueGenerator.typeTranslator = typeTranslator
-    }
-
-    override val irBuiltIns: IrBuiltIns = IrBuiltIns(moduleDescriptor.builtIns, typeTranslator, signaturer, symbolTable)
-
     val sourceManager = PsiSourceManager()
 
     // TODO: inject a correct StorageManager instance, or store NotFoundClasses inside ModuleDescriptor

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/TypeTranslator.kt

@@ -133,19 +133,26 @@ class TypeTranslator(
             return properlyApproximatedType
         }
 
+        private val isWithNewInference = languageVersionSettings.supportsFeature(LanguageFeature.NewInference)
 
-        private fun approximateByKotlinRules(ktType: KotlinType): KotlinType {
-            if (ktType.constructor.isDenotable) return ktType
-
-            return if (languageVersionSettings.supportsFeature(LanguageFeature.NewInference))
-                typeApproximatorForNI.approximateDeclarationType(
-                    ktType,
-                    local = false,
-                    languageVersionSettings = languageVersionSettings
-                )
-            else
-                approximateCapturedTypes(ktType).upper
-        }
+        private fun approximateByKotlinRules(ktType: KotlinType): KotlinType =
+            if (isWithNewInference) {
+                if (ktType.constructor.isDenotable && ktType.arguments.isEmpty())
+                    ktType
+                else
+                    typeApproximatorForNI.approximateDeclarationType(
+                        ktType,
+                        local = false,
+                        languageVersionSettings = languageVersionSettings
+                    )
+            } else {
+                // Hack to preserve *-projections in arguments in OI.
+                // Expected to be removed as soon as OI is deprecated.
+                if (ktType.constructor.isDenotable)
+                    ktType
+                else
+                    approximateCapturedTypes(ktType).upper
+            }
 
     }
 

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileSerializer.kt

@@ -986,7 +986,7 @@ open class IrFileSerializer(
     }
 
     private fun serializeIrDeclarationBase(declaration: IrDeclaration, flags: Long?): ProtoDeclarationBase {
-        expectActualTable.findExpectsForActuals(declaration)
+        if (!skipExpects) expectActualTable.findExpectsForActuals(declaration)
         return with(ProtoDeclarationBase.newBuilder()) {
             symbol = serializeIrSymbol((declaration as IrSymbolOwner).symbol)
             coordinates = serializeCoordinates(declaration.startOffset, declaration.endOffset)

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/mangle/descriptor/DescriptorMangleComputer.kt

@@ -10,7 +10,6 @@ import org.jetbrains.kotlin.backend.common.serialization.mangle.MangleConstant
 import org.jetbrains.kotlin.backend.common.serialization.mangle.MangleMode
 import org.jetbrains.kotlin.backend.common.serialization.mangle.collect
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.resolve.descriptorUtil.module
 import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.typeUtil.isUnit
 import org.jetbrains.kotlin.utils.addToStdlib.ifNotEmpty
@@ -77,6 +76,8 @@ abstract class DescriptorMangleComputer(protected val builder: StringBuilder, pr
     open fun FunctionDescriptor.platformSpecificSuffix(): String? = null
     open fun PropertyDescriptor.platformSpecificSuffix(): String? = null
 
+    protected open fun addReturnType(): Boolean = false
+
     open fun FunctionDescriptor.specialValueParamPrefix(param: ValueParameterDescriptor): String = ""
 
     private val CallableDescriptor.isRealStatic: Boolean
@@ -98,11 +99,6 @@ abstract class DescriptorMangleComputer(protected val builder: StringBuilder, pr
 
         builder.append(name.asString())
 
-        if (visibility == Visibilities.INTERNAL) {
-            builder.append(MangleConstant.MODULE_SEPARATOR)
-            builder.append(module.name.asString().run { substring(1, lastIndex) })
-        }
-
         mangleSignature(isCtor, container)
     }
 
@@ -127,7 +123,7 @@ abstract class DescriptorMangleComputer(protected val builder: StringBuilder, pr
             .collect(builder, MangleConstant.TYPE_PARAMETERS) { mangleTypeParameter(this, it) }
 
         returnType?.run {
-            if (!isCtor && !isUnit()) {
+            if (!isCtor && !isUnit() && addReturnType()) {
                 mangleType(builder, this)
             }
         }

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/mangle/ir/IrMangleComputer.kt

@@ -5,19 +5,16 @@
 
 package org.jetbrains.kotlin.backend.common.serialization.mangle.ir
 
-import org.jetbrains.kotlin.backend.common.ir.isStatic
 import org.jetbrains.kotlin.backend.common.serialization.mangle.KotlinMangleComputer
 import org.jetbrains.kotlin.backend.common.serialization.mangle.MangleConstant
 import org.jetbrains.kotlin.backend.common.serialization.mangle.MangleMode
 import org.jetbrains.kotlin.backend.common.serialization.mangle.collect
-import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol
 import org.jetbrains.kotlin.ir.types.*
 import org.jetbrains.kotlin.ir.util.isVararg
-import org.jetbrains.kotlin.ir.util.module
 import org.jetbrains.kotlin.ir.util.render
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import org.jetbrains.kotlin.types.Variance
@@ -34,6 +31,8 @@ abstract class IrMangleComputer(protected val builder: StringBuilder, private va
 
     open fun IrFunction.specialValueParamPrefix(param: IrValueParameter): String = ""
 
+    open fun addReturnType(): Boolean = false
+
     abstract override fun copy(newMode: MangleMode): IrMangleComputer
 
     private fun StringBuilder.appendName(s: String) {
@@ -96,16 +95,6 @@ abstract class IrMangleComputer(protected val builder: StringBuilder, private va
 
         builder.append(name.asString())
 
-        if (visibility == Visibilities.INTERNAL) {
-            builder.append(MangleConstant.MODULE_SEPARATOR)
-            val moduleName = try {
-                module.name.asString().run { substring(1, lastIndex) }
-            } catch (e: Throwable) {
-                MangleConstant.UNKNOWN_MARK
-            }
-            builder.append(moduleName)
-        }
-
         mangleSignature(isCtor, isStatic)
     }
 
@@ -127,7 +116,7 @@ abstract class IrMangleComputer(protected val builder: StringBuilder, private va
         }
         typeParameters.collect(builder, MangleConstant.TYPE_PARAMETERS) { mangleTypeParameter(this, it) }
 
-        if (!isCtor && !returnType.isUnit()) {
+        if (!isCtor && !returnType.isUnit() && addReturnType()) {
             mangleType(builder, returnType)
         }
     }

compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/klib.kt

@@ -37,6 +37,7 @@ import org.jetbrains.kotlin.js.config.JSConfigurationKeys
 import org.jetbrains.kotlin.konan.properties.propertyList
 import org.jetbrains.kotlin.konan.util.KlibMetadataFactories
 import org.jetbrains.kotlin.library.*
+import org.jetbrains.kotlin.library.impl.BuiltInsPlatform
 import org.jetbrains.kotlin.library.impl.buildKoltinLibrary
 import org.jetbrains.kotlin.library.resolver.KotlinLibraryResolveResult
 import org.jetbrains.kotlin.library.resolver.TopologicalLibraryOrder
@@ -47,6 +48,7 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi2ir.Psi2IrConfiguration
 import org.jetbrains.kotlin.psi2ir.Psi2IrTranslator
 import org.jetbrains.kotlin.psi2ir.generators.GeneratorContext
+import org.jetbrains.kotlin.psi2ir.generators.createGeneratorContext
 import org.jetbrains.kotlin.psi2ir.generators.GeneratorExtensions
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingContextUtils
@@ -241,7 +243,7 @@ private fun runAnalysisAndPreparePsi2Ir(depsDescriptors: ModulesStructure): Gene
     val mangler = JsManglerDesc
     val signaturer = IdSignatureDescriptor(mangler)
 
-    return GeneratorContext(
+    return createGeneratorContext(
         Psi2IrConfiguration(),
         analysisResult.moduleDescriptor,
         analysisResult.bindingContext,
@@ -503,7 +505,8 @@ fun serializeModuleIntoKlib(
         moduleName = moduleName,
         nopack = nopack,
         output = klibPath,
-        versions = versions
+        versions = versions,
+        builtInsPlatform = BuiltInsPlatform.JS
     )
 }
 

compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForSourceDeclaration.kt

@@ -81,7 +81,7 @@ abstract class KtLightClassForSourceDeclaration(
 
     override fun getText() = kotlinOrigin.text ?: ""
 
-    override fun getTextRange(): TextRange = kotlinOrigin.textRange ?: TextRange.EMPTY_RANGE
+    override fun getTextRange(): TextRange? = kotlinOrigin.textRange ?: TextRange.EMPTY_RANGE
 
     override fun getTextOffset() = kotlinOrigin.textOffset
 

compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/ultraLightClass.kt

@@ -5,6 +5,8 @@
 
 package org.jetbrains.kotlin.asJava.classes
 
+import com.intellij.openapi.util.TextRange
+import com.intellij.openapi.util.registry.Registry
 import com.intellij.psi.*
 import com.intellij.psi.impl.InheritanceImplUtil
 import com.intellij.psi.impl.PsiClassImplUtil
@@ -475,4 +477,12 @@ open class KtUltraLightClass(classOrObject: KtClassOrObject, internal val suppor
     override fun isDeprecated(): Boolean = _deprecated
 
     override fun copy(): KtLightClassImpl = KtUltraLightClass(classOrObject.copy() as KtClassOrObject, support)
+
+    override fun getTextRange(): TextRange? {
+        if (Registry.`is`("kotlin.ultra.light.classes.empty.text.range", true)) {
+            return null
+        }
+
+        return super.getTextRange()
+    }
 }

compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/ultraLightMembersCreator.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.asJava.classes
 
+import com.intellij.openapi.progress.ProgressManager
 import com.intellij.psi.*
 import com.intellij.psi.impl.light.LightMethodBuilder
 import com.intellij.psi.impl.light.LightModifierList
@@ -174,6 +175,7 @@ internal class UltraLightMembersCreator(
         numberOfDefaultParametersToAdd: Int = -1,
         methodIndex: Int
     ): KtLightMethod {
+        ProgressManager.checkCanceled()
         val isConstructor = ktFunction is KtConstructor<*>
         val name =
             if (isConstructor) containingClass.name

compiler/psi/src/org/jetbrains/kotlin/psi/Call.java

@@ -67,7 +67,7 @@ public interface Call {
     KtElement getCallElement();
 
     enum CallType {
-        DEFAULT, ARRAY_GET_METHOD, ARRAY_SET_METHOD, INVOKE
+        DEFAULT, ARRAY_GET_METHOD, ARRAY_SET_METHOD, INVOKE, CONTAINS
     }
 
     @NotNull

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/NewCommonSuperTypeCalculator.kt

@@ -97,7 +97,7 @@ object NewCommonSuperTypeCalculator {
         contextStubTypesEqualToAnything: AbstractTypeCheckerContext,
         contextStubTypesNotEqual: AbstractTypeCheckerContext
     ): SimpleTypeMarker {
-        if (types.all { it is ErrorType }) {
+        if (types.any { it is ErrorType }) {
             return ErrorUtils.createErrorType("CST(${types.joinToString()}")
         }
 

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/ExternalComponents.kt

@@ -50,11 +50,16 @@ data class ReturnArgumentsInfo(
     val lastExpression: KotlinCallArgument?,
     val lastExpressionCoercedToUnit: Boolean,
     val returnArgumentsExist: Boolean
-)
+) {
+    companion object {
+        val empty = ReturnArgumentsInfo(emptyList(), null, lastExpressionCoercedToUnit = false, returnArgumentsExist = false)
+    }
+}
 
 data class ReturnArgumentsAnalysisResult(
     val returnArgumentsInfo: ReturnArgumentsInfo,
-    val inferenceSession: InferenceSession?
+    val inferenceSession: InferenceSession?,
+    val hasInapplicableCallForBuilderInference: Boolean = false
 )
 
 // This components hold state (trace). Work with this carefully.

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/InferenceSession.kt

@@ -40,7 +40,7 @@ interface InferenceSession {
         lambda: ResolvedLambdaAtom,
         initialStorage: ConstraintStorage,
         diagnosticsHolder: KotlinDiagnosticsHolder
-    ): Map<TypeConstructor, UnwrappedType>
+    ): Map<TypeConstructor, UnwrappedType>?
 
     fun writeOnlyStubs(callInfo: SingleCallResolutionResult): Boolean
     fun callCompleted(resolvedAtom: ResolvedAtom): Boolean

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/PostponedArgumentsAnalyzer.kt

@@ -120,15 +120,21 @@ class PostponedArgumentsAnalyzer(
             else FilteredAnnotations(annotations, true) { it != KotlinBuiltIns.FQ_NAMES.extensionFunctionType }
         }
 
-        val (returnArgumentsInfo, inferenceSession) = resolutionCallbacks.analyzeAndGetLambdaReturnArguments(
-            lambda.atom,
-            lambda.isSuspend,
-            receiver,
-            parameters,
-            expectedTypeForReturnArguments,
-            convertedAnnotations ?: Annotations.EMPTY,
-            stubsForPostponedVariables.cast()
-        )
+        val (returnArgumentsInfo, inferenceSession, hasInapplicableCallForBuilderInference) =
+            resolutionCallbacks.analyzeAndGetLambdaReturnArguments(
+                lambda.atom,
+                lambda.isSuspend,
+                receiver,
+                parameters,
+                expectedTypeForReturnArguments,
+                convertedAnnotations ?: Annotations.EMPTY,
+                stubsForPostponedVariables.cast()
+            )
+
+        if (hasInapplicableCallForBuilderInference) {
+            c.getBuilder().removePostponedVariables()
+            return
+        }
 
         val returnArguments = returnArgumentsInfo.nonErrorArguments
         returnArguments.forEach { c.addSubsystemFromArgument(it) }
@@ -159,6 +165,10 @@ class PostponedArgumentsAnalyzer(
             val storageSnapshot = c.getBuilder().currentStorage()
 
             val postponedVariables = inferenceSession.inferPostponedVariables(lambda, storageSnapshot, diagnosticHolder)
+            if (postponedVariables == null) {
+                c.getBuilder().removePostponedVariables()
+                return
+            }
 
             for ((constructor, resultType) in postponedVariables) {
                 val variableWithConstraints = storageSnapshot.notFixedTypeVariables[constructor] ?: continue

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/SimpleArgumentsChecks.kt

@@ -179,7 +179,7 @@ private fun checkSubCallArgument(
     diagnosticsHolder: KotlinDiagnosticsHolder,
     receiverInfo: ReceiverInfo,
 ): ResolvedAtom {
-    val subCallResult = subCallArgument.callResult
+    val subCallResult = ResolvedSubCallArgument(subCallArgument)
 
     if (expectedType == null) return subCallResult
 

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystemBuilder.kt

@@ -34,6 +34,7 @@ interface ConstraintSystemOperation {
     fun registerVariable(variable: TypeVariableMarker)
     fun markPostponedVariable(variable: TypeVariableMarker)
     fun unmarkPostponedVariable(variable: TypeVariableMarker)
+    fun removePostponedVariables()
 
     fun addSubtypeConstraint(lowerType: KotlinTypeMarker, upperType: KotlinTypeMarker, position: ConstraintPosition)
     fun addEqualityConstraint(a: KotlinTypeMarker, b: KotlinTypeMarker, position: ConstraintPosition)

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/components/KotlinConstraintSystemCompleter.kt

@@ -167,9 +167,11 @@ class KotlinConstraintSystemCompleter(
 
         val builtIns = (variable as TypeVariableTypeConstructor).builtIns
         val csBuilder = (c as NewConstraintSystemImpl).getBuilder()
+
+        val expectedTypeVariable = postponedAtom.expectedType?.constructor?.takeIf { it in c.allTypeVariables } ?: variable
         val atomToAnalyze = when (postponedAtom) {
             is PostponedCallableReferenceAtom -> postponedAtom.preparePostponedAtomWithTypeVariableAsExpectedType(
-                c, csBuilder, variable,
+                c, csBuilder, expectedTypeVariable,
                 condition = { true },
                 isSuitable = KotlinType::isBuiltinFunctionalTypeOrSubtype,
                 typeVariableCreator = { TypeVariableForCallableReferenceReturnType(builtIns, "_Q") },
@@ -180,7 +182,7 @@ class KotlinConstraintSystemCompleter(
                 }
             )
             is LambdaWithTypeVariableAsExpectedTypeAtom -> postponedAtom.preparePostponedAtomWithTypeVariableAsExpectedType(
-                c, csBuilder, variable,
+                c, csBuilder, expectedTypeVariable,
                 condition = { it.atom.parametersTypes?.all { type -> type != null } != true },
                 isSuitable = KotlinType::isBuiltinFunctionalType,
                 typeVariableCreator = { TypeVariableForLambdaReturnType(postponedAtom.atom, builtIns, "_R") },

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/model/NewConstraintSystemImpl.kt

@@ -103,6 +103,10 @@ class NewConstraintSystemImpl(
         storage.postponedTypeVariables -= variable
     }
 
+    override fun removePostponedVariables() {
+        storage.postponedTypeVariables.clear()
+    }
+
     override fun addSubtypeConstraint(lowerType: KotlinTypeMarker, upperType: KotlinTypeMarker, position: ConstraintPosition) =
         constraintInjector.addInitialSubtypeConstraint(
             apply { checkState(State.BUILDING, State.COMPLETION, State.TRANSACTION) },

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/KotlinCallArguments.kt

@@ -44,7 +44,7 @@ interface SimpleKotlinCallArgument : KotlinCallArgument, ReceiverKotlinCallArgum
 
 interface ExpressionKotlinCallArgument : SimpleKotlinCallArgument, ResolutionAtom
 
-interface SubKotlinCallArgument : SimpleKotlinCallArgument {
+interface SubKotlinCallArgument : SimpleKotlinCallArgument, ResolutionAtom {
     val callResult: PartialCallResolutionResult
 }
 

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/KotlinCallDiagnostics.kt

@@ -152,9 +152,7 @@ sealed class UnstableSmartCast(
             targetType: UnwrappedType,
             isReceiver: Boolean = false, // for reproducing OI behaviour
         ): UnstableSmartCast {
-            return if (isReceiver)
-                UnstableSmartCastResolutionError(argument, targetType)
-            else UnstableSmartCastDiagnosticError(argument, targetType)
+            return UnstableSmartCastResolutionError(argument, targetType)
         }
     }
 }

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/ResolutionAtoms.kt

@@ -85,6 +85,12 @@ class ResolvedExpressionAtom(override val atom: ExpressionKotlinCallArgument) :
     }
 }
 
+class ResolvedSubCallArgument(override val atom: SubKotlinCallArgument) : ResolvedAtom() {
+    init {
+        setAnalyzedResults(listOf(atom.callResult))
+    }
+}
+
 interface PostponedResolvedAtomMarker {
     val inputTypes: Collection<KotlinTypeMarker>
     val outputType: KotlinTypeMarker?

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/TowerUtils.kt

@@ -27,7 +27,7 @@ private val INAPPLICABLE_STATUSES = setOf(
 )
 
 val ResolutionCandidateApplicability.isSuccess: Boolean
-    get() = this <= ResolutionCandidateApplicability.RESOLVED_WITH_ERROR
+    get() = this <= ResolutionCandidateApplicability.RESOLVED_LOW_PRIORITY
 
 val CallableDescriptor.isSynthesized: Boolean
     get() = (this is CallableMemberDescriptor && kind == CallableMemberDescriptor.Kind.SYNTHESIZED)

compiler/testData/cli/js-dce/dceExtraHelp.out

@@ -1,5 +1,7 @@
 Usage: kotlin-dce-js <options> <source files>
 where advanced options include:
+  -Xdev-mode-overwriting-strategy={older|all}
+                             Overwriting strategy during copy dependencies in development mode
   -Xprint-reachability-info  Print declarations marked as reachable
 
 Advanced options are non-standard and may be changed or removed without any notice.

compiler/testData/cli/js/reifiedIntersectionType.args

@@ -0,0 +1,3 @@
+$TESTDATA_DIR$/reifiedIntersectionType.kt
+-output
+$TEMP_DIR$/out.js

compiler/testData/cli/js/reifiedIntersectionType.kt

@@ -0,0 +1,16 @@
+fun test1() {
+    val flow = combine(
+        flowOf("1"),
+        flowOf(2)
+    ) { arr -> arr.joinToString() }
+}
+
+fun <T> Array<out T>.joinToString(): String = ""
+
+public inline fun <reified T, R> combine(
+    vararg flows: Flow<T>,
+    crossinline transform: suspend (Array<T>) -> R
+): Flow<R> = TODO()
+
+fun <T> flowOf(value: T): Flow<T> = TODO()
+interface Flow<out T>

compiler/testData/cli/js/reifiedIntersectionType.out

@@ -0,0 +1,13 @@
+compiler/testData/cli/js/reifiedIntersectionType.kt:2:9: warning: variable 'flow' is never used
+    val flow = combine(
+        ^
+compiler/testData/cli/js/reifiedIntersectionType.kt:11:12: warning: parameter 'flows' is never used
+    vararg flows: Flow<T>,
+           ^
+compiler/testData/cli/js/reifiedIntersectionType.kt:12:17: warning: parameter 'transform' is never used
+    crossinline transform: suspend (Array<T>) -> R
+                ^
+compiler/testData/cli/js/reifiedIntersectionType.kt:15:16: warning: parameter 'value' is never used
+fun <T> flowOf(value: T): Flow<T> = TODO()
+               ^
+OK

compiler/testData/codegen/box/builderInference/lackOfNullCheckOnNullableInsideBuild.kt

@@ -0,0 +1,31 @@
+// !LANGUAGE: +NewInference
+// WITH_RUNTIME
+// IGNORE_BACKEND_FIR: JVM_IR
+// Issue: KT-36371
+
+import kotlin.experimental.ExperimentalTypeInference
+
+class Foo(val string: String? = null)
+
+class Builder<T> {
+    private var resolver: ((Foo) -> T)? = null
+    fun build() = resolver!!
+
+    fun resolve(resolver: (Foo) -> T) {
+        this.resolver = resolver
+    }
+}
+
+@OptIn(ExperimentalTypeInference::class)
+fun <T> build(@BuilderInference configure: Builder<T>.() -> Unit) =
+    Builder<T>().apply(configure).build()
+
+fun box(): String {
+    val resolver = build {
+        resolve { it.string }
+    }
+
+    resolver(Foo())
+
+    return "OK"
+}

compiler/testData/codegen/box/coroutines/emptyCommonConstraintSystemForCoroutineInferenceCall.kt

@@ -0,0 +1,79 @@
+// WITH_RUNTIME
+// WITH_COROUTINES
+// KJS_WITH_FULL_RUNTIME
+// IGNORE_BACKEND_FIR: JVM_IR
+
+import helpers.*
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+import kotlin.experimental.ExperimentalTypeInference
+
+fun test() {
+    flow {
+        emit(1)
+    }.flatMapLatest<Int, Long> {
+        flow {
+            expectInt(42)
+        }
+    }
+
+    flow {
+        emit(1)
+    }.flatMapLatest<Int, Long> {
+        flow {
+            expectInt(42)
+            hang {
+                expectInt(0)
+            }
+        }
+    }
+
+    flow {
+        emit(1)
+    }.flatMap {
+        if (it == 1)
+            flow { expectGeneric(42) }
+        else
+            flow<Int> {}
+    }
+
+    flow {
+        emit(1)
+    }.flatMap {
+        if (it == 1)
+            flow {}
+        else
+            flow<Int> {}
+    }
+
+    flow {
+        emit(1)
+    }.flatMap {
+        if (it == 1)
+            flow {}
+        else flow {}
+    }
+}
+
+fun expectInt(i: Int) {}
+fun <K> expectGeneric(i: K) {}
+
+suspend inline fun hang(onCancellation: () -> Unit) {}
+
+fun <T> Flow<T>.flatMap(mapper: suspend (T) -> Flow<T>): Flow<T> = TODO()
+
+@OptIn(ExperimentalTypeInference::class)
+fun <T> flow(@BuilderInference block: suspend FlowCollector<T>.() -> Unit): Flow<T> = TODO()
+
+@OptIn(ExperimentalTypeInference::class)
+inline fun <T, R> Flow<T>.flatMapLatest(@BuilderInference crossinline transform: suspend (value: T) -> Flow<R>): Flow<R> = TODO()
+
+interface Flow<out T>
+
+interface FlowCollector<in T> {
+    suspend fun emit(value: T)
+}
+
+fun box(): String {
+    return "OK"
+}

compiler/testData/codegen/box/inference/coerctionToUnitForLastExpressionWithStarProjection.kt

@@ -0,0 +1,20 @@
+class Inv<T>
+
+fun Inv<*>.invToInv(): Inv<*>? = null
+
+fun <R> myRun(block: () -> R): R {
+    return block()
+}
+
+fun test(c: Inv<*>) {
+    myRun {
+        if (true) return@myRun // coerction to Unit
+
+        c.invToInv()?.let {}
+    }
+}
+
+fun box(): String {
+    test(Inv<Int>())
+    return "OK"
+}

compiler/testData/codegen/box/reified/reifiedIntersectionType.kt

@@ -0,0 +1,37 @@
+// IGNORE_BACKEND: JS
+// KJS_WITH_FULL_RUNTIME
+
+// Case that was found in kotlinx.coroutines
+
+fun test1() {
+    val flow = combine(
+        flowOf("1"),
+        flowOf(2)
+    ) { arr -> arr.joinToString() }
+}
+
+fun <T> Array<out T>.joinToString(): String = ""
+
+public inline fun <reified T, R> combine(
+    vararg flows: Flow<T>,
+    crossinline transform: suspend (Array<T>) -> R
+): Flow<R> = TODO()
+
+fun <T> flowOf(value: T): Flow<T> = TODO()
+interface Flow<out T>
+
+// Simplified case
+
+class In<in T>
+
+inline fun <reified K> select(x: K, y: K): K = x
+interface A
+interface B
+
+fun test2(a: In<A>, b: In<B>) {
+    select(a, b)
+}
+
+fun box(): String {
+    return "OK"
+}

compiler/testData/compileKotlinAgainstCustomBinaries/missingDependencyConflictingLibraries/library1/a1.kt

@@ -7,3 +7,9 @@ class A<T> {
 class AA<T> {
     inner class Inner<U, V>
 }
+
+class AAA<T> {
+    inner class Inner<K> {
+        inner class InnerInner<S>
+    }
+}

compiler/testData/compileKotlinAgainstCustomBinaries/missingDependencyConflictingLibraries/library1/b1.kt

@@ -2,8 +2,11 @@ package b
 
 import a.A
 import a.AA
+import a.AAA
 
 interface B1 {
     fun produceA(): A<String>.Inner<Int, Unit>
     fun produceAA(): AA<Int>.Inner<Unit, String>
+    fun <T> produceAGeneric(t: T): A<String>.Inner<Int, Unit>
+    fun produceAAA(): AAA<String>.Inner<Int>.InnerInner<Unit>
 }

compiler/testData/compileKotlinAgainstCustomBinaries/missingDependencyConflictingLibraries/library2/a2.kt

@@ -7,3 +7,9 @@ class A<T, U: CharSequence, V> {
 class AA<T, U> {
     inner class Inner<V>
 }
+
+class AAA<T> {
+    inner class Inner<K> {
+        inner class InnerInner<S>
+    }
+}

compiler/testData/compileKotlinAgainstCustomBinaries/missingDependencyConflictingLibraries/library2/b2.kt

@@ -2,8 +2,10 @@ package b
 
 import a.A
 import a.AA
+import a.AAA
 
 interface B2 {
     fun consumeA(a: A<Int, String, Double>.Inner<B2>)
     fun consumeAA(a: AA<Int, Unit>.Inner<String>)
+    fun consumeAAA(a: AAA<String>.Inner<Int>.InnerInner<Unit>)
 }

compiler/testData/compileKotlinAgainstCustomBinaries/missingDependencyConflictingLibraries/output.txt

@@ -7,13 +7,28 @@ compiler/testData/compileKotlinAgainstCustomBinaries/missingDependencyConflictin
 compiler/testData/compileKotlinAgainstCustomBinaries/missingDependencyConflictingLibraries/source.kt:7:20: error: cannot access class 'a.A.Inner'. Check your module classpath for missing or conflicting dependencies
     b2.consumeA(b1.produceA())
                    ^
-compiler/testData/compileKotlinAgainstCustomBinaries/missingDependencyConflictingLibraries/source.kt:11:8: error: cannot access class 'a.AA.Inner'. Check your module classpath for missing or conflicting dependencies
+compiler/testData/compileKotlinAgainstCustomBinaries/missingDependencyConflictingLibraries/source.kt:8:8: error: cannot access class 'a.A.Inner'. Check your module classpath for missing or conflicting dependencies
+    b2.consumeA(b1.produceAGeneric("foo"))
+       ^
+compiler/testData/compileKotlinAgainstCustomBinaries/missingDependencyConflictingLibraries/source.kt:8:17: error: type mismatch: inferred type is A<String>.Inner<Int, Unit> but A<Int, String, Double>.Inner<B2> was expected
+    b2.consumeA(b1.produceAGeneric("foo"))
+                ^
+compiler/testData/compileKotlinAgainstCustomBinaries/missingDependencyConflictingLibraries/source.kt:8:20: error: cannot access class 'a.A.Inner'. Check your module classpath for missing or conflicting dependencies
+    b2.consumeA(b1.produceAGeneric("foo"))
+                   ^
+compiler/testData/compileKotlinAgainstCustomBinaries/missingDependencyConflictingLibraries/source.kt:12:8: error: cannot access class 'a.AA.Inner'. Check your module classpath for missing or conflicting dependencies
     b2.consumeAA(b1.produceAA())
        ^
-compiler/testData/compileKotlinAgainstCustomBinaries/missingDependencyConflictingLibraries/source.kt:11:18: error: type mismatch: inferred type is AA<Int>.Inner<Unit, String> but AA<Int, Unit>.Inner<String> was expected
+compiler/testData/compileKotlinAgainstCustomBinaries/missingDependencyConflictingLibraries/source.kt:12:18: error: type mismatch: inferred type is AA<Int>.Inner<Unit, String> but AA<Int, Unit>.Inner<String> was expected
     b2.consumeAA(b1.produceAA())
                  ^
-compiler/testData/compileKotlinAgainstCustomBinaries/missingDependencyConflictingLibraries/source.kt:11:21: error: cannot access class 'a.AA.Inner'. Check your module classpath for missing or conflicting dependencies
+compiler/testData/compileKotlinAgainstCustomBinaries/missingDependencyConflictingLibraries/source.kt:12:21: error: cannot access class 'a.AA.Inner'. Check your module classpath for missing or conflicting dependencies
     b2.consumeAA(b1.produceAA())
                     ^
-COMPILATION_ERROR
+compiler/testData/compileKotlinAgainstCustomBinaries/missingDependencyConflictingLibraries/source.kt:16:8: error: cannot access class 'a.AAA.Inner.InnerInner'. Check your module classpath for missing or conflicting dependencies
+    b2.consumeAAA(b1.produceAAA())
+       ^
+compiler/testData/compileKotlinAgainstCustomBinaries/missingDependencyConflictingLibraries/source.kt:16:22: error: cannot access class 'a.AAA.Inner.InnerInner'. Check your module classpath for missing or conflicting dependencies
+    b2.consumeAAA(b1.produceAAA())
+                     ^
+COMPILATION_ERROR

compiler/testData/compileKotlinAgainstCustomBinaries/missingDependencyConflictingLibraries/source.kt

@@ -5,8 +5,13 @@ import b.B2
 
 fun testA(b1: B1, b2: B2) {
     b2.consumeA(b1.produceA())
+    b2.consumeA(b1.produceAGeneric("foo"))
 }
 
 fun testAA(b1: B1, b2: B2) {
     b2.consumeAA(b1.produceAA())
 }
+
+fun testAAA(b1: B1, b2: B2) {
+    b2.consumeAAA(b1.produceAAA())
+}

compiler/testData/diagnostics/tests/inference/cstFromErrorAndNonErrorTypes.fir.kt

@@ -0,0 +1,9 @@
+// !LANGUAGE: +NewInference
+
+fun test() {
+    run {
+        if (true)
+            return@run false
+        <!UNRESOLVED_REFERENCE!>unresolved<!>.toString()
+    }
+}

compiler/testData/diagnostics/tests/inference/cstFromErrorAndNonErrorTypes.kt

@@ -0,0 +1,9 @@
+// !LANGUAGE: +NewInference
+
+fun test() {
+    run {
+        if (true)
+            return@run false
+        <!UNRESOLVED_REFERENCE!>unresolved<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>toString<!>()
+    }
+}

compiler/testData/diagnostics/tests/inference/cstFromErrorAndNonErrorTypes.txt

@@ -0,0 +1,3 @@
+package
+
+public fun test(): kotlin.Unit

compiler/testData/diagnostics/tests/inference/kt36819.fir.kt

@@ -0,0 +1,18 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
+// ISSUE: KT-36819
+
+fun <K> select(vararg x: K) = x[0]
+interface A
+class B: A
+class C: A
+fun <T> id1(x: T): T = x
+fun <R> id2(x: R): R = x
+
+class Out<out R>(x: R)
+
+fun main() {
+    val x1 = select(id1 { B() }, id2 { C() })
+    val x2 = select({ B() }, { C() }) // OK, CST = () -> A
+    val x3 = select(id1(Out(B())), id2(Out(C()))) // OK, CST = Out<A>
+}

compiler/testData/diagnostics/tests/inference/kt36819.kt

@@ -0,0 +1,18 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
+// ISSUE: KT-36819
+
+fun <K> select(vararg x: K) = x[0]
+interface A
+class B: A
+class C: A
+fun <T> id1(x: T): T = x
+fun <R> id2(x: R): R = x
+
+class Out<out R>(x: R)
+
+fun main() {
+    val x1 = select(id1 { B() }, id2 { <!TYPE_MISMATCH, TYPE_MISMATCH!>C()<!> })
+    val x2 = select({ B() }, { C() }) // OK, CST = () -> A
+    val x3 = select(id1(Out(B())), id2(Out(C()))) // OK, CST = Out<A>
+}