Create and test source mapping for invocations.

pkg/compiler/lib/src/ssa/codegen.dart

 // Copyright (c) 2012, 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.
 
 part of ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
-  final SourceInformationFactory sourceInformationFactory;
+  final SourceInformationStrategy sourceInformationFactory;
 
   SsaCodeGeneratorTask(JavaScriptBackend backend,
                        this.sourceInformationFactory)
       : this.backend = backend,
         super(backend.compiler);
 
   String get name => 'SSA code generator';
   NativeEmitter get nativeEmitter => backend.emitter.nativeEmitter;
 
-
-  js.Node attachPosition(js.Node node, AstElement element) {
-    return node.withSourceInformation(
-        StartEndSourceInformation.computeSourceInformation(element));
-  }
-
   js.Fun buildJavaScriptFunction(FunctionElement element,
                                  List<js.Parameter> parameters,
                                  js.Block body) {
     js.AsyncModifier asyncModifier = element.asyncMarker.isAsync
         ? (element.asyncMarker.isYielding
             ? const js.AsyncModifier.asyncStar()
             : const js.AsyncModifier.async())
         : (element.asyncMarker.isYielding
             ? const js.AsyncModifier.syncStar()
             : const js.AsyncModifier.sync());
 
     return new js.Fun(parameters, body, asyncModifier: asyncModifier)
-        .withSourceInformation(sourceInformationFactory.forContext(element)
-            .buildDeclaration(element));
+        .withSourceInformation(
+            sourceInformationFactory.createBuilderForContext(element)
+                .buildDeclaration(element));
   }
 
   js.Expression generateCode(CodegenWorkItem work, HGraph graph) {
     if (work.element.isField) {
       return generateLazyInitializer(work, graph);
     } else {
       return generateMethod(work, graph);
     }
   }
 
   js.Expression generateLazyInitializer(work, graph) {
     return measure(() {
       compiler.tracer.traceGraph("codegen", graph);
       SourceInformation sourceInformation =
-          sourceInformationFactory.forContext(work.element)
+          sourceInformationFactory.createBuilderForContext(work.element)
               .buildDeclaration(work.element);
       SsaCodeGenerator codegen = new SsaCodeGenerator(backend, work);
       codegen.visitGraph(graph);
       return new js.Fun(codegen.parameters, codegen.body)
           .withSourceInformation(sourceInformation);
     });
   }
 
   js.Expression generateMethod(CodegenWorkItem work, HGraph graph) {
     return measure(() {
@@ skipping 117 matching lines @@
     if (instruction.isUInt31(compiler)) return false;
     // If the result of a bit-operation is only used by other bit
     // operations, we do not have to convert to an unsigned integer.
     return hasNonBitOpUser(instruction, new Set<HPhi>());
   }
 
   /**
    * If the [instruction] is not `null` it will be used to attach the position
    * to the [statement].
    */
-  void pushStatement(js.Statement statement, [HInstruction instruction]) {
+  void pushStatement(js.Statement statement) {
     assert(expressionStack.isEmpty);
-    if (instruction != null) {
-      statement = attachLocation(statement, instruction);
-    }
     currentContainer.statements.add(statement);
   }
 
   void insertStatementAtStart(js.Statement statement) {
     currentContainer.statements.insert(0, statement);
   }
 
   /**
    * If the [instruction] is not `null` it will be used to attach the position
    * to the [expression].
    */
   pushExpressionAsStatement(js.Expression expression,
-                            [HInstruction instruction]) {
-    pushStatement(new js.ExpressionStatement(expression), instruction);
+                            SourceInformation sourceInformation) {
+    pushStatement(new js.ExpressionStatement(expression)
+        .withSourceInformation(sourceInformation));
   }
 
   /**
    * If the [instruction] is not `null` it will be used to attach the position
    * to the [expression].
    */
-  push(js.Expression expression, [HInstruction instruction]) {
-    if (instruction != null) {
-      expression = attachLocation(expression, instruction);
-    }
+  push(js.Expression expression) {
     expressionStack.add(expression);
   }
 
   js.Expression pop() {
     return expressionStack.removeLast();
   }
 
-  attachLocationToLast(HInstruction instruction) {
-    int index = expressionStack.length - 1;
-    expressionStack[index] =
-        attachLocation(expressionStack[index], instruction);
-  }
-
-  js.Node attachLocation(js.Node jsNode, HInstruction instruction) {
-    return attachSourceInformation(jsNode, instruction.sourceInformation);
-  }
-
-  js.Node attachSourceInformation(js.Node jsNode,
-                                  SourceInformation sourceInformation) {
-    return jsNode.withSourceInformation(sourceInformation);
-  }
-
   void preGenerateMethod(HGraph graph) {
     new SsaInstructionSelection(compiler).visitGraph(graph);
     new SsaTypeKnownRemover().visitGraph(graph);
     new SsaTrustedCheckRemover(compiler).visitGraph(graph);
     new SsaInstructionMerger(generateAtUseSite, compiler).visitGraph(graph);
     new SsaConditionMerger(
         generateAtUseSite, controlFlowOperators).visitGraph(graph);
     SsaLiveIntervalBuilder intervalBuilder = new SsaLiveIntervalBuilder(
         compiler, generateAtUseSite, controlFlowOperators);
     intervalBuilder.visitGraph(graph);
@@ skipping 239 matching lines @@
           // Also check for the shortcut where y equals 1: x++ and x--.
           if ((op == '+' || op == '-') &&
               binary.right is js.LiteralNumber &&
               (binary.right as js.LiteralNumber).value == "1") {
             return new js.Prefix(op == '+' ? '++' : '--', binary.left);
           }
           return new js.Assignment.compound(binary.left, op, binary.right);
         }
       }
     }
-    return new js.Assignment(new js.VariableUse(variableName), value);
+    return new js.Assignment(new js.VariableUse(variableName), value)
+        .withSourceInformation(value.sourceInformation);
   }
 
-  void assignVariable(String variableName, js.Expression value) {
+  void assignVariable(String variableName,
+                      js.Expression value,
+                      SourceInformation sourceInformation) {
     if (isGeneratingExpression) {
       // If we are in an expression then we can't declare the variable here.
       // We have no choice, but to use it and then declare it separately.
       if (!isVariableDeclared(variableName)) {
         collectedVariableDeclarations.add(variableName);
       }
       push(generateExpressionAssignment(variableName, value));
       // Otherwise if we are trying to declare inline and we are in a statement
       // then we declare (unless it was already declared).
     } else if (!shouldGroupVarDeclarations &&
                !declaredLocals.contains(variableName)) {
       // It may be necessary to remove it from the ones to be declared later.
       collectedVariableDeclarations.remove(variableName);
       declaredLocals.add(variableName);
       js.VariableDeclaration decl = new js.VariableDeclaration(variableName);
       js.VariableInitialization initialization =
           new js.VariableInitialization(decl, value);
 
       pushExpressionAsStatement(new js.VariableDeclarationList(
-          <js.VariableInitialization>[initialization]));
+          <js.VariableInitialization>[initialization]),
+          sourceInformation);
     } else {
       // Otherwise we are just going to use it.  If we have not already declared
       // it then we make sure we will declare it later.
       if (!declaredLocals.contains(variableName)) {
         collectedVariableDeclarations.add(variableName);
       }
       pushExpressionAsStatement(
-          generateExpressionAssignment(variableName, value));
+          generateExpressionAssignment(variableName, value),
+          sourceInformation);
     }
   }
 
   void define(HInstruction instruction) {
     // For simple type checks like i = intTypeCheck(i), we don't have to
     // emit an assignment, because the intTypeCheck just returns its
     // argument.
     bool needsAssignment = true;
     if (instruction is HTypeConversion) {
       HTypeConversion typeConversion = instruction;
       String inputName = variableNames.getName(typeConversion.checkedInput);
       if (variableNames.getName(instruction) == inputName) {
         needsAssignment = false;
       }
     }
     if (instruction is HLocalValue) {
       needsAssignment = false;
     }
 
     if (needsAssignment &&
         !instruction.isControlFlow() && variableNames.hasName(instruction)) {
       visitExpression(instruction);
-      assignVariable(variableNames.getName(instruction), pop());
+      assignVariable(variableNames.getName(instruction), pop(),
+                     instruction.sourceInformation);
       return;
     }
 
     if (isGeneratingExpression) {
       visitExpression(instruction);
     } else {
       visitStatement(instruction);
     }
   }
 
@@ skipping 20 matching lines @@
     isGeneratingExpression = true;
     visit(node);
     isGeneratingExpression = oldIsGeneratingExpression;
   }
 
   visitStatement(HInstruction node) {
     assert(!isGeneratingExpression);
     visit(node);
     if (!expressionStack.isEmpty) {
       assert(expressionStack.length == 1);
-      pushExpressionAsStatement(pop());
+      js.Expression expression = pop();
+      pushExpressionAsStatement(expression, node.sourceInformation);
     }
   }
 
   void continueAsBreak(LabelDefinition target) {
     pushStatement(new js.Break(backend.namer.continueLabelName(target)));
   }
 
   void implicitContinueAsBreak(JumpTarget target) {
     pushStatement(new js.Break(
         backend.namer.implicitContinueLabelName(target)));
   }
 
   void implicitBreakWithLabel(JumpTarget target) {
     pushStatement(new js.Break(backend.namer.implicitBreakLabelName(target)));
   }
 
