extracted 'getResultingCall' method

rewrote 'getResultingType' in terms of it

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

@@ -30,6 +30,7 @@ import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallWithTrace;
 import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults;
 import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResultsImpl;
+import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResultsUtil;
 import org.jetbrains.jet.lang.resolve.calls.util.CallMaker;
 import org.jetbrains.jet.lang.resolve.constants.ConstantUtils;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -193,11 +194,7 @@ public class CallExpressionResolver {
         if (!results.isNothing()) {
             checkSuper(call.getExplicitReceiver(), results, context.trace, callExpression);
             result[0] = true;
-            if (results.isSingleResult() && context.resolveMode == ResolveMode.TOP_LEVEL_CALL) {
+            return OverloadResolutionResultsUtil.getResultingCall(results, context.resolveMode);
-                if (!CallResolverUtil.hasInferredReturnType(results.getResultingCall())) return null;
-            }
-
-            return results.isSingleResult() ? results.getResultingCall() : null;
         }
         result[0] = false;
         return null;

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

@@ -20,6 +20,9 @@ import com.google.common.collect.Lists;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
+import org.jetbrains.jet.lang.resolve.calls.CallResolverUtil;
+import org.jetbrains.jet.lang.resolve.calls.context.ResolveMode;
+import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallWithTrace;
 import org.jetbrains.jet.lang.types.JetType;
 
@@ -35,10 +38,24 @@ public class OverloadResolutionResultsUtil {
     }
 
     @Nullable
-    public static <D extends CallableDescriptor> JetType getResultType(OverloadResolutionResults<D> results) {
+    public static <D extends CallableDescriptor> JetType getResultingType(
-        if (results.isSuccess()) {
+            @NotNull OverloadResolutionResults<D> results,
-            return results.getResultingDescriptor().getReturnType();
+            @NotNull ResolveMode resolveMode
+    ) {
+        ResolvedCall<D> resultingCall = getResultingCall((OverloadResolutionResultsImpl<D>) results, resolveMode);
+        return resultingCall != null ? resultingCall.getResultingDescriptor().getReturnType() : null;
+    }
+
+    @Nullable
+    public static <D extends CallableDescriptor> ResolvedCallWithTrace<D> getResultingCall(
+            @NotNull OverloadResolutionResultsImpl<D> results,
+            @NotNull ResolveMode resolveMode
+    ) {
+        if (results.isSingleResult() && resolveMode == ResolveMode.TOP_LEVEL_CALL) {
+            if (!CallResolverUtil.hasInferredReturnType(results.getResultingCall())) {
+                return null;
+            }
         }
-        return null;
+        return results.isSingleResult() ? results.getResultingCall() : null;
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java

@@ -36,8 +36,6 @@ import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowValueFactory;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.Nullability;
 import org.jetbrains.jet.lang.resolve.calls.context.CheckValueArgumentsMode;
 import org.jetbrains.jet.lang.resolve.calls.context.ExpressionPosition;
-import org.jetbrains.jet.lang.resolve.calls.context.ResolutionResultsCache;
-import org.jetbrains.jet.lang.resolve.calls.context.ResolveMode;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallWithTrace;
 import org.jetbrains.jet.lang.resolve.calls.model.VariableAsFunctionResolvedCall;
 import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults;
@@ -1055,7 +1053,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
                 CallMaker.makeCallWithExpressions(callElement, receiver, null, operationSign, Collections.singletonList(left)),
                 operationSign,
                 OperatorConventions.CONTAINS);
-        JetType containsType = OverloadResolutionResultsUtil.getResultType(resolutionResult);
+        JetType containsType = OverloadResolutionResultsUtil.getResultingType(resolutionResult, context.resolveMode);
         ensureBooleanResult(operationSign, OperatorConventions.CONTAINS, containsType, context);
 
         if (left != null) {
@@ -1165,7 +1163,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
             dataFlowInfo = facade.getTypeInfo(right, contextWithDataFlow).getDataFlowInfo();
         }
 
-        return JetTypeInfo.create(OverloadResolutionResultsUtil.getResultType(resolutionResults), dataFlowInfo);
+        return JetTypeInfo.create(OverloadResolutionResultsUtil.getResultingType(resolutionResults, context.resolveMode), dataFlowInfo);
     }
 
     @NotNull

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java

@@ -240,14 +240,15 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
         TemporaryBindingTrace assignmentOperationTrace = TemporaryBindingTrace.create(context.trace, "trace to check assignment operation like '+=' for", expression);
         OverloadResolutionResults<FunctionDescriptor> assignmentOperationDescriptors = BasicExpressionTypingVisitor.getResolutionResultsForBinaryCall(
                 scope, name, context.replaceBindingTrace(assignmentOperationTrace).replaceResolutionResultsCache(), expression, receiver);
-        JetType assignmentOperationType = OverloadResolutionResultsUtil.getResultType(assignmentOperationDescriptors);
+        JetType assignmentOperationType = OverloadResolutionResultsUtil.getResultingType(assignmentOperationDescriptors,
+                                                                                         context.resolveMode);
 
         // Check for '+'
         Name counterpartName = OperatorConventions.BINARY_OPERATION_NAMES.get(OperatorConventions.ASSIGNMENT_OPERATION_COUNTERPARTS.get(operationType));
         TemporaryBindingTrace binaryOperationTrace = TemporaryBindingTrace.create(context.trace, "trace to check binary operation like '+' for", expression);
         OverloadResolutionResults<FunctionDescriptor> binaryOperationDescriptors = BasicExpressionTypingVisitor.getResolutionResultsForBinaryCall(
                 scope, counterpartName, context.replaceBindingTrace(binaryOperationTrace).replaceResolutionResultsCache(), expression, receiver);
-        JetType binaryOperationType = OverloadResolutionResultsUtil.getResultType(binaryOperationDescriptors);
+        JetType binaryOperationType = OverloadResolutionResultsUtil.getResultingType(binaryOperationDescriptors, context.resolveMode);
 
         JetType type = assignmentOperationType != null ? assignmentOperationType : binaryOperationType;
         if (assignmentOperationType != null && binaryOperationType != null) {

compiler/testData/diagnostics/tests/inference/nestedCalls/inferenceForNestedBinaryCall.kt

@@ -0,0 +1,10 @@
+package aaa
+
+fun <T> T.foo(t: T) = t
+
+fun id<T>(t: T) = t
+
+fun a() {
+    val i = id(2 foo 3)
+    i : Int // i shouldn't be resolved to error element
+}

compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java

@@ -2846,6 +2846,11 @@ public class JetDiagnosticsTestGenerated extends AbstractDiagnosticsTestWithEage
                     doTest("compiler/testData/diagnostics/tests/inference/nestedCalls/completeNestedForVariableAsFunctionCall.kt");
                 }
                 
+                @TestMetadata("inferenceForNestedBinaryCall.kt")
+                public void testInferenceForNestedBinaryCall() throws Exception {
+                    doTest("compiler/testData/diagnostics/tests/inference/nestedCalls/inferenceForNestedBinaryCall.kt");
+                }
+                
                 @TestMetadata("kt3395.kt")
                 public void testKt3395() throws Exception {
                     doTest("compiler/testData/diagnostics/tests/inference/nestedCalls/kt3395.kt");