FunctionReferenceGenerationStrategy fake resolved call refactoring

compiler/backend/src/org/jetbrains/kotlin/codegen/ArgumentGenerator.kt

@@ -32,17 +32,13 @@ abstract class ArgumentGenerator {
      * @see kotlin.reflect.jvm.internal.KCallableImpl.callBy
      */
     open fun generate(valueArgumentsByIndex: List<ResolvedValueArgument>, actualArgs: List<ResolvedValueArgument>): DefaultCallMask {
-        //HACK: see tempVariable in ExpressionCodegen
+        assert(valueArgumentsByIndex.size() == actualArgs.size()) {
-        assert (valueArgumentsByIndex.size() == actualArgs.size())
+            "Value arguments collection should have same size, but ${valueArgumentsByIndex.size()} != ${actualArgs.size()}"
-        val actualArguments = if (actualArgs.isNotEmpty()) actualArgs else valueArgumentsByIndex
-
-        assert(valueArgumentsByIndex.size() == actualArguments.size()) {
-            "Value arguments collection should have same size, but ${valueArgumentsByIndex.size()} != ${actualArguments.size()}"
         }
 
         val arg2Index = valueArgumentsByIndex.mapToIndex()
 
-        val actualArgsWithDeclIndex = actualArguments.filter { it !is DefaultValueArgument }.map {
+        val actualArgsWithDeclIndex = actualArgs.filter { it !is DefaultValueArgument }.map {
             ArgumentAndDeclIndex(it, arg2Index[it]!!)
         }.toArrayList()
 

compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionReferenceGenerationStrategy.java

@@ -36,9 +36,7 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.org.objectweb.asm.Type;
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
 
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Iterator;
-import java.util.List;
 
 import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory;
 import static org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue.NO_RECEIVER;
@@ -75,6 +73,18 @@ public class FunctionReferenceGenerationStrategy extends FunctionGenerationStrat
         computeAndSaveArguments(fakeArguments, codegen);
 
         ResolvedCall<CallableDescriptor> fakeResolvedCall = new DelegatingResolvedCall<CallableDescriptor>(resolvedCall) {
+
+            private final Map<ValueParameterDescriptor, ResolvedValueArgument> argumentMap;
+            {
+                argumentMap = new LinkedHashMap<ValueParameterDescriptor, ResolvedValueArgument>(fakeArguments.size());
+                int index = 0;
+                List<ValueParameterDescriptor> parameters = callableDescriptor.getValueParameters();
+                for (ValueArgument argument : fakeArguments) {
+                    argumentMap.put(parameters.get(index), new ExpressionValueArgument(argument));
+                    index++;
+                }
+            }
+
             @NotNull
             @Override
             public ReceiverValue getExtensionReceiver() {
@@ -90,11 +100,13 @@ public class FunctionReferenceGenerationStrategy extends FunctionGenerationStrat
             @NotNull
             @Override
             public List<ResolvedValueArgument> getValueArgumentsByIndex() {
-                List<ResolvedValueArgument> result = new ArrayList<ResolvedValueArgument>(fakeArguments.size());
+                return new ArrayList<ResolvedValueArgument>(argumentMap.values());
-                for (ValueArgument argument : fakeArguments) {
+            }
-                    result.add(new ExpressionValueArgument(argument));
+
-                }
+            @NotNull
-                return result;
+            @Override
+            public Map<ValueParameterDescriptor, ResolvedValueArgument> getValueArguments() {
+                return argumentMap;
             }
         };