-  js.Statement wrapIntoLabels(js.Statement result, List<LabelDefinition> labels) {
+  js.Statement wrapIntoLabels(js.Statement result,
+                              List<LabelDefinition> labels) {
     for (LabelDefinition label in labels) {
       if (label.isTarget) {
         String breakLabelString = backend.namer.breakLabelName(label);
         result = new js.LabeledStatement(breakLabelString, result);
       }
     }
     return result;
   }
 
 
@@ skipping 202 matching lines @@
           // The body might be labeled. Ignore this when recursing on the
           // subgraph.
           // TODO(lrn): Remove this extra labeling when handling all loops
           // using subgraphs.
           oldContainer = currentContainer;
           js.Statement body = new js.Block.empty();
           currentContainer = body;
           visitBodyIgnoreLabels(info);
           currentContainer = oldContainer;
           body = unwrapStatement(body);
-          loop = new js.For(jsInitialization, jsCondition, jsUpdates, body);
+          loop = new js.For(jsInitialization, jsCondition, jsUpdates, body)
+              .withSourceInformation(info.sourceInformation);
         } else {
           // We have either no update graph, or it's too complex to
           // put in an expression.
           if (initialization != null) {
             generateStatements(initialization);
           }
           js.Expression jsCondition;
           js.Block oldContainer = currentContainer;
           js.Statement body = new js.Block.empty();
           if (isConditionExpression && !hasPhiUpdates) {
             jsCondition = generateExpression(condition);
             currentContainer = body;
           } else {
-            jsCondition = newLiteralBool(true);
+            jsCondition = newLiteralBool(true, info.sourceInformation);
             currentContainer = body;
             generateStatements(condition);
             use(condition.conditionExpression);
             js.Expression ifTest = new js.Prefix("!", pop());
             js.Statement jsBreak = new js.Break(null);
             js.Statement exitLoop;
             if (avoidContainer.statements.isEmpty) {
               exitLoop = jsBreak;
             } else {
               avoidContainer.statements.add(jsBreak);
               exitLoop = avoidContainer;
             }
             pushStatement(new js.If.noElse(ifTest, exitLoop));
           }
           if (info.updates != null) {
             wrapLoopBodyForContinue(info);
             generateStatements(info.updates);
           } else {
             visitBodyIgnoreLabels(info);
           }
           currentContainer = oldContainer;
           body = unwrapStatement(body);
-          loop = new js.While(jsCondition, body);
+          loop = new js.While(jsCondition, body)
+              .withSourceInformation(info.sourceInformation);
         }
         break;
       case HLoopBlockInformation.DO_WHILE_LOOP:
         if (info.initializer != null) {
           generateStatements(info.initializer);
         }
         // We inserted a basic block to avoid critical edges. This block is
         // part of the LoopBlockInformation and must therefore be handled here.
         js.Block oldContainer = currentContainer;
         js.Block exitAvoidContainer = new js.Block.empty();
@@ skipping 30 matching lines @@
           push(generateExpression(condition));
         } else {
           generateStatements(condition);
           use(condition.conditionExpression);
         }
         js.Expression jsCondition = pop();
         if (jsCondition == null) {
           // If the condition is dead code, we turn the do-while into
           // a simpler while because we will never reach the condition
           // at the end of the loop anyway.
-          loop = new js.While(newLiteralBool(true), unwrapStatement(body));
+          loop = new js.While(
+              newLiteralBool(true, info.sourceInformation),
+              unwrapStatement(body))
+                  .withSourceInformation(info.sourceInformation);
         } else {
           if (hasPhiUpdates || hasExitPhiUpdates) {
             updateBody.statements.add(new js.Continue(null));
             js.Statement jsBreak = new js.Break(null);
             js.Statement exitLoop;
             if (exitAvoidContainer.statements.isEmpty) {
               exitLoop = jsBreak;
             } else {
               exitAvoidContainer.statements.add(jsBreak);
               exitLoop = exitAvoidContainer;
             }
             body.statements.add(
                 new js.If(jsCondition, updateBody, exitLoop));
-            jsCondition = newLiteralBool(true);
+            jsCondition = newLiteralBool(true, info.sourceInformation);
           }
-          loop = new js.Do(unwrapStatement(body), jsCondition);
+          loop = new js.Do(unwrapStatement(body), jsCondition)
+              .withSourceInformation(info.sourceInformation);
         }
         currentContainer = oldContainer;
         break;
       default:
         compiler.internalError(condition.conditionExpression,
             'Unexpected loop kind: ${info.kind}.');
     }
-    js.Statement result = attachSourceInformation(loop, info.sourceInformation);
+    js.Statement result = loop;
     if (info.kind == HLoopBlockInformation.SWITCH_CONTINUE_LOOP) {
       String continueLabelString =
           backend.namer.implicitContinueLabelName(info.target);
       result = new js.LabeledStatement(continueLabelString, result);
     }
     pushStatement(wrapIntoLabels(result, info.labels));
     return true;
   }
 
   bool visitLabeledBlockInfo(HLabeledBlockInformation labeledBlockInfo) {
@@ skipping 126 matching lines @@
 
     // If this node has block-structure based information attached,
     // try using that to traverse from here.
     if (node.blockFlow != null && handleBlockFlow(node.blockFlow)) {
       return;
     }
     iterateBasicBlock(node);
   }
 
   void emitAssignment(String destination, String source) {
-    assignVariable(destination, new js.VariableUse(source));
+    assignVariable(destination, new js.VariableUse(source), null);
   }
 
   /**
    * Sequentialize a list of conceptually parallel copies. Parallel
    * copies may contain cycles, that this method breaks.
    */
   void sequentializeCopies(Iterable<Copy> copies,
                            String tempName,
                            void doAssignment(String target, String source)) {
     // Map to keep track of the current location (ie the variable that
@@ skipping 79 matching lines @@
     Iterable<Copy> copies = handler.copies.map((Copy copy) {
       return new Copy(variableNames.getName(copy.source),
                       variableNames.getName(copy.destination));
     });
 
     sequentializeCopies(copies, variableNames.getSwapTemp(), emitAssignment);
 
     for (Copy copy in handler.assignments) {
       String name = variableNames.getName(copy.destination);
       use(copy.source);
-      assignVariable(name, pop());
+      assignVariable(name, pop(), null);
     }
   }
 
   void iterateBasicBlock(HBasicBlock node) {
     HInstruction instruction = node.first;
     while (!identical(instruction, node.last)) {
       if (!isGenerateAtUseSite(instruction)) {
         define(instruction);
       }
       instruction = instruction.next;
     }
     assignPhisOfSuccessors(node);
     visit(instruction);
   }
 
