Record argument to parameter map at the beginning

(separately from argument match status)

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

@@ -478,7 +478,7 @@ public class CandidateResolver {
                     }
                 }
                 argumentTypes.add(resultingType);
-                candidateCall.recordArgumentMatch(argument, parameterDescriptor, matchStatus);
+                candidateCall.recordArgumentMatchStatus(argument, matchStatus);
             }
         }
         return new ValueArgumentsCheckingResult(resultStatus, argumentTypes);

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

@@ -203,6 +203,10 @@ import static org.jetbrains.jet.lang.resolve.calls.ValueArgumentsToParametersMap
                 }
             }
 
+            for (Map.Entry<ValueParameterDescriptor, VarargValueArgument> entry : varargs.entrySet()) {
+                candidateCall.recordValueArgument(entry.getKey(), entry.getValue());
+            }
+
             processFunctionLiteralArguments();
             reportUnmappedParameters();
             checkReceiverArgument();
@@ -296,7 +300,6 @@ import static org.jetbrains.jet.lang.resolve.calls.ValueArgumentsToParametersMap
                 if (vararg == null) {
                     vararg = new VarargValueArgument();
                     varargs.put(valueParameterDescriptor, vararg);
-                    candidateCall.recordValueArgument(valueParameterDescriptor, vararg);
                 }
                 vararg.addArgument(valueArgument);
             }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/ArgumentMapping.kt

@@ -36,6 +36,22 @@ enum class ArgumentMatchStatus(val isError: Boolean = true) {
     MATCH_MODULO_UNINFERRED_TYPES : ArgumentMatchStatus()
 }
 
-class ArgumentMatch(val valueParameter: ValueParameterDescriptor, val status: ArgumentMatchStatus): ArgumentMapping {
+trait ArgumentMatch : ArgumentMapping {
+    val valueParameter: ValueParameterDescriptor
+    val status: ArgumentMatchStatus
+
     override fun isError(): Boolean = status.isError
 }
+
+class ArgumentMatchImpl(override val valueParameter: ValueParameterDescriptor): ArgumentMatch {
+    private var _status: ArgumentMatchStatus? = null
+    override val status: ArgumentMatchStatus get() = _status!!
+    fun recordMatchStatus(status: ArgumentMatchStatus) {
+        _status = status
+    }
+    fun replaceValueParameter(newValueParameter: ValueParameterDescriptor): ArgumentMatchImpl {
+        val newArgumentMatch = ArgumentMatchImpl(newValueParameter)
+        newArgumentMatch._status = _status
+        return newArgumentMatch
+    }
+}

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

@@ -47,7 +47,7 @@ public interface MutableResolvedCall<D extends CallableDescriptor> extends Resol
 
     void recordValueArgument(@NotNull ValueParameterDescriptor valueParameter, @NotNull ResolvedValueArgument valueArgument);
 
-    void recordArgumentMatch(@NotNull ValueArgument valueArgument, @NotNull ValueParameterDescriptor parameter, @NotNull ArgumentMatchStatus matchStatus);
+    void recordArgumentMatchStatus(@NotNull ValueArgument valueArgument, @NotNull ArgumentMatchStatus matchStatus);
 
     @Override
     @NotNull

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

@@ -27,7 +27,6 @@ import org.jetbrains.jet.lang.psi.Call;
 import org.jetbrains.jet.lang.psi.ValueArgument;
 import org.jetbrains.jet.lang.resolve.DelegatingBindingTrace;
 import org.jetbrains.jet.lang.resolve.calls.CallResolverUtil;
-import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
 import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintSystem;
 import org.jetbrains.jet.lang.resolve.calls.results.ResolutionStatus;
 import org.jetbrains.jet.lang.resolve.calls.tasks.ExplicitReceiverKind;
@@ -80,7 +79,7 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements MutableRe
     private final Map<TypeParameterDescriptor, JetType> typeArguments = Maps.newLinkedHashMap();
     private final Map<ValueParameterDescriptor, ResolvedValueArgument> valueArguments = Maps.newLinkedHashMap();
     private final MutableDataFlowInfoForArguments dataFlowInfoForArguments;
-    private final Map<ValueArgument, ArgumentMatch> argumentToParameterMap = Maps.newHashMap();
+    private final Map<ValueArgument, ArgumentMatchImpl> argumentToParameterMap = Maps.newHashMap();
 
     private DelegatingBindingTrace trace;
     private TracingStrategy tracing;
@@ -166,26 +165,27 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements MutableRe
             }
         }
 
