Rename "coroutine( inference) *" stuff into "builder inference *"

2021-08-18 17:33:51 +03:00
parent 8e885da677
commit 261a04b587
12 changed files with 46 additions and 46 deletions
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.resolve.calls.inference.buildAbstractResultingSubsti
 import org.jetbrains.kotlin.resolve.calls.inference.components.ConstraintSystemCompletionMode
 import org.jetbrains.kotlin.resolve.calls.inference.model.ConstraintKind
 import org.jetbrains.kotlin.resolve.calls.inference.model.ConstraintStorage
-import org.jetbrains.kotlin.resolve.calls.inference.model.CoroutinePosition
+import org.jetbrains.kotlin.resolve.calls.inference.model.BuilderInferencePosition
 import org.jetbrains.kotlin.resolve.calls.inference.model.NewConstraintSystemImpl
 import org.jetbrains.kotlin.resolve.descriptorUtil.BUILDER_INFERENCE_ANNOTATION_FQ_NAME
 import org.jetbrains.kotlin.types.model.TypeConstructorMarker
@@ -219,7 +219,7 @@ class FirBuilderInferenceSession(
            for ((variableConstructor, type) in storage.fixedTypeVariables) {
                val typeVariable = storage.allTypeVariables.getValue(variableConstructor)
                commonSystem.registerVariable(typeVariable)
-                commonSystem.addEqualityConstraint((typeVariable as ConeTypeVariable).defaultType, type, CoroutinePosition)
+                commonSystem.addEqualityConstraint((typeVariable as ConeTypeVariable).defaultType, type, BuilderInferencePosition)
                introducedConstraint = true
            }
        }
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.fir.types.isMarkedNullable
 import org.jetbrains.kotlin.resolve.calls.components.PostponedArgumentsAnalyzerContext
 import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemBuilder
 import org.jetbrains.kotlin.resolve.calls.inference.components.ConstraintSystemCompletionMode
-import org.jetbrains.kotlin.resolve.calls.inference.model.CoroutinePosition
+import org.jetbrains.kotlin.resolve.calls.inference.model.BuilderInferencePosition
 import org.jetbrains.kotlin.types.model.StubTypeMarker
 import org.jetbrains.kotlin.types.model.TypeVariableMarker
 import org.jetbrains.kotlin.types.model.freshTypeConstructor
@@ -176,7 +176,7 @@ class PostponedArgumentsAnalyzer(
                    val variable = variableWithConstraints.typeVariable as ConeTypeVariable

                    c.getBuilder().unmarkPostponedVariable(variable)
-                    c.getBuilder().addEqualityConstraint(variable.defaultType, resultType, CoroutinePosition)
+                    c.getBuilder().addEqualityConstraint(variable.defaultType, resultType, BuilderInferencePosition)
                }
            }
        }
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt;
 import org.jetbrains.kotlin.resolve.calls.components.InferenceSession;
 import org.jetbrains.kotlin.resolve.calls.context.*;
-import org.jetbrains.kotlin.resolve.calls.inference.CoroutineInferenceUtilKt;
+import org.jetbrains.kotlin.resolve.calls.inference.BuilderInferenceUtilKt;
 import org.jetbrains.kotlin.resolve.calls.model.MutableDataFlowInfoForArguments;
 import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults;
 import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResultsImpl;