-  visitInvokeBinary(HInvokeBinary node, String op) {
+  void handleInvokeBinary(HInvokeBinary node,
+                          String op,
+                          SourceInformation sourceInformation) {
     use(node.left);
     js.Expression jsLeft = pop();
     use(node.right);
-    push(new js.Binary(op, jsLeft, pop()), node);
+    push(new js.Binary(op, jsLeft, pop())
+        .withSourceInformation(sourceInformation));
   }
 
-  visitRelational(HRelational node, String op) => visitInvokeBinary(node, op);
+  visitInvokeBinary(HInvokeBinary node, String op) {
+    handleInvokeBinary(node, op, node.sourceInformation);
+  }
+
+  visitRelational(HRelational node, String op) {
+    handleInvokeBinary(node, op, node.sourceInformation);
+  }
 
   // We want the outcome of bit-operations to be positive. We use the unsigned
   // shift operator to achieve this.
   visitBitInvokeBinary(HBinaryBitOp node, String op) {
     visitInvokeBinary(node, op);
     if (op != '>>>' && requiresUintConversion(node)) {
-      push(new js.Binary(">>>", pop(), new js.LiteralNumber("0")), node);
+      push(new js.Binary(">>>", pop(), new js.LiteralNumber("0"))
+              .withSourceInformation(node.sourceInformation));
     }
   }
 
   visitInvokeUnary(HInvokeUnary node, String op) {
     use(node.operand);
-    push(new js.Prefix(op, pop()), node);
+    push(new js.Prefix(op, pop())
+        .withSourceInformation(node.sourceInformation));
   }
 
   // We want the outcome of bit-operations to be positive. We use the unsigned
   // shift operator to achieve this.
   visitBitInvokeUnary(HInvokeUnary node, String op) {
     visitInvokeUnary(node, op);
     if (requiresUintConversion(node)) {
-      push(new js.Binary(">>>", pop(), new js.LiteralNumber("0")), node);
+      push(new js.Binary(">>>", pop(), new js.LiteralNumber("0"))
+          .withSourceInformation(node.sourceInformation));
     }
   }
 
-  void emitIdentityComparison(HIdentity instruction, bool inverse) {
+  void emitIdentityComparison(HIdentity instruction,
+                              SourceInformation sourceInformation,
+                              {bool inverse: false}) {
     String op = instruction.singleComparisonOp;
     HInstruction left = instruction.left;
     HInstruction right = instruction.right;
     if (op != null) {
       use(left);
       js.Expression jsLeft = pop();
       use(right);
-      push(new js.Binary(mapRelationalOperator(op, inverse), jsLeft, pop()));
+      push(new js.Binary(mapRelationalOperator(op, inverse), jsLeft, pop())
+         .withSourceInformation(sourceInformation));
     } else {
       assert(NullConstantValue.JsNull == 'null');
       use(left);
       js.Binary leftEqualsNull =
           new js.Binary("==", pop(), new js.LiteralNull());
       use(right);
       js.Binary rightEqualsNull =
           new js.Binary(mapRelationalOperator("==", inverse),
                         pop(), new js.LiteralNull());
       use(right);
       use(left);
       js.Binary tripleEq = new js.Binary(mapRelationalOperator("===", inverse),
                                          pop(), pop());
 
-      push(new js.Conditional(leftEqualsNull, rightEqualsNull, tripleEq));
+      push(new js.Conditional(leftEqualsNull, rightEqualsNull, tripleEq)
+          .withSourceInformation(sourceInformation));
     }
   }
 
   visitIdentity(HIdentity node) {
-    emitIdentityComparison(node, false);
+    emitIdentityComparison(node, node.sourceInformation, inverse: false);
   }
 
   visitAdd(HAdd node)               => visitInvokeBinary(node, '+');
   visitDivide(HDivide node)         => visitInvokeBinary(node, '/');
   visitMultiply(HMultiply node)     => visitInvokeBinary(node, '*');
   visitSubtract(HSubtract node)     => visitInvokeBinary(node, '-');
   visitBitAnd(HBitAnd node)         => visitBitInvokeBinary(node, '&');
   visitBitNot(HBitNot node)         => visitBitInvokeUnary(node, '~');
   visitBitOr(HBitOr node)           => visitBitInvokeBinary(node, '|');
   visitBitXor(HBitXor node)         => visitBitInvokeBinary(node, '^');
   visitShiftLeft(HShiftLeft node)   => visitBitInvokeBinary(node, '<<');
   visitShiftRight(HShiftRight node) => visitBitInvokeBinary(node, '>>>');
 
   visitTruncatingDivide(HTruncatingDivide node) {
     assert(node.isUInt31(compiler));
     // TODO(karlklose): Enable this assertion again when type propagation is
     // fixed. Issue 23555.
 //    assert(node.left.isUInt32(compiler));
     assert(node.right.isPositiveInteger(compiler));
     use(node.left);
     js.Expression jsLeft = pop();
     use(node.right);
-    push(new js.Binary('/', jsLeft, pop()), node);
-    push(new js.Binary('|', pop(), new js.LiteralNumber("0")), node);
+    push(new js.Binary('/', jsLeft, pop())
+        .withSourceInformation(node.sourceInformation));
+    push(new js.Binary('|', pop(), new js.LiteralNumber("0"))
+        .withSourceInformation(node.sourceInformation));
   }
 
-  visitNegate(HNegate node)         => visitInvokeUnary(node, '-');
+  visitNegate(HNegate node)             => visitInvokeUnary(node, '-');
 
   visitLess(HLess node)                 => visitRelational(node, '<');
   visitLessEqual(HLessEqual node)       => visitRelational(node, '<=');
   visitGreater(HGreater node)           => visitRelational(node, '>');
   visitGreaterEqual(HGreaterEqual node) => visitRelational(node, '>=');
 
   visitBoolify(HBoolify node) {
     assert(node.inputs.length == 1);
     use(node.inputs[0]);
-    push(new js.Binary('===', pop(), newLiteralBool(true)), node);
+    push(new js.Binary('===', pop(),
+                       newLiteralBool(true, node.sourceInformation))
+        .withSourceInformation(node.sourceInformation));
   }
 
   visitExit(HExit node) {
     // Don't do anything.
   }
 
   visitGoto(HGoto node) {
     HBasicBlock block = node.block;
     assert(block.successors.length == 1);
     List<HBasicBlock> dominated = block.dominatedBlocks;
@@ skipping 35 matching lines @@
     if (action == null) return false;
     action(entity);
     return true;
   }
 
   visitBreak(HBreak node) {
     assert(node.block.successors.length == 1);
     if (node.label != null) {
       LabelDefinition label = node.label;
       if (!tryCallAction(breakAction, label)) {
-        pushStatement(new js.Break(backend.namer.breakLabelName(label)), node);
+        pushStatement(
+            new js.Break(backend.namer.breakLabelName(label))
+                .withSourceInformation(node.sourceInformation));
       }
     } else {
       JumpTarget target = node.target;
       if (!tryCallAction(breakAction, target)) {
         if (node.breakSwitchContinueLoop) {
-          pushStatement(new js.Break(
-              backend.namer.implicitContinueLabelName(target)), node);
+          pushStatement(
+              new js.Break(backend.namer.implicitContinueLabelName(target))
+                  .withSourceInformation(node.sourceInformation));
         } else {
-          pushStatement(new js.Break(null), node);
+          pushStatement(new js.Break(null)
+              .withSourceInformation(node.sourceInformation));
         }
       }
     }
   }
 
   visitContinue(HContinue node) {
     assert(node.block.successors.length == 1);
     if (node.label != null) {
       LabelDefinition label = node.label;
       if (!tryCallAction(continueAction, label)) {
         // TODO(floitsch): should this really be the breakLabelName?
-        pushStatement(new js.Continue(backend.namer.breakLabelName(label)),
-                      node);
+        pushStatement(
+            new js.Continue(backend.namer.breakLabelName(label))
+                .withSourceInformation(node.sourceInformation));
       }
     } else {
       JumpTarget target = node.target;
       if (!tryCallAction(continueAction, target)) {
         if (target.statement is ast.SwitchStatement) {
-          pushStatement(new js.Continue(
-              backend.namer.implicitContinueLabelName(target)), node);
+          pushStatement(
+              new js.Continue(backend.namer.implicitContinueLabelName(target))
+                  .withSourceInformation(node.sourceInformation));
         } else {
-          pushStatement(new js.Continue(null), node);
+          pushStatement(new js.Continue(null)
+              .withSourceInformation(node.sourceInformation));
         }
       }
     }
   }
 
   visitExitTry(HExitTry node) {
     // An [HExitTry] is used to represent the control flow graph of a
     // try/catch block, ie the try body is always a predecessor
     // of the catch and finally. Here, we continue visiting the try
     // body by visiting the block that contains the user-level control
@@ skipping 30 matching lines @@
     use(node.inputs[0]);
     js.Expression test = pop();
 
     HStatementInformation thenGraph = info.thenGraph;
     HStatementInformation elseGraph = info.elseGraph;
     js.Statement thenPart =
         unwrapStatement(generateStatementsInNewBlock(thenGraph));
     js.Statement elsePart =
         unwrapStatement(generateStatementsInNewBlock(elseGraph));
 
-    pushStatement(new js.If(test, thenPart, elsePart), node);
+    pushStatement(new js.If(test, thenPart, elsePart)
+        .withSourceInformation(node.sourceInformation));
   }
 
   visitIf(HIf node) {
     if (tryControlFlowOperation(node)) return;
 
     HInstruction condition = node.inputs[0];
     HIfBlockInformation info = node.blockInformation.body;
 
     if (condition.isConstant()) {
       HConstant constant = condition;
@@ skipping 34 matching lines @@
       push(js.js('# && #', [receiverExpression, constant]));
     } else {
       assert(node.inputs.length == 1);
       registry.registerSpecializedGetInterceptor(node.interceptedClasses);
       js.Name name =
           backend.namer.nameForGetInterceptor(node.interceptedClasses);
       var isolate = new js.VariableUse(
           backend.namer.globalObjectFor(backend.interceptorsLibrary));
       use(node.receiver);
       List<js.Expression> arguments = <js.Expression>[pop()];
-      push(js.propertyCall(isolate, name, arguments), node);
+      push(js.propertyCall(isolate, name, arguments)
+           .withSourceInformation(node.sourceInformation));
       registry.registerUseInterceptor();
     }
   }
 
   visitInvokeDynamicMethod(HInvokeDynamicMethod node) {
     use(node.receiver);
     js.Expression object = pop();
     String methodName;
     List<js.Expression> arguments = visitArguments(node.inputs);
     Element target = node.element;
@@ skipping 18 matching lines @@
       }
     }
 
     js.Name methodLiteral;
     if (methodName == null) {
       methodLiteral = backend.namer.invocationName(node.selector);
       registerMethodInvoke(node);
     } else {
       methodLiteral = backend.namer.asName(methodName);
     }
-    push(js.propertyCall(object, methodLiteral, arguments), node);
+    push(js.propertyCall(object, methodLiteral, arguments)
+         .withSourceInformation(node.sourceInformation));
   }
 
   void visitInvokeConstructorBody(HInvokeConstructorBody node) {
     use(node.inputs[0]);
     js.Expression object = pop();
     js.Name methodName = backend.namer.instanceMethodName(node.element);
     List<js.Expression> arguments = visitArguments(node.inputs);
-    push(js.propertyCall(object, methodName, arguments), node);
+    push(js.propertyCall(object, methodName, arguments)
+         .withSourceInformation(node.sourceInformation));
     registry.registerStaticUse(node.element);
   }
 
   void visitOneShotInterceptor(HOneShotInterceptor node) {
     List<js.Expression> arguments = visitArguments(node.inputs);
     var isolate = new js.VariableUse(
         backend.namer.globalObjectFor(backend.interceptorsLibrary));
     Selector selector = node.selector;
     TypeMask mask = getOptimizedSelectorFor(node, selector, node.mask);
     js.Name methodName = backend.registerOneShotInterceptor(selector);
-    push(js.propertyCall(isolate, methodName, arguments), node);
+    push(js.propertyCall(isolate, methodName, arguments)
+        .withSourceInformation(node.sourceInformation));
     if (selector.isGetter) {
       registerGetter(node);
     } else if (selector.isSetter) {
       registerSetter(node);
     } else {
       registerMethodInvoke(node);
     }
     registry.registerUseInterceptor();
   }
 
