Complete type inference for nested calls

inside non resolved invocation

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

@@ -454,16 +454,17 @@ public class CandidateResolver {
             JetExpression expression = argument.getArgumentExpression();
 
             JetExpression keyExpression = getDeferredComputationKeyExpression(expression);
-            markResultingCallAsCompleted(context, keyExpression);
 
             CallCandidateResolutionContext<?> storedContextForArgument =
                     context.resolutionResultsCache.getDeferredComputation(keyExpression);
-            if (storedContextForArgument != null) {
+            if (storedContextForArgument == null) continue;
-                completeNestedCallsForNotResolvedInvocation(storedContextForArgument);
+            if (storedContextForArgument.candidateCall.isCompleted()) continue;
-                CallCandidateResolutionContext<?> newContext = storedContextForArgument.replaceBindingTrace(context.trace);
+
-                completeUnmappedArguments(newContext, storedContextForArgument.candidateCall.getUnmappedArguments());
+            CallCandidateResolutionContext<?> newContext =
-                argumentTypeResolver.checkTypesForFunctionArgumentsWithNoCallee(newContext.replaceContextDependency(INDEPENDENT));
+                    storedContextForArgument.replaceBindingTrace(context.trace).replaceContextDependency(INDEPENDENT);
-            }
+            completeTypeInferenceDependentOnExpectedTypeForCall(newContext, true);
+
+            markResultingCallAsCompleted(context, keyExpression);
         }
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/util/resolvedCallUtil.kt

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2010-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.lang.resolve.calls.util
+
+import org.jetbrains.jet.lang.descriptors.CallableDescriptor
+import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall
+import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults
+import org.jetbrains.jet.lang.resolve.calls.model.ArgumentUnmapped
+import org.jetbrains.jet.lang.resolve.calls.model.ResolvedValueArgument
+import org.jetbrains.jet.lang.resolve.calls.model.ArgumentMapping
+import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor
+
+fun <D : CallableDescriptor> ResolvedCall<D>.noErrorsInValueArguments(): Boolean {
+    return getCall().getValueArguments().all { argument -> !getArgumentMapping(argument!!).isError() }
+}
+
+fun <D : CallableDescriptor> ResolvedCall<D>.hasUnmappedArguments(): Boolean {
+    return getCall().getValueArguments().any { argument -> getArgumentMapping(argument!!) == ArgumentUnmapped }
+}
+
+fun <D : CallableDescriptor> ResolvedCall<D>.hasUnmappedParameters(): Boolean {
+    val parameterToArgumentMap = getValueArguments()
+    return !parameterToArgumentMap.keySet().containsAll(getResultingDescriptor().getValueParameters())
+}
+
+fun <D : CallableDescriptor> ResolvedCall<D>.hasErrorOnParameter(parameter: ValueParameterDescriptor): Boolean {
+    val resolvedValueArgument = getValueArguments()[parameter]
+    if (resolvedValueArgument == null) return true
+
+    return resolvedValueArgument.getArguments().any { argument -> getArgumentMapping(argument).isError() }
+}

compiler/testData/diagnostics/tests/inference/cannotCompleteResolveNoInfoForParameter.kt

@@ -4,7 +4,7 @@ fun f<T>(<!UNUSED_PARAMETER!>i<!>: Int, <!UNUSED_PARAMETER!>c<!>: Collection<T>)
 fun f<T>(<!UNUSED_PARAMETER!>a<!>: Any, <!UNUSED_PARAMETER!>l<!>: List<T>): Collection<T> {throw Exception()}
 
 fun test<T>(<!UNUSED_PARAMETER!>l<!>: List<T>) {
-    <!CANNOT_COMPLETE_RESOLVE!>f<!>(1, emptyList())
+    <!CANNOT_COMPLETE_RESOLVE!>f<!>(1, <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>())
 }
 
 fun emptyList<T>(): List<T> {throw Exception()}

compiler/testData/diagnostics/tests/resolve/nestedCalls/completeTypeInferenceForNestedInNoneApplicable.kt

@@ -0,0 +1,10 @@
+package h
+
+fun foo(i: Int) = i
+fun foo(s: String) = s
+
+fun test() {
+    <!NONE_APPLICABLE!>foo<!>(<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>())
+}
+
+fun emptyList<T>(): List<T> {throw Exception()}

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

@@ -6290,6 +6290,11 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                     doTest("compiler/testData/diagnostics/tests/resolve/nestedCalls/analyzeUnmappedArguments.kt");
                 }
                 
+                @TestMetadata("completeTypeInferenceForNestedInNoneApplicable.kt")
+                public void testCompleteTypeInferenceForNestedInNoneApplicable() throws Exception {
+                    doTest("compiler/testData/diagnostics/tests/resolve/nestedCalls/completeTypeInferenceForNestedInNoneApplicable.kt");
+                }
+                
                 @TestMetadata("completeUnmappedArguments.kt")
                 public void testCompleteUnmappedArguments() throws Exception {
                     doTest("compiler/testData/diagnostics/tests/resolve/nestedCalls/completeUnmappedArguments.kt");

idea/src/org/jetbrains/jet/plugin/completion/smart/SmartCompetionUtil.kt

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2010-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.plugin.completion.smart
+
+import org.jetbrains.jet.lang.descriptors.CallableDescriptor
+import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults
+import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall
+import org.jetbrains.jet.lang.resolve.calls.util.noErrorsInValueArguments
+import org.jetbrains.jet.lang.resolve.calls.util.hasUnmappedParameters
+
+
+fun <D : CallableDescriptor> OverloadResolutionResults<D>.getCandidatesForCompletion(): Collection<ResolvedCall<D>> {
+    return getAllCandidates()!!.filter { resolvedCall ->
+        resolvedCall.noErrorsInValueArguments() && resolvedCall.hasUnmappedParameters()
+    }
+}