From ca13aea26a18433da6c6fe9cdaece7522df0544e Mon Sep 17 00:00:00 2001 From: Victor Petukhov Date: Mon, 20 Sep 2021 17:01:31 +0300 Subject: [PATCH] Creating resolved and resolution atoms for callable references --- .../resolve/calls/tower/NewCallArguments.kt | 3 +- .../calls/tower/ResolvedAtomCompleter.kt | 2 +- .../components/CallableReferenceResolution.kt | 5 ++-- .../calls/components/KotlinCallCompleter.kt | 5 ++-- .../KotlinConstraintSystemCompleter.kt | 6 ++-- .../calls/model/KotlinCallArguments.kt | 6 ++-- .../resolve/calls/model/ResolutionAtoms.kt | 30 +++++++++++++------ .../resolve/calls/model/ResolvedCallAtoms.kt | 14 ++++++++- 8 files changed, 48 insertions(+), 23 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/NewCallArguments.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/NewCallArguments.kt index 44c28b544fa..89308a06ac9 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/NewCallArguments.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/NewCallArguments.kt @@ -139,7 +139,8 @@ class CallableReferenceKotlinCallArgumentImpl( val ktCallableReferenceExpression: KtCallableReferenceExpression, override val argumentName: Name?, override val lhsResult: LHSResult, - override val rhsName: Name + override val rhsName: Name, + override val call: KotlinCall ) : CallableReferenceKotlinCallArgument, PSIKotlinCallArgument() class CollectionLiteralKotlinCallArgumentImpl( diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/ResolvedAtomCompleter.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/ResolvedAtomCompleter.kt index eb97768f22f..c7b84d8e5b5 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/ResolvedAtomCompleter.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/ResolvedAtomCompleter.kt @@ -79,7 +79,7 @@ class ResolvedAtomCompleter( when (resolvedAtom) { is ResolvedCollectionLiteralAtom -> completeCollectionLiteralCalls(resolvedAtom) - is ResolvedCallableReferenceAtom -> completeCallableReference(resolvedAtom) + is ResolvedCallableReferenceArgumentAtom -> completeCallableReferenceArgument(resolvedAtom) is ResolvedLambdaAtom -> completeLambda(resolvedAtom) is ResolvedCallAtom -> completeResolvedCall(resolvedAtom, emptyList()) is ResolvedSubCallArgument -> completeSubCallArgument(resolvedAtom) diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/CallableReferenceResolution.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/CallableReferenceResolution.kt index 2e8618f1fda..26ba0c5a1e0 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/CallableReferenceResolution.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/CallableReferenceResolution.kt @@ -60,9 +60,8 @@ class CallableReferenceAdaptation( * C::foo <-> Object * D.E::foo <-> Expression */ -fun createCallableReferenceProcessor(factory: CallableReferencesCandidateFactory): ScopeTowerProcessor { - val lhsResult = factory.argument.lhsResult - when (lhsResult) { +fun createCallableReferenceProcessor(factory: CallableReferencesCandidateFactory): ScopeTowerProcessor { + when (val lhsResult = factory.kotlinCall.lhsResult) { LHSResult.Empty, LHSResult.Error, is LHSResult.Expression -> { val explicitReceiver = (lhsResult as? LHSResult.Expression)?.lshCallArgument?.receiver return factory.createCallableProcessor(explicitReceiver) diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/KotlinCallCompleter.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/KotlinCallCompleter.kt index 0111ce3db30..2ef7800fe1f 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/KotlinCallCompleter.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/KotlinCallCompleter.kt @@ -165,8 +165,9 @@ class KotlinCallCompleter( callComponents.languageVersionSettings.supportsFeature(LanguageFeature.SamConversionPerArgument) && !callComponents.languageVersionSettings.supportsFeature(LanguageFeature.ProhibitVarargAsArrayAfterSamArgument) - if (samConversionPerArgumentWithWarningsForVarargAfterSam && resolvedCall.candidateDescriptor is SyntheticMemberDescriptor<*>) { - val declarationDescriptor = resolvedCall.candidateDescriptor.baseDescriptorForSynthetic as? FunctionDescriptor ?: return + val candidateDescriptor = resolvedCall.candidateDescriptor + if (samConversionPerArgumentWithWarningsForVarargAfterSam && candidateDescriptor is SyntheticMemberDescriptor<*>) { + val declarationDescriptor = candidateDescriptor.baseDescriptorForSynthetic as? FunctionDescriptor ?: return if (declarationDescriptor.valueParameters.lastOrNull()?.isVararg == true) { diagnosticHolder.addDiagnostic( diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/components/KotlinConstraintSystemCompleter.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/components/KotlinConstraintSystemCompleter.kt index 56ccb30825a..c1bca857399 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/components/KotlinConstraintSystemCompleter.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/components/KotlinConstraintSystemCompleter.kt @@ -421,8 +421,8 @@ class KotlinConstraintSystemCompleter( is ResolvedCallAtom -> freshVariablesSubstitutor.freshVariables.map { it.freshTypeConstructor } is PostponedCallableReferenceAtom -> getVariablesFromRevisedExpectedType(revisedExpectedType).orEmpty() + - candidate?.freshSubstitutor?.freshVariables?.map { it.freshTypeConstructor }.orEmpty() - is ResolvedCallableReferenceAtom -> candidate?.freshSubstitutor?.freshVariables?.map { it.freshTypeConstructor }.orEmpty() + candidate?.freshVariablesSubstitutor?.freshVariables?.map { it.freshTypeConstructor }.orEmpty() + is ResolvedCallableReferenceArgumentAtom -> candidate?.freshVariablesSubstitutor?.freshVariables?.map { it.freshTypeConstructor }.orEmpty() is ResolvedLambdaAtom -> listOfNotNull(typeVariableForLambdaReturnType?.freshTypeConstructor) else -> emptyList() } @@ -493,7 +493,7 @@ class KotlinConstraintSystemCompleter( fun ResolvedAtom.check(): ResolvedAtom? { val suitableCall = when (this) { is ResolvedCallAtom -> typeVariable in freshVariablesSubstitutor.freshVariables - is ResolvedCallableReferenceAtom -> candidate?.freshSubstitutor?.freshVariables?.let { typeVariable in it } ?: false + is ResolvedCallableReferenceArgumentAtom -> candidate?.freshVariablesSubstitutor?.freshVariables?.let { typeVariable in it } ?: false is ResolvedLambdaAtom -> typeVariable == typeVariableForLambdaReturnType else -> false } diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/KotlinCallArguments.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/KotlinCallArguments.kt index 501c9aa32e5..a88c2d91a7b 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/KotlinCallArguments.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/KotlinCallArguments.kt @@ -120,13 +120,13 @@ sealed class LHSResult { object Error : LHSResult() } -interface CallableReferenceKotlinCallArgument : PostponableKotlinCallArgument { +interface CallableReferenceKotlinCallArgument : PostponableKotlinCallArgument, CallableReferenceResolutionAtom { override val isSpread: Boolean get() = false - val lhsResult: LHSResult + override val lhsResult: LHSResult - val rhsName: Name + override val call: KotlinCall } interface CollectionLiteralKotlinCallArgument : PostponableKotlinCallArgument diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/ResolutionAtoms.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/ResolutionAtoms.kt index e73d9362a02..71f36f78e5f 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/ResolutionAtoms.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/ResolutionAtoms.kt @@ -7,15 +7,14 @@ package org.jetbrains.kotlin.resolve.calls.model import org.jetbrains.kotlin.descriptors.CallableDescriptor import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor -import org.jetbrains.kotlin.resolve.calls.components.candidate.CallableReferenceResolutionCandidate -import org.jetbrains.kotlin.resolve.calls.components.ReturnArgumentsInfo -import org.jetbrains.kotlin.resolve.calls.components.TypeArgumentsToParametersMapper -import org.jetbrains.kotlin.resolve.calls.components.extractInputOutputTypesFromCallableReferenceExpectedType +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.resolve.calls.components.* 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.tasks.ExplicitReceiverKind import org.jetbrains.kotlin.resolve.calls.components.candidate.ResolutionCandidate +import org.jetbrains.kotlin.resolve.calls.components.candidate.CallableReferenceResolutionCandidate import org.jetbrains.kotlin.resolve.constants.IntegerValueTypeConstant import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.TypeConstructor @@ -32,6 +31,20 @@ import org.jetbrains.kotlin.utils.addToStdlib.safeAs */ interface ResolutionAtom +sealed interface CallableReferenceResolutionAtom : ResolutionAtom { + val lhsResult: LHSResult + val rhsName: Name + val call: KotlinCall +} + +class CallableReferenceKotlinCall( + override val call: KotlinCall, + override val lhsResult: LHSResult, + override val rhsName: Name, +) : CallableReferenceResolutionAtom + +sealed interface ResolvedCallableReferenceAtom + sealed class ResolvedAtom { abstract val atom: ResolutionAtom? // CallResolutionResult has no ResolutionAtom @@ -163,10 +176,10 @@ fun ResolvedLambdaAtom.unwrap(): ResolvedLambdaAtom { return if (resultArgumentsInfo != null) this else subResolvedAtoms!!.single() as ResolvedLambdaAtom } -abstract class ResolvedCallableReferenceAtom( +abstract class ResolvedCallableReferenceArgumentAtom( override val atom: CallableReferenceKotlinCallArgument, override val expectedType: UnwrappedType? -) : PostponedResolvedAtom() { +) : PostponedResolvedAtom(), ResolvedCallableReferenceAtom { var candidate: CallableReferenceResolutionCandidate? = null private set @@ -185,8 +198,7 @@ abstract class ResolvedCallableReferenceAtom( class EagerCallableReferenceAtom( atom: CallableReferenceKotlinCallArgument, expectedType: UnwrappedType? -) : ResolvedCallableReferenceAtom(atom, expectedType) { - +) : ResolvedCallableReferenceArgumentAtom(atom, expectedType) { override val inputTypes: Collection get() = emptyList() override val outputType: UnwrappedType? get() = null @@ -196,7 +208,7 @@ class EagerCallableReferenceAtom( sealed class AbstractPostponedCallableReferenceAtom( atom: CallableReferenceKotlinCallArgument, expectedType: UnwrappedType? -) : ResolvedCallableReferenceAtom(atom, expectedType) { +) : ResolvedCallableReferenceArgumentAtom(atom, expectedType) { override val inputTypes: Collection get() = extractInputOutputTypesFromCallableReferenceExpectedType(expectedType)?.inputTypes ?: listOfNotNull(expectedType) diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/ResolvedCallAtoms.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/ResolvedCallAtoms.kt index 498ce95b23c..20ea27812ec 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/ResolvedCallAtoms.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/ResolvedCallAtoms.kt @@ -64,7 +64,19 @@ fun KotlinDiagnosticsHolder.addError(error: ConstraintSystemError) { addDiagnostic(error.asDiagnostic()) } -class MutableResolvedCallAtom( +class ResolvedCallableReferenceCallAtom( + atom: KotlinCall, + candidateDescriptor: CallableDescriptor, + explicitReceiverKind: ExplicitReceiverKind, + dispatchReceiverArgument: SimpleKotlinCallArgument?, + extensionReceiverArgument: SimpleKotlinCallArgument?, + reflectionCandidateType: UnwrappedType? = null, + candidate: CallableReferenceResolutionCandidate? = null +) : MutableResolvedCallAtom( + atom, candidateDescriptor, explicitReceiverKind, dispatchReceiverArgument, extensionReceiverArgument, reflectionCandidateType, candidate +), ResolvedCallableReferenceAtom + +open class MutableResolvedCallAtom( override val atom: KotlinCall, override val candidateDescriptor: CallableDescriptor, // original candidate descriptor override val explicitReceiverKind: ExplicitReceiverKind,