@@ skipping 44 matching lines @@
   void registerGetter(HInvokeDynamic node) {
     Selector selector = node.selector;
     TypeMask mask = getOptimizedSelectorFor(node, selector, node.mask);
     registry.registerDynamicGetter(
         new UniverseSelector(selector, mask));
   }
 
   visitInvokeDynamicSetter(HInvokeDynamicSetter node) {
     use(node.receiver);
     js.Name name = backend.namer.invocationName(node.selector);
-    push(js.propertyCall(pop(), name, visitArguments(node.inputs)), node);
+    push(js.propertyCall(pop(), name, visitArguments(node.inputs))
+         .withSourceInformation(node.sourceInformation));
     registerSetter(node);
   }
 
   visitInvokeDynamicGetter(HInvokeDynamicGetter node) {
     use(node.receiver);
     js.Name name = backend.namer.invocationName(node.selector);
-    push(js.propertyCall(pop(), name, visitArguments(node.inputs)), node);
+    push(js.propertyCall(pop(), name, visitArguments(node.inputs))
+         .withSourceInformation(node.sourceInformation));
     registerGetter(node);
   }
 
   visitInvokeClosure(HInvokeClosure node) {
     Selector call = new Selector.callClosureFrom(node.selector);
     use(node.receiver);
     push(js.propertyCall(pop(),
                          backend.namer.invocationName(call),
-                         visitArguments(node.inputs)),
-         node);
+                         visitArguments(node.inputs))
+            .withSourceInformation(node.sourceInformation));
     registry.registerDynamicInvocation(
         new UniverseSelector(call, null));
   }
 
   visitInvokeStatic(HInvokeStatic node) {
     Element element = node.element;
     List<DartType> instantiatedTypes = node.instantiatedTypes;
 
     if (instantiatedTypes != null && !instantiatedTypes.isEmpty) {
       instantiatedTypes.forEach((type) {
@@ skipping 21 matching lines @@
       // more optimizations available to the loop.  This form is 50% faster on
       // some small loop, almost as fast as loops with no concurrent
       // modification check.
       push(js.js('# || (0, #)(#)',[
           arguments[0],
           backend.emitter.staticFunctionAccess(throwFunction),
           arguments[1]]));
     } else {
       registry.registerStaticInvocation(element);
       push(backend.emitter.staticFunctionAccess(element));
-      push(new js.Call(pop(), arguments), node);
+      push(new js.Call(pop(), arguments,
+          sourceInformation: node.sourceInformation));
     }
 
   }
 
   visitInvokeSuper(HInvokeSuper node) {
     Element superMethod = node.element;
     registry.registerSuperInvocation(superMethod);
     ClassElement superClass = superMethod.enclosingClass;
     if (superMethod.kind == ElementKind.FIELD) {
       js.Name fieldName =
           backend.namer.instanceFieldPropertyName(superMethod);
       use(node.inputs[0]);
-      js.PropertyAccess access = new js.PropertyAccess(pop(), fieldName);
+      js.PropertyAccess access =
+          new js.PropertyAccess(pop(), fieldName)
+              .withSourceInformation(node.sourceInformation);
       if (node.isSetter) {
         use(node.value);
-        push(new js.Assignment(access, pop()), node);
+        push(new js.Assignment(access, pop())
+            .withSourceInformation(node.sourceInformation));
       } else {
-        push(access, node);
+        push(access);
       }
     } else {
       Selector selector = node.selector;
 
       if (!backend.maybeRegisterAliasedSuperMember(superMethod, selector)) {
         js.Name methodName;
         if (selector.isGetter) {
           // If the selector we need to register a typed getter to the
           // [world]. The emitter needs to know if it needs to emit a
           // bound closure for a method.
           TypeMask receiverType =
               new TypeMask.nonNullExact(superClass, compiler.world);
           // TODO(floitsch): we know the target. We shouldn't register a
           // dynamic getter.
           registry.registerDynamicGetter(
               new UniverseSelector(selector, receiverType));
           registry.registerGetterForSuperMethod(node.element);
           methodName = backend.namer.invocationName(selector);
         } else {
           assert(invariant(node, compiler.hasIncrementalSupport));
           methodName = backend.namer.instanceMethodName(superMethod);
         }
         push(js.js('#.#.call(#)',
                    [backend.emitter.prototypeAccess(superClass,
                                                     hasBeenInstantiated: true),
-                    methodName, visitArguments(node.inputs, start: 0)]),
-             node);
+                    methodName, visitArguments(node.inputs, start: 0)])
+                .withSourceInformation(node.sourceInformation));
       } else {
         use(node.receiver);
         push(
           js.js('#.#(#)', [
             pop(), backend.namer.aliasedSuperMemberPropertyName(superMethod),
-            visitArguments(node.inputs, start: 1)]), // Skip receiver argument.
-          node);
+            visitArguments(node.inputs, start: 1)]) // Skip receiver argument.
+              .withSourceInformation(node.sourceInformation));
       }
     }
   }
 
   visitFieldGet(HFieldGet node) {
     use(node.receiver);
     Element element = node.element;
     if (node.isNullCheck) {
       // We access a JavaScript member we know all objects besides
       // null and undefined have: V8 does not like accessing a member
       // that does not exist.
-      push(new js.PropertyAccess.field(pop(), 'toString'), node);
+      push(new js.PropertyAccess.field(pop(), 'toString')
+          .withSourceInformation(node.sourceInformation));
     } else if (element == backend.jsIndexableLength) {
       // We're accessing a native JavaScript property called 'length'
       // on a JS String or a JS array. Therefore, the name of that
       // property should not be mangled.
-      push(new js.PropertyAccess.field(pop(), 'length'), node);
+      push(new js.PropertyAccess.field(pop(), 'length')
+          .withSourceInformation(node.sourceInformation));
     } else {
       js.Name name = backend.namer.instanceFieldPropertyName(element);
-      push(new js.PropertyAccess(pop(), name), node);
+      push(new js.PropertyAccess(pop(), name)
+          .withSourceInformation(node.sourceInformation));
       registry.registerFieldGetter(element);
     }
   }
 
   visitFieldSet(HFieldSet node) {
     Element element = node.element;
     registry.registerFieldSetter(element);
     js.Name name = backend.namer.instanceFieldPropertyName(element);
     use(node.receiver);
     js.Expression receiver = pop();
     use(node.value);
-    push(new js.Assignment(new js.PropertyAccess(receiver, name), pop()),
-        node);
+    push(new js.Assignment(new js.PropertyAccess(receiver, name), pop())
+        .withSourceInformation(node.sourceInformation));
   }
 
   visitReadModifyWrite(HReadModifyWrite node) {
     Element element = node.element;
     registry.registerFieldSetter(element);
     js.Name name = backend.namer.instanceFieldPropertyName(element);
     use(node.receiver);
     js.Expression fieldReference = new js.PropertyAccess(pop(), name);
     if (node.isPreOp) {
-      push(new js.Prefix(node.jsOp, fieldReference), node);
+      push(new js.Prefix(node.jsOp, fieldReference)
+          .withSourceInformation(node.sourceInformation));
     } else if (node.isPostOp) {
-      push(new js.Postfix(node.jsOp, fieldReference), node);
+      push(new js.Postfix(node.jsOp, fieldReference)
+          .withSourceInformation(node.sourceInformation));
     } else {
       use(node.value);
-      push(new js.Assignment.compound(fieldReference, node.jsOp, pop()), node);
+      push(new js.Assignment.compound(fieldReference, node.jsOp, pop())
+          .withSourceInformation(node.sourceInformation));
     }
   }
 
   visitLocalGet(HLocalGet node) {
     use(node.receiver);
   }
 
   visitLocalSet(HLocalSet node) {
     use(node.value);
-    assignVariable(variableNames.getName(node.receiver), pop());
+    assignVariable(variableNames.getName(node.receiver),
+                   pop(),
+                   node.sourceInformation);
   }
 
   void registerForeignTypes(HForeign node) {
     native.NativeBehavior nativeBehavior = node.nativeBehavior;
     if (nativeBehavior == null) return;
     nativeBehavior.typesReturned.forEach((type) {
       if (type is InterfaceType) {
         registry.registerInstantiatedType(type);
       }
     });
   }
 
   visitForeignCode(HForeignCode node) {
     List<HInstruction> inputs = node.inputs;
     if (node.isJsStatement()) {
       List<js.Expression> interpolatedExpressions = <js.Expression>[];
       for (int i = 0; i < inputs.length; i++) {
         use(inputs[i]);
         interpolatedExpressions.add(pop());
       }
-      pushStatement(node.codeTemplate.instantiate(interpolatedExpressions));
+      pushStatement(node.codeTemplate.instantiate(interpolatedExpressions)
+          .withSourceInformation(node.sourceInformation));
     } else {
       List<js.Expression> interpolatedExpressions = <js.Expression>[];
       for (int i = 0; i < inputs.length; i++) {
         use(inputs[i]);
         interpolatedExpressions.add(pop());
       }
-      push(node.codeTemplate.instantiate(interpolatedExpressions));
+      push(node.codeTemplate.instantiate(interpolatedExpressions)
+          .withSourceInformation(node.sourceInformation));
     }
 
     // TODO(sra): Tell world.nativeEnqueuer about the types created here.
     registerForeignTypes(node);
   }
 
   visitForeignNew(HForeignNew node) {
     js.Expression jsClassReference =
         backend.emitter.constructorAccess(node.element);
     List<js.Expression> arguments = visitArguments(node.inputs, start: 0);
-    push(new js.New(jsClassReference, arguments), node);
+    push(new js.New(jsClassReference, arguments)
+        .withSourceInformation(node.sourceInformation));
     registerForeignTypes(node);
     // We also use ForeignNew to instantiate closure classes that belong to
     // function expressions. We have to register their use here, as otherwise
     // code for them might not be emitted.
     if (node.element.isClosure) {
       registry.registerInstantiatedClass(node.element);
     }
     if (node.instantiatedTypes == null) {
       return;
     }
     node.instantiatedTypes.forEach((type) {
       registry.registerInstantiatedType(type);
     });
   }
 
