Add minor memory optimization

Get rid of 'unsubstitutedValueArguments' in resolved call

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/DelegatingResolvedCall.java

@@ -87,12 +87,6 @@ public abstract class DelegatingResolvedCall<D extends CallableDescriptor> imple
         return resolvedCall.getValueArguments();
     }
 
-    @NotNull
-    @Override
-    public Map<ValueParameterDescriptor, ResolvedValueArgument> getUnsubstitutedValueArguments() {
-        return resolvedCall.getUnsubstitutedValueArguments();
-    }
-
     @NotNull
     @Override
     public ArgumentMapping getArgumentMapping(@NotNull ValueArgument valueArgument) {

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ResolvedCall.java

@@ -64,10 +64,6 @@ public interface ResolvedCall<D extends CallableDescriptor> {
     @NotNull
     Map<ValueParameterDescriptor, ResolvedValueArgument> getValueArguments();
 
-    /** Values (arguments) for value parameters, no type parameter substitution */
-    @NotNull
-    Map<ValueParameterDescriptor, ResolvedValueArgument> getUnsubstitutedValueArguments();
-
     /** Values (arguments) for value parameters indexed by parameter index */
     @Nullable
     List<ResolvedValueArgument> getValueArgumentsByIndex();

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

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.resolve.calls.model;
 import com.google.common.collect.Maps;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.util.Function;
+import com.intellij.util.SmartList;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.CallableDescriptor;
@@ -41,6 +42,7 @@ import org.jetbrains.kotlin.types.TypeProjection;
 import org.jetbrains.kotlin.types.TypeSubstitutor;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 
@@ -84,7 +86,6 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements MutableRe
 
     private final Map<TypeParameterDescriptor, KotlinType> typeArguments = Maps.newLinkedHashMap();
     private final Map<ValueParameterDescriptor, ResolvedValueArgument> valueArguments = Maps.newLinkedHashMap();
-    private Map<ValueParameterDescriptor, ResolvedValueArgument> valueArgumentsBeforeSubstitution;
     private final MutableDataFlowInfoForArguments dataFlowInfoForArguments;
     private final Map<ValueArgument, ArgumentMatchImpl> argumentToParameterMap = Maps.newHashMap();
 
@@ -201,9 +202,12 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements MutableRe
             substitutedParametersMap.put(valueParameterDescriptor.getOriginal(), valueParameterDescriptor);
         }
 
-        valueArgumentsBeforeSubstitution = Maps.newLinkedHashMap(valueArguments);
+        Collection<Map.Entry<ValueParameterDescriptor, ResolvedValueArgument>> valueArgumentsBeforeSubstitution =
+                new SmartList<Map.Entry<ValueParameterDescriptor, ResolvedValueArgument>>(valueArguments.entrySet());
+
         valueArguments.clear();
-        for (Map.Entry<ValueParameterDescriptor, ResolvedValueArgument> entry : valueArgumentsBeforeSubstitution.entrySet()) {
+
+        for (Map.Entry<ValueParameterDescriptor, ResolvedValueArgument> entry : valueArgumentsBeforeSubstitution) {
             ValueParameterDescriptor substitutedVersion = substitutedParametersMap.get(entry.getKey().getOriginal());
             assert substitutedVersion != null : entry.getKey();
             valueArguments.put(substitutedVersion, entry.getValue());
@@ -265,14 +269,6 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements MutableRe
         return valueArguments;
     }
 
-    @Override
-    @NotNull
-    public Map<ValueParameterDescriptor, ResolvedValueArgument> getUnsubstitutedValueArguments() {
-        // TODO We need unsubstituted value arguments to compare signatures for specificity when explicit type arguments are provided.
-        // Current implementation is questionable (mostly due to lack of well-defined contract for MutableResolvedCall).
-        return valueArgumentsBeforeSubstitution != null ? valueArgumentsBeforeSubstitution : valueArguments;
-    }
-
     @Nullable
     @Override
     public List<ResolvedValueArgument> getValueArgumentsByIndex() {

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/CandidateCallWithArgumentMapping.kt

@@ -70,7 +70,7 @@ class CandidateCallWithArgumentMapping<D : CallableDescriptor, K> private constr
             var parametersWithDefaultValuesCount = 0
 
             val unsubstitutedValueParameters = call.candidateDescriptor.original.valueParameters
-            for ((valueParameterDescriptor, resolvedValueArgument) in call.unsubstitutedValueArguments.entries) {
+            for ((valueParameterDescriptor, resolvedValueArgument) in call.valueArguments.entries) {
                 if (resolvedValueArgument is DefaultValueArgument) {
                     parametersWithDefaultValuesCount++
                 }