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

This reverts commit bab8047bb3.

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

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<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,
@@ -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);

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

@@ -144,36 +144,8 @@ 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> runResolutionAndInferenceForGivenOldCandidates(
+    fun <D : CallableDescriptor> runResolutionAndInferenceForGivenCandidates(
         context: BasicCallResolutionContext,
         resolutionCandidates: Collection<OldResolutionCandidate<D>>,
         tracingStrategy: TracingStrategy

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<ReceiverParameterDescriptor> results =
-                components.callResolver.resolveThisOrSuperCallWithGivenDescriptor(context, call, descriptor);
+        OldResolutionCandidate<ReceiverParameterDescriptor> resolutionCandidate =
+                OldResolutionCandidate.create(
+                        call, descriptor, null, ExplicitReceiverKind.NO_EXPLICIT_RECEIVER, null);
 
-        ResolvedCall<?> resolvedCall = results.getResultingCall();
+        ResolvedCallImpl<ReceiverParameterDescriptor> 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) {