-  js.Expression newLiteralBool(bool value) {
+  js.Expression newLiteralBool(bool value,
+                               SourceInformation sourceInformation) {
     if (compiler.enableMinification) {
       // Use !0 for true, !1 for false.
-      return new js.Prefix("!", new js.LiteralNumber(value ? "0" : "1"));
+      return new js.Prefix("!", new js.LiteralNumber(value ? "0" : "1"))
+          .withSourceInformation(sourceInformation);
     } else {
-      return new js.LiteralBool(value);
+      return new js.LiteralBool(value)
+          .withSourceInformation(sourceInformation);
     }
   }
 
-  void generateConstant(ConstantValue constant) {
+  void generateConstant(ConstantValue constant,
+                        SourceInformation sourceInformation) {
     if (constant.isFunction) {
       FunctionConstantValue function = constant;
       registry.registerStaticUse(function.element);
     }
     if (constant.isType) {
       // If the type is a web component, we need to ensure the constructors are
       // available to 'upgrade' the native object.
       TypeConstantValue type = constant;
       Element element = type.representedType.element;
       if (element != null && element.isClass) {
         registry.registerTypeConstant(element);
       }
     }
-    push(backend.emitter.constantReference(constant));
+    push(backend.emitter.constantReference(constant)
+            .withSourceInformation(sourceInformation));
   }
 
   visitConstant(HConstant node) {
     assert(isGenerateAtUseSite(node));
-    generateConstant(node.constant);
+    generateConstant(node.constant, node.sourceInformation);
 
     registry.registerCompileTimeConstant(node.constant);
     backend.constants.addCompileTimeConstantForEmission(node.constant);
   }
 
   visitNot(HNot node) {
     assert(node.inputs.length == 1);
-    generateNot(node.inputs[0]);
-    attachLocationToLast(node);
+    generateNot(node.inputs[0], node.sourceInformation);
   }
 
   static String mapRelationalOperator(String op, bool inverse) {
     Map<String, String> inverseOperator = const <String, String>{
       "==" : "!=",
       "!=" : "==",
       "===": "!==",
       "!==": "===",
       "<"  : ">=",
       "<=" : ">",
       ">"  : "<=",
       ">=" : "<"
     };
     return inverse ? inverseOperator[op] : op;
   }
 
-  void generateNot(HInstruction input) {
+  void generateNot(HInstruction input, SourceInformation sourceInformation) {
     bool canGenerateOptimizedComparison(HInstruction instruction) {
       if (instruction is !HRelational) return false;
 
       HRelational relational = instruction;
 
       HInstruction left = relational.left;
       HInstruction right = relational.right;
       if (left.isStringOrNull(compiler) && right.isStringOrNull(compiler)) {
         return true;
       }
 
       // This optimization doesn't work for NaN, so we only do it if the
       // type is known to be an integer.
       return left.isInteger(compiler) && right.isInteger(compiler);
     }
 
     bool handledBySpecialCase = false;
     if (isGenerateAtUseSite(input)) {
       handledBySpecialCase = true;
       if (input is HIs) {
-        emitIs(input, '!==');
+        emitIs(input, '!==', sourceInformation);
       } else if (input is HIsViaInterceptor) {
-        emitIsViaInterceptor(input, true);
+        emitIsViaInterceptor(input, sourceInformation, negative: true);
       } else if (input is HNot) {
         use(input.inputs[0]);
       } else if (input is HIdentity) {
-        emitIdentityComparison(input, true);
+        emitIdentityComparison(input, sourceInformation, inverse: true);
       } else if (input is HBoolify) {
         use(input.inputs[0]);
-        push(new js.Binary("!==", pop(), newLiteralBool(true)), input);
+        push(new js.Binary("!==", pop(),
+                           newLiteralBool(true, input.sourceInformation))
+            .withSourceInformation(sourceInformation));
       } else if (canGenerateOptimizedComparison(input)) {
         HRelational relational = input;
         BinaryOperation operation =
             relational.operation(backend.constantSystem);
         String op = mapRelationalOperator(operation.name, true);
-        visitRelational(input, op);
+        handleInvokeBinary(input, op, sourceInformation);
       } else {
         handledBySpecialCase = false;
       }
     }
     if (!handledBySpecialCase) {
       use(input);
-      push(new js.Prefix("!", pop()));
+      push(new js.Prefix("!", pop()).withSourceInformation(sourceInformation));
     }
   }
 
   visitParameterValue(HParameterValue node) {
     assert(!isGenerateAtUseSite(node));
     String name = variableNames.getName(node);
     parameters.add(new js.Parameter(name));
     declaredLocals.add(name);
   }
 
@@ skipping 10 matching lines @@
     HBasicBlock ifBlock = node.block.dominator;
     assert(controlFlowOperators.contains(ifBlock.last));
     HInstruction input = ifBlock.last.inputs[0];
     if (input.isConstantFalse()) {
       use(node.inputs[1]);
     } else if (input.isConstantTrue()) {
       use(node.inputs[0]);
     } else if (node.inputs[1].isConstantBoolean()) {
       String operation = node.inputs[1].isConstantFalse() ? '&&' : '||';
       if (operation == '||') {
-        generateNot(input);
+        generateNot(input, input.sourceInformation);
       } else {
         use(input);
       }
       js.Expression left = pop();
       use(node.inputs[0]);
       push(new js.Binary(operation, left, pop()));
     } else {
       use(input);
       js.Expression test = pop();
       use(node.inputs[0]);
       js.Expression then = pop();
       use(node.inputs[1]);
       push(new js.Conditional(test, then, pop()));
     }
   }
 
   visitReturn(HReturn node) {
     assert(node.inputs.length == 1);
     HInstruction input = node.inputs[0];
     if (input.isConstantNull()) {
-      pushStatement(new js.Return(null), node);
+      pushStatement(new js.Return()
+          .withSourceInformation(node.sourceInformation));
     } else {
       use(node.inputs[0]);
-      pushStatement(new js.Return(pop()), node);
+      pushStatement(new js.Return(pop())
+          .withSourceInformation(node.sourceInformation));
     }
   }
 
   visitThis(HThis node) {
     push(new js.This());
   }
 
   visitThrow(HThrow node) {
     if (node.isRethrow) {
       use(node.inputs[0]);
-      pushStatement(new js.Throw(pop()), node);
+      pushStatement(new js.Throw(pop())
+          .withSourceInformation(node.sourceInformation));
     } else {
-      generateThrowWithHelper('wrapException', node.inputs[0]);
+      generateThrowWithHelper('wrapException', node.inputs[0],
+          sourceInformation: node.sourceInformation);
     }
   }
 
   visitAwait(HAwait node) {
     use(node.inputs[0]);
-    push(new js.Await(pop()), node);
+    push(new js.Await(pop())
+        .withSourceInformation(node.sourceInformation));
   }
 
   visitYield(HYield node) {
     use(node.inputs[0]);
-    pushStatement(new js.DartYield(pop(), node.hasStar), node);
+    pushStatement(new js.DartYield(pop(), node.hasStar)
+        .withSourceInformation(node.sourceInformation));
   }
 
   visitRangeConversion(HRangeConversion node) {
     // Range conversion instructions are removed by the value range
     // analyzer.
     assert(false);
   }
 
   visitBoundsCheck(HBoundsCheck node) {
     // TODO(ngeoffray): Separate the two checks of the bounds check, so,
@@ skipping 29 matching lines @@
           ? over
           : over == null
               ? under
               : new js.Binary("||", under, over);
       js.Statement thenBody = new js.Block.empty();
       js.Block oldContainer = currentContainer;
       currentContainer = thenBody;
       generateThrowWithHelper('ioore', [node.array, node.index]);
       currentContainer = oldContainer;
       thenBody = unwrapStatement(thenBody);
-      pushStatement(new js.If.noElse(underOver, thenBody), node);
+      pushStatement(new js.If.noElse(underOver, thenBody)
+          .withSourceInformation(node.sourceInformation));
     } else {
       generateThrowWithHelper('ioore', [node.array, node.index]);
     }
   }
 
-  void generateThrowWithHelper(String helperName, argument) {
+  void generateThrowWithHelper(String helperName, argument,
+                               {SourceInformation sourceInformation}) {
     Element helper = backend.findHelper(helperName);
     registry.registerStaticUse(helper);
     js.Expression jsHelper = backend.emitter.staticFunctionAccess(helper);
     List arguments = [];
     var location;
     if (argument is List) {
       location = argument[0];
       argument.forEach((instruction) {
         use(instruction);
         arguments.add(pop());
       });
     } else {
       location = argument;
       use(argument);
       arguments.add(pop());
     }
-    js.Call value = new js.Call(jsHelper, arguments.toList(growable: false));
-    value = attachLocation(value, location);
+    js.Call value = new js.Call(jsHelper, arguments.toList(growable: false),
+        sourceInformation: sourceInformation);
     // BUG(4906): Using throw/return here adds to the size of the generated code
     // but it has the advantage of explicitly telling the JS engine that
     // this code path will terminate abruptly. Needs more work.
     if (helperName == 'wrapException') {
-      pushStatement(new js.Throw(value));
+      pushStatement(new js.Throw(value)
+          .withSourceInformation(sourceInformation));
     } else {
       Element element = work.element;
       if (element is FunctionElement && element.asyncMarker.isYielding) {
         // `return <expr>;` is illegal in a sync* or async* function.
         // To have the the async-translator working, we avoid introducing
         // `return` nodes.
-        pushStatement(new js.ExpressionStatement(value));
+        pushStatement(new js.ExpressionStatement(value)
+            .withSourceInformation(sourceInformation));
       } else {
-        pushStatement(new js.Return(value));
+        pushStatement(new js.Return(value)
+            .withSourceInformation(sourceInformation));
       }
     }
   }
 
   visitThrowExpression(HThrowExpression node) {
     HInstruction argument = node.inputs[0];
     use(argument);
 
     Element helper = backend.findHelper("throwExpression");
     registry.registerStaticUse(helper);
 
     js.Expression jsHelper = backend.emitter.staticFunctionAccess(helper);
-    js.Call value = new js.Call(jsHelper, [pop()]);
-    value = attachLocation(value, argument);
-    push(value, node);
+    js.Call value = new js.Call(jsHelper, [pop()])
+        .withSourceInformation(node.sourceInformation);
+    push(value);
   }
 
   void visitSwitch(HSwitch node) {
     // Switches are handled using [visitSwitchInfo].
   }
 
   void visitStatic(HStatic node) {
     Element element = node.element;
     assert(element.isFunction || element.isField);
     if (element.isFunction) {
-      push(backend.emitter.isolateStaticClosureAccess(element));
+      push(backend.emitter.isolateStaticClosureAccess(element)
+           .withSourceInformation(node.sourceInformation));
       registry.registerGetOfStaticFunction(element);
     } else {
-      push(backend.emitter.staticFieldAccess(element));
+      push(backend.emitter.staticFieldAccess(element)
+           .withSourceInformation(node.sourceInformation));
     }
     registry.registerStaticUse(element);
   }
 
   void visitLazyStatic(HLazyStatic node) {
     Element element = node.element;
     registry.registerStaticUse(element);
     js.Expression lazyGetter =
         backend.emitter.isolateLazyInitializerAccess(element);
-    js.Call call = new js.Call(lazyGetter, <js.Expression>[]);
-    push(call, node);
+    js.Call call = new js.Call(lazyGetter, <js.Expression>[],
+        sourceInformation: node.sourceInformation);
+    push(call);
   }
 
   void visitStaticStore(HStaticStore node) {
     registry.registerStaticUse(node.element);
     js.Node variable = backend.emitter.staticFieldAccess(node.element);
     use(node.inputs[0]);
-    push(new js.Assignment(variable, pop()), node);
+    push(new js.Assignment(variable, pop())
+        .withSourceInformation(node.sourceInformation));
   }
 
   void visitStringConcat(HStringConcat node) {
     use(node.left);
     js.Expression jsLeft = pop();
     use(node.right);
-    push(new js.Binary('+', jsLeft, pop()), node);
+    push(new js.Binary('+', jsLeft, pop())
+        .withSourceInformation(node.sourceInformation));
   }
 
   void visitStringify(HStringify node) {
     HInstruction input = node.inputs.first;
     if (input.isString(compiler)) {
       use(input);
     } else if (input.isInteger(compiler) || input.isBoolean(compiler)) {
       // JavaScript's + operator with a string for the left operand will convert
       // the right operand to a string, and the conversion result is correct.
       use(input);
       if (node.usedBy.length == 1
           && node.usedBy[0] is HStringConcat
           && node.usedBy[0].inputs[1] == node) {
         // The context is already <string> + value.
       } else {
         // Force an empty string for the first operand.
-        push(new js.Binary('+', js.string(""), pop()), node);
+        push(new js.Binary('+', js.string(""), pop())
+            .withSourceInformation(node.sourceInformation));
       }
     } else {
       Element convertToString = backend.getStringInterpolationHelper();
       registry.registerStaticUse(convertToString);
       js.Expression jsHelper =
           backend.emitter.staticFunctionAccess(convertToString);
       use(input);
-      push(new js.Call(jsHelper, <js.Expression>[pop()]), node);
+      push(new js.Call(jsHelper, <js.Expression>[pop()],
+                       sourceInformation: node.sourceInformation));
     }
   }
 
   void visitLiteralList(HLiteralList node) {
     registry.registerInstantiatedClass(compiler.listClass);
     generateArrayLiteral(node);
   }
 
   void generateArrayLiteral(HLiteralList node) {
     List<js.Expression> elements = node.inputs.map((HInstruction input) {
       use(input);
       return pop();
     }).toList();
-    push(new js.ArrayInitializer(elements), node);
+    push(new js.ArrayInitializer(elements)
+        .withSourceInformation(node.sourceInformation));
   }
 
   void visitIndex(HIndex node) {
     use(node.receiver);
     js.Expression receiver = pop();
     use(node.index);
-    push(new js.PropertyAccess(receiver, pop()), node);
+    push(new js.PropertyAccess(receiver, pop())
+        .withSourceInformation(node.sourceInformation));
   }
 
   void visitIndexAssign(HIndexAssign node) {
     use(node.receiver);
     js.Expression receiver = pop();
     use(node.index);
     js.Expression index = pop();
     use(node.value);
-    push(new js.Assignment(new js.PropertyAccess(receiver, index), pop()),
-         node);
+    push(new js.Assignment(new js.PropertyAccess(receiver, index), pop())
+        .withSourceInformation(node.sourceInformation));
   }
 
   void checkInt(HInstruction input, String cmp) {
     use(input);
     js.Expression left = pop();
     use(input);
     js.Expression or0 = new js.Binary("|", pop(), new js.LiteralNumber("0"));
     push(new js.Binary(cmp, left, or0));
   }
 
-  void checkBigInt(HInstruction input, String cmp) {
+  void checkBigInt(HInstruction input, String cmp,
+                   SourceInformation sourceInformation) {
     use(input);
     js.Expression left = pop();
     use(input);
     js.Expression right = pop();
     // TODO(4984): Deal with infinity and -0.0.
-    push(js.js('Math.floor(#) $cmp #', <js.Expression>[left, right]));
+    push(js.js('Math.floor(#) $cmp #', <js.Expression>[left, right])
+            .withSourceInformation(sourceInformation));
   }
 
-  void checkTypeOf(HInstruction input, String cmp, String typeName) {
+  void checkTypeOf(HInstruction input, String cmp, String typeName,
+                   SourceInformation sourceInformation) {
     use(input);
     js.Expression typeOf = new js.Prefix("typeof", pop());
     push(new js.Binary(cmp, typeOf, js.string(typeName)));
   }
 
-  void checkNum(HInstruction input, String cmp)
-      => checkTypeOf(input, cmp, 'number');
+  void checkNum(HInstruction input, String cmp,
+                SourceInformation sourceInformation) {
+    return checkTypeOf(input, cmp, 'number', sourceInformation);
+  }
 
-  void checkDouble(HInstruction input, String cmp)  => checkNum(input, cmp);
+  void checkDouble(HInstruction input, String cmp,
+                   SourceInformation sourceInformation) {
+    return checkNum(input, cmp, sourceInformation);
+  }
 
-  void checkString(HInstruction input, String cmp)
-      => checkTypeOf(input, cmp, 'string');
+  void checkString(HInstruction input, String cmp,
+                   SourceInformation sourceInformation) {
+    return checkTypeOf(input, cmp, 'string', sourceInformation);
+  }
 
-  void checkBool(HInstruction input, String cmp)
-      => checkTypeOf(input, cmp, 'boolean');
+  void checkBool(HInstruction input, String cmp,
+                 SourceInformation sourceInformation) {
+    return checkTypeOf(input, cmp, 'boolean', sourceInformation);
+  }
 
-  void checkObject(HInstruction input, String cmp) {
+  void checkObject(HInstruction input, String cmp,
+                   SourceInformation sourceInformation) {
     assert(NullConstantValue.JsNull == 'null');
     if (cmp == "===") {
-      checkTypeOf(input, '===', 'object');
+      checkTypeOf(input, '===', 'object', sourceInformation);
       js.Expression left = pop();
       use(input);
       js.Expression notNull = new js.Binary("!==", pop(), new js.LiteralNull());
-      push(new js.Binary("&&", left, notNull));
+      push(new js.Binary("&&", left, notNull)
+          .withSourceInformation(sourceInformation));
     } else {
       assert(cmp == "!==");
-      checkTypeOf(input, '!==', 'object');
+      checkTypeOf(input, '!==', 'object', sourceInformation);
       js.Expression left = pop();
       use(input);
       js.Expression eqNull = new js.Binary("===", pop(), new js.LiteralNull());
-      push(new js.Binary("||", left, eqNull));
+      push(new js.Binary("||", left, eqNull)
+          .withSourceInformation(sourceInformation));
     }
   }
 
   void checkArray(HInstruction input, String cmp) {
     use(input);
     js.PropertyAccess constructor =
         new js.PropertyAccess.field(pop(), 'constructor');
     push(new js.Binary(cmp, constructor, new js.VariableUse('Array')));
   }
 
@@ skipping 30 matching lines @@
     use(input);
     push(new js.Binary('==', pop(), new js.LiteralNull()));
   }
 
   void checkNonNull(HInstruction input) {
     use(input);
     push(new js.Binary('!=', pop(), new js.LiteralNull()));
   }
 
   void checkType(HInstruction input, HInstruction interceptor,
-                 DartType type, {bool negative: false}) {
+                 DartType type,
+                 SourceInformation sourceInformation,
+                 {bool negative: false}) {
     Element element = type.element;
     if (element == backend.jsArrayClass) {
       checkArray(input, negative ? '!==': '===');
       return;
     } else if (element == backend.jsMutableArrayClass) {
       if (negative) {
         checkImmutableArray(input);
       } else {
         checkMutableArray(input);
       }
@@ skipping 14 matching lines @@
       return;
     } else if (element == backend.jsUnmodifiableArrayClass) {
       if (negative) {
         checkMutableArray(input);
       } else {
         checkImmutableArray(input);
       }
       return;
     }
     if (interceptor != null) {
-      checkTypeViaProperty(interceptor, type, negative);
+      checkTypeViaProperty(interceptor, type, sourceInformation,
+                           negative: negative);
     } else {
-      checkTypeViaProperty(input, type, negative);
+      checkTypeViaProperty(input, type, sourceInformation, negative: negative);
     }
   }
 
-  void checkTypeViaProperty(HInstruction input, DartType type, bool negative) {
+  void checkTypeViaProperty(HInstruction input, DartType type,
+                            SourceInformation sourceInformation,
+                            {bool negative: false}) {
     registry.registerIsCheck(type);
 
     use(input);
 
     js.PropertyAccess field =
-        new js.PropertyAccess(pop(), backend.namer.operatorIsType(type));
+        new js.PropertyAccess(pop(), backend.namer.operatorIsType(type))
+            .withSourceInformation(sourceInformation);
     // We always negate at least once so that the result is boolified.
-    push(new js.Prefix('!', field));
+    push(new js.Prefix('!', field)
+        .withSourceInformation(sourceInformation));
     // If the result is not negated, put another '!' in front.
-    if (!negative) push(new js.Prefix('!', pop()));
+    if (!negative) {
+      push(new js.Prefix('!', pop())
+          .withSourceInformation(sourceInformation));
+    }
   }
 
   void checkTypeViaInstanceof(
-      HInstruction input, DartType type, bool negative) {
+      HInstruction input, DartType type,
+      SourceInformation sourceInformation,
+      {bool negative: false}) {
     registry.registerIsCheck(type);
 
     use(input);
 
     js.Expression jsClassReference =
         backend.emitter.constructorAccess(type.element);
-    push(js.js('# instanceof #', [pop(), jsClassReference]));
-    if (negative) push(new js.Prefix('!', pop()));
+    push(js.js('# instanceof #', [pop(), jsClassReference])
+            .withSourceInformation(sourceInformation));
+    if (negative) {
+      push(new js.Prefix('!', pop())
+          .withSourceInformation(sourceInformation));
+    }
     registry.registerInstantiatedType(type);
   }
 
   void handleNumberOrStringSupertypeCheck(HInstruction input,
                                           HInstruction interceptor,
                                           DartType type,
-                                          { bool negative: false }) {
-    assert(!identical(type.element, compiler.listClass)
-           && !Elements.isListSupertype(type.element, compiler)
-           && !Elements.isStringOnlySupertype(type.element, compiler));
+                                          SourceInformation sourceInformation,
+                                          {bool negative: false}) {
+    assert(!identical(type.element, compiler.listClass) &&
+           !Elements.isListSupertype(type.element, compiler) &&
+           !Elements.isStringOnlySupertype(type.element, compiler));
     String relation = negative ? '!==' : '===';
-    checkNum(input, relation);
+    checkNum(input, relation, sourceInformation);
     js.Expression numberTest = pop();
-    checkString(input, relation);
+    checkString(input, relation, sourceInformation);
     js.Expression stringTest = pop();
-    checkObject(input, relation);
+    checkObject(input, relation, sourceInformation);
     js.Expression objectTest = pop();
-    checkType(input, interceptor, type, negative: negative);
+    checkType(input, interceptor, type, sourceInformation, negative: negative);
     String combiner = negative ? '&&' : '||';
     String combiner2 = negative ? '||' : '&&';
     push(new js.Binary(combiner,
-                       new js.Binary(combiner, numberTest, stringTest),
-                       new js.Binary(combiner2, objectTest, pop())));
+                       new js.Binary(combiner, numberTest, stringTest)
+                          .withSourceInformation(sourceInformation),
+                       new js.Binary(combiner2, objectTest, pop())
+                          .withSourceInformation(sourceInformation))
+        .withSourceInformation(sourceInformation));
   }
 
   void handleStringSupertypeCheck(HInstruction input,
                                   HInstruction interceptor,
                                   DartType type,
-                                  { bool negative: false }) {
+                                  SourceInformation sourceInformation,
+                                  {bool negative: false}) {
     assert(!identical(type.element, compiler.listClass)
            && !Elements.isListSupertype(type.element, compiler)
            && !Elements.isNumberOrStringSupertype(type.element, compiler));
     String relation = negative ? '!==' : '===';
-    checkString(input, relation);
+    checkString(input, relation, sourceInformation);
     js.Expression stringTest = pop();
-    checkObject(input, relation);
+    checkObject(input, relation, sourceInformation);
     js.Expression objectTest = pop();
-    checkType(input, interceptor, type, negative: negative);
+    checkType(input, interceptor, type, sourceInformation, negative: negative);
     String combiner = negative ? '||' : '&&';
     push(new js.Binary(negative ? '&&' : '||',
                        stringTest,
                        new js.Binary(combiner, objectTest, pop())));
   }
 
   void handleListOrSupertypeCheck(HInstruction input,
                                   HInstruction interceptor,
                                   DartType type,
+                                  SourceInformation sourceInformation,
                                   { bool negative: false }) {
     assert(!identical(type.element, compiler.stringClass)
            && !Elements.isStringOnlySupertype(type.element, compiler)
            && !Elements.isNumberOrStringSupertype(type.element, compiler));
     String relation = negative ? '!==' : '===';
-    checkObject(input, relation);
+    checkObject(input, relation, sourceInformation);
     js.Expression objectTest = pop();
     checkArray(input, relation);
     js.Expression arrayTest = pop();
-    checkType(input, interceptor, type, negative: negative);
+    checkType(input, interceptor, type, sourceInformation, negative: negative);
     String combiner = negative ? '&&' : '||';
     push(new js.Binary(negative ? '||' : '&&',
                        objectTest,
-                       new js.Binary(combiner, arrayTest, pop())));
+                       new js.Binary(combiner, arrayTest, pop()))
+        .withSourceInformation(sourceInformation));
   }
 
   void visitIs(HIs node) {
-    emitIs(node, "===");
+    emitIs(node, "===", node.sourceInformation);
   }
 
   void visitIsViaInterceptor(HIsViaInterceptor node) {
-    emitIsViaInterceptor(node, false);
+    emitIsViaInterceptor(node, node.sourceInformation, negative: false);
   }
 
-  void emitIs(HIs node, String relation)  {
+  void emitIs(HIs node, String relation, SourceInformation sourceInformation)  {
     DartType type = node.typeExpression;
     registry.registerIsCheck(type);
     HInstruction input = node.expression;
 
     // If this is changed to single == there are several places below that must
     // be changed to match.
     assert(relation == '===' || relation == '!==');
     bool negative = relation == '!==';
 
     if (node.isVariableCheck || node.isCompoundCheck) {
       use(node.checkCall);
       if (negative) push(new js.Prefix('!', pop()));
     } else {
       assert(node.isRawCheck);
       HInstruction interceptor = node.interceptor;
       ClassElement objectClass = compiler.objectClass;
       Element element = type.element;
       if (element == compiler.nullClass) {
         if (negative) {
           checkNonNull(input);
         } else {
           checkNull(input);
         }
       } else if (identical(element, objectClass) || type.treatAsDynamic) {
         // The constant folder also does this optimization, but we make
         // it safe by assuming it may have not run.
-        push(newLiteralBool(!negative), node);
+        push(newLiteralBool(!negative, sourceInformation));
       } else if (element == compiler.stringClass) {
-        checkString(input, relation);
-        attachLocationToLast(node);
+        checkString(input, relation, sourceInformation);
       } else if (element == compiler.doubleClass) {
-        checkDouble(input, relation);
-        attachLocationToLast(node);
+        checkDouble(input, relation, sourceInformation);
       } else if (element == compiler.numClass) {
-        checkNum(input, relation);
-        attachLocationToLast(node);
+        checkNum(input, relation, sourceInformation);
       } else if (element == compiler.boolClass) {
-        checkBool(input, relation);
-        attachLocationToLast(node);
+        checkBool(input, relation, sourceInformation);
       } else if (element == compiler.intClass) {
         // The is check in the code tells us that it might not be an
         // int. So we do a typeof first to avoid possible
         // deoptimizations on the JS engine due to the Math.floor check.
-        checkNum(input, relation);
+        checkNum(input, relation, sourceInformation);
         js.Expression numTest = pop();
-        checkBigInt(input, relation);
-        push(new js.Binary(negative ? '||' : '&&', numTest, pop()), node);
+        checkBigInt(input, relation, sourceInformation);
+        push(new js.Binary(negative ? '||' : '&&', numTest, pop())
+            .withSourceInformation(sourceInformation));
       } else if (node.useInstanceOf) {
         assert(interceptor == null);
-        checkTypeViaInstanceof(input, type, negative);
-        attachLocationToLast(node);
+        checkTypeViaInstanceof(input, type,
+                               sourceInformation,
+                               negative: negative);
       } else if (Elements.isNumberOrStringSupertype(element, compiler)) {
         handleNumberOrStringSupertypeCheck(
-            input, interceptor, type, negative: negative);
-        attachLocationToLast(node);
+            input, interceptor, type,
+            sourceInformation,
+            negative: negative);
       } else if (Elements.isStringOnlySupertype(element, compiler)) {
         handleStringSupertypeCheck(
-            input, interceptor, type, negative: negative);
-        attachLocationToLast(node);
-      } else if (identical(element, compiler.listClass)
-                 || Elements.isListSupertype(element, compiler)) {
+            input, interceptor, type,
+            sourceInformation,
+            negative: negative);
+      } else if (identical(element, compiler.listClass) ||
+                 Elements.isListSupertype(element, compiler)) {
         handleListOrSupertypeCheck(
-            input, interceptor, type, negative: negative);
-        attachLocationToLast(node);
+            input, interceptor, type,
+            sourceInformation,
+            negative: negative);
       } else if (type.isFunctionType) {
-        checkType(input, interceptor, type, negative: negative);
-        attachLocationToLast(node);
+        checkType(input, interceptor, type,
+                  sourceInformation,
+                  negative: negative);
       } else if ((input.canBePrimitive(compiler)
                   && !input.canBePrimitiveArray(compiler))
                  || input.canBeNull()) {
-        checkObject(input, relation);
+        checkObject(input, relation, node.sourceInformation);
         js.Expression objectTest = pop();
-        checkType(input, interceptor, type, negative: negative);
-        push(new js.Binary(negative ? '||' : '&&', objectTest, pop()), node);
+        checkType(input, interceptor, type,
+                  sourceInformation,
+                  negative: negative);
+        push(new js.Binary(negative ? '||' : '&&', objectTest, pop())
+            .withSourceInformation(sourceInformation));
       } else {
-        checkType(input, interceptor, type, negative: negative);
-        attachLocationToLast(node);
+        checkType(input, interceptor, type,
+                  sourceInformation,
+                  negative: negative);
       }
     }
   }
 
