Removed 'getCallToCompleteTypeArgumentInference'

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java

@@ -376,7 +376,7 @@ public class CallResolver {
         }
 
         CallCandidateResolutionContext<D> candidateContext = CallCandidateResolutionContext.createForCallBeingAnalyzed(
-                results.getResultingCall().getCallToCompleteTypeArgumentInference(), context, tracing);
+                results.getResultingCall(), context, tracing);
         candidateResolver.completeTypeInferenceDependentOnFunctionLiteralsForCall(candidateContext);
     }
 
@@ -395,20 +395,19 @@ public class CallResolver {
         }
 
         MutableResolvedCall<D> resolvedCall = results.getResultingCall();
-        ResolvedCallImpl<D> callToCompleteInference = resolvedCall.getCallToCompleteTypeArgumentInference();
 
-        Set<ValueArgument> unmappedArguments = callToCompleteInference.getUnmappedArguments();
+        Set<ValueArgument> unmappedArguments = resolvedCall.getUnmappedArguments();
         argumentTypeResolver.checkUnmappedArgumentTypes(context, unmappedArguments);
         candidateResolver.completeUnmappedArguments(context, unmappedArguments);
 
         CallCandidateResolutionContext<D> callCandidateResolutionContext =
-                CallCandidateResolutionContext.createForCallBeingAnalyzed(callToCompleteInference, context, tracing);
+                CallCandidateResolutionContext.createForCallBeingAnalyzed(resolvedCall, context, tracing);
         candidateResolver.completeTypeInferenceDependentOnExpectedTypeForCall(callCandidateResolutionContext, false);
 
         resolvedCall.markCallAsCompleted();
         candidateResolver.completeTypeInferenceForAllCandidates(context, results);
 
