Add operators test to source_mapping_test.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library dart2js.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 642 matching lines @@
 
   @override
   ir.Primitive handleDynamicGet(
       ast.Send node,
       ast.Node receiver,
       Selector selector,
       _) {
     return irBuilder.buildDynamicGet(
         translateReceiver(receiver),
         selector,
-        elements.getTypeMask(node));
+        elements.getTypeMask(node),
+        sourceInformationBuilder.buildGet(node));
   }
 
   @override
   ir.Primitive visitIfNotNullDynamicPropertyGet(
       ast.Send node,
       ast.Node receiver,
       Selector selector,
       _) {
     ir.Primitive target = visit(receiver);
     return irBuilder.buildIfNotNullSend(
         target,
         nested(() => irBuilder.buildDynamicGet(
-            target, selector, elements.getTypeMask(node))));
+            target, selector, elements.getTypeMask(node),
+            sourceInformationBuilder.buildGet(node))));
   }
 
   @override
   ir.Primitive visitDynamicTypeLiteralGet(
       ast.Send node,
       ConstantExpression constant,
       _) {
     return buildConstantExpression(constant,
         sourceInformationBuilder.buildGet(node));
   }
@@ skipping 187 matching lines @@
 
   @override
   ir.Primitive visitIndex(ast.Send node,
                           ast.Node receiver,
                           ast.Node index, _) {
     Selector selector = new Selector.index();
     ir.Primitive target = visit(receiver);
     List<ir.Primitive> arguments = <ir.Primitive>[visit(index)];
     arguments = normalizeDynamicArguments(selector.callStructure, arguments);
     return irBuilder.buildDynamicInvocation(
-        target, selector, elements.getTypeMask(node), arguments);
+        target, selector, elements.getTypeMask(node), arguments,
+        sourceInformation:
+            sourceInformationBuilder.buildCall(receiver, node.selector));
   }
 
   ir.Primitive translateSuperBinary(FunctionElement function,
                                     op.BinaryOperator operator,
                                     ast.Node argument) {
     CallStructure callStructure = CallStructure.ONE_ARG;
     List<ir.Primitive> arguments = <ir.Primitive>[visit(argument)];
     arguments = normalizeDynamicArguments(callStructure, arguments);
     return irBuilder.buildSuperMethodInvocation(
         function, callStructure, arguments);
@@ skipping 64 matching lines @@
         translateSuperBinary(function, op.BinaryOperator.NOT_EQ, argument));
   }
 
   @override
   ir.Primitive visitUnary(ast.Send node,
                           op.UnaryOperator operator, ast.Node expression, _) {
     // TODO(johnniwinther): Clean up the creation of selectors.
     Selector selector = operator.selector;
     ir.Primitive receiver = translateReceiver(expression);
     return irBuilder.buildDynamicInvocation(
-        receiver, selector, elements.getTypeMask(node), const []);
+        receiver, selector, elements.getTypeMask(node), const [],
+        sourceInformation: sourceInformationBuilder.buildCall(
+            expression, node));
   }
 
   @override
   ir.Primitive visitSuperUnary(
       ast.Send node,
       op.UnaryOperator operator,
       FunctionElement function,
       _) {
     return irBuilder.buildSuperMethodInvocation(
         function, CallStructure.NO_ARGS, const []);
@@ skipping 262 matching lines @@
   ir.Primitive visitSuperIndexSet(
       ast.SendSet node,
       FunctionElement function,
       ast.Node index,
       ast.Node rhs,
       _) {
     return irBuilder.buildSuperIndexSet(function, visit(index), visit(rhs));
   }
 
   ir.Primitive translateCompounds(
+      ast.SendSet node,
       {ir.Primitive getValue(),
        CompoundRhs rhs,
-       void setValue(ir.Primitive value),
-       TypeMask operatorTypeMask}) {
+       void setValue(ir.Primitive value)}) {
     ir.Primitive value = getValue();
     op.BinaryOperator operator = rhs.operator;
     if (operator.kind == op.BinaryOperatorKind.IF_NULL) {
       // Unlike other compound operators if-null conditionally will not do the
       // assignment operation.
       return irBuilder.buildIfNull(value, nested(() {
         ir.Primitive newValue = build(rhs.rhs);
         setValue(newValue);
         return newValue;
       }));
     }
 
     Selector operatorSelector =
         new Selector.binaryOperator(operator.selectorName);
     ir.Primitive rhsValue;
     if (rhs.kind == CompoundKind.ASSIGNMENT) {
       rhsValue = visit(rhs.rhs);
     } else {
       rhsValue = irBuilder.buildIntegerConstant(1);
     }
     List<ir.Primitive> arguments = <ir.Primitive>[rhsValue];
     arguments = normalizeDynamicArguments(
         operatorSelector.callStructure, arguments);
-    ir.Primitive result =
-        irBuilder.buildDynamicInvocation(
-            value, operatorSelector, operatorTypeMask, arguments);
+    TypeMask operatorTypeMask =
+        elements.getOperatorTypeMaskInComplexSendSet(node);
+    SourceInformation operatorSourceInformation =
+        sourceInformationBuilder.buildCall(node, node.assignmentOperator);
+    ir.Primitive result = irBuilder.buildDynamicInvocation(
+        value, operatorSelector, operatorTypeMask, arguments,
+            sourceInformation: operatorSourceInformation);
     setValue(result);
     return rhs.kind == CompoundKind.POSTFIX ? value : result;
   }
 
   @override
   ir.Primitive handleDynamicSet(
       ast.SendSet node,
       ast.Node receiver,
       Selector selector,
       ast.Node rhs,
@@ skipping 74 matching lines @@
     return irBuilder.buildStaticSetterSet(setter, visit(rhs));
   }
 
   @override
   ir.Primitive handleTypeLiteralConstantCompounds(
       ast.SendSet node,
       ConstantExpression constant,
       CompoundRhs rhs,
       arg) {
     return translateCompounds(
+        node,
         getValue: () {
           return buildConstantExpression(constant,
             sourceInformationBuilder.buildGet(node));
         },
         rhs: rhs,
-        setValue: (value) {}, // The binary operator will throw before this.
-        operatorTypeMask: elements.getOperatorTypeMaskInComplexSendSet(node));
+        setValue: (value) {}); // The binary operator will throw before this.
   }
 
   @override
   ir.Primitive handleDynamicCompounds(
       ast.SendSet node,
       ast.Node receiver,
       CompoundRhs rhs,
       Selector getterSelector,
       Selector setterSelector,
       arg) {
     ir.Primitive target = translateReceiver(receiver);
     ir.Primitive helper() {
       return translateCompounds(
+          node,
           getValue: () => irBuilder.buildDynamicGet(
               target,
               getterSelector,
-              elements.getGetterTypeMaskInComplexSendSet(node)),
+              elements.getGetterTypeMaskInComplexSendSet(node),
+              sourceInformationBuilder.buildGet(node)),
           rhs: rhs,
           setValue: (ir.Primitive result) {
             irBuilder.buildDynamicSet(
                 target, setterSelector, elements.getTypeMask(node), result);
-          },
-          operatorTypeMask: elements.getOperatorTypeMaskInComplexSendSet(node));
+          });
     }
     return node.isConditional
         ? irBuilder.buildIfNotNullSend(target, nested(helper))
         : helper();
   }
 
   ir.Primitive buildLocalNoSuchSetter(Local local, ir.Primitive value) {
     Selector selector = new Selector.setter(local.name, null);
     return buildStaticNoSuchMethod(selector, [value]);
   }
 
   @override
   ir.Primitive handleLocalCompounds(
       ast.SendSet node,
       LocalElement local,
       CompoundRhs rhs,
       arg,
       {bool isSetterValid}) {
     return translateCompounds(
+        node,
         getValue: () {
           if (local.isFunction) {
             return irBuilder.buildLocalFunctionGet(local);
           } else {
             return irBuilder.buildLocalVariableGet(local);
           }
         },
         rhs: rhs,
         setValue: (ir.Primitive result) {
           if (isSetterValid) {
             irBuilder.buildLocalVariableSet(local, result);
           } else {
             return buildLocalNoSuchSetter(local, result);
           }
-        },
-        operatorTypeMask: elements.getOperatorTypeMaskInComplexSendSet(node));
+        });
   }
 
   ir.Primitive buildStaticNoSuchGetter(Element element) {
     return buildStaticNoSuchMethod(
         new Selector.getter(element.name, element.library),
         const <ir.Primitive>[]);
   }
 
   ir.Primitive buildStaticNoSuchSetter(Element element, ir.Primitive value) {
     return buildStaticNoSuchMethod(
         new Selector.setter(element.name, element.library),
         <ir.Primitive>[value]);
   }
 
   @override
   ir.Primitive handleStaticCompounds(
       ast.SendSet node,
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
       CompoundRhs rhs,
       arg) {
     return translateCompounds(
+        node,
         getValue: () {
           switch (getterKind) {
             case CompoundGetter.FIELD:
               SourceInformation src = sourceInformationBuilder.buildGet(node);
               return irBuilder.buildStaticFieldGet(getter, src);
             case CompoundGetter.GETTER:
               return irBuilder.buildStaticGetterGet(
                   getter, sourceInformationBuilder.buildGet(node));
             case CompoundGetter.METHOD:
               return irBuilder.buildStaticFunctionGet(getter);
             case CompoundGetter.UNRESOLVED:
               return buildStaticNoSuchGetter(getter);
           }
         },
         rhs: rhs,
         setValue: (ir.Primitive result) {
           switch (setterKind) {
             case CompoundSetter.FIELD:
               return irBuilder.buildStaticFieldSet(setter, result);
             case CompoundSetter.SETTER:
               return irBuilder.buildStaticSetterSet(setter, result);
             case CompoundSetter.INVALID:
               // TODO(johnniwinther): Ensure [setter] is non null.
               return buildStaticNoSuchSetter(
                   setter != null ? setter : getter, result);
           }
-        },
-        operatorTypeMask: elements.getOperatorTypeMaskInComplexSendSet(node));
+        });
   }
 
   ir.Primitive buildSuperNoSuchGetter(Element element, TypeMask mask) {
     return buildInstanceNoSuchMethod(
         new Selector.getter(element.name, element.library),
         mask,
         const <ir.Primitive>[]);
   }
 
   ir.Primitive buildSuperNoSuchSetter(Element element,
                                       TypeMask mask,
                                       ir.Primitive value) {
     return buildInstanceNoSuchMethod(
         new Selector.setter(element.name, element.library),
         mask,
         <ir.Primitive>[value]);
   }
 
   @override
   ir.Primitive handleSuperCompounds(
       ast.SendSet node,
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
       CompoundRhs rhs,
       arg) {
     return translateCompounds(
+        node,
         getValue: () {
           switch (getterKind) {
             case CompoundGetter.FIELD:
               return irBuilder.buildSuperFieldGet(getter);
             case CompoundGetter.GETTER:
               return irBuilder.buildSuperGetterGet(
                   getter, sourceInformationBuilder.buildGet(node));
             case CompoundGetter.METHOD:
               return irBuilder.buildSuperMethodGet(getter);
             case CompoundGetter.UNRESOLVED:
               // TODO(johnniwinther): Ensure [getter] is not null.
               return buildSuperNoSuchGetter(
                   getter != null ? getter : setter,
                   elements.getGetterTypeMaskInComplexSendSet(node));
           }
         },
         rhs: rhs,
         setValue: (ir.Primitive result) {
           switch (setterKind) {
             case CompoundSetter.FIELD:
               return irBuilder.buildSuperFieldSet(setter, result);
             case CompoundSetter.SETTER:
               return irBuilder.buildSuperSetterSet(setter, result);
             case CompoundSetter.INVALID:
               return buildSuperNoSuchSetter(
                   setter, elements.getTypeMask(node), result);
           }
-        },
-        operatorTypeMask: elements.getOperatorTypeMaskInComplexSendSet(node));
+        });
   }
 
   @override
   ir.Primitive handleTypeVariableTypeLiteralCompounds(
       ast.SendSet node,
       TypeVariableElement typeVariable,
       CompoundRhs rhs,
       arg) {
     return translateCompounds(
+        node,
         getValue: () {
           return irBuilder.buildReifyTypeVariable(
             typeVariable.type,
             sourceInformationBuilder.buildGet(node));
         },
         rhs: rhs,
-        setValue: (value) {}, // The binary operator will throw before this.
-        operatorTypeMask: elements.getOperatorTypeMaskInComplexSendSet(node));
+        setValue: (value) {}); // The binary operator will throw before this.
   }
 
   @override
   ir.Primitive handleIndexCompounds(
       ast.SendSet node,
       ast.Node receiver,
       ast.Node index,
       CompoundRhs rhs,
       arg) {
     ir.Primitive target = visit(receiver);
     ir.Primitive indexValue = visit(index);
     return translateCompounds(
+        node,
         getValue: () {
           Selector selector = new Selector.index();
           List<ir.Primitive> arguments = <ir.Primitive>[indexValue];
           arguments =
               normalizeDynamicArguments(selector.callStructure, arguments);
           return irBuilder.buildDynamicInvocation(
               target,
               selector,
               elements.getGetterTypeMaskInComplexSendSet(node),
-              arguments);
+              arguments,
+              sourceInformation:
+                  sourceInformationBuilder.buildCall(receiver, node));
         },
         rhs: rhs,
         setValue: (ir.Primitive result) {
           irBuilder.buildDynamicIndexSet(
               target,
               elements.getTypeMask(node),
               indexValue,
               result);
-        },
-        operatorTypeMask: elements.getOperatorTypeMaskInComplexSendSet(node));
+        });
   }
 
   @override
   ir.Primitive handleSuperIndexCompounds(
       ast.SendSet node,
       Element indexFunction,
       Element indexSetFunction,
       ast.Node index,
       CompoundRhs rhs,
       arg,
       {bool isGetterValid,
        bool isSetterValid}) {
     ir.Primitive indexValue = visit(index);
     return translateCompounds(
+        node,
         getValue: () {
           if (isGetterValid) {
             return irBuilder.buildSuperIndex(indexFunction, indexValue);
           } else {
             return buildInstanceNoSuchMethod(
                 new Selector.index(),
                 elements.getGetterTypeMaskInComplexSendSet(node),
                 <ir.Primitive>[indexValue]);
           }
         },
         rhs: rhs,
         setValue: (ir.Primitive result) {
           if (isSetterValid) {
             irBuilder.buildSuperIndexSet(indexSetFunction, indexValue, result);
           } else {
             buildInstanceNoSuchMethod(
                 new Selector.indexSet(),
                 elements.getTypeMask(node),
                 <ir.Primitive>[indexValue, result]);
           }
-        },
-        operatorTypeMask: elements.getOperatorTypeMaskInComplexSendSet(node));
+        });
   }
 
   /// Evaluates a string interpolation and appends each part to [accumulator]
   /// (after stringify conversion).
   void buildStringParts(ast.Node node, List<ir.Primitive> accumulator) {
     if (node is ast.StringJuxtaposition) {
       buildStringParts(node.first, accumulator);
       buildStringParts(node.second, accumulator);
     } else if (node is ast.StringInterpolation) {
       buildStringParts(node.string, accumulator);
@@ skipping 1748 matching lines @@
   }
 
   processSetStatic(ir.SetStatic node) {
     node.body = replacementFor(node.body);
   }
 
   processContinuation(ir.Continuation node) {
     node.body = replacementFor(node.body);
   }
 }