[FE 1.0] Resolve this and super calls through the new type inference infra

^KT-48961 In progress

compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.kt

@@ -15,6 +15,7 @@ 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.*
@@ -290,7 +291,7 @@ class DelegatedPropertyResolver(
 
         resolutionErrorFactory?.let {
             val expectedFunction = renderCall(delegateOperatorCall, trace.bindingContext)
-            trace.report(it.on(delegateExpression, expectedFunction, delegateOperatorResults.resultingCalls))
+            trace.reportDiagnosticOnce(it.on(delegateExpression, expectedFunction, delegateOperatorResults.resultingCalls))
         }
 
         return resolutionErrorFactory != null

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java

@@ -290,6 +290,21 @@ public class CallResolver {
                 callResolutionContext, resolutionCandidates, TracingStrategyImpl.create(expression, call));
     }
 
+    @NotNull
+    public OverloadResolutionResults<ReceiverParameterDescriptor> 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<FunctionDescriptor> resolveFunctionCall(
             @NotNull BindingTrace trace,
@@ -605,7 +620,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.runResolutionAndInferenceForGivenCandidates(context, resolutionTask.givenCandidates, tracing);
+            return PSICallResolver.runResolutionAndInferenceForGivenOldCandidates(context, resolutionTask.givenCandidates, tracing);
         }
 
         TemporaryBindingTrace traceToResolveCall = TemporaryBindingTrace.create(context.trace, "trace to resolve call", call);

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

@@ -143,8 +143,36 @@ class PSICallResolver(
         }
     }
 
+    fun <D : CallableDescriptor> runResolutionAndInferenceForGivenDescriptors(
+        context: BasicCallResolutionContext,
+        descriptors: Collection<CallableDescriptor>,
+        tracingStrategy: TracingStrategy
+    ): OverloadResolutionResults<D> {
+        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<D>(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 <D : CallableDescriptor> runResolutionAndInferenceForGivenCandidates(
+    fun <D : CallableDescriptor> runResolutionAndInferenceForGivenOldCandidates(
         context: BasicCallResolutionContext,
         resolutionCandidates: Collection<OldResolutionCandidate<D>>,
         tracingStrategy: TracingStrategy

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java

@@ -58,7 +58,6 @@ 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;
@@ -636,27 +635,13 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     ) {
         BindingTrace trace = context.trace;
         Call call = CallMaker.makeCall(expression, null, null, expression, Collections.emptyList());
-        OldResolutionCandidate<ReceiverParameterDescriptor> resolutionCandidate =
+        OverloadResolutionResults<ReceiverParameterDescriptor> results =
-                OldResolutionCandidate.create(
+                components.callResolver.resolveThisOrSuperCallWithGivenDescriptor(context, call, descriptor);
-                        call, descriptor, null, ExplicitReceiverKind.NO_EXPLICIT_RECEIVER, null);
 
-        ResolvedCallImpl<ReceiverParameterDescriptor> resolvedCall =
+        ResolvedCall<?> resolvedCall = results.getResultingCall();
-                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) {

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/KotlinResolverContext.kt

@@ -19,6 +19,7 @@ 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.*
@@ -48,7 +49,7 @@ class KotlinCallComponents(
 )
 
 class GivenCandidate(
-    val descriptor: FunctionDescriptor,
+    val descriptor: CallableDescriptor,
     val dispatchReceiver: ReceiverValueWithSmartCastInfo?,
     val knownTypeParametersResultingSubstitutor: TypeSubstitutor?
 )

compiler/testData/diagnostics/tests/delegatedProperty/inference/noErrorsForImplicitConstraints.fir.kt

@@ -1,44 +0,0 @@
-package foo
-
-import kotlin.reflect.KProperty
-
-class A {
-    var a5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>MyProperty1()<!>
-    var b5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>getMyProperty1()<!>
-}
-
-fun <A, B> getMyProperty1() = MyProperty1<A, B>()
-
-class MyProperty1<T, R> {
-
-    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 <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>MyProperty2()<!>
-    var b5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>getMyProperty2()<!>
-}
-
-fun <A, B> getMyProperty2() = MyProperty2<A, B>()
-
-class MyProperty2<T, R> {
-
-    operator fun getValue(thisRef: R, desc: KProperty<*>): T {
-        throw Exception()
-    }
-
-    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun setValue(i: Int) {
-        println("set")
-    }
-}
-
-// -----------------
-fun println(a: Any?) = a

compiler/testData/diagnostics/tests/delegatedProperty/inference/noErrorsForImplicitConstraints.kt

@@ -1,10 +1,11 @@
+// FIR_IDENTICAL
 package foo
 
 import kotlin.reflect.KProperty
 
 class A {
-    var a5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>MyProperty1<!>()<!>
+    var a5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>MyProperty1()<!>
-    var b5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty1<!>()<!>
+    var b5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>getMyProperty1()<!>
 }
 
 fun <A, B> getMyProperty1() = MyProperty1<A, B>()
@@ -23,8 +24,8 @@ class MyProperty1<T, R> {
 // -----------------
 
 class B {
-    var a5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>MyProperty2<!>()<!>
+    var a5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>MyProperty2()<!>
-    var b5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty2<!>()<!>
+    var b5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>getMyProperty2()<!>
 }
 
 fun <A, B> getMyProperty2() = MyProperty2<A, B>()

compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingNullableType.fir.kt

@@ -0,0 +1,17 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+import kotlin.reflect.KProperty
+
+class A {
+  var a: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>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) {
+  }
+}

compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingNullableType.kt

@@ -1,10 +1,9 @@
-// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 import kotlin.reflect.KProperty
 
 class A {
-  var a: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate()<!>
+  var a: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate()<!>
 }
 
 var aTopLevel: Int by Delegate()

compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingType.fir.kt

@@ -0,0 +1,17 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+import kotlin.reflect.KProperty
+
+class A {
+  var a: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate()<!>
+}
+
+var aTopLevel: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate()<!>
+
+class Delegate {
+  fun getValue(t: Nothing, p: KProperty<*>): Int {
+    return 1
+  }
+  fun setValue(t: Nothing, p: KProperty<*>, a: Int) {
+  }
+}

compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingType.kt

@@ -1,10 +1,9 @@
-// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 import kotlin.reflect.KProperty
 
 class A {
-  var a: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate()<!>
+  var a: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate()<!>
 }
 
 var aTopLevel: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate()<!>