From 5fcb18ac2b741c37d2c7660c59dca0ceaf052c2a Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Mon, 12 Sep 2022 11:28:52 +0200 Subject: [PATCH] Revert "[FE 1.0] Resolve this and super calls through the new type inference infra" This reverts commit bab8047bb3aeb99f5cac9eeb0a66fede0c42e080. --- .../resolve/DelegatedPropertyResolver.kt | 3 +- .../kotlin/resolve/calls/CallResolver.java | 17 +------ .../resolve/calls/tower/PSICallResolver.kt | 30 +------------ .../BasicExpressionTypingVisitor.java | 21 +++++++-- .../calls/model/KotlinResolverContext.kt | 3 +- .../noErrorsForImplicitConstraints.fir.kt | 44 +++++++++++++++++++ .../noErrorsForImplicitConstraints.kt | 9 ++-- .../thisOfNothingNullableType.fir.kt | 17 ------- .../thisOfNothingNullableType.kt | 3 +- .../thisOfNothingType.fir.kt | 17 ------- .../delegatedProperty/thisOfNothingType.kt | 3 +- 11 files changed, 74 insertions(+), 93 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/delegatedProperty/inference/noErrorsForImplicitConstraints.fir.kt delete mode 100644 compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingNullableType.fir.kt delete mode 100644 compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingType.fir.kt diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.kt index d5cc683f4bb..130cc871ec6 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.kt @@ -15,7 +15,6 @@ import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.descriptors.VariableAccessorDescriptor import org.jetbrains.kotlin.descriptors.VariableDescriptorWithAccessors import org.jetbrains.kotlin.diagnostics.Errors.* -import org.jetbrains.kotlin.diagnostics.reportDiagnosticOnce import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.renderer.DescriptorRenderer import org.jetbrains.kotlin.resolve.BindingContext.* @@ -291,7 +290,7 @@ class DelegatedPropertyResolver( resolutionErrorFactory?.let { val expectedFunction = renderCall(delegateOperatorCall, trace.bindingContext) - trace.reportDiagnosticOnce(it.on(delegateExpression, expectedFunction, delegateOperatorResults.resultingCalls)) + trace.report(it.on(delegateExpression, expectedFunction, delegateOperatorResults.resultingCalls)) } return resolutionErrorFactory != null diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java index b8c20928838..ed8faed18a8 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java @@ -290,21 +290,6 @@ public class CallResolver { callResolutionContext, resolutionCandidates, TracingStrategyImpl.create(expression, call)); } - @NotNull - public OverloadResolutionResults resolveThisOrSuperCallWithGivenDescriptor( - @NotNull ExpressionTypingContext context, - @NotNull Call call, - @NotNull ReceiverParameterDescriptor descriptor - ) { - BasicCallResolutionContext callResolutionContext = BasicCallResolutionContext.create(context, call, CheckArgumentTypesMode.CHECK_VALUE_ARGUMENTS); - - return PSICallResolver.runResolutionAndInferenceForGivenDescriptors( - callResolutionContext, - Collections.singletonList(descriptor), - TracingStrategy.EMPTY - ); - } - @NotNull public OverloadResolutionResults resolveFunctionCall( @NotNull BindingTrace trace, @@ -620,7 +605,7 @@ public class CallResolver { if (newInferenceEnabled && resolutionKind instanceof NewResolutionOldInference.ResolutionKind.GivenCandidates) { assert resolutionTask.givenCandidates != null; BindingContextUtilsKt.recordScope(context.trace, context.scope, context.call.getCalleeExpression()); - return PSICallResolver.runResolutionAndInferenceForGivenOldCandidates(context, resolutionTask.givenCandidates, tracing); + return PSICallResolver.runResolutionAndInferenceForGivenCandidates(context, resolutionTask.givenCandidates, tracing); } TemporaryBindingTrace traceToResolveCall = TemporaryBindingTrace.create(context.trace, "trace to resolve call", call); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/PSICallResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/PSICallResolver.kt index 7662897b165..08b745d7124 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/PSICallResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/PSICallResolver.kt @@ -144,36 +144,8 @@ class PSICallResolver( } } - fun runResolutionAndInferenceForGivenDescriptors( - context: BasicCallResolutionContext, - descriptors: Collection, - tracingStrategy: TracingStrategy - ): OverloadResolutionResults { - val isSpecialFunction = descriptors.any { it.name in SPECIAL_FUNCTION_NAMES } - val kotlinCall = toKotlinCall( - context, KotlinCallKind.FUNCTION, context.call, givenCandidatesName, tracingStrategy, isSpecialFunction, null - ) - val scopeTower = ASTScopeTower(context) - val resolutionCallbacks = createResolutionCallbacks(context) - val givenCandidates = descriptors.map { - GivenCandidate( - it, - dispatchReceiver = null, - knownTypeParametersResultingSubstitutor = null - ) - } - - val result = kotlinCallResolver.resolveAndCompleteGivenCandidates( - scopeTower, resolutionCallbacks, kotlinCall, calculateExpectedType(context), givenCandidates, context.collectAllCandidates - ) - - return convertToOverloadResolutionResults(context, result, tracingStrategy).also { - clearCacheForApproximationResults() - } - } - // actually, `D` is at least FunctionDescriptor, but right now because of CallResolver it isn't possible change upper bound for `D` - fun runResolutionAndInferenceForGivenOldCandidates( + fun runResolutionAndInferenceForGivenCandidates( context: BasicCallResolutionContext, resolutionCandidates: Collection>, tracingStrategy: TracingStrategy diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java index 6053dba0198..9b8e9c6b328 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java @@ -58,6 +58,7 @@ import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResultsUtil; import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo; import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValue; import org.jetbrains.kotlin.resolve.calls.smartcasts.Nullability; +import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind; import org.jetbrains.kotlin.resolve.calls.tasks.OldResolutionCandidate; import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategy; import org.jetbrains.kotlin.resolve.calls.tower.NewAbstractResolvedCall; @@ -635,13 +636,27 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { ) { BindingTrace trace = context.trace; Call call = CallMaker.makeCall(expression, null, null, expression, Collections.emptyList()); - OverloadResolutionResults results = - components.callResolver.resolveThisOrSuperCallWithGivenDescriptor(context, call, descriptor); + OldResolutionCandidate resolutionCandidate = + OldResolutionCandidate.create( + call, descriptor, null, ExplicitReceiverKind.NO_EXPLICIT_RECEIVER, null); - ResolvedCall resolvedCall = results.getResultingCall(); + ResolvedCallImpl resolvedCall = + ResolvedCallImpl.create(resolutionCandidate, + TemporaryBindingTrace.create(trace, "Fake trace for fake 'this' or 'super' resolved call"), + TracingStrategy.EMPTY, + new DataFlowInfoForArgumentsImpl(context.dataFlowInfo, call)); + resolvedCall.markCallAsCompleted(); trace.record(RESOLVED_CALL, call, resolvedCall); trace.record(CALL, expression, call); + + if (context.trace.wantsDiagnostics()) { + CallCheckerContext callCheckerContext = + createCallCheckerContext(context); + for (CallChecker checker : components.callCheckers) { + checker.check(resolvedCall, expression, callCheckerContext); + } + } } private static boolean isDeclaredInClass(ReceiverParameterDescriptor receiver) { diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/KotlinResolverContext.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/KotlinResolverContext.kt index 7121c1d7567..57d71ec95cc 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/KotlinResolverContext.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/KotlinResolverContext.kt @@ -19,7 +19,6 @@ package org.jetbrains.kotlin.resolve.calls.model import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.builtins.ReflectionTypes import org.jetbrains.kotlin.config.LanguageVersionSettings -import org.jetbrains.kotlin.descriptors.CallableDescriptor import org.jetbrains.kotlin.descriptors.FunctionDescriptor import org.jetbrains.kotlin.incremental.components.LookupTracker import org.jetbrains.kotlin.resolve.calls.components.* @@ -49,7 +48,7 @@ class KotlinCallComponents( ) class GivenCandidate( - val descriptor: CallableDescriptor, + val descriptor: FunctionDescriptor, val dispatchReceiver: ReceiverValueWithSmartCastInfo?, val knownTypeParametersResultingSubstitutor: TypeSubstitutor? ) diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/inference/noErrorsForImplicitConstraints.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/inference/noErrorsForImplicitConstraints.fir.kt new file mode 100644 index 00000000000..914e317e5d0 --- /dev/null +++ b/compiler/testData/diagnostics/tests/delegatedProperty/inference/noErrorsForImplicitConstraints.fir.kt @@ -0,0 +1,44 @@ +package foo + +import kotlin.reflect.KProperty + +class A { + var a5: String by MyProperty1() + var b5: String by getMyProperty1() +} + +fun getMyProperty1() = MyProperty1() + +class MyProperty1 { + + operator fun getValue(thisRef: R, desc: KProperty<*>): T { + throw Exception() + } + + operator fun setValue(i: Int, j: Any, k: Int) { + println("set") + } +} + +// ----------------- + +class B { + var a5: String by MyProperty2() + var b5: String by getMyProperty2() +} + +fun getMyProperty2() = MyProperty2() + +class MyProperty2 { + + operator fun getValue(thisRef: R, desc: KProperty<*>): T { + throw Exception() + } + + operator fun setValue(i: Int) { + println("set") + } +} + +// ----------------- +fun println(a: Any?) = a diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/inference/noErrorsForImplicitConstraints.kt b/compiler/testData/diagnostics/tests/delegatedProperty/inference/noErrorsForImplicitConstraints.kt index 19e6dce1454..68c0eb2d53d 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/inference/noErrorsForImplicitConstraints.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/inference/noErrorsForImplicitConstraints.kt @@ -1,11 +1,10 @@ -// FIR_IDENTICAL package foo import kotlin.reflect.KProperty class A { - var a5: String by MyProperty1() - var b5: String by getMyProperty1() + var a5: String by MyProperty1() + var b5: String by getMyProperty1() } fun getMyProperty1() = MyProperty1() @@ -24,8 +23,8 @@ class MyProperty1 { // ----------------- class B { - var a5: String by MyProperty2() - var b5: String by getMyProperty2() + var a5: String by MyProperty2() + var b5: String by getMyProperty2() } fun getMyProperty2() = MyProperty2() diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingNullableType.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingNullableType.fir.kt deleted file mode 100644 index 0ef43a4fc44..00000000000 --- a/compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingNullableType.fir.kt +++ /dev/null @@ -1,17 +0,0 @@ -// !DIAGNOSTICS: -UNUSED_PARAMETER - -import kotlin.reflect.KProperty - -class A { - var a: Int by Delegate() -} - -var aTopLevel: Int by Delegate() - -class Delegate { - operator fun getValue(t: Nothing?, p: KProperty<*>): Int { - return 1 - } - operator fun setValue(t: Nothing?, p: KProperty<*>, a: Int) { - } -} diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingNullableType.kt b/compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingNullableType.kt index de408633be1..166a2aa8a70 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingNullableType.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingNullableType.kt @@ -1,9 +1,10 @@ +// FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_PARAMETER import kotlin.reflect.KProperty class A { - var a: Int by Delegate() + var a: Int by Delegate() } var aTopLevel: Int by Delegate() diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingType.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingType.fir.kt deleted file mode 100644 index 1088ea9b8fd..00000000000 --- a/compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingType.fir.kt +++ /dev/null @@ -1,17 +0,0 @@ -// !DIAGNOSTICS: -UNUSED_PARAMETER - -import kotlin.reflect.KProperty - -class A { - var a: Int by Delegate() -} - -var aTopLevel: Int by Delegate() - -class Delegate { - fun getValue(t: Nothing, p: KProperty<*>): Int { - return 1 - } - fun setValue(t: Nothing, p: KProperty<*>, a: Int) { - } -} diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingType.kt b/compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingType.kt index e1eadab0b52..d916945818b 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingType.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingType.kt @@ -1,9 +1,10 @@ +// FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_PARAMETER import kotlin.reflect.KProperty class A { - var a: Int by Delegate() + var a: Int by Delegate() } var aTopLevel: Int by Delegate()