-        Map<ValueParameterDescriptor, ValueParameterDescriptor> parameterMap = Maps.newHashMap();
+        Map<ValueParameterDescriptor, ValueParameterDescriptor> substitutedParametersMap = Maps.newHashMap();
         for (ValueParameterDescriptor valueParameterDescriptor : resultingDescriptor.getValueParameters()) {
-            parameterMap.put(valueParameterDescriptor.getOriginal(), valueParameterDescriptor);
+            substitutedParametersMap.put(valueParameterDescriptor.getOriginal(), valueParameterDescriptor);
         }
 
         Map<ValueParameterDescriptor, ResolvedValueArgument> originalValueArguments = Maps.newLinkedHashMap(valueArguments);
         valueArguments.clear();
         for (Map.Entry<ValueParameterDescriptor, ResolvedValueArgument> entry : originalValueArguments.entrySet()) {
-            ValueParameterDescriptor substitutedVersion = parameterMap.get(entry.getKey().getOriginal());
+            ValueParameterDescriptor substitutedVersion = substitutedParametersMap.get(entry.getKey().getOriginal());
             assert substitutedVersion != null : entry.getKey();
             valueArguments.put(substitutedVersion, entry.getValue());
         }
 
-        Map<ValueArgument, ArgumentMatch> originalArgumentToParameterMap = Maps.newLinkedHashMap(argumentToParameterMap);
+        Map<ValueArgument, ArgumentMatchImpl> originalArgumentToParameterMap = Maps.newLinkedHashMap(argumentToParameterMap);
         argumentToParameterMap.clear();
-        for (Map.Entry<ValueArgument, ArgumentMatch> entry : originalArgumentToParameterMap.entrySet()) {
-            ArgumentMatch argumentMatch = entry.getValue();
-            ValueParameterDescriptor substitutedVersion = parameterMap.get(argumentMatch.getValueParameter().getOriginal());
-            assert substitutedVersion != null : argumentMatch.getValueParameter();
-            argumentToParameterMap.put(entry.getKey(), new ArgumentMatch(substitutedVersion, argumentMatch.getStatus()));
+        for (Map.Entry<ValueArgument, ArgumentMatchImpl> entry : originalArgumentToParameterMap.entrySet()) {
+            ArgumentMatchImpl argumentMatch = entry.getValue();
+            ValueParameterDescriptor valueParameterDescriptor = argumentMatch.getValueParameter();
+            ValueParameterDescriptor substitutedVersion = substitutedParametersMap.get(valueParameterDescriptor.getOriginal());
+            assert substitutedVersion != null : valueParameterDescriptor;
+            argumentToParameterMap.put(entry.getKey(), argumentMatch.replaceValueParameter(substitutedVersion));
         }
     }
 
@@ -205,6 +205,9 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements MutableRe
     public void recordValueArgument(@NotNull ValueParameterDescriptor valueParameter, @NotNull ResolvedValueArgument valueArgument) {
         assert !valueArguments.containsKey(valueParameter) : valueParameter + " -> " + valueArgument;
         valueArguments.put(valueParameter, valueArgument);
+        for (ValueArgument argument : valueArgument.getArguments()) {
+            argumentToParameterMap.put(argument, new ArgumentMatchImpl(valueParameter));
+        }
     }
 
     @Override
@@ -259,10 +262,9 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements MutableRe
     }
 
     @Override
-    public void recordArgumentMatch(
-            @NotNull ValueArgument valueArgument, @NotNull ValueParameterDescriptor parameter, @NotNull ArgumentMatchStatus matchStatus
-    ) {
-        argumentToParameterMap.put(valueArgument, new ArgumentMatch(parameter, matchStatus));
+    public void recordArgumentMatchStatus(@NotNull ValueArgument valueArgument, @NotNull ArgumentMatchStatus matchStatus) {
+        ArgumentMatchImpl argumentMatch = argumentToParameterMap.get(valueArgument);
+        argumentMatch.recordMatchStatus(matchStatus);
     }
 
     @NotNull