Add operators test to source_mapping_test.

pkg/compiler/lib/src/js_backend/codegen/unsugar.dart

 library dart2js.unsugar_cps;
 
 import '../../cps_ir/cps_ir_nodes.dart';
 
 import '../../cps_ir/optimizers.dart' show ParentVisitor;
 import '../../constants/expressions.dart';
 import '../../constants/values.dart';
 import '../../elements/elements.dart' show
     ClassElement,
     FieldElement,
@@ skipping 109 matching lines @@
     Continuation returnFalse = new Continuation(<Parameter>[]);
     Primitive falsePrimitive = falseConstant;
     returnFalse.body =
         new LetPrim(falsePrimitive,
             new InvokeContinuation(
                 function.returnContinuation, <Primitive>[falsePrimitive]));
 
     Primitive nullPrimitive = nullConstant;
     Primitive test = new ApplyBuiltinOperator(
         BuiltinOperator.Identical,
-          <Primitive>[function.parameters.single, nullPrimitive]);
+          <Primitive>[function.parameters.single, nullPrimitive],
+          function.parameters.single.sourceInformation);
 
     Expression newBody =
         new LetCont.many(<Continuation>[returnFalse, originalBody],
             new LetPrim(nullPrimitive,
                 new LetPrim(test,
                     new Branch(
                         new IsTrue(test),
                         returnFalse,
                         originalBody))));
     function.body = newBody;
@@ skipping 10 matching lines @@
       Parameter result,
       Expression node) {
     InteriorNode parent = node.parent;
     Continuation continuation = new Continuation([result]);
     continuation.body = node;
     _parentVisitor.processContinuation(continuation);
 
     Selector selector = new Selector.fromElement(function);
     // TODO(johnniwinther): Come up with an implementation of SourceInformation
     // for calls such as this one that don't appear in the original source.
-    InvokeStatic invoke =
-        new InvokeStatic(function, selector, arguments, continuation, null);
+    InvokeStatic invoke = new InvokeStatic(
+        function, selector, arguments, continuation, null);
     _parentVisitor.processInvokeStatic(invoke);
 
     LetCont letCont = new LetCont(continuation, invoke);
     _parentVisitor.processLetCont(letCont);
 
     parent.body = letCont;
     letCont.parent = parent;
   }
 
   processLetHandler(LetHandler node) {
@@ skipping 65 matching lines @@
       // If the receiver is the explicit receiver, we are calling a method in
       // the same interceptor:
       //  Change 'receiver.foo()'  to  'this.foo(receiver)'.
       newReceiver = thisParameter;
     } else {
       // TODO(sra): Move the computation of interceptedClasses to a much later
       // phase and take into account the remaining uses of the interceptor.
       Set<ClassElement> interceptedClasses =
         _glue.getInterceptedClassesOn(selector);
       _glue.registerSpecializedGetInterceptor(interceptedClasses);
-      newReceiver = new Interceptor(receiver, interceptedClasses);
+      newReceiver = new Interceptor(
+          receiver, interceptedClasses, node.sourceInformation);
       insertLetPrim(newReceiver, node);
     }
 
     node.arguments.insert(0, node.receiver);
     node.receiver = new Reference<Primitive>(newReceiver);
   }
 
   processInvokeMethodDirectly(InvokeMethodDirectly node) {
     if (_glue.isInterceptedMethod(node.target)) {
       Primitive nullPrim = nullConstant;
       insertLetPrim(nullPrim, node);
       node.arguments.insert(0, node.receiver);
       // TODO(sra): `null` is not adequate.  Interceptors project the class
       // hierarchy onto an interceptor hierarchy.  A super call that does a
       // method call will use the javascript 'this' parameter to avoid calling
       // getInterceptor again, so the receiver must be the interceptor (likely
       // `this`), not `null`.
       node.receiver = new Reference<Primitive>(nullPrim);
     }
   }
 
   processBranch(Branch node) {
     // TODO(karlklose): implement the checked mode part of boolean conversion.
     InteriorNode parent = node.parent;
     IsTrue condition = node.condition;
     Primitive t = trueConstant;
     Primitive i = new ApplyBuiltinOperator(
         BuiltinOperator.Identical,
-        <Primitive>[condition.value.definition, t]);
+        <Primitive>[condition.value.definition, t],
+        condition.value.definition.sourceInformation);
     LetPrim newNode = new LetPrim(t,
         new LetPrim(i,
             new Branch(new IsTrue(i),
                 node.trueContinuation.definition,
                 node.falseContinuation.definition)));
     condition.value.unlink();
     node.trueContinuation.unlink();
     node.falseContinuation.unlink();
     parent.body = newNode;
   }
 
   processInterceptor(Interceptor node) {
     _glue.registerSpecializedGetInterceptor(node.interceptedClasses);
   }
 }