-        if (callToCompleteInference.getStatus().isSuccess()) {
+        if (resolvedCall.getStatus().isSuccess()) {
             return OverloadResolutionResultsImpl.success(resolvedCall);
         }
         return results;
@@ -431,10 +430,9 @@ public class CallResolver {
         context.resolutionResultsCache.recordResolutionTrace(callKey, deltasTraceToCacheResolve);
 
         if (results.isSingleResult()) {
-            MutableResolvedCall<F> resultingCall = results.getResultingCall();
+            CallCandidateResolutionContext<F> contextForCallToCompleteTypeArgumentInference =
-            CallCandidateResolutionContext<F> contextForCallToCompleteTypeArgumentInference = CallCandidateResolutionContext.createForCallBeingAnalyzed(
+                    CallCandidateResolutionContext.createForCallBeingAnalyzed(results.getResultingCall(), context, tracing);
-                    results.getResultingCall().getCallToCompleteTypeArgumentInference(), context, tracing);
+            context.resolutionResultsCache.recordDeferredComputationForCall(callKey, contextForCallToCompleteTypeArgumentInference);
-            context.resolutionResultsCache.recordDeferredComputationForCall(callKey, resultingCall, contextForCallToCompleteTypeArgumentInference);
         }
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java

@@ -297,10 +297,9 @@ public class CandidateResolver {
 
             TemporaryBindingTrace temporaryBindingTrace = TemporaryBindingTrace.create(
                     context.trace, "Trace to complete a candidate that is not a resulting call");
-            ResolvedCallImpl<D> callToCompleteInference = mutableResolvedCall.getCallToCompleteTypeArgumentInference();
 
             CallCandidateResolutionContext<D> callCandidateResolutionContext = CallCandidateResolutionContext.createForCallBeingAnalyzed(
-                    callToCompleteInference, context.replaceBindingTrace(temporaryBindingTrace), TracingStrategy.EMPTY);
+                    mutableResolvedCall, context.replaceBindingTrace(temporaryBindingTrace), TracingStrategy.EMPTY);
 
             completeTypeInferenceDependentOnExpectedTypeForCall(callCandidateResolutionContext, false);
             mutableResolvedCall.markCallAsCompleted();
@@ -474,11 +473,6 @@ public class CandidateResolver {
         if (storedContextForArgument == null) return;
 
         storedContextForArgument.candidateCall.markCallAsCompleted();
-
-        // clean data for "invoke" calls
-        MutableResolvedCall<?> resolvedCall = context.resolutionResultsCache.getCallForArgument(keyExpression);
-        assert resolvedCall != null : "Resolved call for '" + keyExpression + "' is not stored, but CallCandidateResolutionContext is.";
-        resolvedCall.markCallAsCompleted();
     }
 
     @Nullable

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/ResolutionResultsCache.java

@@ -37,16 +37,11 @@ public interface ResolutionResultsCache {
     @Nullable
     DelegatingBindingTrace getResolutionTrace(@NotNull CallKey callKey);
 
-    //For VariableAsFunctionCall deferredComputation is taken for its function call, but resolvedCall is the VariableAsFunctionCall itself.
     <D extends CallableDescriptor> void recordDeferredComputationForCall(
             @NotNull CallKey callKey,
-            @NotNull MutableResolvedCall<D> resolvedCall,
             @NotNull CallCandidateResolutionContext<D> deferredComputation
     );
 
     @Nullable
     CallCandidateResolutionContext<?> getDeferredComputation(@Nullable JetExpression expression);
-
-    @Nullable
-    MutableResolvedCall<?> getCallForArgument(@Nullable JetExpression expression);
 }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/ResolutionResultsCacheImpl.java

@@ -24,7 +24,6 @@ import org.jetbrains.jet.lang.psi.CallKey;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.DelegatingBindingTrace;
-import org.jetbrains.jet.lang.resolve.calls.model.MutableResolvedCall;
 import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResultsImpl;
 import org.jetbrains.jet.util.slicedmap.BasicWritableSlice;
 import org.jetbrains.jet.util.slicedmap.Slices;
@@ -37,7 +36,6 @@ public class ResolutionResultsCacheImpl implements ResolutionResultsCache {
     public static final WritableSlice<CallKey, OverloadResolutionResultsImpl<CallableDescriptor>> RESOLUTION_RESULTS = Slices.createSimpleSlice();
     public static final WritableSlice<CallKey, DelegatingBindingTrace> TRACE_DELTAS_CACHE = Slices.createSimpleSlice();
     public static final WritableSlice<CallKey, CallCandidateResolutionContext<?>> DEFERRED_COMPUTATION_FOR_CALL = Slices.createSimpleSlice();
-    public static final WritableSlice<CallKey, MutableResolvedCall<?>> RESOLVED_CALL_FOR_ARGUMENT = Slices.createSimpleSlice();
 
     static {
         BasicWritableSlice.initSliceDebugNames(ResolutionResultsCacheImpl.class);
@@ -78,11 +76,9 @@ public class ResolutionResultsCacheImpl implements ResolutionResultsCache {
     @Override
     public <D extends CallableDescriptor> void recordDeferredComputationForCall(
             @NotNull CallKey callKey,
-            @NotNull MutableResolvedCall<D> resolvedCall,
             @NotNull CallCandidateResolutionContext<D> deferredComputation
     ) {
         trace.record(DEFERRED_COMPUTATION_FOR_CALL, callKey, deferredComputation);
-        trace.record(RESOLVED_CALL_FOR_ARGUMENT, callKey, resolvedCall);
     }
 
     @Override
@@ -107,12 +103,6 @@ public class ResolutionResultsCacheImpl implements ResolutionResultsCache {
         return null;
     }
 
-    @Nullable
-    @Override
-    public MutableResolvedCall<?> getCallForArgument(@Nullable JetExpression expression) {
-        return getValueTryingAllCallTypes(expression, RESOLVED_CALL_FOR_ARGUMENT);
-    }
-
     @NotNull
     public static ResolutionResultsCache create() {
         return new ResolutionResultsCacheImpl();

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/TemporaryResolutionResultsCache.java

@@ -22,7 +22,6 @@ import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
 import org.jetbrains.jet.lang.psi.CallKey;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.resolve.DelegatingBindingTrace;
-import org.jetbrains.jet.lang.resolve.calls.model.MutableResolvedCall;
 import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResultsImpl;
 
 public class TemporaryResolutionResultsCache implements ResolutionResultsCache {
@@ -76,10 +75,9 @@ public class TemporaryResolutionResultsCache implements ResolutionResultsCache {
     @Override
     public <D extends CallableDescriptor> void recordDeferredComputationForCall(
             @NotNull CallKey callKey,
-            @NotNull MutableResolvedCall<D> resolvedCall,
             @NotNull CallCandidateResolutionContext<D> deferredComputation
     ) {
-        innerCache.recordDeferredComputationForCall(callKey, resolvedCall, deferredComputation);
+        innerCache.recordDeferredComputationForCall(callKey, deferredComputation);
     }
 
     @Nullable
@@ -92,16 +90,6 @@ public class TemporaryResolutionResultsCache implements ResolutionResultsCache {
         return parentCache.getDeferredComputation(expression);
     }
 
-    @Nullable
-    @Override
-    public MutableResolvedCall<?> getCallForArgument(@Nullable JetExpression expression) {
-        MutableResolvedCall<?> resolvedCall = innerCache.getCallForArgument(expression);
-        if (resolvedCall != null) {
-            return resolvedCall;
-        }
-        return parentCache.getCallForArgument(expression);
-    }
-
     public void commit() {
         if (parentCache instanceof ResolutionResultsCacheImpl) {
             ((ResolutionResultsCacheImpl) parentCache).addData(innerCache);

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/MutableResolvedCall.java

@@ -58,13 +58,6 @@ public interface MutableResolvedCall<D extends CallableDescriptor> extends Resol
     @NotNull
     DelegatingBindingTrace getTrace();
 
-    /**
-     * //todo get rid of Impl class in the interface
-     * If the call has incomplete type parameters, it should be completed after resolution process is finished.
-     * Returns this for normal call and function call for VariableAsFunctionCall.
-     */
-    @NotNull
-    ResolvedCallImpl<D> getCallToCompleteTypeArgumentInference();
 
     void markCallAsCompleted();
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/ResolvedCallImpl.java

@@ -324,12 +324,6 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements MutableRe
         return dataFlowInfoForArguments;
     }
 
-    @NotNull
-    @Override
-    public ResolvedCallImpl<D> getCallToCompleteTypeArgumentInference() {
-        return this;
-    }
-
     @Override
     public boolean hasInferredReturnType() {
         if (!completed) {

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/OverloadResolutionResultsUtil.java

@@ -52,7 +52,7 @@ public class OverloadResolutionResultsUtil {
     ) {
         if (results.isSingleResult() && contextDependency == ContextDependency.INDEPENDENT) {
             ResolvedCall<D> resultingCall = results.getResultingCall();
-            if (!((MutableResolvedCall<D>)resultingCall).getCallToCompleteTypeArgumentInference().hasInferredReturnType()) {
+            if (!((MutableResolvedCall<D>)resultingCall).hasInferredReturnType()) {
                 return null;
             }
         }