@@ -616,7 +616,7 @@ public class CallResolver {
        OverloadResolutionResultsImpl<D> results = doResolveCall(newContext, resolutionTask, tracing);

        // this is necessary because we already run CallCompleter for such calls
-        if (CoroutineInferenceUtilKt.isResultWithCoroutineInference(results)) {
+        if (BuilderInferenceUtilKt.isResultWithBuilderInference(results)) {
            traceToResolveCall.commit();
            return results;
        }
@@ -54,7 +54,7 @@ val SPECIAL_FUNCTION_NAMES = ResolveConstruct.values().map { it.specialFunctionN

 class GenericCandidateResolver(
    private val argumentTypeResolver: ArgumentTypeResolver,
-    private val coroutineInferenceSupport: CoroutineInferenceSupport,
+    private val builderInferenceSupport: BuilderInferenceSupport,
    private val languageVersionSettings: LanguageVersionSettings,
    private val dataFlowValueFactory: DataFlowValueFactory
 ) {
@@ -384,8 +384,8 @@ class GenericCandidateResolver(

        val effectiveExpectedType = getEffectiveExpectedType(valueParameterDescriptor, valueArgument, context)

-        if (isCoroutineCallWithAdditionalInference(valueParameterDescriptor, valueArgument, languageVersionSettings)) {
-            coroutineInferenceSupport.analyzeCoroutine(functionLiteral, valueArgument, constraintSystem, context, effectiveExpectedType)
+        if (isBuilderInferenceCall(valueParameterDescriptor, valueArgument, languageVersionSettings)) {
+            builderInferenceSupport.analyzeBuilderInferenceCall(functionLiteral, valueArgument, constraintSystem, context, effectiveExpectedType)
        }

        val currentSubstitutor = constraintSystem.build().currentSubstitutor
@@ -365,7 +365,7 @@ class BuilderInferenceSession(
            for ((variableConstructor, type) in storage.fixedTypeVariables) {
                val typeVariable = storage.allTypeVariables.getValue(variableConstructor)
                commonSystem.registerVariable(typeVariable)
-                commonSystem.addEqualityConstraint((typeVariable as NewTypeVariable).defaultType, type, CoroutinePosition)
+                commonSystem.addEqualityConstraint((typeVariable as NewTypeVariable).defaultType, type, BuilderInferencePosition)
            }
        }
    }
@@ -48,7 +48,7 @@ import javax.inject.Inject

 class TypeTemplate(
    val typeVariable: TypeVariable,
-    val coroutineInferenceData: CoroutineInferenceData,
+    val builderInferenceData: BuilderInferenceData,
    nullable: Boolean = true
 ) : FlexibleType(
    typeVariable.originalTypeParameter.builtIns.nothingType,
@@ -56,7 +56,7 @@ class TypeTemplate(
 ) {
    override fun replaceAnnotations(newAnnotations: Annotations) = this

-    override fun makeNullableAsSpecified(newNullability: Boolean) = TypeTemplate(typeVariable, coroutineInferenceData, newNullability)
+    override fun makeNullableAsSpecified(newNullability: Boolean) = TypeTemplate(typeVariable, builderInferenceData, newNullability)

    override val delegate: SimpleType
        get() = upperBound
@@ -68,7 +68,7 @@ class TypeTemplate(
    override fun refine(kotlinTypeRefiner: KotlinTypeRefiner) = this
 }

-class CoroutineInferenceData {
+class BuilderInferenceData {
    private val csBuilder = ConstraintSystemBuilderImpl()
    private val typeTemplates = HashMap<TypeVariable, TypeTemplate>()
    private var hereIsBadCall = false
@@ -129,7 +129,7 @@ class CoroutineInferenceData {
    }
 }

-class CoroutineInferenceSupport(
+class BuilderInferenceSupport(
    val argumentTypeResolver: ArgumentTypeResolver,
    val expressionTypingServices: ExpressionTypingServices
 ) {
@@ -138,7 +138,7 @@ class CoroutineInferenceSupport(

    private val languageVersionSettings get() = expressionTypingServices.languageVersionSettings

-    fun analyzeCoroutine(
+    fun analyzeBuilderInferenceCall(
        functionLiteral: KtFunction,
        valueArgument: ValueArgument,
        csBuilder: ConstraintSystem.Builder,
@@ -150,7 +150,7 @@ class CoroutineInferenceSupport(

        val lambdaReceiverType = lambdaExpectedType.getReceiverTypeFromFunctionType() ?: return

-        val inferenceData = CoroutineInferenceData()
+        val inferenceData = BuilderInferenceData()

        val constraintSystem = csBuilder.build()
        val newSubstitution = object : DelegatedTypeSubstitution(constraintSystem.currentSubstitutor.substitution) {
@@ -189,13 +189,13 @@ class CoroutineInferenceSupport(
        inferenceData.initSystem()

        // this trace shouldn't be committed
-        val temporaryForCoroutine = TemporaryTraceAndCache.create(
-            context, "trace for type argument inference for coroutine", functionLiteral
+        val temporaryForBuilderInference = TemporaryTraceAndCache.create(
+            context, "trace to infer a type argument using the builder inference", functionLiteral
        )

        val newContext = context.replaceExpectedType(newExpectedType)
            .replaceDataFlowInfo(context.candidateCall.dataFlowInfoForArguments.getInfo(valueArgument))
-            .replaceContextDependency(ContextDependency.INDEPENDENT).replaceTraceAndCache(temporaryForCoroutine)
+            .replaceContextDependency(ContextDependency.INDEPENDENT).replaceTraceAndCache(temporaryForBuilderInference)
        argumentTypeResolver.getFunctionLiteralTypeInfo(argumentExpression, functionLiteral, newContext, RESOLVE_FUNCTION_ARGUMENTS, true)

        inferenceData.reportInferenceResult(csBuilder)
@@ -208,12 +208,12 @@ class CoroutineInferenceSupport(
            expectedType.isSuspendFunctionType
    }

-    fun checkCoroutineCalls(
+    fun checkBuilderInferenceCalls(
        context: BasicCallResolutionContext,
        tracingStrategy: TracingStrategy,
        overloadResults: OverloadResolutionResultsImpl<*>
    ) {
-        val inferenceData = overloadResults.getCoroutineInferenceData() ?: return
+        val inferenceData = overloadResults.getBuilderInferenceData() ?: return

        val resultingCall = overloadResults.resultingCall

@@ -232,7 +232,7 @@ class CoroutineInferenceSupport(

            with(NewKotlinTypeChecker.Default) {
                val parameterType = getEffectiveExpectedType(argumentMatch.valueParameter, valueArgument, context)
-                CoroutineTypeCheckerContext(allowOnlyTrivialConstraints = false).isSubtypeOf(kotlinType.unwrap(), parameterType.unwrap())
+                BuilderInferenceTypeCheckerContext(allowOnlyTrivialConstraints = false).isSubtypeOf(kotlinType.unwrap(), parameterType.unwrap())
            }
        }

@@ -245,14 +245,14 @@ class CoroutineInferenceSupport(

        resultingCall.extensionReceiver?.let { actualReceiver ->
            with(NewKotlinTypeChecker.Default) {
-                CoroutineTypeCheckerContext(allowOnlyTrivialConstraints = allowOnlyTrivialConstraintsForReceiver).isSubtypeOf(
+                BuilderInferenceTypeCheckerContext(allowOnlyTrivialConstraints = allowOnlyTrivialConstraintsForReceiver).isSubtypeOf(
                    actualReceiver.type.unwrap(), extensionReceiver.value.type.unwrap()
                )
            }
        }
    }

-    private class CoroutineTypeCheckerContext(
+    private class BuilderInferenceTypeCheckerContext(
        private val allowOnlyTrivialConstraints: Boolean
    ) : ClassicTypeCheckerContext(errorTypeEqualsToAnything = true) {

@@ -260,7 +260,7 @@ class CoroutineInferenceSupport(
            require(subType is UnwrappedType)
            require(superType is UnwrappedType)
            val typeTemplate = subType as? TypeTemplate ?: superType as? TypeTemplate
-            typeTemplate?.coroutineInferenceData?.addConstraint(subType, superType, allowOnlyTrivialConstraints)
+            typeTemplate?.builderInferenceData?.addConstraint(subType, superType, allowOnlyTrivialConstraints)
            return null
        }
    }
@@ -302,7 +302,7 @@ fun isApplicableCallForBuilderInference(descriptor: CallableDescriptor, language
    if (languageVersionSettings.supportsFeature(LanguageFeature.UnrestrictedBuilderInference)) return true

    if (!languageVersionSettings.supportsFeature(LanguageFeature.ExperimentalBuilderInference)) {
-        return isGoodCallForOldCoroutines(descriptor)
+        return isGoodCallForOldBuilderInference(descriptor)
    }

    if (descriptor.isExtension && !descriptor.hasBuilderInferenceAnnotation()) {
@@ -313,7 +313,7 @@ fun isApplicableCallForBuilderInference(descriptor: CallableDescriptor, language
    return !returnType.containsTypeTemplate()
 }

-private fun isGoodCallForOldCoroutines(resultingDescriptor: CallableDescriptor): Boolean {
+private fun isGoodCallForOldBuilderInference(resultingDescriptor: CallableDescriptor): Boolean {
    val returnType = resultingDescriptor.returnType ?: return false
    if (returnType.containsTypeTemplate()) return false

@@ -324,7 +324,7 @@ private fun isGoodCallForOldCoroutines(resultingDescriptor: CallableDescriptor):
    return true
 }

-fun isCoroutineCallWithAdditionalInference(
+fun isBuilderInferenceCall(
    parameterDescriptor: ValueParameterDescriptor,
    argument: ValueArgument,
    languageVersionSettings: LanguageVersionSettings
@@ -342,18 +342,18 @@ fun isCoroutineCallWithAdditionalInference(
            parameterDescriptor.type.let { it.isBuiltinFunctionalType && it.getReceiverTypeFromFunctionType() != null }
 }

-fun OverloadResolutionResultsImpl<*>.isResultWithCoroutineInference() = getCoroutineInferenceData() != null
+fun OverloadResolutionResultsImpl<*>.isResultWithBuilderInference() = getBuilderInferenceData() != null

-private fun OverloadResolutionResultsImpl<*>.getCoroutineInferenceData(): CoroutineInferenceData? {
+private fun OverloadResolutionResultsImpl<*>.getBuilderInferenceData(): BuilderInferenceData? {
    if (!isSingleResult) return null

-    fun getData(receiverValue: ReceiverValue?): CoroutineInferenceData? {
-        var coroutineInferenceData: CoroutineInferenceData? = null
+    fun getData(receiverValue: ReceiverValue?): BuilderInferenceData? {
+        var builderInferenceData: BuilderInferenceData? = null
        receiverValue?.type?.contains {
-            (it as? TypeTemplate)?.coroutineInferenceData?.let { coroutineInferenceData = it }
+            (it as? TypeTemplate)?.builderInferenceData?.let { builderInferenceData = it }
            false
        }
-        return coroutineInferenceData
+        return builderInferenceData
    }
    return getData(resultingCall.dispatchReceiver) ?: getData(resultingCall.extensionReceiver)
 }
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.resolve.calls.components.KotlinResolutionStatelessCa
 import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemBuilderImpl
 import org.jetbrains.kotlin.resolve.calls.inference.components.ConstraintInjector
 import org.jetbrains.kotlin.resolve.calls.inference.components.SimpleConstraintSystemImpl
-import org.jetbrains.kotlin.resolve.calls.inference.isCoroutineCallWithAdditionalInference
+import org.jetbrains.kotlin.resolve.calls.inference.isBuilderInferenceCall
 import org.jetbrains.kotlin.resolve.calls.model.CallableReferenceKotlinCallArgument
 import org.jetbrains.kotlin.resolve.calls.model.KotlinCall
 import org.jetbrains.kotlin.resolve.calls.model.KotlinCallArgument
@@ -92,8 +92,8 @@ class KotlinResolutionStatelessCallbacksImpl(
    override fun getVariableCandidateIfInvoke(functionCall: KotlinCall) =
        functionCall.safeAs<PSIKotlinCallForInvoke>()?.variableCall

-    override fun isCoroutineCall(argument: KotlinCallArgument, parameter: ValueParameterDescriptor): Boolean =
-        isCoroutineCallWithAdditionalInference(parameter, argument.psiCallArgument.valueArgument, languageVersionSettings)
+    override fun isBuilderInferenceCall(argument: KotlinCallArgument, parameter: ValueParameterDescriptor): Boolean =
+        isBuilderInferenceCall(parameter, argument.psiCallArgument.valueArgument, languageVersionSettings)

    override fun isApplicableCallForBuilderInference(
        descriptor: CallableDescriptor,
@@ -37,7 +37,7 @@ import org.jetbrains.kotlin.resolve.calls.callResolverUtil.isConventionCall
 import org.jetbrains.kotlin.resolve.calls.callResolverUtil.isInfixCall
 import org.jetbrains.kotlin.resolve.calls.callUtil.createLookupLocation
 import org.jetbrains.kotlin.resolve.calls.context.*
-import org.jetbrains.kotlin.resolve.calls.inference.CoroutineInferenceSupport
+import org.jetbrains.kotlin.resolve.calls.inference.BuilderInferenceSupport
 import org.jetbrains.kotlin.resolve.calls.model.KotlinCallDiagnostic
 import org.jetbrains.kotlin.resolve.calls.model.MutableResolvedCall
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCallImpl
@@ -71,7 +71,7 @@ class NewResolutionOldInference(
    private val dynamicCallableDescriptors: DynamicCallableDescriptors,
    private val syntheticScopes: SyntheticScopes,
    private val languageVersionSettings: LanguageVersionSettings,
-    private val coroutineInferenceSupport: CoroutineInferenceSupport,
+    private val builderInferenceSupport: BuilderInferenceSupport,
    private val deprecationResolver: DeprecationResolver,
    private val typeApproximator: TypeApproximator,
    private val implicitsResolutionFilter: ImplicitsExtensionsResolutionFilter,
@@ -218,7 +218,7 @@ class NewResolutionOldInference(
        }

        val overloadResults = convertToOverloadResults<D>(candidates, tracing, context)
-        coroutineInferenceSupport.checkCoroutineCalls(context, tracing, overloadResults)
+        builderInferenceSupport.checkBuilderInferenceCalls(context, tracing, overloadResults)
        return overloadResults
    }

@@ -80,8 +80,8 @@ data class IncorporationConstraintPosition(
    override fun toString(): String = "Incorporate $initialConstraint from position $from"
 }

-object CoroutinePosition : ConstraintPosition() {
-    override fun toString(): String = "for coroutine call"
+object BuilderInferencePosition : ConstraintPosition() {
+    override fun toString(): String = "For builder inference call"
 }

 // TODO: should be used only in SimpleConstraintSystemImpl
@@ -38,7 +38,7 @@ interface KotlinResolutionStatelessCallbacks {
    fun isSuperExpression(receiver: SimpleKotlinCallArgument?): Boolean
    fun getScopeTowerForCallableReferenceArgument(argument: CallableReferenceKotlinCallArgument): ImplicitScopeTower
    fun getVariableCandidateIfInvoke(functionCall: KotlinCall): KotlinResolutionCandidate?
-    fun isCoroutineCall(argument: KotlinCallArgument, parameter: ValueParameterDescriptor): Boolean
+    fun isBuilderInferenceCall(argument: KotlinCallArgument, parameter: ValueParameterDescriptor): Boolean
    fun isApplicableCallForBuilderInference(descriptor: CallableDescriptor, languageVersionSettings: LanguageVersionSettings): Boolean

    fun isOldIntersectionIsEmpty(types: Collection<KotlinType>): Boolean
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.descriptors.annotations.FilteredAnnotations
 import org.jetbrains.kotlin.resolve.calls.inference.addSubsystemFromArgument
 import org.jetbrains.kotlin.resolve.calls.inference.components.ConstraintSystemCompletionMode
-import org.jetbrains.kotlin.resolve.calls.inference.model.CoroutinePosition
+import org.jetbrains.kotlin.resolve.calls.inference.model.BuilderInferencePosition
 import org.jetbrains.kotlin.resolve.calls.inference.model.LambdaArgumentConstraintPositionImpl
 import org.jetbrains.kotlin.resolve.calls.model.*
 import org.jetbrains.kotlin.types.KotlinType
@@ -199,7 +199,7 @@ class PostponedArgumentsAnalyzer(
                val variable = variableWithConstraints.typeVariable

                c.getBuilder().unmarkPostponedVariable(variable)
-                c.getBuilder().addEqualityConstraint(variable.defaultType(c), resultType, CoroutinePosition)
+                c.getBuilder().addEqualityConstraint(variable.defaultType(c), resultType, BuilderInferencePosition)
            }
        }
    }
@@ -272,7 +272,7 @@ internal object CreateFreshVariablesSubstitutor : ResolutionPart() {
 internal object PostponedVariablesInitializerResolutionPart : ResolutionPart() {
    override fun KotlinResolutionCandidate.process(workIndex: Int) {
        for ((argument, parameter) in resolvedCall.argumentToCandidateParameter) {
-            if (!callComponents.statelessCallbacks.isCoroutineCall(argument, parameter)) continue
+            if (!callComponents.statelessCallbacks.isBuilderInferenceCall(argument, parameter)) continue
            val receiverType = parameter.type.getReceiverTypeFromFunctionType() ?: continue

            if (argument is LambdaKotlinCallArgument && !argument.hasBuilderInferenceAnnotation) {