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

This reverts commit 7c4101e.

 #KT-31866 Fixed
 #KT-31868 Fixed
 #EA-125401 Fixed
 #KT-25290 Open

Author: zarechenskiy

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

@@ -45,7 +45,6 @@ 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
@@ -171,7 +170,6 @@ private fun createContainerToResolveCommonCode(
 
         configureCommonSpecificComponents()
         useInstance(metadataPartProvider)
-        useImpl<SubstitutingScopeProviderImpl>()
 
         val metadataFinderFactory = ServiceManager.getService(
             moduleContext.project,

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

@@ -46,7 +46,6 @@ 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,
@@ -128,7 +127,6 @@ fun StorageComponentContainer.configureJavaSpecificComponents(
     )
 
     useImpl<FilesByFacadeFqNameIndexer>()
-    useImpl<SubstitutingScopeProviderImpl>()
 }
 
 fun ComponentProvider.initJvmBuiltInsForTopDownAnalysis() {

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

@@ -81,7 +81,8 @@ public void setOutType(KotlinType outType) {
     @NotNull
     @Override
     public LocalVariableDescriptor substitute(@NotNull TypeSubstitutor substitutor) {
-        return this;
+        if (substitutor.isEmpty()) return this;
+        throw new UnsupportedOperationException(); // TODO
     }
 
     @Override

compiler/frontend/src/org/jetbrains/kotlin/descriptors/impl/LocalVariableDescriptor.java

@@ -38,7 +38,6 @@ 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
@@ -78,9 +77,7 @@ fun ResolutionContext<*>.reportTypeMismatchDueToTypeProjection(
         TypeConstructorSubstitution
             .create(receiverType)
             .wrapWithCapturingSubstitution(needApproximation = false)
-            .buildSubstitutor().apply {
-                setSubstitutingScopeProvider(SubstitutingScopeProvider.DEFAULT)
-            }.let { callableDescriptor.substitute(it) } ?: return false
+            .buildSubstitutor().let { callableDescriptor.substitute(it) } ?: return false
 
     val nonApproximatedExpectedType = correspondingNotApproximatedTypeByDescriptor(substitutedDescriptor) ?: return false
     if (!TypeUtils.contains(nonApproximatedExpectedType) { it.isCaptured() }) return false

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

@@ -34,7 +34,6 @@ 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
@@ -118,7 +117,6 @@ fun createContainerForBodyResolve(
     useImpl<AnnotationResolverImpl>()
 
     useImpl<BodyResolver>()
-    useImpl<SubstitutingScopeProviderImpl>()
 }
 
 fun createContainerForLazyBodyResolve(
@@ -138,7 +136,6 @@ fun createContainerForLazyBodyResolve(
     useImpl<AnnotationResolverImpl>()
     useImpl<LazyTopDownAnalyzer>()
     useImpl<BasicAbsentDescriptorHandler>()
-    useImpl<SubstitutingScopeProviderImpl>()
 }
 
 fun createContainerForLazyLocalClassifierAnalyzer(
@@ -169,7 +166,6 @@ fun createContainerForLazyLocalClassifierAnalyzer(
     useImpl<DeclarationScopeProviderForLocalClassifierAnalyzer>()
     useImpl<LocalLazyDeclarationResolver>()
 
-    useImpl<SubstitutingScopeProviderImpl>()
     useInstance(statementFilter)
 }
 
@@ -187,7 +183,6 @@ fun createContainerForLazyResolve(
     configureStandardResolveComponents()
 
     useInstance(declarationProviderFactory)
-    useImpl<SubstitutingScopeProviderImpl>()
 
     targetEnvironment.configure(this)
 

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

@@ -911,8 +911,7 @@ private PropertyDescriptor resolveAsPropertyDescriptor(
                 container instanceof ClassDescriptor && ((ClassDescriptor) container).isExpect(),
                 modifierList != null && PsiUtilsKt.hasActualModifier(modifierList),
                 modifierList != null && modifierList.hasModifier(KtTokens.EXTERNAL_KEYWORD),
-                propertyInfo.getHasDelegate(),
-                new SubstitutingScopeProviderImpl(languageVersionSettings)
+                propertyInfo.getHasDelegate()
         );
 
         List<TypeParameterDescriptorImpl> typeParameterDescriptors;

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

@@ -8,8 +8,6 @@ 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.*
@@ -25,13 +23,12 @@ 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.substituteAndApproximateIntegerLiteralTypes
+import org.jetbrains.kotlin.resolve.calls.inference.substituteAndApproximateCapturedTypes
 import org.jetbrains.kotlin.resolve.calls.model.*
 import org.jetbrains.kotlin.resolve.calls.resolvedCallUtil.makeNullableTypeIfSafeReceiver
 import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus
@@ -41,13 +38,14 @@ 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
@@ -295,14 +293,15 @@ class KotlinToResolvedCallTransformer(
             // todo external argument
 
             val argumentExpression = valueArgument.getArgumentExpression() ?: continue
-            updateRecordedType(argumentExpression, parameter, newContext)
+            updateRecordedType(argumentExpression, parameter, newContext, resolvedCall.isReallySuccess())
         }
     }
 
     fun updateRecordedType(
         expression: KtExpression,
         parameter: ValueParameterDescriptor?,
-        context: BasicCallResolutionContext
+        context: BasicCallResolutionContext,
+        reportErrorForTypeMismatch: Boolean
     ): KotlinType? {
         val deparenthesized = expression.let {
             KtPsiUtil.getLastElementDeparenthesized(it, context.statementFilter)
@@ -319,6 +318,9 @@ 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) {
@@ -327,14 +329,15 @@ class KotlinToResolvedCallTransformer(
                     updatedType = argumentTypeResolver.updateResultArgumentTypeIfNotDenotable(
                         context.trace, context.statementFilter, context.expectedType, generalNumberType, expression
                     )
+                    reportErrorDuringTypeCheck = true
                 }
 
             }
         }
 
         updatedType = updateRecordedTypeForArgument(updatedType, recordedType, expression, context)
 
-        dataFlowAnalyzer.checkType(updatedType, deparenthesized, context, false)
+        dataFlowAnalyzer.checkType(updatedType, deparenthesized, context, reportErrorDuringTypeCheck)
 
         return updatedType
     }
@@ -687,44 +690,32 @@ class NewResolvedCallImpl<D : CallableDescriptor>(
         @Suppress("UNCHECKED_CAST")
         resultingDescriptor = run {
             val candidateDescriptor = resolvedCallAtom.candidateDescriptor
-            val containsIntegerLiteralTypes = resolvedCallAtom.candidateDescriptor.returnType?.contains {
-                it.constructor is IntegerLiteralTypeConstructor
-            } ?: false
+            val containsCapturedTypes = resolvedCallAtom.candidateDescriptor.returnType?.contains { it is NewCapturedType } ?: false
+            val containsIntegerLiteralTypes = resolvedCallAtom.candidateDescriptor.returnType?.contains { it.constructor is IntegerLiteralTypeConstructor } ?: false
 
             when {
                 candidateDescriptor is FunctionDescriptor ||
-                        (candidateDescriptor is PropertyDescriptor && candidateDescriptor.typeParameters.isNotEmpty() || containsIntegerLiteralTypes) ->
+                        (candidateDescriptor is PropertyDescriptor && (candidateDescriptor.typeParameters.isNotEmpty() || containsCapturedTypes || 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.substituteAndApproximateIntegerLiteralTypes(resolvedCallAtom.substitutor).let {
-                        if (substitutor != null) {
-                            it.substitute(substitutor)
-                        } else {
-                            it
-                        }
-                    }
-
+                    candidateDescriptor.substitute(resolvedCallAtom.substitutor).substituteAndApproximateCapturedTypes(
+                        substitutor ?: FreshVariableNewTypeSubstitutor.Empty
+                    )
                 else ->
                     candidateDescriptor
             }
         } as D
 
         typeArguments = resolvedCallAtom.substitutor.freshVariables.map {
-            (substitutor ?: FreshVariableNewTypeSubstitutor.Empty).safeSubstitute(it.defaultType)
+            val substituted = (substitutor ?: FreshVariableNewTypeSubstitutor.Empty).safeSubstitute(it.defaultType)
+            TypeApproximator(substituted.constructor.builtIns)
+                .approximateToSuperType(substituted, TypeApproximatorConfiguration.IntegerLiteralsTypesApproximation)
+                ?: substituted
         }
 
         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)
 
@@ -817,41 +808,3 @@ 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().setOriginal(original).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
-}

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

@@ -382,7 +382,6 @@ class PSICallResolver(
 
             return cache.getOrPut(implicitReceiver) {
                 context.transformToReceiverWithSmartCastInfo(implicitReceiver.value)
-                    .prepareReceiverRegardingCaptureTypes()
             }
         }
     }

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

@@ -110,7 +110,6 @@ class ResolvedAtomCompleter(
 
         kotlinToResolvedCallTransformer.reportDiagnostics(topLevelCallContext, topLevelTrace, resolvedCall, diagnostics)
 
-        resolvedCall.approximateCapturedTypesAndHackSetters()
         return resolvedCall
     }
 
@@ -156,7 +155,9 @@ class ResolvedAtomCompleter(
                     .replaceBindingTrace(topLevelTrace)
 
             val argumentExpression = resultValueArgument.valueArgument.getArgumentExpression() ?: continue
-            kotlinToResolvedCallTransformer.updateRecordedType(argumentExpression, parameter = null, context = newContext)
+            kotlinToResolvedCallTransformer.updateRecordedType(
+                argumentExpression, parameter = null, context = newContext, reportErrorForTypeMismatch = true
+            )
         }
     }
 

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

@@ -24,12 +24,10 @@ 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