-  void emitIsViaInterceptor(HIsViaInterceptor node, bool negative) {
-    checkTypeViaProperty(node.interceptor, node.typeExpression, negative);
-    attachLocationToLast(node);
+  void emitIsViaInterceptor(HIsViaInterceptor node,
+                            SourceInformation sourceInformation,
+                            {bool negative: false}) {
+    checkTypeViaProperty(node.interceptor, node.typeExpression,
+                         sourceInformation,
+                         negative: negative);
   }
 
   js.Expression generateReceiverOrArgumentTypeTest(
       HInstruction input, TypeMask checkedType) {
     ClassWorld classWorld = compiler.world;
     TypeMask inputType = input.instructionType;
     // Figure out if it is beneficial to turn this into a null check.
     // V8 generally prefers 'typeof' checks, but for integers and
     // indexable primitives we cannot compile this test into a single
     // typeof check so the null check is cheaper.
     bool isIntCheck = checkedType.containsOnlyInt(classWorld);
     bool turnIntoNumCheck = isIntCheck && input.isIntegerOrNull(compiler);
     bool turnIntoNullCheck = !turnIntoNumCheck
         && (checkedType.nullable() == inputType)
         && (isIntCheck
             || checkedType.satisfies(backend.jsIndexableClass, classWorld));
 
     if (turnIntoNullCheck) {
       use(input);
-      return new js.Binary("==", pop(), new js.LiteralNull());
+      return new js.Binary("==", pop(), new js.LiteralNull())
+          .withSourceInformation(input.sourceInformation);
     } else if (isIntCheck && !turnIntoNumCheck) {
       // input is !int
-      checkBigInt(input, '!==');
+      checkBigInt(input, '!==', input.sourceInformation);
       return pop();
     } else if (turnIntoNumCheck || checkedType.containsOnlyNum(classWorld)) {
       // input is !num
-      checkNum(input, '!==');
+      checkNum(input, '!==', input.sourceInformation);
       return pop();
     } else if (checkedType.containsOnlyBool(classWorld)) {
       // input is !bool
-      checkBool(input, '!==');
+      checkBool(input, '!==', input.sourceInformation);
       return pop();
     } else if (checkedType.containsOnlyString(classWorld)) {
       // input is !string
-      checkString(input, '!==');
+      checkString(input, '!==', input.sourceInformation);
       return pop();
     }
     compiler.internalError(input, 'Unexpected check.');
     return null;
   }
 
   void visitTypeConversion(HTypeConversion node) {
     if (node.isArgumentTypeCheck || node.isReceiverTypeCheck) {
       ClassWorld classWorld = compiler.world;
       // An int check if the input is not int or null, is not
@@ skipping 10 matching lines @@
         generateThrowWithHelper('iae', node.checkedInput);
       } else if (node.isReceiverTypeCheck) {
         use(node.checkedInput);
         js.Name methodName =
             backend.namer.invocationName(node.receiverTypeCheckSelector);
         js.Expression call = js.propertyCall(pop(), methodName, []);
         pushStatement(new js.Return(call));
       }
       currentContainer = oldContainer;
       body = unwrapStatement(body);
-      pushStatement(new js.If.noElse(test, body), node);
+      pushStatement(new js.If.noElse(test, body)
+          .withSourceInformation(node.sourceInformation));
       return;
     }
 
     assert(node.isCheckedModeCheck || node.isCastTypeCheck);
     DartType type = node.typeExpression;
     assert(type.kind != TypeKind.TYPEDEF);
     if (type.isFunctionType) {
       // TODO(5022): We currently generate $isFunction checks for
       // function types.
       registry.registerIsCheck(compiler.functionClass.rawType);
@@ skipping 119 matching lines @@
   js.PropertyAccess accessHelper(String name) {
     Element helper = backend.findHelper(name);
     if (helper == null) {
       // For mocked-up tests.
       return js.js('(void 0).$name');
     }
     registry.registerStaticUse(helper);
     return backend.emitter.staticFunctionAccess(helper);
   }
 }