[NI] Disable capturing/approximation type in TypeSubstitutor with enabled NI

2026-04-04 15:51:54 +00:00 · 2019-05-29 10:35:46 +03:00
parent dad334ffcd
commit 7c4101e21c
80 changed files with 890 additions and 201 deletions
--- a/compiler/cli/cli-common/src/org/jetbrains/kotlin/analyzer/common/CommonResolverForModuleFactory.kt
+++ b/compiler/cli/cli-common/src/org/jetbrains/kotlin/analyzer/common/CommonResolverForModuleFactory.kt
@@ -45,6 +45,7 @@ import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService
 import org.jetbrains.kotlin.serialization.deserialization.MetadataPackageFragmentProvider
 import org.jetbrains.kotlin.serialization.deserialization.MetadataPartProvider
+import org.jetbrains.kotlin.types.SubstitutingScopeProviderImpl

 class CommonAnalysisParameters(
    val metadataPartProviderFactory: (ModuleContent<*>) -> MetadataPartProvider
@@ -170,6 +171,7 @@ private fun createContainerToResolveCommonCode(

        configureCommonSpecificComponents()
        useInstance(metadataPartProvider)
+        useImpl<SubstitutingScopeProviderImpl>()

        val metadataFinderFactory = ServiceManager.getService(
            moduleContext.project,
--- a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirDiagnosticsSmokeTestGenerated.java
+++ b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirDiagnosticsSmokeTestGenerated.java
@@ -8086,6 +8086,11 @@ public class FirDiagnosticsSmokeTestGenerated extends AbstractFirDiagnosticsSmok
            runTest("compiler/testData/diagnostics/tests/generics/argumentsForT.kt");
        }

+        @TestMetadata("capturedTypeInInputPosition.kt")
+        public void testCapturedTypeInInputPosition() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/generics/capturedTypeInInputPosition.kt");
+        }
+
        @TestMetadata("commonSupertypeContravariant.kt")
        public void testCommonSupertypeContravariant() throws Exception {
            runTest("compiler/testData/diagnostics/tests/generics/commonSupertypeContravariant.kt");
@@ -8925,6 +8930,11 @@ public class FirDiagnosticsSmokeTestGenerated extends AbstractFirDiagnosticsSmok
                runTest("compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutAssign.kt");
            }

+            @TestMetadata("setterProjectedOutAssignFromJava.kt")
+            public void testSetterProjectedOutAssignFromJava() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutAssignFromJava.kt");
+            }
+
            @TestMetadata("setterProjectedOutNoPlusAssign.kt")
            public void testSetterProjectedOutNoPlusAssign() throws Exception {
                runTest("compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutNoPlusAssign.kt");
@@ -17373,6 +17383,11 @@ public class FirDiagnosticsSmokeTestGenerated extends AbstractFirDiagnosticsSmok
            runTest("compiler/testData/diagnostics/tests/resolve/HiddenDeclarations.kt");
        }

+        @TestMetadata("implicitAndExplicitThis.kt")
+        public void testImplicitAndExplicitThis() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/resolve/implicitAndExplicitThis.kt");
+        }
+
        @TestMetadata("implicitReceiverProperty.kt")
        public void testImplicitReceiverProperty() throws Exception {
            runTest("compiler/testData/diagnostics/tests/resolve/implicitReceiverProperty.kt");
@@ -18090,6 +18105,11 @@ public class FirDiagnosticsSmokeTestGenerated extends AbstractFirDiagnosticsSmok
            runTest("compiler/testData/diagnostics/tests/samConversions/GenericSubstitutionKT.kt");
        }

