Stepping: do not write line numbers for call arguments

#KT-3080 Fixed

compiler/backend/src/org/jetbrains/jet/codegen/CallBasedArgumentGenerator.java

@@ -22,6 +22,7 @@ import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.psi.ValueArgument;
 import org.jetbrains.jet.lang.resolve.calls.model.DefaultValueArgument;
 import org.jetbrains.jet.lang.resolve.calls.model.ExpressionValueArgument;
+import org.jetbrains.jet.lang.resolve.calls.model.ResolvedValueArgument;
 import org.jetbrains.jet.lang.resolve.calls.model.VarargValueArgument;
 import org.jetbrains.org.objectweb.asm.Type;
 
@@ -50,6 +51,16 @@ public class CallBasedArgumentGenerator extends ArgumentGenerator {
                 "Value parameters and their types mismatch in sizes: " + valueParameters.size() + " != " + valueParameterTypes.size();
     }
 
+    @NotNull
+    @Override
+    public List<Integer> generate(@NotNull List<ResolvedValueArgument> valueArguments) {
+        boolean shouldMarkLineNumbers = codegen.isShouldMarkLineNumbers();
+        codegen.setShouldMarkLineNumbers(false);
+        List<Integer> masks = super.generate(valueArguments);
+        codegen.setShouldMarkLineNumbers(shouldMarkLineNumbers);
+        return masks;
+    }
+
     @Override
     protected void generateExpression(int i, @NotNull ExpressionValueArgument argument) {
         ValueParameterDescriptor parameter = valueParameters.get(i);

compiler/backend/src/org/jetbrains/jet/codegen/CallGenerator.java

@@ -23,9 +23,9 @@ import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
 
-public interface CallGenerator {
+public abstract class CallGenerator {
 
-    class DefaultCallGenerator implements CallGenerator {
+    static class DefaultCallGenerator extends CallGenerator {
 
         private final ExpressionCodegen codegen;
 
@@ -34,7 +34,7 @@ public interface CallGenerator {
         }
 
         @Override
-        public void genCall(
+        public void genCallInner(
                 @NotNull CallableMethod callableMethod,
                 ResolvedCall<?> resolvedCall,
                 boolean callDefault,
@@ -90,24 +90,35 @@ public interface CallGenerator {
         }
     }
 
-    void genCall(@NotNull CallableMethod callableMethod, @Nullable ResolvedCall<?> resolvedCall, boolean callDefault, @NotNull ExpressionCodegen codegen);
+    public void genCall(@NotNull CallableMethod callableMethod, @Nullable ResolvedCall<?> resolvedCall, boolean callDefault, @NotNull ExpressionCodegen codegen) {
+        if (resolvedCall != null) {
+            JetExpression calleeExpression = resolvedCall.getCall().getCalleeExpression();
+            if (calleeExpression != null) {
+                codegen.markStartLineNumber(calleeExpression);
+            }
+        }
 
-    void genCallWithoutAssertions(@NotNull CallableMethod callableMethod, @NotNull ExpressionCodegen codegen);
+        genCallInner(callableMethod, resolvedCall, callDefault, codegen);
+    }
 
-    void afterParameterPut(@NotNull Type type, StackValue stackValue, @NotNull ValueParameterDescriptor valueParameterDescriptor);
+    public abstract void genCallInner(@NotNull CallableMethod callableMethod, @Nullable ResolvedCall<?> resolvedCall, boolean callDefault, @NotNull ExpressionCodegen codegen);
 
-    void genValueAndPut(
+    public abstract void genCallWithoutAssertions(@NotNull CallableMethod callableMethod, @NotNull ExpressionCodegen codegen);
+
+    public abstract void afterParameterPut(@NotNull Type type, StackValue stackValue, @NotNull ValueParameterDescriptor valueParameterDescriptor);
+
+    public abstract void genValueAndPut(
             @NotNull ValueParameterDescriptor valueParameterDescriptor,
             @NotNull JetExpression argumentExpression,
             @NotNull Type parameterType
     );
 
-    void putValueIfNeeded(@Nullable ValueParameterDescriptor valueParameterDescriptor, @NotNull Type parameterType, @NotNull StackValue value);
+    public abstract void putValueIfNeeded(@Nullable ValueParameterDescriptor valueParameterDescriptor, @NotNull Type parameterType, @NotNull StackValue value);
 
-    void putCapturedValueOnStack(
+    public abstract void putCapturedValueOnStack(
             @NotNull StackValue stackValue,
             @NotNull Type valueType, int paramIndex
     );
 
-    void putHiddenParams();
+    public abstract void putHiddenParams();
 }

compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java

@@ -123,6 +123,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     public final Map<JetElement, StackValue> tempVariables = Maps.newHashMap();
 
     private int myLastLineNumber = -1;
+    private boolean shouldMarkLineNumbers = true;
 
     public ExpressionCodegen(
             @NotNull MethodVisitor mv,
@@ -1636,11 +1637,21 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         });
     }
 
+    public boolean isShouldMarkLineNumbers() {
+        return shouldMarkLineNumbers;
+    }
+
+    public void setShouldMarkLineNumbers(boolean shouldMarkLineNumbers) {
+        this.shouldMarkLineNumbers = shouldMarkLineNumbers;
+    }
+
     public void markStartLineNumber(@NotNull JetElement element) {
         markLineNumber(element, false);
     }
 
     public void markLineNumber(@NotNull JetElement statement, boolean markEndOffset) {
+        if (!shouldMarkLineNumbers) return;
+
         Integer lineNumber = CodegenUtil.getLineNumberForElement(statement, markEndOffset);
         if (lineNumber == null || lineNumber == myLastLineNumber) {
             return;

compiler/backend/src/org/jetbrains/jet/codegen/inline/InlineCodegen.java

@@ -57,7 +57,7 @@ import static org.jetbrains.jet.codegen.AsmUtil.getMethodAsmFlags;
 import static org.jetbrains.jet.codegen.AsmUtil.isPrimitive;
 import static org.jetbrains.jet.codegen.inline.InlineCodegenUtil.addInlineMarker;
 
-public class InlineCodegen implements CallGenerator {
+public class InlineCodegen extends CallGenerator {
     private final GenerationState state;
     private final JetTypeMapper typeMapper;
 
@@ -115,7 +115,7 @@ public class InlineCodegen implements CallGenerator {
     }
 
     @Override
-    public void genCall(@NotNull CallableMethod callableMethod, @Nullable ResolvedCall<?> resolvedCall, boolean callDefault, @NotNull ExpressionCodegen codegen) {
+    public void genCallInner(@NotNull CallableMethod callableMethod, @Nullable ResolvedCall<?> resolvedCall, boolean callDefault, @NotNull ExpressionCodegen codegen) {
         MethodNode node = null;
 
         try {