+        @TestMetadata("kt25290.kt")
+        public void testKt25290() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/samConversions/kt25290.kt");
+        }
+
        @TestMetadata("OverloadPriority.kt")
        public void testOverloadPriority() throws Exception {
            runTest("compiler/testData/diagnostics/tests/samConversions/OverloadPriority.kt");
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt
@@ -46,6 +46,7 @@ import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformAnalyzerServices
 import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
+import org.jetbrains.kotlin.types.SubstitutingScopeProviderImpl

 fun createContainerForLazyResolveWithJava(
    jvmPlatform: TargetPlatform,
@@ -127,6 +128,7 @@ fun StorageComponentContainer.configureJavaSpecificComponents(
    )

    useImpl<FilesByFacadeFqNameIndexer>()
+    useImpl<SubstitutingScopeProviderImpl>()
 }

 fun ComponentProvider.initJvmBuiltInsForTopDownAnalysis() {
--- a/compiler/frontend/src/org/jetbrains/kotlin/descriptors/impl/LocalVariableDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/descriptors/impl/LocalVariableDescriptor.java
@@ -81,8 +81,7 @@ public class LocalVariableDescriptor extends VariableDescriptorWithInitializerIm
    @NotNull
    @Override
    public LocalVariableDescriptor substitute(@NotNull TypeSubstitutor substitutor) {
-        if (substitutor.isEmpty()) return this;
-        throw new UnsupportedOperationException(); // TODO
+        return this;
    }

    @Override
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/diagnosticUtils.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/diagnosticUtils.kt
@@ -38,6 +38,7 @@ import org.jetbrains.kotlin.resolve.calls.inference.wrapWithCapturingSubstitutio
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.calls.model.VariableAsFunctionResolvedCall
 import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.kotlin.types.SubstitutingScopeProvider
 import org.jetbrains.kotlin.types.TypeConstructorSubstitution
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.types.typeUtil.isAnyOrNullableAny
@@ -77,7 +78,9 @@ fun ResolutionContext<*>.reportTypeMismatchDueToTypeProjection(
        TypeConstructorSubstitution
            .create(receiverType)
            .wrapWithCapturingSubstitution(needApproximation = false)
-            .buildSubstitutor().let { callableDescriptor.substitute(it) } ?: return false
+            .buildSubstitutor().apply {
+                setSubstitutingScopeProvider(SubstitutingScopeProvider.DEFAULT)
+            }.let { callableDescriptor.substitute(it) } ?: return false

    val nonApproximatedExpectedType = correspondingNotApproximatedTypeByDescriptor(substitutedDescriptor) ?: return false
    if (!TypeUtils.contains(nonApproximatedExpectedType) { it.isCaptured() }) return false
--- a/compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt
@@ -34,6 +34,7 @@ import org.jetbrains.kotlin.resolve.calls.tower.KotlinResolutionStatelessCallbac
 import org.jetbrains.kotlin.resolve.checkers.ExperimentalUsageChecker
 import org.jetbrains.kotlin.resolve.lazy.*
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
+import org.jetbrains.kotlin.types.SubstitutingScopeProviderImpl
 import org.jetbrains.kotlin.types.expressions.DeclarationScopeProviderForLocalClassifierAnalyzer
 import org.jetbrains.kotlin.types.expressions.LocalClassDescriptorHolder
 import org.jetbrains.kotlin.types.expressions.LocalLazyDeclarationResolver
@@ -117,6 +118,7 @@ fun createContainerForBodyResolve(
    useImpl<AnnotationResolverImpl>()

    useImpl<BodyResolver>()
+    useImpl<SubstitutingScopeProviderImpl>()
 }

 fun createContainerForLazyBodyResolve(
@@ -136,6 +138,7 @@ fun createContainerForLazyBodyResolve(
    useImpl<AnnotationResolverImpl>()
    useImpl<LazyTopDownAnalyzer>()
    useImpl<BasicAbsentDescriptorHandler>()
+    useImpl<SubstitutingScopeProviderImpl>()
 }

 fun createContainerForLazyLocalClassifierAnalyzer(
@@ -166,6 +169,7 @@ fun createContainerForLazyLocalClassifierAnalyzer(
    useImpl<DeclarationScopeProviderForLocalClassifierAnalyzer>()
    useImpl<LocalLazyDeclarationResolver>()

+    useImpl<SubstitutingScopeProviderImpl>()
    useInstance(statementFilter)
 }

@@ -183,6 +187,7 @@ fun createContainerForLazyResolve(
    configureStandardResolveComponents()

    useInstance(declarationProviderFactory)
+    useImpl<SubstitutingScopeProviderImpl>()

    targetEnvironment.configure(this)

--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java
@@ -911,7 +911,8 @@ public class DescriptorResolver {
                container instanceof ClassDescriptor && ((ClassDescriptor) container).isExpect(),
                modifierList != null && PsiUtilsKt.hasActualModifier(modifierList),
                modifierList != null && modifierList.hasModifier(KtTokens.EXTERNAL_KEYWORD),
-                propertyInfo.getHasDelegate()
+                propertyInfo.getHasDelegate(),
+                new SubstitutingScopeProviderImpl(languageVersionSettings)
        );

        List<TypeParameterDescriptorImpl> typeParameterDescriptors;
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/KotlinToResolvedCallTransformer.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/KotlinToResolvedCallTransformer.kt
@@ -8,6 +8,8 @@ package org.jetbrains.kotlin.resolve.calls.tower
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
+import org.jetbrains.kotlin.descriptors.impl.PropertyDescriptorImpl
+import org.jetbrains.kotlin.descriptors.impl.PropertySetterDescriptorImpl
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.diagnostics.Errors
 import org.jetbrains.kotlin.psi.*
@@ -23,12 +25,13 @@ import org.jetbrains.kotlin.resolve.calls.components.AdditionalDiagnosticReporte
 import org.jetbrains.kotlin.resolve.calls.components.isVararg
 import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
 import org.jetbrains.kotlin.resolve.calls.context.CallPosition
+import org.jetbrains.kotlin.resolve.calls.inference.approximateCapturedTypes
 import org.jetbrains.kotlin.resolve.calls.inference.buildResultingSubstitutor
 import org.jetbrains.kotlin.resolve.calls.inference.components.FreshVariableNewTypeSubstitutor
 import org.jetbrains.kotlin.resolve.calls.inference.components.NewTypeSubstitutor
 import org.jetbrains.kotlin.resolve.calls.inference.model.*
 import org.jetbrains.kotlin.resolve.calls.inference.substitute
-import org.jetbrains.kotlin.resolve.calls.inference.substituteAndApproximateCapturedTypes
+import org.jetbrains.kotlin.resolve.calls.inference.substituteAndApproximateIntegerLiteralTypes
 import org.jetbrains.kotlin.resolve.calls.model.*
 import org.jetbrains.kotlin.resolve.calls.resolvedCallUtil.makeNullableTypeIfSafeReceiver
 import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus
@@ -38,14 +41,13 @@ import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind
 import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategy
 import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant
 import org.jetbrains.kotlin.resolve.constants.IntegerLiteralTypeConstructor
-import org.jetbrains.kotlin.resolve.constants.IntegerValueTypeConstant
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator
 import org.jetbrains.kotlin.resolve.deprecation.DeprecationResolver
+import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.resolve.scopes.receivers.CastImplicitClassReceiver
 import org.jetbrains.kotlin.resolve.scopes.receivers.ImplicitClassReceiver
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
 import org.jetbrains.kotlin.types.*
-import org.jetbrains.kotlin.types.checker.NewCapturedType
 import org.jetbrains.kotlin.types.expressions.DataFlowAnalyzer
 import org.jetbrains.kotlin.types.expressions.DoubleColonExpressionResolver
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices
@@ -293,15 +295,14 @@ class KotlinToResolvedCallTransformer(
            // todo external argument

            val argumentExpression = valueArgument.getArgumentExpression() ?: continue
-            updateRecordedType(argumentExpression, parameter, newContext, resolvedCall.isReallySuccess())
+            updateRecordedType(argumentExpression, parameter, newContext)
        }
    }

    fun updateRecordedType(
        expression: KtExpression,
        parameter: ValueParameterDescriptor?,
-        context: BasicCallResolutionContext,
-        reportErrorForTypeMismatch: Boolean
+        context: BasicCallResolutionContext
    ): KotlinType? {
        val deparenthesized = expression.let {
            KtPsiUtil.getLastElementDeparenthesized(it, context.statementFilter)
@@ -318,9 +319,6 @@ class KotlinToResolvedCallTransformer(
            updatedType = argumentTypeResolver.updateResultArgumentTypeIfNotDenotable(context, deparenthesized) ?: updatedType
        }

-
-        var reportErrorDuringTypeCheck = reportErrorForTypeMismatch
-
        if (parameter != null && ImplicitIntegerCoercion.isEnabledForParameter(parameter)) {
            val argumentCompileTimeValue = context.trace[BindingContext.COMPILE_TIME_VALUE, deparenthesized]
            if (argumentCompileTimeValue != null && argumentCompileTimeValue.parameters.isConvertableConstVal) {
@@ -329,7 +327,6 @@ class KotlinToResolvedCallTransformer(
                    updatedType = argumentTypeResolver.updateResultArgumentTypeIfNotDenotable(
                        context.trace, context.statementFilter, context.expectedType, generalNumberType, expression
                    )
-                    reportErrorDuringTypeCheck = true
                }

            }
@@ -337,7 +334,7 @@ class KotlinToResolvedCallTransformer(

        updatedType = updateRecordedTypeForArgument(updatedType, recordedType, expression, context)

-        dataFlowAnalyzer.checkType(updatedType, deparenthesized, context, reportErrorDuringTypeCheck)
+        dataFlowAnalyzer.checkType(updatedType, deparenthesized, context, false)

        return updatedType
    }
@@ -690,32 +687,44 @@ class NewResolvedCallImpl<D : CallableDescriptor>(
        @Suppress("UNCHECKED_CAST")
        resultingDescriptor = run {
            val candidateDescriptor = resolvedCallAtom.candidateDescriptor
-            val containsCapturedTypes = resolvedCallAtom.candidateDescriptor.returnType?.contains { it is NewCapturedType } ?: false
-            val containsIntegerLiteralTypes = resolvedCallAtom.candidateDescriptor.returnType?.contains { it.constructor is IntegerLiteralTypeConstructor } ?: false
+            val containsIntegerLiteralTypes = resolvedCallAtom.candidateDescriptor.returnType?.contains {
+                it.constructor is IntegerLiteralTypeConstructor
+            } ?: false

            when {
                candidateDescriptor is FunctionDescriptor ||
-                        (candidateDescriptor is PropertyDescriptor && (candidateDescriptor.typeParameters.isNotEmpty() || containsCapturedTypes || containsIntegerLiteralTypes)) ->
+                        (candidateDescriptor is PropertyDescriptor && candidateDescriptor.typeParameters.isNotEmpty() || containsIntegerLiteralTypes) ->
                    // this code is very suspicious. Now it is very useful for BE, because they cannot do nothing with captured types,
                    // but it seems like temporary solution.
-                    candidateDescriptor.substitute(resolvedCallAtom.substitutor).substituteAndApproximateCapturedTypes(
-                        substitutor ?: FreshVariableNewTypeSubstitutor.Empty
-                    )
+                    candidateDescriptor.substituteAndApproximateIntegerLiteralTypes(resolvedCallAtom.substitutor).let {
+                        if (substitutor != null) {
+                            it.substitute(substitutor)
+                        } else {
+                            it
+                        }
+                    }
+
                else ->
                    candidateDescriptor
            }
        } as D

        typeArguments = resolvedCallAtom.substitutor.freshVariables.map {
-            val substituted = (substitutor ?: FreshVariableNewTypeSubstitutor.Empty).safeSubstitute(it.defaultType)
-            TypeApproximator(substituted.constructor.builtIns)
-                .approximateToSuperType(substituted, TypeApproximatorConfiguration.IntegerLiteralsTypesApproximation)
-                ?: substituted
+            (substitutor ?: FreshVariableNewTypeSubstitutor.Empty).safeSubstitute(it.defaultType)
        }

        calculateExpectedTypeForSamConvertedArgumentMap(substitutor)
    }

+    fun approximateCapturedTypesAndHackSetters() {
+        val approximator = TypeApproximator(resultingDescriptor.builtIns)
+        resultingDescriptor = resultingDescriptor.hackSettersAccordingToCapturedOutTypes()
+        resultingDescriptor = resultingDescriptor.approximateCapturedTypes()
+        typeArguments = typeArguments.map {
+            approximator.approximateToSuperType(it, TypeApproximatorConfiguration.CapturedAndIntegerLiteralsTypesApproximation) ?: it
+        }
+    }
+
    fun getExpectedTypeForSamConvertedArgument(valueArgument: ValueArgument): UnwrappedType? =
        expedtedTypeForSamConvertedArgumentMap?.get(valueArgument)

@@ -808,3 +817,41 @@ fun NewResolvedCallImpl<*>.hasInferredReturnType(): Boolean {
    val returnType = this.resultingDescriptor.returnType ?: return false
    return !returnType.contains { ErrorUtils.isUninferredParameter(it) }
 }
+
+fun ResolvedCall<*>.approximateCapturedTypesAndHackSetters() {
+    when (this) {
+        is NewResolvedCallImpl<*> -> approximateCapturedTypesAndHackSetters()
+        is NewVariableAsFunctionResolvedCallImpl -> {
+            functionCall.approximateCapturedTypesAndHackSetters()
+            variableCall.approximateCapturedTypesAndHackSetters()
+        }
+        else -> throw UnsupportedOperationException("Illegal resolved call: $this")
+    }
+}
+
+fun <D : CallableDescriptor> D.hackSettersAccordingToCapturedOutTypes(): D {
+    return when (this) {
+        is PropertyDescriptorImpl -> hackSettersAccordingToCapturedOutTypes() as D
+        else -> this
+    }
+}
+
+private fun PropertyDescriptorImpl.hackSettersAccordingToCapturedOutTypes(): PropertyDescriptor {
+    val setter = setter ?: return this
+    val valueParameter = setter.valueParameters.first()
+    val inputType = valueParameter.type
+    val approximatedType = TypeApproximator(builtIns).approximateToSubType(
+        inputType.unwrap(),
+        TypeApproximatorConfiguration.CapturedAndIntegerLiteralsTypesApproximation
+    ) ?: return this
+
+    val newProperty = newCopyBuilder().build() as PropertyDescriptorImpl
+
+    val newSetter = with(setter) {
+        PropertySetterDescriptorImpl(newProperty, annotations, modality, visibility, isDefault, isExternal, isInline, kind, original, source)
+    }
+    newSetter.initialize(PropertySetterDescriptorImpl.createSetterParameter(newSetter, approximatedType, setter.annotations))
+    newProperty.initialize(getter, newSetter, backingField, delegateField)
+    newProperty.isSetterProjectedOut = true
+    return newProperty
+}
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/PSICallResolver.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/PSICallResolver.kt
@@ -382,6 +382,7 @@ class PSICallResolver(

            return cache.getOrPut(implicitReceiver) {
                context.transformToReceiverWithSmartCastInfo(implicitReceiver.value)
+                    .prepareReceiverRegardingCaptureTypes()
            }
        }
    }
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/ResolvedAtomCompleter.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/ResolvedAtomCompleter.kt
@@ -110,6 +110,7 @@ class ResolvedAtomCompleter(

        kotlinToResolvedCallTransformer.reportDiagnostics(topLevelCallContext, topLevelTrace, resolvedCall, diagnostics)

+        resolvedCall.approximateCapturedTypesAndHackSetters()
        return resolvedCall
    }

@@ -155,9 +156,7 @@ class ResolvedAtomCompleter(
                    .replaceBindingTrace(topLevelTrace)

            val argumentExpression = resultValueArgument.valueArgument.getArgumentExpression() ?: continue
-            kotlinToResolvedCallTransformer.updateRecordedType(
-                argumentExpression, parameter = null, context = newContext, reportErrorForTypeMismatch = true
-            )
+            kotlinToResolvedCallTransformer.updateRecordedType(argumentExpression, parameter = null, context = newContext)
        }
    }

--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyClassContext.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyClassContext.kt
@@ -24,10 +24,12 @@ import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.extensions.SyntheticResolveExtension
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
 import org.jetbrains.kotlin.storage.StorageManager
+import org.jetbrains.kotlin.types.SubstitutingScopeProvider
 import org.jetbrains.kotlin.types.WrappedTypeFactory

 interface LazyClassContext {
    val declarationScopeProvider: DeclarationScopeProvider
+    val substitutingScopeProvider: SubstitutingScopeProvider

    val storageManager: StorageManager
    val trace: BindingTrace
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java
@@ -44,6 +44,7 @@ import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyPackageDescriptor;
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope;
 import org.jetbrains.kotlin.resolve.scopes.MemberScope;
 import org.jetbrains.kotlin.storage.*;
+import org.jetbrains.kotlin.types.SubstitutingScopeProvider;
 import org.jetbrains.kotlin.types.WrappedTypeFactory;
 import org.jetbrains.kotlin.utils.SmartList;

@@ -81,6 +82,7 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
    private DelegationFilter delegationFilter;
    private WrappedTypeFactory wrappedTypeFactory;
    private PlatformDiagnosticSuppressor platformDiagnosticSuppressor;
+    private SubstitutingScopeProvider substitutingScopeProvider;

    private final SyntheticResolveExtension syntheticResolveExtension;

@@ -146,6 +148,17 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
        this.platformDiagnosticSuppressor = platformDiagnosticSuppressor;
    }

+    @NotNull
+    @Override
+    public SubstitutingScopeProvider getSubstitutingScopeProvider() {
+        return substitutingScopeProvider;
+    }
+
+    @Inject
+    public void setSubstitutingScopeProvider(SubstitutingScopeProvider substitutingScopeProvider) {
+        this.substitutingScopeProvider = substitutingScopeProvider;
+    }
+
    // Only calls from injectors expected
    @Deprecated
    public ResolveSession(
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java
@@ -113,7 +113,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
    ) {
        super(c.getStorageManager(), containingDeclaration, name,
              KotlinSourceElementKt.toSourceElement(classLikeInfo.getCorrespondingClassOrObject()),
-              isExternal
+              isExternal, c.getSubstitutingScopeProvider()
        );
        this.c = c;

--- a/compiler/frontend/src/org/jetbrains/kotlin/types/SubstitutingScopeProviderImpl.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/SubstitutingScopeProviderImpl.kt
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. 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.types
+
+import org.jetbrains.kotlin.config.LanguageFeature
+import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.resolve.calls.inference.OldCapturedTypeCreator
+import org.jetbrains.kotlin.resolve.scopes.MemberScope
+import org.jetbrains.kotlin.resolve.scopes.SubstitutingScope
+import org.jetbrains.kotlin.types.typesApproximation.OldCaptureTypeApproximator
+
+class SubstitutingScopeProviderImpl(private val languageVersionSettings: LanguageVersionSettings) : SubstitutingScopeProvider {
+    override val isNewInferenceEnabled: Boolean get() = languageVersionSettings.supportsFeature(LanguageFeature.NewInference)
+
+    override fun createSubstitutingScope(workerScope: MemberScope, givenSubstitutor: TypeSubstitutor): SubstitutingScope {
+        return SubstitutingScope(workerScope, givenSubstitutor, this)
+    }
+
+    override fun provideApproximator(): CapturedTypeApproximator {
+        return if (isNewInferenceEnabled) {
+            NoCapturedTypeApproximator
+        } else {
+            OldCaptureTypeApproximator()
+        }
+    }
+
+    override fun provideCapturedTypeCreator(): CapturedTypeCreator {
+        return if (isNewInferenceEnabled) {
+            NoCapturedTypeCreator
+        } else {
+            OldCapturedTypeCreator
+        }
+    }
+}
+
+object NoCapturedTypeCreator : CapturedTypeCreator {
+    override fun createCapturedType(typeProjection: TypeProjection): TypeProjection {
+        return typeProjection
+    }
+}
+
+object NoCapturedTypeApproximator : CapturedTypeApproximator {
+    override fun approximateCapturedTypes(typeProjection: TypeProjection?, approximateContravariant: Boolean): TypeProjection? {
+        return typeProjection
+    }
+}
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java
@@ -958,6 +958,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {

        boolean result = true;
        KtExpression reportOn = expression != null ? expression : expressionWithParenthesis;
+        KtExpression originalReportOn = reportOn;
        if (reportOn instanceof KtQualifiedExpression) {
            KtExpression selector = ((KtQualifiedExpression) reportOn).getSelectorExpression();
            if (selector != null)
@@ -968,14 +969,19 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
            PropertyDescriptor propertyDescriptor = (PropertyDescriptor) variable;
            PropertySetterDescriptor setter = propertyDescriptor.getSetter();
            if (propertyDescriptor.isSetterProjectedOut()) {
-                trace.report(SETTER_PROJECTED_OUT.on(reportOn, propertyDescriptor));
+                trace.report(SETTER_PROJECTED_OUT.on(originalReportOn, propertyDescriptor));
                result = false;
            }
            else if (setter != null) {
                ResolvedCall<?> resolvedCall = CallUtilKt.getResolvedCall(expressionWithParenthesis, context.trace.getBindingContext());
                assert resolvedCall != null
                        : "Call is not resolved for property setter: " + PsiUtilsKt.getElementTextWithContext(expressionWithParenthesis);
-                checkPropertySetterCall(context.replaceBindingTrace(trace), setter, resolvedCall, reportOn);
+                if (((PropertyDescriptor)resolvedCall.getResultingDescriptor()).isSetterProjectedOut()) {
+                    trace.report(SETTER_PROJECTED_OUT.on(originalReportOn, propertyDescriptor));
+                    result = false;
+                } else {
+                    checkPropertySetterCall(context.replaceBindingTrace(trace), setter, resolvedCall, reportOn);
+                }
            }
        }

--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt
@@ -50,6 +50,7 @@ import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassDescriptor
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope
 import org.jetbrains.kotlin.resolve.scopes.LexicalWritableScope
 import org.jetbrains.kotlin.storage.StorageManager
+import org.jetbrains.kotlin.types.SubstitutingScopeProvider
 import org.jetbrains.kotlin.types.WrappedTypeFactory

 class LocalClassifierAnalyzer(
@@ -65,7 +66,8 @@ class LocalClassifierAnalyzer(
    private val supertypeLoopChecker: SupertypeLoopChecker,
    private val languageVersionSettings: LanguageVersionSettings,
    private val delegationFilter: DelegationFilter,
-    private val wrappedTypeFactory: WrappedTypeFactory
+    private val wrappedTypeFactory: WrappedTypeFactory,
+    private val substitutingScopeProvider: SubstitutingScopeProvider
 ) {
    fun processClassOrObject(
        scope: LexicalWritableScope?,
@@ -98,7 +100,8 @@ class LocalClassifierAnalyzer(
                languageVersionSettings,
                SyntheticResolveExtension.getInstance(project),
                delegationFilter,
-                wrappedTypeFactory
+                wrappedTypeFactory,
+                substitutingScopeProvider
            ),
            analyzerServices
        )
@@ -126,7 +129,8 @@ class LocalClassDescriptorHolder(
    val languageVersionSettings: LanguageVersionSettings,
    val syntheticResolveExtension: SyntheticResolveExtension,
    val delegationFilter: DelegationFilter,
-    val wrappedTypeFactory: WrappedTypeFactory
+    val wrappedTypeFactory: WrappedTypeFactory,
+    val substitutingScopeProvider: SubstitutingScopeProvider
 ) {
    // We do not need to synchronize here, because this code is used strictly from one thread
    private var classDescriptor: ClassDescriptor? = null
@@ -166,6 +170,7 @@ class LocalClassDescriptorHolder(
                    override val syntheticResolveExtension = this@LocalClassDescriptorHolder.syntheticResolveExtension
                    override val delegationFilter: DelegationFilter = this@LocalClassDescriptorHolder.delegationFilter
                    override val wrappedTypeFactory: WrappedTypeFactory = this@LocalClassDescriptorHolder.wrappedTypeFactory
+                    override val substitutingScopeProvider: SubstitutingScopeProvider = this@LocalClassDescriptorHolder.substitutingScopeProvider
                },
                containingDeclaration,
                classOrObject.nameAsSafeName,
--- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/InferenceUtils.kt
+++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/InferenceUtils.kt
@@ -60,6 +60,20 @@ val CallableDescriptor.returnTypeOrNothing: UnwrappedType

 fun TypeSubstitutor.substitute(type: UnwrappedType): UnwrappedType = safeSubstitute(type, Variance.INVARIANT).unwrap()

+fun CallableDescriptor.substituteAndApproximateIntegerLiteralTypes(substitutor: NewTypeSubstitutor): CallableDescriptor {
+    val wrappedSubstitution = object : TypeSubstitution() {
+        override fun get(key: KotlinType): TypeProjection? = null
+
+        override fun prepareTopLevelType(topLevelType: KotlinType, position: Variance) =
+            substitutor.safeSubstitute(topLevelType.unwrap()).let { substitutedType ->
+                TypeApproximator(builtIns).approximateToSuperType(substitutedType, TypeApproximatorConfiguration.IntegerLiteralsTypesApproximation)
+                    ?: substitutedType
+            }
+    }
+
+    return substitute(TypeSubstitutor.create(wrappedSubstitution))
+}
+
 fun CallableDescriptor.substitute(substitutor: NewTypeSubstitutor): CallableDescriptor {
    val wrappedSubstitution = object : TypeSubstitution() {
        override fun get(key: KotlinType): TypeProjection? = null
@@ -68,18 +82,25 @@ fun CallableDescriptor.substitute(substitutor: NewTypeSubstitutor): CallableDesc
    return substitute(TypeSubstitutor.create(wrappedSubstitution))
 }

-fun CallableDescriptor.substituteAndApproximateCapturedTypes(substitutor: NewTypeSubstitutor): CallableDescriptor {
+fun <D: CallableDescriptor> D.approximateCapturedTypes(): D {
+    val approximator = TypeApproximator(builtIns)
+    var anyChanges = false
    val wrappedSubstitution = object : TypeSubstitution() {
        override fun get(key: KotlinType): TypeProjection? = null

-        override fun prepareTopLevelType(topLevelType: KotlinType, position: Variance) =
-            substitutor.safeSubstitute(topLevelType.unwrap()).let { substitutedType ->
-                TypeApproximator(builtIns).approximateToSuperType(substitutedType, TypeApproximatorConfiguration.CapturedAndIntegerLiteralsTypesApproximation)
-                    ?: substitutedType
+        override fun prepareTopLevelType(topLevelType: KotlinType, position: Variance): KotlinType {
+            val type = topLevelType.unwrap()
+            val approximatedType =
+                approximator.approximateToSuperType(type, TypeApproximatorConfiguration.CapturedAndIntegerLiteralsTypesApproximation)
+            if (approximatedType != null) {
+                anyChanges = true
            }
+            return approximatedType as? KotlinType ?: type
+        }
    }

-    return substitute(TypeSubstitutor.create(wrappedSubstitution))
+    val substitutedDescriptor = substitute(TypeSubstitutor.create(wrappedSubstitution)) as D
+    return if (anyChanges) substitutedDescriptor else this
 }

-internal fun <E> MutableList<E>.trimToSize(newSize: Int) = subList(newSize, size).clear()
+internal fun <E> MutableList<E>.trimToSize(newSize: Int) = subList(newSize, size).clear()
--- a/compiler/resolution/src/org/jetbrains/kotlin/types/TypeApproximator.kt
+++ b/compiler/resolution/src/org/jetbrains/kotlin/types/TypeApproximator.kt
@@ -21,14 +21,10 @@ import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.resolve.calls.NewCommonSuperTypeCalculator
 import org.jetbrains.kotlin.resolve.calls.components.ClassicTypeSystemContextForCS
-import org.jetbrains.kotlin.resolve.calls.inference.model.TypeVariableTypeConstructor
-import org.jetbrains.kotlin.resolve.constants.IntegerLiteralTypeConstructor
 import org.jetbrains.kotlin.types.TypeApproximatorConfiguration.IntersectionStrategy.*
-import org.jetbrains.kotlin.types.checker.NewCapturedType
 import org.jetbrains.kotlin.types.checker.NewCapturedTypeConstructor
 import org.jetbrains.kotlin.types.model.*
 import org.jetbrains.kotlin.types.model.CaptureStatus.*
-import org.jetbrains.kotlin.types.typeUtil.builtIns


 open class TypeApproximatorConfiguration {
@@ -424,6 +420,8 @@ abstract class AbstractTypeApproximator(val ctx: TypeSystemInferenceExtensionCon
            if (argument.isStarProjection()) continue

            val argumentType = argument.getType()//.unwrap()
+            val argumentTypeIsNullable = argumentType.asSimpleType()?.isMarkedNullable() ?: false
+
            val effectiveVariance = AbstractTypeChecker.effectiveVariance(parameter.getVariance(), argument.getVariance())
            when (effectiveVariance) {
                null -> {
@@ -487,7 +485,7 @@ abstract class AbstractTypeApproximator(val ctx: TypeSystemInferenceExtensionCon
                     */
                    if (argumentType.typeConstructor() is NewCapturedTypeConstructor) {
                        val subType = approximateToSubType(argumentType, conf, depth) ?: continue@loop
-                        if (!subType.isTrivialSub()) {
+                        if (!subType.isTrivialSub(argumentTypeIsNullable)) {
                            newArguments[index] = createTypeArgument(subType, TypeVariance.IN)
                            continue@loop
                        }
@@ -498,7 +496,7 @@ abstract class AbstractTypeApproximator(val ctx: TypeSystemInferenceExtensionCon
                    if (approximatedSuperType.isTrivialSuper()) {
                        val approximatedSubType =
                            approximateToSubType(argumentType, conf, depth) ?: continue@loop // seems like this is never null
-                        if (!approximatedSubType.isTrivialSub()) {
+                        if (!approximatedSubType.isTrivialSub(argumentTypeIsNullable)) {
                            newArguments[index] = createTypeArgument(approximatedSubType, TypeVariance.IN)
                            continue@loop
                        }
@@ -527,7 +525,12 @@ abstract class AbstractTypeApproximator(val ctx: TypeSystemInferenceExtensionCon
    private fun KotlinTypeMarker.isTrivialSuper() = upperBoundIfFlexible().isNullableAny()

    // Nothing or Nothing!
-    private fun KotlinTypeMarker.isTrivialSub() = lowerBoundIfFlexible().isNothing()
+    private fun KotlinTypeMarker.isTrivialSub(originalIsNullable: Boolean) = lowerBoundIfFlexible().let {
+        if (originalIsNullable)
+            it.isNothing() || it.isNullableNothing()
+        else
+            it.isNothing()
+    }
 }
 //
 //internal fun KotlinTypeMarker.typeDepth() =
--- a/compiler/testData/diagnostics/tests/callableReference/sam.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/sam.kt
@@ -1,4 +1,6 @@
 // FILE: test/GenericSam.java
+// !WITH_NEW_INFERENCE
+// NI_EXPECTED_FILE

 package test;

@@ -16,7 +18,7 @@ fun f3() = java.lang.Runnable::class
 fun f4() = java.lang.Runnable::run

 fun f5() = GenericSam::class
-fun f6() = GenericSam<*>::invoke
+fun f6() = GenericSam<*>::<!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>invoke<!>
 fun f7() = test.GenericSam::class
 fun f8() = test.GenericSam<String>::invoke

--- a/compiler/testData/diagnostics/tests/callableReference/sam.ni.txt
+++ b/compiler/testData/diagnostics/tests/callableReference/sam.ni.txt
@@ -0,0 +1,28 @@
+package
+
+public fun f1(): kotlin.reflect.KClass<java.lang.Runnable>
+public fun f2(): kotlin.reflect.KFunction1<java.lang.Runnable, kotlin.Unit>
+public fun f3(): kotlin.reflect.KClass<java.lang.Runnable>
+public fun f4(): kotlin.reflect.KFunction1<java.lang.Runnable, kotlin.Unit>
+public fun f5(): kotlin.reflect.KClass<test.GenericSam<*>>
+public fun f6(): kotlin.reflect.KFunction0<[ERROR : <ERROR FUNCTION RETURN TYPE>]>
+public fun f7(): kotlin.reflect.KClass<test.GenericSam<*>>
+public fun f8(): kotlin.reflect.KFunction2<test.GenericSam<kotlin.String>, @kotlin.ParameterName(name = "t") kotlin.String!, kotlin.Unit>
+public fun g1(): kotlin.reflect.KClass<out java.lang.Runnable>
+public fun g2(): kotlin.reflect.KFunction0<kotlin.Unit>
+public fun g3(): kotlin.reflect.KClass<out java.lang.Runnable>
+public fun g4(): kotlin.reflect.KFunction0<kotlin.Unit>
+public fun g5(): kotlin.reflect.KClass<out test.GenericSam<kotlin.String>>
+public fun g6(): kotlin.reflect.KFunction1<@kotlin.ParameterName(name = "t") kotlin.String!, kotlin.Unit>
+public fun g7(): kotlin.reflect.KClass<out test.GenericSam<kotlin.String>>
+public fun g8(): kotlin.reflect.KFunction1<@kotlin.ParameterName(name = "t") kotlin.String!, kotlin.Unit>
+
+package test {
+
+    public interface GenericSam</*0*/ T : kotlin.Any!> {
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public abstract operator fun invoke(/*0*/ t: T!): kotlin.Unit
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
--- a/compiler/testData/diagnostics/tests/collectionLiterals/collectionLiteralsWithVarargs.kt
+++ b/compiler/testData/diagnostics/tests/collectionLiterals/collectionLiteralsWithVarargs.kt
@@ -37,5 +37,5 @@ annotation class AnnArray(val a: Array<String>)
@AnnArray(<!OI;NON_VARARG_SPREAD!>*<!>["/"])
 fun testArray() {}

-@Ann1(<!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH, TYPE_MISMATCH!>[""]<!>)
+@Ann1(<!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH, TYPE_MISMATCH!>[""]<!>)
 fun testVararg() {}
--- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/elvisNotProcessed.kt
+++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/elvisNotProcessed.kt
@@ -34,6 +34,6 @@ val bbb = null ?: ( l() <!USELESS_ELVIS_RIGHT_IS_NULL!>?: null<!>)
 val bbbb = ( l() <!USELESS_ELVIS_RIGHT_IS_NULL!>?: null<!>) ?: ( l() <!USELESS_ELVIS_RIGHT_IS_NULL!>?: null<!>)

 fun f(x : Long?): Long {
-    var a = x ?: (<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>fun() {}<!> <!USELESS_ELVIS!>?: <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>fun() {}<!><!>)
+    var a = x ?: (<!TYPE_MISMATCH!>fun() {}<!> <!USELESS_ELVIS!>?: <!TYPE_MISMATCH!>fun() {}<!><!>)
    return <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!>
 }
--- a/compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt
+++ b/compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt
@@ -108,7 +108,7 @@ fun testImplicitCoercion() {
    val <!UNUSED_VARIABLE!>h<!> = if (false) <!IMPLICIT_CAST_TO_ANY!>4<!> else <!IMPLICIT_CAST_TO_ANY!>{}<!>

    bar(<!NI;TYPE_MISMATCH!>if (true) {
-        <!CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>4<!>
+        <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>4<!>
    }
        else {
        <!UNUSED_VALUE!>z =<!> 342
--- a/compiler/testData/diagnostics/tests/functionLiterals/ExpectedParametersTypesMismatch.kt
+++ b/compiler/testData/diagnostics/tests/functionLiterals/ExpectedParametersTypesMismatch.kt
@@ -26,7 +26,7 @@ fun test1() {
        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!UNUSED_ANONYMOUS_PARAMETER!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>y<!><!> -> ""
    }<!>
    foo1 <!NI;TYPE_MISMATCH!>{
-        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> <!CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>
+        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> <!CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>
    }<!>


@@ -40,6 +40,6 @@ fun test1() {
        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH, UNUSED_ANONYMOUS_PARAMETER!>x<!> -> ""
    }<!>
    foo2 <!NI;TYPE_MISMATCH!>{
-         <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> <!CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>
+         <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> <!CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>
    }<!>
 }
--- a/compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnsWithExplicitReturnType.kt
+++ b/compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnsWithExplicitReturnType.kt
@@ -1,10 +1,10 @@
 // !WITH_NEW_INFERENCE
 fun test(a: Int) {
    run<Int>f@{
-      if (a > 0) return@f <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>""<!>
+      if (a > 0) return@f <!TYPE_MISMATCH!>""<!>
      return@f 1
    }

-    run<Int>{ <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>""<!> }
+    run<Int>{ <!TYPE_MISMATCH!>""<!> }
    run<Int>{ 1 }
 }
--- a/compiler/testData/diagnostics/tests/generics/capturedTypeInInputPosition.kt
+++ b/compiler/testData/diagnostics/tests/generics/capturedTypeInInputPosition.kt
@@ -0,0 +1,20 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_EXPRESSION
+
+interface Inv<T1>
+class InvImpl<T2> : Inv<T2>
+open class OpenInv<T>
+
+class A<T> {
+    fun <F : OpenInv<T>> foo(x: F) = 1
+
+}
+class B<T> {
+    fun <F : Inv<T>> foo(x: F) = 1
+
+}
+
+fun test(a: A<out CharSequence>, b: B<out CharSequence>) {
+    a.<!OI;TYPE_INFERENCE_INCORPORATION_ERROR!>foo<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>OpenInv<!>())
+    b.<!OI;TYPE_INFERENCE_INCORPORATION_ERROR!>foo<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>InvImpl<!>())
+}
--- a/compiler/testData/diagnostics/tests/generics/capturedTypeInInputPosition.txt
+++ b/compiler/testData/diagnostics/tests/generics/capturedTypeInInputPosition.txt
@@ -0,0 +1,39 @@
+package
+
+public fun test(/*0*/ a: A<out kotlin.CharSequence>, /*1*/ b: B<out kotlin.CharSequence>): kotlin.Unit
+
+public final class A</*0*/ T> {
+    public constructor A</*0*/ T>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun </*0*/ F : OpenInv<T>> foo(/*0*/ x: F): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class B</*0*/ T> {
+    public constructor B</*0*/ T>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun </*0*/ F : Inv<T>> foo(/*0*/ x: F): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface Inv</*0*/ T1> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class InvImpl</*0*/ T2> : Inv<T2> {
+    public constructor InvImpl</*0*/ T2>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class OpenInv</*0*/ T> {
+    public constructor OpenInv</*0*/ T>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
--- a/compiler/testData/diagnostics/tests/generics/innerClasses/innerUncheckedCast.kt
+++ b/compiler/testData/diagnostics/tests/generics/innerClasses/innerUncheckedCast.kt
@@ -20,7 +20,7 @@ class Outer<E> {
        }

        if (y is Outer<*>.Inner<*>) {
-            <!DEBUG_INFO_SMARTCAST!>y<!>.prop.checkType { _<Any?>() }
+            <!OI;DEBUG_INFO_SMARTCAST!>y<!>.prop.checkType { _<Any?>() }
        }
    }

--- a/compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutSmartCast.kt
+++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutSmartCast.kt
@@ -9,7 +9,7 @@ fun foo(x: Any?, y: C<*>) {
    y.<!OI;MEMBER_PROJECTED_OUT!>bindTo<!>(<!NI;TYPE_MISMATCH!>""<!>)

    if (x is C<*>) {
-        <!DEBUG_INFO_SMARTCAST!>x<!>.<!OI;MEMBER_PROJECTED_OUT!>bindTo<!>(<!NI;TYPE_MISMATCH!>""<!>)
+        <!OI;DEBUG_INFO_SMARTCAST!>x<!>.<!OI;MEMBER_PROJECTED_OUT!>bindTo<!>(<!NI;TYPE_MISMATCH!>""<!>)
        with(<!DEBUG_INFO_SMARTCAST!>x<!>) {
            <!OI;MEMBER_PROJECTED_OUT!>bindTo<!>(<!NI;TYPE_MISMATCH!>""<!>)
        }
@@ -17,7 +17,7 @@ fun foo(x: Any?, y: C<*>) {

    with(x) {
        if (this is C<*>) {
-            <!DEBUG_INFO_IMPLICIT_RECEIVER_SMARTCAST, OI;MEMBER_PROJECTED_OUT!>bindTo<!>(<!NI;TYPE_MISMATCH!>""<!>)
+            <!OI;DEBUG_INFO_IMPLICIT_RECEIVER_SMARTCAST, OI;MEMBER_PROJECTED_OUT!>bindTo<!>(<!NI;TYPE_MISMATCH!>""<!>)
        }
    }
 }
--- a/compiler/testData/diagnostics/tests/generics/projectionsScope/starNullabilityRecursive.kt
+++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/starNullabilityRecursive.kt
@@ -5,5 +5,6 @@ interface A<T : A<T?>?> {
    fun foo(): T?
 }
 fun testA(a: A<*>) {
-    a.foo() checkType { _<A<*>?>() }
+    // in new inference here we have A<A<A<*>>>
+    a.foo() checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><A<*>?>() }
 }
--- a/compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchInLambda.kt
+++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchInLambda.kt
@@ -14,14 +14,14 @@ class A<E> {
 fun test(a: A<out CharSequence>, z: Out<CharSequence>) {
    a.foo {
        val x: String = <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> // Should be no TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS
-        <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>""<!>
+        <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>""<!>
    }
-    a.bar { <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>Out<CharSequence>()<!> }
+    a.bar { <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>Out<CharSequence>()<!> }
    a.bar { Out() }
-    a.bar { <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>z.id()<!> }
+    a.bar { <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>z.id()<!> }

    a.foo {
-        z.foobar(if (1 > 2) return@foo <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>""<!> else "")
-        <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>""<!>
+        z.foobar(if (1 > 2) return@foo <!TYPE_MISMATCH!>""<!> else "")
+        <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>""<!>
    }
 }
--- a/compiler/testData/diagnostics/tests/generics/projectionsScope/typeParameterBounds.kt
+++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/typeParameterBounds.kt
@@ -14,14 +14,14 @@ class A<T> {

 fun foo2(a: A<out CharSequence>, b: A<in CharSequence>) {
    a.<!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>foo1<!>(<!NI;TYPE_MISMATCH!>Out<CharSequence>()<!>)
-    a.foo1<<!UPPER_BOUND_VIOLATED!>Out<CharSequence><!>>(<!NI;TYPE_MISMATCH!>Out()<!>)
+    a.foo1<<!UPPER_BOUND_VIOLATED!>Out<CharSequence><!>>(Out())

    a.foo1(Out())
    a.foo1(Out<Nothing>())

-    a.<!OI;TYPE_INFERENCE_INCORPORATION_ERROR!>foo2<!>(<!NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Inv<!>()<!>)
+    a.<!OI;TYPE_INFERENCE_INCORPORATION_ERROR!>foo2<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Inv<!>())
    a.<!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>foo2<!>(<!NI;TYPE_MISMATCH!>Inv<CharSequence>()<!>)
-    a.foo2<<!UPPER_BOUND_VIOLATED!>Inv<CharSequence><!>>(<!NI;TYPE_MISMATCH!>Inv()<!>)
+    a.foo2<<!UPPER_BOUND_VIOLATED!>Inv<CharSequence><!>>(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>Inv()<!>)

    a.foo3(In())
    a.foo3(In<CharSequence>())
@@ -31,13 +31,13 @@ fun foo2(a: A<out CharSequence>, b: A<in CharSequence>) {
    b.foo1(Out<CharSequence>())
    b.foo1<Out<CharSequence>>(Out())

-    b.<!OI;TYPE_INFERENCE_INCORPORATION_ERROR!>foo2<!>(<!NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Inv<!>()<!>)
+    b.<!OI;TYPE_INFERENCE_INCORPORATION_ERROR!>foo2<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Inv<!>())
    b.<!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>foo2<!>(<!NI;TYPE_MISMATCH!>Inv<CharSequence>()<!>)
-    b.foo2<<!UPPER_BOUND_VIOLATED!>Inv<CharSequence><!>>(<!NI;TYPE_MISMATCH!>Inv()<!>)
+    b.foo2<<!UPPER_BOUND_VIOLATED!>Inv<CharSequence><!>>(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>Inv()<!>)


    b.<!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>foo3<!>(<!NI;TYPE_MISMATCH!>In<CharSequence>()<!>)
-    b.foo3<<!UPPER_BOUND_VIOLATED!>In<CharSequence><!>>(<!NI;TYPE_MISMATCH!>In()<!>)
+    b.foo3<<!UPPER_BOUND_VIOLATED!>In<CharSequence><!>>(In())

    b.foo3(In<Any?>())
    b.foo3(In())
--- a/compiler/testData/diagnostics/tests/generics/starProjections/invalid.kt
+++ b/compiler/testData/diagnostics/tests/generics/starProjections/invalid.kt
@@ -13,8 +13,8 @@ class Inv2<<!FINITE_BOUNDS_VIOLATION!>T : Inv2<in T><!>>(val x: T)
 fun main(a: A<*>, j: JavaClass<*>, i2: Inv2<*>) {
    // Probably it's too restrictive to suppose star projection type here as Any?,
    // but looks like we can refine it later
-    a.foo() checkType { _<Any?>() }
-    j.foo() checkType { _<Any?>() }
+    a.foo() checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Any?>() }
+    j.foo() checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Any?>() }
    i2.x checkType { _<Any?>() }

    j.bar(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!>, <!NI;TYPE_MISMATCH, OI;TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS!>Any()<!>)
--- a/compiler/testData/diagnostics/tests/generics/varProjection/setterNotProjectedOutAssign.kt
+++ b/compiler/testData/diagnostics/tests/generics/varProjection/setterNotProjectedOutAssign.kt
@@ -5,6 +5,6 @@ interface Tr<T> {
 }

 fun test(t: Tr<*>) {
-    <!SETTER_PROJECTED_OUT!>t.v<!> = t
+    <!SETTER_PROJECTED_OUT!>t.v<!> = <!NI;TYPE_MISMATCH!>t<!>
    t.v checkType { _<Tr<*>>() }
 }
--- a/compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutAssign.kt
+++ b/compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutAssign.kt
@@ -7,8 +7,9 @@ interface Tr<T> {
 }

 fun test(t: Tr<*>) {
-    t.v = null!!
-    <!SETTER_PROJECTED_OUT!>t.v<!> = ""
-    <!SETTER_PROJECTED_OUT!>t.v<!> = null
+    <!NI;SETTER_PROJECTED_OUT!>t.v<!> = null!!
+    <!SETTER_PROJECTED_OUT!>t.v<!> = <!NI;TYPE_MISMATCH!>""<!>
+    <!SETTER_PROJECTED_OUT!>t.v<!> = <!NI;NULL_FOR_NONNULL_TYPE!>null<!>
+
    t.v checkType { _<Any?>() }
 }
--- a/compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutAssignFromJava.kt
+++ b/compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutAssignFromJava.kt
@@ -0,0 +1,16 @@
+// !WITH_NEW_INFERENCE
+// Issue: KT-31594
+
+// FILE: Tr.java
+
+public class Tr<T> {
+    public T getV() { return null; }
+    public void setV(T value) {}
+}
+
+// FILE: main.kt
+
+fun test(t: Tr<*>) {
+    <!NI;SETTER_PROJECTED_OUT!>t.v<!> = null
+    <!NI;SETTER_PROJECTED_OUT!>t.v<!> = <!NI;TYPE_MISMATCH!>""<!>
+}
--- a/compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutAssignFromJava.txt
+++ b/compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutAssignFromJava.txt
@@ -0,0 +1,12 @@
+package
+
+public fun test(/*0*/ t: Tr<*>): kotlin.Unit
+
+public open class Tr</*0*/ T : kotlin.Any!> {
+    public constructor Tr</*0*/ T : kotlin.Any!>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun getV(): T!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open fun setV(/*0*/ value: T!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
--- a/compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutNoPlusAssign.kt
+++ b/compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutNoPlusAssign.kt
@@ -7,5 +7,5 @@ interface Tr<T> {
 fun test(t: Tr<out String>) {
    // resolved as t.v = t.v + null!!, where type of right operand is String,
    // so TYPE_MISMATCH: String is not <: of Captured(out String)
-    <!SETTER_PROJECTED_OUT!>t.v<!> += null!!
+    <!NI;TYPE_MISMATCH!><!SETTER_PROJECTED_OUT!>t.v<!> += null!!<!>
 }
--- a/compiler/testData/diagnostics/tests/inference/capturedTypes/captureForNullableTypes.kt
+++ b/compiler/testData/diagnostics/tests/inference/capturedTypes/captureForNullableTypes.kt
@@ -5,15 +5,15 @@
 fun <T: Any> bar(a: Array<T>): Array<T?> =  null!!

 fun test1(a: Array<out Int>) {
-    val r: Array<out Int?> = <!NI;TYPE_MISMATCH!><!NI;UNSUPPORTED!>bar<!>(a)<!>
-    val t = <!NI;UNSUPPORTED!>bar<!>(a)
-    <!NI;UNSUPPORTED!>t<!> checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Array<out Int?>>() }
+    val r: Array<out Int?> = bar(a)
+    val t = bar(a)
+    t checkType { _<Array<out Int?>>() }
 }

 fun <T: Any> foo(l: Array<T>): Array<Array<T?>> = null!!

 fun test2(a: Array<out Int>) {
-    val r: Array<out Array<out Int?>> = <!NI;TYPE_MISMATCH!><!NI;UNSUPPORTED!>foo<!>(a)<!>
-    val t = <!NI;UNSUPPORTED!>foo<!>(a)
-    <!NI;UNSUPPORTED!>t<!> checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Array<out Array<out Int?>>>() }
+    val r: Array<out Array<out Int?>> = foo(a)
+    val t = foo(a)
+    t checkType { _<Array<out Array<out Int?>>>() }
 }
--- a/compiler/testData/diagnostics/tests/inference/commonSystem/cstFromNullableChildAndNonParameterizedType.kt
+++ b/compiler/testData/diagnostics/tests/inference/commonSystem/cstFromNullableChildAndNonParameterizedType.kt
@@ -16,5 +16,5 @@ fun <S> test1(a: ParameterizedChild<S>?, b: Child): Base<S> = myRun {
 }

 fun <S> test2(a: S?, b: S): S = myRun {
-    <!TYPE_MISMATCH, TYPE_MISMATCH!>select(a, b)<!>
+    <!TYPE_MISMATCH!>select(a, b)<!>
 }
--- a/compiler/testData/diagnostics/tests/inference/regressions/kt2283.kt
+++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2283.kt
@@ -10,5 +10,5 @@ fun <A, B> Foo<A>.map(<!UNUSED_PARAMETER!>f<!>: (A) -> B): Foo<B> = object : Foo

 fun foo() {
    val l: Foo<String> = object : Foo<String> {}
-    val <!UNUSED_VARIABLE!>m<!>: Foo<String> = l.<!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>map { <!UNUSED_ANONYMOUS_PARAMETER!>ppp<!> -> <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> }<!>
+    val <!UNUSED_VARIABLE!>m<!>: Foo<String> = l.<!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>map { <!UNUSED_ANONYMOUS_PARAMETER!>ppp<!> -> <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> }<!>
 }
--- a/compiler/testData/diagnostics/tests/j+k/sam/enhancedSamConstructor.kt
+++ b/compiler/testData/diagnostics/tests/j+k/sam/enhancedSamConstructor.kt
@@ -18,11 +18,11 @@ public interface J2 extends J {
 fun main() {
    J <!NI;TYPE_MISMATCH!>{ <!EXPECTED_PARAMETER_TYPE_MISMATCH!>s: String<!> -> s}<!> // should be prohibited, because SAM value parameter has nullable type
    J { "" + it<!UNSAFE_CALL!>.<!>length }
-    J { <!NI;NULL_FOR_NONNULL_TYPE, NI;NULL_FOR_NONNULL_TYPE, NULL_FOR_NONNULL_TYPE!>null<!> }
-    J { <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>it?.length?.toString()<!> }
+    J { <!NI;NULL_FOR_NONNULL_TYPE, NULL_FOR_NONNULL_TYPE!>null<!> }
+    J { <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>it?.length?.toString()<!> }

    J2 <!NI;TYPE_MISMATCH!>{ <!EXPECTED_PARAMETER_TYPE_MISMATCH!>s: String<!> -> s}<!>
    J2 { "" + it<!UNSAFE_CALL!>.<!>length }
-    J2 { <!NI;NULL_FOR_NONNULL_TYPE, NI;NULL_FOR_NONNULL_TYPE, NULL_FOR_NONNULL_TYPE!>null<!> }
-    J2 { <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>it?.length?.toString()<!> }
+    J2 { <!NI;NULL_FOR_NONNULL_TYPE, NULL_FOR_NONNULL_TYPE!>null<!> }
+    J2 { <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>it?.length?.toString()<!> }
 }
--- a/compiler/testData/diagnostics/tests/j+k/samByProjectedType/genericInReturnType.kt
+++ b/compiler/testData/diagnostics/tests/j+k/samByProjectedType/genericInReturnType.kt
@@ -34,7 +34,7 @@ fun main() {
    }

    A.baz {
-        x -> <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>x.hashCode()<!>
+        x -> <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>x.hashCode()<!>
    }

    val block: (String) -> Any? = {
--- a/compiler/testData/diagnostics/tests/kt13401.kt
+++ b/compiler/testData/diagnostics/tests/kt13401.kt
@@ -14,5 +14,5 @@ class Owner<in T> {
        fun getT() = u
    }

-    fun foo(arg: Inner<*>) = arg.getT()
+    <!NI;TYPE_VARIANCE_CONFLICT!>fun foo(arg: Inner<*>)<!> = arg.getT()
 }
--- a/compiler/testData/diagnostics/tests/kt13401.ni.txt
+++ b/compiler/testData/diagnostics/tests/kt13401.ni.txt
@@ -3,7 +3,7 @@ package
 public final class Owner</*0*/ in T> {
    public constructor Owner</*0*/ in T>()
    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public final fun foo(/*0*/ arg: Owner<T>.Inner<*>): kotlin.Any?
+    public final fun foo(/*0*/ arg: Owner<T>.Inner<*>): T
    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String

@@ -26,7 +26,7 @@ public interface Rec</*0*/ T : Rec<T>> {

 public interface Super</*0*/ out U> {
    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public open fun foo(/*0*/ p: Rec<*>): Rec<*>
+    public open fun foo(/*0*/ p: Rec<*>): Rec<out Rec<out Rec<out Rec<out Rec<out Rec<out kotlin.Any?>>>>>>
    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
--- a/compiler/testData/diagnostics/tests/operatorRem/noWarningForModFromBuiltinsWhenApi1_0_after.kt
+++ b/compiler/testData/diagnostics/tests/operatorRem/noWarningForModFromBuiltinsWhenApi1_0_after.kt
@@ -29,9 +29,9 @@ class WithMod {
    <!FORBIDDEN_BINARY_MOD!>operator<!> fun mod(other: WithMod) = this

    fun test() {
-        val a = this <!OI;FORBIDDEN_BINARY_MOD_AS_REM!>%<!> <!NI;TYPE_MISMATCH!>this<!>
+        val a = this <!OI;FORBIDDEN_BINARY_MOD_AS_REM!>%<!> this
        var b = this.mod(this)
-        <!NI;TYPE_MISMATCH!>b <!OI;FORBIDDEN_BINARY_MOD_AS_REM!>%=<!> <!NI;TYPE_MISMATCH!>this<!><!>
+        <!NI;TYPE_MISMATCH!>b <!OI;FORBIDDEN_BINARY_MOD_AS_REM!>%=<!> this<!>
    }
 }

@@ -43,6 +43,6 @@ fun builtIns(b: Byte, s: Short) {
    var a = 1 % 2
    a <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE!>%=<!> 3
    1.mod(2)
-    b % <!NI;TYPE_MISMATCH!>s<!>
-    1.0 % <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>2.0<!>
+    b % s
+    1.0 % 2.0
 }
--- a/compiler/testData/diagnostics/tests/operatorRem/noWarningForModFromBuiltinsWhenApi1_0_before.kt
+++ b/compiler/testData/diagnostics/tests/operatorRem/noWarningForModFromBuiltinsWhenApi1_0_before.kt
@@ -29,9 +29,9 @@ class WithMod {
    <!DEPRECATED_BINARY_MOD!>operator<!> fun mod(other: WithMod) = this

    fun test() {
-        val a = this <!OI;DEPRECATED_BINARY_MOD_AS_REM!>%<!> <!NI;TYPE_MISMATCH!>this<!>
+        val a = this <!OI;DEPRECATED_BINARY_MOD_AS_REM!>%<!> this
        var b = this.mod(this)
-        <!NI;TYPE_MISMATCH!>b <!OI;DEPRECATED_BINARY_MOD_AS_REM!>%=<!> <!NI;TYPE_MISMATCH!>this<!><!>
+        <!NI;TYPE_MISMATCH!>b <!OI;DEPRECATED_BINARY_MOD_AS_REM!>%=<!> this<!>
    }
 }

@@ -43,6 +43,6 @@ fun builtIns(b: Byte, s: Short) {
    var a = 1 % 2
    a <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE!>%=<!> 3
    1.mod(2)
-    b % <!NI;TYPE_MISMATCH!>s<!>
-    1.0 % <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>2.0<!>
+    b % s
+    1.0 % 2.0
 }
--- a/compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/methodTypeParameter.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/methodTypeParameter.kt
@@ -11,9 +11,13 @@ public class A {
 // FILE: k.kt

 fun test() {
-    A.<!OI;TYPE_INFERENCE_INCORPORATION_ERROR!>bar<!>(<!NULL_FOR_NONNULL_TYPE!>null<!>, "")
+    A.<!OI;TYPE_INFERENCE_INCORPORATION_ERROR!>bar<!>(<!OI;NULL_FOR_NONNULL_TYPE!>null<!>, "")

    A.bar<String>(<!NULL_FOR_NONNULL_TYPE!>null<!>, "")
-    A.bar<String?>(<!NULL_FOR_NONNULL_TYPE!>null<!>, "")
-    A.<!OI;TYPE_INFERENCE_INCORPORATION_ERROR!>bar<!>(<!NULL_FOR_NONNULL_TYPE!>null<!>, A.platformString())
+    A.bar<String?>(<!OI;NULL_FOR_NONNULL_TYPE!>null<!>, "")
+    A.<!OI;TYPE_INFERENCE_INCORPORATION_ERROR!>bar<!>(<!OI;NULL_FOR_NONNULL_TYPE!>null<!>, A.platformString())
+
+    val x: String? = null
+    A.<!OI;TYPE_INFERENCE_INCORPORATION_ERROR!>bar<!>(<!OI;TYPE_MISMATCH!>x<!>, "")
+    A.<!OI;TYPE_INFERENCE_INCORPORATION_ERROR!>bar<!>(<!OI;NULL_FOR_NONNULL_TYPE!>null<!>, "")
 }
--- a/compiler/testData/diagnostics/tests/regressions/correctResultSubstitutorForErrorCandidate.kt
+++ b/compiler/testData/diagnostics/tests/regressions/correctResultSubstitutorForErrorCandidate.kt
@@ -2,7 +2,7 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER

 fun test(a: Int, b: Boolean) {
-    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>(a.<!OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>foo<!>(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>b<!>))
+    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>(a.<!OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>foo<!>(<!NI;TYPE_MISMATCH, TYPE_MISMATCH!>b<!>))
 }

 fun <T, R> T.foo(l: (T) -> R): R = TODO()
--- a/compiler/testData/diagnostics/tests/resolve/implicitAndExplicitThis.kt
+++ b/compiler/testData/diagnostics/tests/resolve/implicitAndExplicitThis.kt
@@ -0,0 +1,29 @@
+// !LANGUAGE: -NewInference
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// !WITH_NEW_INFERENCE
+
+abstract class A<Context : A<Context>> {
+    val x: X = TODO()
+
+    fun getGetX(): X = TODO()
+}
+
+class B<D> : A<B<D>>()
+
+class C : A<C>()
+
+interface X {
+    fun foo()
+}
+
+fun B<*>.checkValueArguments() {
+    this.x.foo()
+    x.foo()
+
+    this.getGetX().foo()
+    getGetX().foo()
+}
+
+fun C.test() {
+    x.foo()
+}
--- a/compiler/testData/diagnostics/tests/resolve/implicitAndExplicitThis.txt
+++ b/compiler/testData/diagnostics/tests/resolve/implicitAndExplicitThis.txt
@@ -0,0 +1,38 @@
+package
+
+public fun B<*>.checkValueArguments(): kotlin.Unit
+public fun C.test(): kotlin.Unit
+
+public abstract class A</*0*/ Context : A<Context>> {
+    public constructor A</*0*/ Context : A<Context>>()
+    public final val x: X
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun getGetX(): X
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class B</*0*/ D> : A<B<D>> {
+    public constructor B</*0*/ D>()
+    public final override /*1*/ /*fake_override*/ val x: X
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final override /*1*/ /*fake_override*/ fun getGetX(): X
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class C : A<C> {
+    public constructor C()
+    public final override /*1*/ /*fake_override*/ val x: X
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final override /*1*/ /*fake_override*/ fun getGetX(): X
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface X {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
--- a/compiler/testData/diagnostics/tests/resolve/specialConstructions/constantsInIf.kt
+++ b/compiler/testData/diagnostics/tests/resolve/specialConstructions/constantsInIf.kt
@@ -8,7 +8,7 @@ fun test() {
        <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!>
    }<!>)

-    bar(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!><!CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> ?: <!CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!><!>)
+    bar(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!><!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> ?: <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!><!>)
 }

 fun bar(s: String) = s
--- a/compiler/testData/diagnostics/tests/samConversions/kt25290.kt
+++ b/compiler/testData/diagnostics/tests/samConversions/kt25290.kt
@@ -0,0 +1,29 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
+
+// FILE: JavaFace.java
+public interface JavaFace<T> {
+    void singleMethod();
+}
+
+// FILE: JavaFaceUser.java
+public class JavaFaceUser<T> {
+    public <X> void use1(JavaFace<X> face) {}
+    public void use2(JavaFace<T> face) {}
+}
+
+// FILE: KotlinSamUser.kt
+fun JavaFaceUser<out Any>.useOut() {
+    use1<Any> {}
+    use2 {}
+}
+
+fun JavaFaceUser<in Any>.useIn() {
+    use1<Any> {}
+    use2 {}
+}
+
+fun JavaFaceUser<Any>.useInv() {
+    use1<Any> {}
+    use2 {}
+}
--- a/compiler/testData/diagnostics/tests/samConversions/kt25290.txt
+++ b/compiler/testData/diagnostics/tests/samConversions/kt25290.txt
@@ -0,0 +1,21 @@
+package
+
+public fun JavaFaceUser<in kotlin.Any>.useIn(): kotlin.Unit
+public fun JavaFaceUser<kotlin.Any>.useInv(): kotlin.Unit
+public fun JavaFaceUser<out kotlin.Any>.useOut(): kotlin.Unit
+
+public interface JavaFace</*0*/ T : kotlin.Any!> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public abstract fun singleMethod(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class JavaFaceUser</*0*/ T : kotlin.Any!> {
+    public constructor JavaFaceUser</*0*/ T : kotlin.Any!>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    public open fun </*0*/ X : kotlin.Any!> use1(/*0*/ face: JavaFace<X!>!): kotlin.Unit
+    public open fun use2(/*0*/ face: JavaFace<T!>!): kotlin.Unit
+}
--- a/compiler/testData/diagnostics/tests/substitutions/starProjections.kt
+++ b/compiler/testData/diagnostics/tests/substitutions/starProjections.kt
@@ -17,9 +17,9 @@ interface B<R, T: B<List<R>, <!UPPER_BOUND_VIOLATED!>T<!>>> {
 }

 fun testB(b: B<*, *>) {
-    <!OI;TYPE_MISMATCH!>b<!>.<!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>r<!>().<!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>checkType<!> { <!NI;UNRESOLVED_REFERENCE!>_<!><Any?>() }
-    <!OI;TYPE_MISMATCH!>b<!>.<!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>t<!>().<!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>checkType<!> { <!NI;UNRESOLVED_REFERENCE!>_<!><B<List<*>, *>>() }
+    <!OI;TYPE_MISMATCH!>b<!>.r().checkType { _<Any?>() }
+    <!OI;TYPE_MISMATCH!>b<!>.t().checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><B<List<*>, *>>() }

-    <!OI;TYPE_MISMATCH!><!OI;TYPE_MISMATCH!>b<!>.<!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>t<!>()<!>.<!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>r<!>().<!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>size<!>
+    <!OI;TYPE_MISMATCH!><!OI;TYPE_MISMATCH!>b<!>.t()<!>.r().size
 }

--- a/compiler/testData/diagnostics/tests/varargs/noAssigningArraysToVarargsFeature.kt
+++ b/compiler/testData/diagnostics/tests/varargs/noAssigningArraysToVarargsFeature.kt
@@ -21,21 +21,21 @@ fun test2() {}
@Ann(s = <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>arrayOf(1)<!>)
 fun test3() {}

-@Ann(s = <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH, TYPE_MISMATCH!>["value"]<!>)
+@Ann(s = <!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH, TYPE_MISMATCH!>["value"]<!>)
 fun test5() {}

@JavaAnn(value = <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>arrayOf("value")<!>)
 fun jTest1() {}

-@JavaAnn(value = <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH, TYPE_MISMATCH!>["value"]<!>)
+@JavaAnn(value = <!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH, TYPE_MISMATCH!>["value"]<!>)
 fun jTest2() {}

-@JavaAnn(value = <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH, TYPE_MISMATCH!>["value"]<!>, path = ["path"])
+@JavaAnn(value = <!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH, TYPE_MISMATCH!>["value"]<!>, path = ["path"])
 fun jTest3() {}

 annotation class IntAnn(vararg val i: Int)

-@IntAnn(i = <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH, TYPE_MISMATCH!>[1, 2]<!>)
+@IntAnn(i = <!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH, TYPE_MISMATCH!>[1, 2]<!>)
 fun foo1() {}

@IntAnn(i = <!TYPE_MISMATCH!>intArrayOf(0)<!>)
--- a/compiler/tests-common/tests/org/jetbrains/kotlin/tests/di/injection.kt
+++ b/compiler/tests-common/tests/org/jetbrains/kotlin/tests/di/injection.kt
@@ -28,6 +28,7 @@ import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformAnalyzerServices
+import org.jetbrains.kotlin.types.SubstitutingScopeProviderImpl
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices
 import org.jetbrains.kotlin.types.expressions.FakeCallResolver

@@ -40,6 +41,7 @@ fun createContainerForTests(project: Project, module: ModuleDescriptor): Contain
            BindingTraceContext(),
            LanguageVersionSettingsImpl.DEFAULT
        )
+        useImpl<SubstitutingScopeProviderImpl>()
        useImpl<AnnotationResolverImpl>()
    })
 }
--- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/38.kt
+++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/38.kt
@@ -83,7 +83,7 @@ fun case_5(x: Any?) {
            <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!><!DEBUG_INFO_EXPRESSION_TYPE("ClassWithThreeTypeParameters<*, *, *> & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>x<!>.x<!>
            <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!><!DEBUG_INFO_SMARTCAST!>x<!>.y<!>
            <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!><!DEBUG_INFO_SMARTCAST!>x<!>.z<!>
-            <!DEBUG_INFO_EXPRESSION_TYPE("InterfaceWithTwoTypeParameters<*, *> & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>x<!>.ip2test()
+            <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithThreeTypeParameters<*, *, *> & InterfaceWithTwoTypeParameters<*, *> & kotlin.Any & kotlin.Any?")!>x<!>.ip2test()
            <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithThreeTypeParameters<*, *, *> & InterfaceWithTwoTypeParameters<*, *> & kotlin.Any & kotlin.Any?")!>x<!>
            <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!><!DEBUG_INFO_EXPRESSION_TYPE("ClassWithThreeTypeParameters<*, *, *> & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>x<!>.x<!>
        }
--- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/50.kt
+++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/50.kt
@@ -14,18 +14,18 @@
 // TESTCASE NUMBER: 1
 fun Any.case_1() {
    if (this is Inv<*>) {
-        <!DEBUG_INFO_EXPRESSION_TYPE("Inv<*>"), DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any"), DEBUG_INFO_SMARTCAST!>this<!>.test()
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!><!DEBUG_INFO_EXPRESSION_TYPE("Inv<*>"), DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any"), DEBUG_INFO_SMARTCAST!>this<!>.prop_4<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!><!DEBUG_INFO_EXPRESSION_TYPE("Inv<*>"), DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any"), DEBUG_INFO_SMARTCAST!>this<!>.prop_4<!>.inv()
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int"), DEBUG_INFO_IMPLICIT_RECEIVER_SMARTCAST!>prop_4<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int"), DEBUG_INFO_IMPLICIT_RECEIVER_SMARTCAST!>prop_4<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("Inv<*> & kotlin.Any"), DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any")!>this<!>.test()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!><!DEBUG_INFO_EXPRESSION_TYPE("Inv<*> & kotlin.Any"), DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any")!>this<!>.prop_4<!>
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!><!DEBUG_INFO_EXPRESSION_TYPE("Inv<*> & kotlin.Any"), DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any")!>this<!>.prop_4<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!>prop_4<!>
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!>prop_4<!>.inv()
    }
 }

 // TESTCASE NUMBER: 2
 fun Any.case_2() {
    if (this is ClassWithSixTypeParameters<*, *, *, *, *, *>) {
-        <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithSixTypeParameters<*, *, *, *, *, *>"), DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any"), DEBUG_INFO_SMARTCAST!>this<!>.test()
+        <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithSixTypeParameters<*, *, *, *, *, *> & kotlin.Any"), DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any")!>this<!>.test()
        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!><!DEBUG_INFO_EXPRESSION_TYPE("ClassWithSixTypeParameters<*, *, *, *, *, *>"), DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any"), DEBUG_INFO_SMARTCAST!>this<!>.x<!>
        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!><!DEBUG_INFO_EXPRESSION_TYPE("ClassWithSixTypeParameters<*, *, *, *, *, *>"), DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any"), DEBUG_INFO_SMARTCAST!>this<!>.y<!>
        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?"), DEBUG_INFO_IMPLICIT_RECEIVER_SMARTCAST!>x<!>
@@ -36,18 +36,18 @@ fun Any.case_2() {
 // TESTCASE NUMBER: 3
 fun <T> T.case_3() {
    if (this is Inv<*>) {
-        <!DEBUG_INFO_EXPRESSION_TYPE("Inv<*>"), DEBUG_INFO_EXPRESSION_TYPE("T"), DEBUG_INFO_SMARTCAST!>this<!>.test()
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!><!DEBUG_INFO_EXPRESSION_TYPE("Inv<*>"), DEBUG_INFO_EXPRESSION_TYPE("T"), DEBUG_INFO_SMARTCAST!>this<!>.prop_4<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!><!DEBUG_INFO_EXPRESSION_TYPE("Inv<*>"), DEBUG_INFO_EXPRESSION_TYPE("T"), DEBUG_INFO_SMARTCAST!>this<!>.prop_4<!>.inv()
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int"), DEBUG_INFO_IMPLICIT_RECEIVER_SMARTCAST!>prop_4<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int"), DEBUG_INFO_IMPLICIT_RECEIVER_SMARTCAST!>prop_4<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("Inv<*> & T & T!!"), DEBUG_INFO_EXPRESSION_TYPE("T")!>this<!>.test()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!><!DEBUG_INFO_EXPRESSION_TYPE("Inv<*> & T & T!!"), DEBUG_INFO_EXPRESSION_TYPE("T")!>this<!>.prop_4<!>
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!><!DEBUG_INFO_EXPRESSION_TYPE("Inv<*> & T & T!!"), DEBUG_INFO_EXPRESSION_TYPE("T")!>this<!>.prop_4<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!>prop_4<!>
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!>prop_4<!>.inv()
    }
 }

 // TESTCASE NUMBER: 4
 fun <T> T?.case_4() {
    if (this is ClassWithSixTypeParameters<*, *, *, *, *, *>) {
-        <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithSixTypeParameters<*, *, *, *, *, *>"), DEBUG_INFO_EXPRESSION_TYPE("T?"), DEBUG_INFO_SMARTCAST!>this<!>.test()
+        <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithSixTypeParameters<*, *, *, *, *, *> & T!! & T?"), DEBUG_INFO_EXPRESSION_TYPE("T?")!>this<!>.test()
        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!><!DEBUG_INFO_EXPRESSION_TYPE("ClassWithSixTypeParameters<*, *, *, *, *, *>"), DEBUG_INFO_EXPRESSION_TYPE("T?"), DEBUG_INFO_SMARTCAST!>this<!>.x<!>
        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!><!DEBUG_INFO_EXPRESSION_TYPE("ClassWithSixTypeParameters<*, *, *, *, *, *>"), DEBUG_INFO_EXPRESSION_TYPE("T?"), DEBUG_INFO_SMARTCAST!>this<!>.y<!>
        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?"), DEBUG_INFO_IMPLICIT_RECEIVER_SMARTCAST!>x<!>
--- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/9.kt
+++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/9.kt
@@ -36,26 +36,26 @@ fun case_2(a: Out<<!REDUNDANT_PROJECTION!>out<!> Out<<!REDUNDANT_PROJECTION!>out
    if (a != null) {
        val b = <!DEBUG_INFO_EXPRESSION_TYPE("Out<out Out<out Out<out Out<out Out<out Out<out kotlin.Int?>?>?>?>?>?> & Out<out Out<out Out<out Out<out Out<out Out<out kotlin.Int?>?>?>?>?>?>?")!>a<!>.get()
        if (b != null) {
-            val c = <!DEBUG_INFO_EXPRESSION_TYPE("Out<Out<Out<Out<Out<kotlin.Int?>?>?>?>?> & Out<Out<Out<Out<Out<kotlin.Int?>?>?>?>?>?"), DEBUG_INFO_SMARTCAST!>b<!>.get()
+            val c = <!DEBUG_INFO_EXPRESSION_TYPE("Out<Out<Out<Out<Out<kotlin.Any?>?>?>?>?> & Out<Out<Out<Out<Out<kotlin.Any?>?>?>?>?>?"), DEBUG_INFO_SMARTCAST!>b<!>.get()
            if (c != null) {
-                val d = <!DEBUG_INFO_EXPRESSION_TYPE("Out<Out<Out<Out<kotlin.Int?>?>?>?> & Out<Out<Out<Out<kotlin.Int?>?>?>?>?"), DEBUG_INFO_SMARTCAST!>c<!>.get()
+                val d = <!DEBUG_INFO_EXPRESSION_TYPE("Out<Out<Out<Out<kotlin.Any?>?>?>?> & Out<Out<Out<Out<kotlin.Any?>?>?>?>?"), DEBUG_INFO_SMARTCAST!>c<!>.get()
                if (d != null) {
-                    val e = <!DEBUG_INFO_EXPRESSION_TYPE("Out<Out<Out<kotlin.Int?>?>?> & Out<Out<Out<kotlin.Int?>?>?>?"), DEBUG_INFO_SMARTCAST!>d<!>.get()
+                    val e = <!DEBUG_INFO_EXPRESSION_TYPE("Out<Out<Out<kotlin.Any?>?>?> & Out<Out<Out<kotlin.Any?>?>?>?"), DEBUG_INFO_SMARTCAST!>d<!>.get()
                    if (e != null) {
-                        val f = <!DEBUG_INFO_EXPRESSION_TYPE("Out<Out<kotlin.Int?>?> & Out<Out<kotlin.Int?>?>?"), DEBUG_INFO_SMARTCAST!>e<!>.get()
+                        val f = <!DEBUG_INFO_EXPRESSION_TYPE("Out<Out<kotlin.Any?>?> & Out<Out<kotlin.Any?>?>?"), DEBUG_INFO_SMARTCAST!>e<!>.get()
                        if (f != null) {
-                            val g = <!DEBUG_INFO_EXPRESSION_TYPE("Out<kotlin.Int?> & Out<kotlin.Int?>?"), DEBUG_INFO_SMARTCAST!>f<!>.get()
+                            val g = <!DEBUG_INFO_EXPRESSION_TYPE("Out<kotlin.Any?> & Out<kotlin.Any?>?"), DEBUG_INFO_SMARTCAST!>f<!>.get()
                            if (g != null) {
-                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int & kotlin.Int?")!>g<!>
-                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int & kotlin.Int?"), DEBUG_INFO_SMARTCAST!>g<!>.equals(null)
-                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int & kotlin.Int?"), DEBUG_INFO_SMARTCAST!>g<!>.propT
-                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int & kotlin.Int?"), DEBUG_INFO_SMARTCAST!>g<!>.propAny
-                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int & kotlin.Int?")!>g<!>.propNullableT
-                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int & kotlin.Int?")!>g<!>.propNullableAny
-                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int & kotlin.Int?"), DEBUG_INFO_SMARTCAST!>g<!>.funT()
-                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int & kotlin.Int?"), DEBUG_INFO_SMARTCAST!>g<!>.funAny()
-                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int & kotlin.Int?")!>g<!>.funNullableT()
-                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int & kotlin.Int?")!>g<!>.funNullableAny()
+                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any?")!>g<!>
+                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>g<!>.equals(null)
+                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>g<!>.propT
+                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>g<!>.propAny
+                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any?")!>g<!>.propNullableT
+                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any?")!>g<!>.propNullableAny
+                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>g<!>.funT()
+                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>g<!>.funAny()
+                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any?")!>g<!>.funNullableT()
+                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any?")!>g<!>.funNullableAny()
                            }
                        }
                    }
@@ -392,26 +392,26 @@ fun case_17(a: Inv<out Out<Out<Out<Out<Out<Int?>?>?>?>?>?>?) {
    if (a != null) {
        val b = <!DEBUG_INFO_EXPRESSION_TYPE("Inv<out Out<Out<Out<Out<Out<kotlin.Int?>?>?>?>?>?> & Inv<out Out<Out<Out<Out<Out<kotlin.Int?>?>?>?>?>?>?")!>a<!>.get()
        if (b != null) {
-            val c = <!DEBUG_INFO_EXPRESSION_TYPE("Out<Out<Out<Out<Out<kotlin.Int?>?>?>?>?> & Out<Out<Out<Out<Out<kotlin.Int?>?>?>?>?>?"), DEBUG_INFO_SMARTCAST!>b<!>.get()
+            val c = <!DEBUG_INFO_EXPRESSION_TYPE("Out<Out<Out<Out<Out<kotlin.Any?>?>?>?>?> & Out<Out<Out<Out<Out<kotlin.Any?>?>?>?>?>?"), DEBUG_INFO_SMARTCAST!>b<!>.get()
            if (c != null) {
-                val d = <!DEBUG_INFO_EXPRESSION_TYPE("Out<Out<Out<Out<kotlin.Int?>?>?>?> & Out<Out<Out<Out<kotlin.Int?>?>?>?>?"), DEBUG_INFO_SMARTCAST!>c<!>.get()
+                val d = <!DEBUG_INFO_EXPRESSION_TYPE("Out<Out<Out<Out<kotlin.Any?>?>?>?> & Out<Out<Out<Out<kotlin.Any?>?>?>?>?"), DEBUG_INFO_SMARTCAST!>c<!>.get()
                if (d != null) {
-                    val e = <!DEBUG_INFO_EXPRESSION_TYPE("Out<Out<Out<kotlin.Int?>?>?> & Out<Out<Out<kotlin.Int?>?>?>?"), DEBUG_INFO_SMARTCAST!>d<!>.get()
+                    val e = <!DEBUG_INFO_EXPRESSION_TYPE("Out<Out<Out<kotlin.Any?>?>?> & Out<Out<Out<kotlin.Any?>?>?>?"), DEBUG_INFO_SMARTCAST!>d<!>.get()
                    if (e != null) {
-                        val f = <!DEBUG_INFO_EXPRESSION_TYPE("Out<Out<kotlin.Int?>?> & Out<Out<kotlin.Int?>?>?"), DEBUG_INFO_SMARTCAST!>e<!>.get()
+                        val f = <!DEBUG_INFO_EXPRESSION_TYPE("Out<Out<kotlin.Any?>?> & Out<Out<kotlin.Any?>?>?"), DEBUG_INFO_SMARTCAST!>e<!>.get()
                        if (f != null) {
-                            val g = <!DEBUG_INFO_EXPRESSION_TYPE("Out<kotlin.Int?> & Out<kotlin.Int?>?"), DEBUG_INFO_SMARTCAST!>f<!>.get()
+                            val g = <!DEBUG_INFO_EXPRESSION_TYPE("Out<kotlin.Any?> & Out<kotlin.Any?>?"), DEBUG_INFO_SMARTCAST!>f<!>.get()
                            if (g != null) {
-                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int & kotlin.Int?")!>g<!>
-                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int & kotlin.Int?"), DEBUG_INFO_SMARTCAST!>g<!>.equals(null)
-                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int & kotlin.Int?"), DEBUG_INFO_SMARTCAST!>g<!>.propT
-                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int & kotlin.Int?"), DEBUG_INFO_SMARTCAST!>g<!>.propAny
-                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int & kotlin.Int?")!>g<!>.propNullableT
-                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int & kotlin.Int?")!>g<!>.propNullableAny
-                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int & kotlin.Int?"), DEBUG_INFO_SMARTCAST!>g<!>.funT()
-                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int & kotlin.Int?"), DEBUG_INFO_SMARTCAST!>g<!>.funAny()
-                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int & kotlin.Int?")!>g<!>.funNullableT()
-                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int & kotlin.Int?")!>g<!>.funNullableAny()
+                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any?")!>g<!>
+                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>g<!>.equals(null)
+                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>g<!>.propT
+                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>g<!>.propAny
+                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any?")!>g<!>.propNullableT
+                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any?")!>g<!>.propNullableAny
+                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>g<!>.funT()
+                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>g<!>.funAny()
+                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any?")!>g<!>.funNullableT()
+                                <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any?")!>g<!>.funNullableAny()
                            }
                        }
                    }
--- a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java
+++ b/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java
@@ -8093,6 +8093,11 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTest {
                runTest("compiler/testData/diagnostics/tests/generics/argumentsForT.kt");
            }

+            @TestMetadata("capturedTypeInInputPosition.kt")
+            public void testCapturedTypeInInputPosition() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/generics/capturedTypeInInputPosition.kt");
+            }
+
            @TestMetadata("commonSupertypeContravariant.kt")
            public void testCommonSupertypeContravariant() throws Exception {
                runTest("compiler/testData/diagnostics/tests/generics/commonSupertypeContravariant.kt");
@@ -8932,6 +8937,11 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTest {
                    runTest("compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutAssign.kt");
                }

+                @TestMetadata("setterProjectedOutAssignFromJava.kt")
+                public void testSetterProjectedOutAssignFromJava() throws Exception {
+                    runTest("compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutAssignFromJava.kt");
+                }
+
                @TestMetadata("setterProjectedOutNoPlusAssign.kt")
                public void testSetterProjectedOutNoPlusAssign() throws Exception {
                    runTest("compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutNoPlusAssign.kt");
@@ -17385,6 +17395,11 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTest {
                runTest("compiler/testData/diagnostics/tests/resolve/HiddenDeclarations.kt");
            }

+            @TestMetadata("implicitAndExplicitThis.kt")
+            public void testImplicitAndExplicitThis() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/resolve/implicitAndExplicitThis.kt");
+            }
+
            @TestMetadata("implicitReceiverProperty.kt")
            public void testImplicitReceiverProperty() throws Exception {
                runTest("compiler/testData/diagnostics/tests/resolve/implicitReceiverProperty.kt");
@@ -18102,6 +18117,11 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTest {
                runTest("compiler/testData/diagnostics/tests/samConversions/GenericSubstitutionKT.kt");
            }

+            @TestMetadata("kt25290.kt")
+            public void testKt25290() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/samConversions/kt25290.kt");
+            }
+
            @TestMetadata("OverloadPriority.kt")
            public void testOverloadPriority() throws Exception {
                runTest("compiler/testData/diagnostics/tests/samConversions/OverloadPriority.kt");
--- a/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java
+++ b/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java
@@ -8088,6 +8088,11 @@ public class DiagnosticsUsingJavacTestGenerated extends AbstractDiagnosticsUsing
                runTest("compiler/testData/diagnostics/tests/generics/argumentsForT.kt");
            }

+            @TestMetadata("capturedTypeInInputPosition.kt")
+            public void testCapturedTypeInInputPosition() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/generics/capturedTypeInInputPosition.kt");
+            }
+
            @TestMetadata("commonSupertypeContravariant.kt")
            public void testCommonSupertypeContravariant() throws Exception {
                runTest("compiler/testData/diagnostics/tests/generics/commonSupertypeContravariant.kt");
@@ -8927,6 +8932,11 @@ public class DiagnosticsUsingJavacTestGenerated extends AbstractDiagnosticsUsing
                    runTest("compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutAssign.kt");
                }

+                @TestMetadata("setterProjectedOutAssignFromJava.kt")
+                public void testSetterProjectedOutAssignFromJava() throws Exception {
+                    runTest("compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutAssignFromJava.kt");
+                }
+
                @TestMetadata("setterProjectedOutNoPlusAssign.kt")
                public void testSetterProjectedOutNoPlusAssign() throws Exception {
                    runTest("compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutNoPlusAssign.kt");
@@ -17375,6 +17385,11 @@ public class DiagnosticsUsingJavacTestGenerated extends AbstractDiagnosticsUsing
                runTest("compiler/testData/diagnostics/tests/resolve/HiddenDeclarations.kt");
            }

+            @TestMetadata("implicitAndExplicitThis.kt")
+            public void testImplicitAndExplicitThis() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/resolve/implicitAndExplicitThis.kt");
+            }
+
            @TestMetadata("implicitReceiverProperty.kt")
            public void testImplicitReceiverProperty() throws Exception {
                runTest("compiler/testData/diagnostics/tests/resolve/implicitReceiverProperty.kt");
@@ -18092,6 +18107,11 @@ public class DiagnosticsUsingJavacTestGenerated extends AbstractDiagnosticsUsing
                runTest("compiler/testData/diagnostics/tests/samConversions/GenericSubstitutionKT.kt");
            }

+            @TestMetadata("kt25290.kt")
+            public void testKt25290() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/samConversions/kt25290.kt");
+            }
+
            @TestMetadata("OverloadPriority.kt")
            public void testOverloadPriority() throws Exception {
                runTest("compiler/testData/diagnostics/tests/samConversions/OverloadPriority.kt");
--- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/context.kt
+++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/context.kt
@@ -42,6 +42,7 @@ import org.jetbrains.kotlin.load.kotlin.KotlinClassFinder
 import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
 import org.jetbrains.kotlin.serialization.deserialization.ErrorReporter
 import org.jetbrains.kotlin.storage.StorageManager
+import org.jetbrains.kotlin.types.SubstitutingScopeProvider
 import java.util.*

 class JavaResolverComponents(
@@ -64,7 +65,8 @@ class JavaResolverComponents(
    val annotationTypeQualifierResolver: AnnotationTypeQualifierResolver,
    val signatureEnhancement: SignatureEnhancement,
    val javaClassesTracker: JavaClassesTracker,
-    val settings: JavaResolverSettings
+    val settings: JavaResolverSettings,
+    val substitutingScopeProvider: SubstitutingScopeProvider
 ) {
    fun replace(
        javaResolverCache: JavaResolverCache = this.javaResolverCache
@@ -73,7 +75,7 @@ class JavaResolverComponents(
        signaturePropagator, errorReporter, javaResolverCache,
        javaPropertyInitializerEvaluator, samConversionResolver, sourceElementFactory,
        moduleClassResolver, packagePartProvider, supertypeLoopChecker, lookupTracker, module, reflectionTypes,
-        annotationTypeQualifierResolver, signatureEnhancement, javaClassesTracker, settings
+        annotationTypeQualifierResolver, signatureEnhancement, javaClassesTracker, settings, substitutingScopeProvider
    )
 }

--- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt
+++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt
@@ -46,7 +46,8 @@ class LazyJavaClassDescriptor(
 ) : ClassDescriptorBase(
    outerContext.storageManager, containingDeclaration, jClass.name,
    outerContext.components.sourceElementFactory.source(jClass),
-    /* isExternal = */ false
+    /* isExternal = */ false,
+    outerContext.components.substitutingScopeProvider
 ), JavaClassDescriptor {

    companion object {
--- a/core/descriptors.runtime/src/kotlin/reflect/jvm/internal/components/RuntimeModuleData.kt
+++ b/core/descriptors.runtime/src/kotlin/reflect/jvm/internal/components/RuntimeModuleData.kt
@@ -43,6 +43,7 @@ import org.jetbrains.kotlin.serialization.deserialization.ContractDeserializer
 import org.jetbrains.kotlin.serialization.deserialization.DeserializationComponents
 import org.jetbrains.kotlin.serialization.deserialization.DeserializationConfiguration
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
+import org.jetbrains.kotlin.types.SubstitutingScopeProvider
 import org.jetbrains.kotlin.utils.Jsr305State

 class RuntimeModuleData private constructor(
@@ -70,7 +71,7 @@ class RuntimeModuleData private constructor(
                singleModuleClassResolver, PackagePartProvider.Empty, SupertypeLoopChecker.EMPTY, LookupTracker.DO_NOTHING, module,
                ReflectionTypes(module, notFoundClasses), annotationTypeQualifierResolver,
                SignatureEnhancement(annotationTypeQualifierResolver, Jsr305State.DISABLED),
-                JavaClassesTracker.Default, JavaResolverSettings.Default
+                JavaClassesTracker.Default, JavaResolverSettings.Default, SubstitutingScopeProvider.DEFAULT
            )

            val lazyJavaPackageFragmentProvider = LazyJavaPackageFragmentProvider(javaResolverComponents)
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractClassDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractClassDescriptor.java
@@ -24,7 +24,6 @@ import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.scopes.InnerClassesScopeWrapper;
 import org.jetbrains.kotlin.resolve.scopes.MemberScope;
-import org.jetbrains.kotlin.resolve.scopes.SubstitutingScope;
 import org.jetbrains.kotlin.storage.NotNullLazyValue;
 import org.jetbrains.kotlin.storage.StorageManager;
 import org.jetbrains.kotlin.types.*;
@@ -34,10 +33,11 @@ import java.util.List;
 public abstract class AbstractClassDescriptor implements ClassDescriptor {
    private final Name name;
    protected final NotNullLazyValue<SimpleType> defaultType;
+    protected final SubstitutingScopeProvider substitutingScopeProvider;
    private final NotNullLazyValue<MemberScope> unsubstitutedInnerClassesScope;
    private final NotNullLazyValue<ReceiverParameterDescriptor> thisAsReceiverParameter;

-    public AbstractClassDescriptor(@NotNull StorageManager storageManager, @NotNull Name name) {
+    public AbstractClassDescriptor(@NotNull StorageManager storageManager, @NotNull Name name, @NotNull SubstitutingScopeProvider substitutingScopeProvider) {
        this.name = name;
        this.defaultType = storageManager.createLazyValue(new Function0<SimpleType>() {
            @Override
@@ -57,6 +57,11 @@ public abstract class AbstractClassDescriptor implements ClassDescriptor {
                return new LazyClassReceiverParameterDescriptor(AbstractClassDescriptor.this);
            }
        });
+        this.substitutingScopeProvider = substitutingScopeProvider;
+    }
+
+    public AbstractClassDescriptor(@NotNull StorageManager storageManager, @NotNull Name name) {
+        this(storageManager, name, SubstitutingScopeProvider.Companion.getDEFAULT());
    }

    @NotNull
@@ -92,7 +97,7 @@ public abstract class AbstractClassDescriptor implements ClassDescriptor {
        if (typeArguments.isEmpty()) return getUnsubstitutedMemberScope();

        TypeSubstitutor substitutor = TypeConstructorSubstitution.create(getTypeConstructor(), typeArguments).buildSubstitutor();
-        return new SubstitutingScope(getUnsubstitutedMemberScope(), substitutor);
+        return substitutingScopeProvider.createSubstitutingScope(getUnsubstitutedMemberScope(), substitutor);
    }

    @NotNull
@@ -101,7 +106,7 @@ public abstract class AbstractClassDescriptor implements ClassDescriptor {
        if (typeSubstitution.isEmpty()) return getUnsubstitutedMemberScope();

        TypeSubstitutor substitutor = TypeSubstitutor.create(typeSubstitution);
-        return new SubstitutingScope(getUnsubstitutedMemberScope(), substitutor);
+        return substitutingScopeProvider.createSubstitutingScope(getUnsubstitutedMemberScope(), substitutor);
    }

    @NotNull
@@ -110,7 +115,7 @@ public abstract class AbstractClassDescriptor implements ClassDescriptor {
        if (substitutor.isEmpty()) {
            return this;
        }
-        return new LazySubstitutingClassDescriptor(this, substitutor);
+        return new LazySubstitutingClassDescriptor(this, substitutor, substitutingScopeProvider);
    }

    @NotNull
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ClassDescriptorBase.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ClassDescriptorBase.java
@@ -21,6 +21,7 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.descriptors.SourceElement;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.storage.StorageManager;
+import org.jetbrains.kotlin.types.SubstitutingScopeProvider;

 public abstract class ClassDescriptorBase extends AbstractClassDescriptor {

@@ -35,7 +36,18 @@ public abstract class ClassDescriptorBase extends AbstractClassDescriptor {
            @NotNull SourceElement source,
            boolean isExternal
    ) {
-        super(storageManager, name);
+        this(storageManager, containingDeclaration, name, source, isExternal, SubstitutingScopeProvider.Companion.getDEFAULT());
+    }
+
+    protected ClassDescriptorBase(
+            @NotNull StorageManager storageManager,
+            @NotNull DeclarationDescriptor containingDeclaration,
+            @NotNull Name name,
+            @NotNull SourceElement source,
+            boolean isExternal,
+            @NotNull SubstitutingScopeProvider substitutingScopeProvider
+    ) {
+        super(storageManager, name, substitutingScopeProvider);
        this.containingDeclaration = containingDeclaration;
        this.source = source;
        this.isExternal = isExternal;
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/FunctionDescriptorImpl.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/FunctionDescriptorImpl.java
@@ -324,11 +324,21 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo
    }

    @Override
+    @Nullable
    public FunctionDescriptor substitute(@NotNull TypeSubstitutor originalSubstitutor) {
+        return substitute(originalSubstitutor, SubstitutingScopeProvider.Companion.getDEFAULT());
+    }
+
+    @Nullable
+    public FunctionDescriptor substitute(@NotNull TypeSubstitutor originalSubstitutor, SubstitutingScopeProvider substitutingScopeProvider) {
        if (originalSubstitutor.isEmpty()) {
            return this;
        }
-        return newCopyBuilder(originalSubstitutor).setOriginal(getOriginal()).setJustForTypeSubstitution(true).build();
+        return newCopyBuilder(originalSubstitutor)
+                .setOriginal(getOriginal())
+                .setJustForTypeSubstitution(true)
+                .setSubstitutingScopeProvider(substitutingScopeProvider)
+                .build();
    }

    @Nullable
@@ -365,6 +375,7 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo
        private Map<UserDataKey<?>, Object> userDataMap = new LinkedHashMap<UserDataKey<?>, Object>();
        private Boolean newHasSynthesizedParameterNames = null;
        protected boolean justForTypeSubstitution = false;
+        protected @NotNull SubstitutingScopeProvider substitutingScopeProvider;

        public CopyConfiguration(
                @NotNull TypeSubstitution substitution,
@@ -386,6 +397,7 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo
            this.newExtensionReceiverParameter = newExtensionReceiverParameter;
            this.newReturnType = newReturnType;
            this.name = name;
+            substitutingScopeProvider = SubstitutingScopeProvider.Companion.getDEFAULT();
        }

        @Override
@@ -554,6 +566,12 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo
            justForTypeSubstitution = value;
            return this;
        }
+
+        @NotNull
+        public CopyConfiguration setSubstitutingScopeProvider(@NotNull SubstitutingScopeProvider substitutingScopeProvider) {
+            this.substitutingScopeProvider = substitutingScopeProvider;
+            return this;
+        }
    }

    @Override
@@ -591,7 +609,8 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo
        List<TypeParameterDescriptor> substitutedTypeParameters =
                new ArrayList<TypeParameterDescriptor>(unsubstitutedTypeParameters.size());
        final TypeSubstitutor substitutor = DescriptorSubstitutor.substituteTypeParameters(
-                unsubstitutedTypeParameters, configuration.substitution, substitutedDescriptor, substitutedTypeParameters, wereChanges
+                unsubstitutedTypeParameters, configuration.substitution, substitutedDescriptor, substitutedTypeParameters,
+                wereChanges, configuration.substitutingScopeProvider
        );
        if (substitutor == null) return null;

--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazySubstitutingClassDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazySubstitutingClassDescriptor.java
@@ -28,10 +28,12 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor {
    private List<TypeParameterDescriptor> typeConstructorParameters;
    private List<TypeParameterDescriptor> declaredTypeParameters;
    private TypeConstructor typeConstructor;
+    private final SubstitutingScopeProvider substitutingScopeProvider;

-    public LazySubstitutingClassDescriptor(ClassDescriptor descriptor, TypeSubstitutor substitutor) {
+    public LazySubstitutingClassDescriptor(ClassDescriptor descriptor, TypeSubstitutor substitutor, SubstitutingScopeProvider substitutingScopeProvider) {
        this.original = descriptor;
        this.originalSubstitutor = substitutor;
+        this.substitutingScopeProvider = substitutingScopeProvider;
    }

    private TypeSubstitutor getSubstitutor() {
@@ -87,7 +89,7 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor {
        if (originalSubstitutor.isEmpty()) {
            return memberScope;
        }
-        return new SubstitutingScope(memberScope, getSubstitutor());
+        return substitutingScopeProvider.createSubstitutingScope(memberScope, getSubstitutor());
    }

    @NotNull
@@ -97,7 +99,7 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor {
        if (originalSubstitutor.isEmpty()) {
            return memberScope;
        }
-        return new SubstitutingScope(memberScope, getSubstitutor());
+        return substitutingScopeProvider.createSubstitutingScope(memberScope, getSubstitutor());
    }

    @NotNull
@@ -107,7 +109,7 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor {
        if (originalSubstitutor.isEmpty()) {
            return memberScope;
        }
-        return new SubstitutingScope(memberScope, getSubstitutor());
+        return substitutingScopeProvider.createSubstitutingScope(memberScope, getSubstitutor());
    }

    @NotNull
@@ -175,7 +177,7 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor {
    @Override
    public ClassDescriptor substitute(@NotNull TypeSubstitutor substitutor) {
        if (substitutor.isEmpty()) return this;
-        return new LazySubstitutingClassDescriptor(this, TypeSubstitutor.createChainedSubstitutor(substitutor.getSubstitution(), getSubstitutor().getSubstitution()));
+        return new LazySubstitutingClassDescriptor(this, TypeSubstitutor.createChainedSubstitutor(substitutor.getSubstitution(), getSubstitutor().getSubstitution()), substitutingScopeProvider);
    }

    @Override
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyDescriptorImpl.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyDescriptorImpl.java
@@ -47,6 +47,8 @@ public class PropertyDescriptorImpl extends VariableDescriptorWithInitializerImp
    private final boolean isExternal;
    private final boolean isDelegated;

+    private final SubstitutingScopeProvider substitutingScopeProvider;
+
    private ReceiverParameterDescriptor dispatchReceiverParameter;
    private ReceiverParameterDescriptor extensionReceiverParameter;
    private List<TypeParameterDescriptor> typeParameters;
@@ -72,6 +74,28 @@ public class PropertyDescriptorImpl extends VariableDescriptorWithInitializerImp
            boolean isActual,
            boolean isExternal,
            boolean isDelegated
+    ) {
+        this(containingDeclaration, original, annotations, modality, visibility, isVar, name, kind, source,
+             lateInit, isConst, isExpect, isActual, isExternal, isDelegated, SubstitutingScopeProvider.Companion.getDEFAULT());
+    }
+
+    protected PropertyDescriptorImpl(
+            @NotNull DeclarationDescriptor containingDeclaration,
+            @Nullable PropertyDescriptor original,
+            @NotNull Annotations annotations,
+            @NotNull Modality modality,
+            @NotNull Visibility visibility,
+            boolean isVar,
+            @NotNull Name name,
+            @NotNull Kind kind,
+            @NotNull SourceElement source,
+            boolean lateInit,
+            boolean isConst,
+            boolean isExpect,
+            boolean isActual,
+            boolean isExternal,
+            boolean isDelegated,
+            @NotNull SubstitutingScopeProvider substitutingScopeProvider
    ) {
        super(containingDeclaration, annotations, name, null, isVar, source);
        this.modality = modality;
@@ -84,6 +108,7 @@ public class PropertyDescriptorImpl extends VariableDescriptorWithInitializerImp
        this.isActual = isActual;
        this.isExternal = isExternal;
        this.isDelegated = isDelegated;
+        this.substitutingScopeProvider = substitutingScopeProvider;
    }

    @NotNull
@@ -102,10 +127,39 @@ public class PropertyDescriptorImpl extends VariableDescriptorWithInitializerImp
            boolean isActual,
            boolean isExternal,
            boolean isDelegated
+    ) {
+        return create(containingDeclaration, annotations, modality, visibility, isVar, name, kind, source,
+                      lateInit, isConst, isExpect, isActual, isExternal, isDelegated, SubstitutingScopeProvider.Companion.getDEFAULT());
+    }
+
+    @NotNull
+    public static PropertyDescriptorImpl create(
+            @NotNull DeclarationDescriptor containingDeclaration,
+            @NotNull Annotations annotations,
+            @NotNull Modality modality,
+            @NotNull Visibility visibility,
+            boolean isVar,
+            @NotNull Name name,
+            @NotNull Kind kind,
+            @NotNull SourceElement source,
+            boolean lateInit,
+            boolean isConst,
+            boolean isExpect,
+            boolean isActual,
+            boolean isExternal,
+            boolean isDelegated,
+            @NotNull SubstitutingScopeProvider substitutingScopeProvider
    ) {
        return new PropertyDescriptorImpl(containingDeclaration, null, annotations,
                                          modality, visibility, isVar, name, kind, source, lateInit, isConst,
-                                          isExpect, isActual, isExternal, isDelegated);
+                                          isExpect, isActual, isExternal, isDelegated, substitutingScopeProvider);
+    }
+
+    @NotNull
+    public PropertyDescriptorImpl getCopy() {
+        return new PropertyDescriptorImpl(getContainingDeclaration(), original, getAnnotations(),
+                                          modality, visibility, isVar(), getName(), kind, getSource(), lateInit, isConst,
+                                          isExpect, isActual, isExternal, isDelegated, substitutingScopeProvider);
    }

    public void setType(
@@ -258,6 +312,7 @@ public class PropertyDescriptorImpl extends VariableDescriptorWithInitializerImp
        private ReceiverParameterDescriptor dispatchReceiverParameter = PropertyDescriptorImpl.this.dispatchReceiverParameter;
        private List<TypeParameterDescriptor> newTypeParameters = null;
        private Name name = getName();
+        private boolean setterProjectedOut = PropertyDescriptorImpl.this.setterProjectedOut;

        @NotNull
        @Override
@@ -364,6 +419,7 @@ public class PropertyDescriptorImpl extends VariableDescriptorWithInitializerImp
        TypeSubstitutor substitutor = DescriptorSubstitutor.substituteTypeParameters(
                originalTypeParameters, copyConfiguration.substitution, substitutedDescriptor, substitutedTypeParameters
        );
+        substitutor.setSubstitutingScopeProvider(substitutingScopeProvider);

        KotlinType originalOutType = getType();
        KotlinType outType = substitutor.substitute(originalOutType, Variance.OUT_VARIANCE);
@@ -460,6 +516,8 @@ public class PropertyDescriptorImpl extends VariableDescriptorWithInitializerImp
            substitutedDescriptor.setCompileTimeInitializer(compileTimeInitializer);
        }

+        substitutedDescriptor.setterProjectedOut = copyConfiguration.setterProjectedOut;
+
        return substitutedDescriptor;
    }

@@ -470,7 +528,7 @@ public class PropertyDescriptorImpl extends VariableDescriptorWithInitializerImp
        return prev;
    }

-    private static FunctionDescriptor getSubstitutedInitialSignatureDescriptor(
+    public static FunctionDescriptor getSubstitutedInitialSignatureDescriptor(
            @NotNull TypeSubstitutor substitutor,
            @NotNull PropertyAccessorDescriptor accessorDescriptor
    ) {
@@ -490,7 +548,7 @@ public class PropertyDescriptorImpl extends VariableDescriptorWithInitializerImp
    ) {
        return new PropertyDescriptorImpl(
                newOwner, original, getAnnotations(), newModality, newVisibility, isVar(), newName, kind, SourceElement.NO_SOURCE,
-                isLateInit(), isConst(), isExpect(), isActual(), isExternal(), isDelegated()
+                isLateInit(), isConst(), isExpect(), isActual(), isExternal(), isDelegated(), substitutingScopeProvider
        );
    }

@@ -564,4 +622,9 @@ public class PropertyDescriptorImpl extends VariableDescriptorWithInitializerImp
    public <V> V getUserData(UserDataKey<V> key) {
        return null;
    }
+
+    @NotNull
+    public SubstitutingScopeProvider getSubstitutingScopeProvider() {
+        return substitutingScopeProvider;
+    }
 }
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ValueParameterDescriptorImpl.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ValueParameterDescriptorImpl.kt
@@ -21,6 +21,7 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.TypeSubstitutor
+import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.utils.join

 open class ValueParameterDescriptorImpl(
@@ -102,8 +103,7 @@ open class ValueParameterDescriptorImpl(
    override fun getOriginal() = if (original === this) this else original.original

    override fun substitute(substitutor: TypeSubstitutor): ValueParameterDescriptor {
-        if (substitutor.isEmpty) return this
-        throw UnsupportedOperationException() // TODO
+        return this
    }

    override fun <R, D> accept(visitor: DeclarationDescriptorVisitor<R, D>, data: D): R {
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/CapturedTypeConstructor.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/CapturedTypeConstructor.kt
@@ -100,16 +100,25 @@ class CapturedType(
        CapturedType(typeProjection, constructor, isMarkedNullable, newAnnotations)
 }

+object OldCapturedTypeCreator : CapturedTypeCreator {
+    override fun createCapturedType(typeProjection: TypeProjection): TypeProjection {
+        return TypeProjectionImpl(CapturedType(typeProjection))
+    }
+}
+
 fun createCapturedType(typeProjection: TypeProjection): KotlinType = CapturedType(typeProjection)

 fun KotlinType.isCaptured(): Boolean = constructor is CapturedTypeConstructor

-fun TypeSubstitution.wrapWithCapturingSubstitution(needApproximation: Boolean = true): TypeSubstitution =
+fun TypeSubstitution.wrapWithCapturingSubstitution(
+    capturedTypeCreator: CapturedTypeCreator = OldCapturedTypeCreator,
+    needApproximation: Boolean = true
+): TypeSubstitution =
    if (this is IndexedParametersSubstitution)
        IndexedParametersSubstitution(
            this.parameters,
            this.arguments.zip(this.parameters).map {
-                it.first.createCapturedIfNeeded(it.second)
+                it.first.createCapturedIfNeeded(it.second, capturedTypeCreator)
            }.toTypedArray(),
            approximateCapturedTypes = needApproximation
        )
@@ -117,10 +126,16 @@ fun TypeSubstitution.wrapWithCapturingSubstitution(needApproximation: Boolean =
        object : DelegatedTypeSubstitution(this@wrapWithCapturingSubstitution) {
            override fun approximateContravariantCapturedTypes() = needApproximation
            override fun get(key: KotlinType) =
-                super.get(key)?.createCapturedIfNeeded(key.constructor.declarationDescriptor as? TypeParameterDescriptor)
+                super.get(key)?.createCapturedIfNeeded(
+                    key.constructor.declarationDescriptor as? TypeParameterDescriptor,
+                    capturedTypeCreator
+                )
        }

-private fun TypeProjection.createCapturedIfNeeded(typeParameterDescriptor: TypeParameterDescriptor?): TypeProjection {
+private fun TypeProjection.createCapturedIfNeeded(
+    typeParameterDescriptor: TypeParameterDescriptor?,
+    capturedTypeCreator: CapturedTypeCreator
+): TypeProjection {
    if (typeParameterDescriptor == null || projectionKind == Variance.INVARIANT) return this

    // Treat consistent projections as invariant
@@ -134,5 +149,5 @@ private fun TypeProjection.createCapturedIfNeeded(typeParameterDescriptor: TypeP
            TypeProjectionImpl(this@createCapturedIfNeeded.type)
    }

-    return TypeProjectionImpl(createCapturedType(this))
+    return capturedTypeCreator.createCapturedType(this)
 }
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/SubstitutingScope.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/SubstitutingScope.kt
@@ -18,18 +18,24 @@ package org.jetbrains.kotlin.resolve.scopes

 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.Substitutable
+import org.jetbrains.kotlin.descriptors.impl.FunctionDescriptorImpl
 import org.jetbrains.kotlin.incremental.components.LookupLocation
+import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.calls.inference.wrapWithCapturingSubstitution
+import org.jetbrains.kotlin.types.ErrorUtils
+import org.jetbrains.kotlin.types.SubstitutingScopeProvider
 import org.jetbrains.kotlin.types.TypeSubstitutor
 import org.jetbrains.kotlin.utils.Printer
 import org.jetbrains.kotlin.utils.newLinkedHashSetWithExpectedSize
 import org.jetbrains.kotlin.utils.sure
 import java.util.*

-class SubstitutingScope(private val workerScope: MemberScope, givenSubstitutor: TypeSubstitutor) : MemberScope {
+class SubstitutingScope(private val workerScope: MemberScope, givenSubstitutor: TypeSubstitutor, private val substitutingScopeProvider: SubstitutingScopeProvider) : MemberScope {

-    private val substitutor = givenSubstitutor.substitution.wrapWithCapturingSubstitution().buildSubstitutor()
+    private val substitutor: TypeSubstitutor = givenSubstitutor.substitution
+        .wrapWithCapturingSubstitution(capturedTypeCreator = substitutingScopeProvider.provideCapturedTypeCreator())
+        .buildSubstitutor().also { it.setSubstitutingScopeProvider(substitutingScopeProvider) }

    private var substitutedDescriptors: MutableMap<DeclarationDescriptor, DeclarationDescriptor>? = null

@@ -43,11 +49,44 @@ class SubstitutingScope(private val workerScope: MemberScope, givenSubstitutor:
        }

        val substituted = substitutedDescriptors!!.getOrPut(descriptor) {
+            val assertionMessage = {
+                "We expect that no conflict should happen while substitution is guaranteed to generate invariant projection, " +
+                        "but $descriptor substitution fails"
+            }
            when (descriptor) {
-                is Substitutable<*> -> descriptor.substitute(substitutor).sure {
-                    "We expect that no conflict should happen while substitution is guaranteed to generate invariant projection, " +
-                    "but $descriptor substitution fails"
+                /*
+                 * Here we can take null if NI enabled, because inside this place we have OI and NI collide. See following example:
+                 *
+                 * class Out<out T>
+                 *
+                 * class A<T> {
+                 *   fun T.foo() {}
+                 *   fun Out<T>.bar() {}
+                 * }
+                 *
+                 * fun test(x: A<out CharSequence>, y: Out<CharSequence>) {
+                 *   with(x) {
+                 *     "".foo()   <-- problem is here
+                 *   }
+                 * }
+                 *
+                 * Because of we don't capture type projections, in call "".foo() we have `out CharSequence` as substituted type `T`
+                 *   (instead of `CapturedType(out CharSequence)`, and `in String` as type from receiver, so we have type variance error
+                 *   and can not substitute descriptor.
+                 *
+                 * So, fix of it is hack
+                 */
+                is FunctionDescriptorImpl -> {
+                    val substitutedDescriptor = descriptor.substitute(substitutor, substitutingScopeProvider)
+                    if (substitutingScopeProvider.isNewInferenceEnabled) {
+                        substitutedDescriptor ?: ErrorUtils.createErrorScope("Cannot substitute functional descriptor")
+                            .getContributedFunctions(descriptor.name, NoLookupLocation.WHEN_RESOLVE_DECLARATION).first()
+                    } else {
+                        substitutedDescriptor.sure(assertionMessage)
+                    }
                }
+
+                is Substitutable<*> -> descriptor.substitute(substitutor).sure(assertionMessage)
                else -> error("Unknown descriptor in scope: $descriptor")
            }
        }
@@ -72,7 +111,7 @@ class SubstitutingScope(private val workerScope: MemberScope, givenSubstitutor:
    override fun getContributedVariables(name: Name, location: LookupLocation) = substitute(workerScope.getContributedVariables(name, location))

    override fun getContributedClassifier(name: Name, location: LookupLocation) =
-            workerScope.getContributedClassifier(name, location)?.let { substitute(it) }
+        workerScope.getContributedClassifier(name, location)?.let { substitute(it) }

    override fun getContributedFunctions(name: Name, location: LookupLocation) = substitute(workerScope.getContributedFunctions(name, location))

--- a/core/descriptors/src/org/jetbrains/kotlin/types/CapturedTypeApproximation.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/CapturedTypeApproximation.kt
@@ -28,6 +28,12 @@ import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.typeUtil.builtIns
 import java.util.*

+class OldCaptureTypeApproximator : CapturedTypeApproximator {
+    override fun approximateCapturedTypes(typeProjection: TypeProjection?, approximateContravariant: Boolean): TypeProjection? {
+        return approximateCapturedTypesIfNecessary(typeProjection, approximateContravariant)
+    }
+}
+
 data class ApproximationBounds<out T>(
    val lower: T,
    val upper: T
--- a/core/descriptors/src/org/jetbrains/kotlin/types/DescriptorSubstitutor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/DescriptorSubstitutor.java
@@ -40,7 +40,7 @@ public class DescriptorSubstitutor {
            @NotNull DeclarationDescriptor newContainingDeclaration,
            @NotNull @Mutable List<TypeParameterDescriptor> result
    ) {
-        TypeSubstitutor substitutor = substituteTypeParameters(typeParameters, originalSubstitution, newContainingDeclaration, result, null);
+        TypeSubstitutor substitutor = substituteTypeParameters(typeParameters, originalSubstitution, newContainingDeclaration, result, null, SubstitutingScopeProvider.Companion.getDEFAULT());
        if (substitutor == null) throw new AssertionError("Substitution failed");
        return substitutor;
    }
@@ -51,7 +51,8 @@ public class DescriptorSubstitutor {
            @NotNull TypeSubstitution originalSubstitution,
            @NotNull DeclarationDescriptor newContainingDeclaration,
            @NotNull @Mutable List<TypeParameterDescriptor> result,
-            @Nullable boolean[] wereChanges
+            @Nullable boolean[] wereChanges,
+            @NotNull SubstitutingScopeProvider substitutingScopeProvider
    ) {
        Map<TypeConstructor, TypeProjection> mutableSubstitution = new HashMap<TypeConstructor, TypeProjection>();

@@ -76,7 +77,7 @@ public class DescriptorSubstitutor {

        TypeSubstitutor substitutor = TypeSubstitutor.createChainedSubstitutor(
                originalSubstitution, TypeConstructorSubstitution.createByConstructorsMap(mutableSubstitution)
-        );
+        ).setSubstitutingScopeProvider(substitutingScopeProvider);

        for (TypeParameterDescriptor descriptor : typeParameters) {
            TypeParameterDescriptorImpl substituted = substitutedMap.get(descriptor);
--- a/core/descriptors/src/org/jetbrains/kotlin/types/SubstitutingScopeProvider.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/SubstitutingScopeProvider.kt
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. 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.types
+
+import org.jetbrains.kotlin.resolve.calls.inference.OldCapturedTypeCreator
+import org.jetbrains.kotlin.resolve.scopes.MemberScope
+import org.jetbrains.kotlin.resolve.scopes.SubstitutingScope
+import org.jetbrains.kotlin.types.typesApproximation.OldCaptureTypeApproximator
+
+interface SubstitutingScopeProvider {
+    fun createSubstitutingScope(workerScope: MemberScope, givenSubstitutor: TypeSubstitutor): SubstitutingScope
+
+    fun provideCapturedTypeCreator(): CapturedTypeCreator
+
+    fun provideApproximator(): CapturedTypeApproximator
+
+    val isNewInferenceEnabled: Boolean
+
+    companion object {
+        val DEFAULT: SubstitutingScopeProvider = object : SubstitutingScopeProvider {
+            override fun createSubstitutingScope(workerScope: MemberScope, givenSubstitutor: TypeSubstitutor): SubstitutingScope {
+                return SubstitutingScope(workerScope, givenSubstitutor, this)
+            }
+
+            override fun provideCapturedTypeCreator(): CapturedTypeCreator {
+                return OldCapturedTypeCreator
+            }
+
+            override fun provideApproximator(): CapturedTypeApproximator {
+                return OldCaptureTypeApproximator()
+            }
+
+            override val isNewInferenceEnabled: Boolean get() = false
+        }
+    }
+}
+
+interface CapturedTypeCreator {
+    fun createCapturedType(typeProjection: TypeProjection): TypeProjection
+}
+
+interface CapturedTypeApproximator {
+    fun approximateCapturedTypes(typeProjection: TypeProjection?, approximateContravariant: Boolean): TypeProjection?
+}
--- a/core/descriptors/src/org/jetbrains/kotlin/types/TypeSubstitutor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/TypeSubstitutor.java
@@ -28,7 +28,6 @@ import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.resolve.calls.inference.CapturedTypeConstructorKt;
 import org.jetbrains.kotlin.types.model.TypeSubstitutorMarker;
 import org.jetbrains.kotlin.types.typeUtil.TypeUtilsKt;
-import org.jetbrains.kotlin.types.typesApproximation.CapturedTypeApproximationKt;
 import org.jetbrains.kotlin.utils.ExceptionUtilsKt;

 import java.util.ArrayList;
@@ -47,6 +46,14 @@ public class TypeSubstitutor implements TypeSubstitutorMarker {
        }
    }

+    private @NotNull SubstitutingScopeProvider substitutingScopeProvider;
+
+    @NotNull
+    public TypeSubstitutor setSubstitutingScopeProvider(@NotNull SubstitutingScopeProvider substitutingScopeProvider) {
+        this.substitutingScopeProvider = substitutingScopeProvider;
+        return this;
+    }
+
    @NotNull
    public static TypeSubstitutor create(@NotNull TypeSubstitution substitution) {
        return new TypeSubstitutor(substitution);
@@ -73,6 +80,7 @@ public class TypeSubstitutor implements TypeSubstitutorMarker {

    protected TypeSubstitutor(@NotNull TypeSubstitution substitution) {
        this.substitution = substitution;
+        this.substitutingScopeProvider = SubstitutingScopeProvider.Companion.getDEFAULT();
    }

    public boolean isEmpty() {
@@ -110,8 +118,12 @@ public class TypeSubstitutor implements TypeSubstitutorMarker {
        if (!substitution.approximateCapturedTypes() && !substitution.approximateContravariantCapturedTypes()) {
            return substitutedTypeProjection;
        }
-        return CapturedTypeApproximationKt.approximateCapturedTypesIfNecessary(
-                substitutedTypeProjection, substitution.approximateContravariantCapturedTypes());
+
+        CapturedTypeApproximator approximator = substitutingScopeProvider.provideApproximator();
+        return approximator.approximateCapturedTypes(
+                substitutedTypeProjection,
+                substitution.approximateContravariantCapturedTypes()
+        );
    }

    @Nullable
--- a/core/descriptors/src/org/jetbrains/kotlin/types/TypeUtils.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/TypeUtils.java
@@ -55,6 +55,11 @@ public class TypeUtils {
            throw new IllegalStateException(name);
        }

+        @Override
+        public boolean isMarkedNullable() {
+            return false;
+        }
+
        @NotNull
        @Override
        public String toString() {
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/lightClasses/IDELightClassContexts.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/lightClasses/IDELightClassContexts.kt
@@ -72,10 +72,7 @@ import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProvid
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.storage.StorageManager
-import org.jetbrains.kotlin.types.ErrorUtils
-import org.jetbrains.kotlin.types.KotlinType
-import org.jetbrains.kotlin.types.TypeUtils
-import org.jetbrains.kotlin.types.WrappedTypeFactory
+import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.utils.sure


@@ -334,7 +331,7 @@ internal object IDELightClassContexts {
            })

            IdeaEnvironment.configure(this)
-
+            useImpl<SubstitutingScopeProviderImpl>()
            useImpl<ResolveSession>()
        }

--- a/js/js.frontend/src/org/jetbrains/kotlin/frontend/js/di/injection.kt
+++ b/js/js.frontend/src/org/jetbrains/kotlin/frontend/js/di/injection.kt
@@ -34,6 +34,7 @@ import org.jetbrains.kotlin.platform.js.JsPlatforms
 import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
+import org.jetbrains.kotlin.types.SubstitutingScopeProviderImpl

 fun createTopDownAnalyzerForJs(
        moduleContext: ModuleContext,
@@ -55,6 +56,7 @@ fun createTopDownAnalyzerForJs(

        configureIncrementalCompilation(lookupTracker, expectActualTracker)
        configureStandardResolveComponents()
+        useImpl<SubstitutingScopeProviderImpl>()

        useInstance(declarationProviderFactory)
        CompilerEnvironment.configure(this)