Create and test source mapping for invocations.

pkg/compiler/lib/src/ssa/builder.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 SsaFunctionCompiler implements FunctionCompiler {
   SsaCodeGeneratorTask generator;
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
 
   SsaFunctionCompiler(JavaScriptBackend backend,
-                      SourceInformationFactory sourceInformationFactory)
+                      SourceInformationStrategy sourceInformationFactory)
       : generator = new SsaCodeGeneratorTask(backend, sourceInformationFactory),
         builder = new SsaBuilderTask(backend, sourceInformationFactory),
         optimizer = new SsaOptimizerTask(backend);
 
   /// Generates JavaScript code for `work.element`.
   /// Using the ssa builder, optimizer and codegenerator.
   js.Fun compile(CodegenWorkItem work) {
     HGraph graph = builder.build(work);
     optimizer.optimize(work, graph);
     Element element = work.element;
@@ skipping 66 matching lines @@
   final ExecutableElement executableContext;
 
   SyntheticLocal(this.name, this.executableContext);
 
   toString() => 'SyntheticLocal($name)';
 }
 
 class SsaBuilderTask extends CompilerTask {
   final CodeEmitterTask emitter;
   final JavaScriptBackend backend;
-  final SourceInformationFactory sourceInformationFactory;
+  final SourceInformationStrategy sourceInformationFactory;
 
   String get name => 'SSA builder';
 
   SsaBuilderTask(JavaScriptBackend backend, this.sourceInformationFactory)
     : emitter = backend.emitter,
       backend = backend,
       super(backend.compiler);
 
   HGraph build(CodegenWorkItem work) {
     return measure(() {
@@ skipping 362 matching lines @@
 
   bool isUsedInTryOrGenerator(Local local) {
     return closureData.variablesUsedInTryOrGenerator.contains(local);
   }
 
   /**
    * Returns an [HInstruction] for the given element. If the element is
    * boxed or stored in a closure then the method generates code to retrieve
    * the value.
    */
-  HInstruction readLocal(Local local) {
+  HInstruction readLocal(Local local,
+                         {SourceInformation sourceInformation}) {
     if (isAccessedDirectly(local)) {
       if (directLocals[local] == null) {
         if (local is TypeVariableElement) {
           builder.compiler.internalError(builder.compiler.currentElement,
               "Runtime type information not available for $local.");
         } else {
           builder.compiler.internalError(local,
               "Cannot find value $local.");
         }
       }
       return directLocals[local];
     } else if (isStoredInClosureField(local)) {
       ClosureFieldElement redirect = redirectionMapping[local];
       HInstruction receiver = readLocal(closureData.closureElement);
       TypeMask type = local is BoxLocal
           ? builder.backend.nonNullType
           : builder.getTypeOfCapturedVariable(redirect);
       HInstruction fieldGet = new HFieldGet(redirect, receiver, type);
       builder.add(fieldGet);
-      return fieldGet;
+      return fieldGet..sourceInformation = sourceInformation;
     } else if (isBoxed(local)) {
       BoxFieldElement redirect = redirectionMapping[local];
       // In the function that declares the captured variable the box is
       // accessed as direct local. Inside the nested closure the box is
       // accessed through a closure-field.
       // Calling [readLocal] makes sure we generate the correct code to get
       // the box.
       HInstruction box = readLocal(redirect.box);
       HInstruction lookup = new HFieldGet(
           redirect, box, builder.getTypeOfCapturedVariable(redirect));
       builder.add(lookup);
-      return lookup;
+      return lookup..sourceInformation = sourceInformation;
     } else {
       assert(isUsedInTryOrGenerator(local));
       HLocalValue localValue = getLocal(local);
       HInstruction instruction = new HLocalGet(
           local, localValue, builder.backend.dynamicType);
       builder.add(instruction);
-      return instruction;
+      return instruction..sourceInformation = sourceInformation;
     }
   }
 
   HInstruction readThis() {
     HInstruction res = readLocal(closureData.thisLocal);
     if (res.instructionType == null) {
       res.instructionType = builder.getTypeOfThis();
     }
     return res;
   }
 
-  HLocalValue getLocal(Local local) {
+  HLocalValue getLocal(Local local,
+                       {SourceInformation sourceInformation}) {
     // If the element is a parameter, we already have a
     // HParameterValue for it. We cannot create another one because
     // it could then have another name than the real parameter. And
     // the other one would not know it is just a copy of the real
     // parameter.
     if (local is ParameterElement) return builder.parameters[local];
 
     return builder.activationVariables.putIfAbsent(local, () {
       JavaScriptBackend backend = builder.backend;
-      HLocalValue localValue = new HLocalValue(local, backend.nonNullType);
+      HLocalValue localValue = new HLocalValue(local, backend.nonNullType)
+          ..sourceInformation = sourceInformation;
       builder.graph.entry.addAtExit(localValue);
       return localValue;
     });
   }
 
   Local getTypeVariableAsLocal(TypeVariableType type) {
     return typeVariableLocals.putIfAbsent(type, () {
       return new TypeVariableLocal(type, executableContext);
     });
   }
 
   /**
    * Sets the [element] to [value]. If the element is boxed or stored in a
    * closure then the method generates code to set the value.
    */
-  void updateLocal(Local local, HInstruction value) {
+  void updateLocal(Local local, HInstruction value,
+                   {SourceInformation sourceInformation}) {
     assert(!isStoredInClosureField(local));
     if (isAccessedDirectly(local)) {
       directLocals[local] = value;
     } else if (isBoxed(local)) {
       BoxFieldElement redirect = redirectionMapping[local];
       // The box itself could be captured, or be local. A local variable that
       // is captured will be boxed, but the box itself will be a local.
       // Inside the closure the box is stored in a closure-field and cannot
       // be accessed directly.
       HInstruction box = readLocal(redirect.box);
-      builder.add(new HFieldSet(redirect, box, value));
+      builder.add(new HFieldSet(redirect, box, value)
+          ..sourceInformation = sourceInformation);
     } else {
       assert(isUsedInTryOrGenerator(local));
       HLocalValue localValue = getLocal(local);
-      builder.add(new HLocalSet(local, localValue, value));
+      builder.add(new HLocalSet(local, localValue, value)
+          ..sourceInformation = sourceInformation);
     }
   }
 
   /**
    * This function, startLoop, must be called before visiting any children of
    * the loop. In particular it needs to be called before executing the
    * initializers.
    *
    * The [LocalsHandler] will make the boxes and updates at the right moment.
    * The builder just needs to call [enterLoopBody] and [enterLoopUpdates]
@@ skipping 520 matching lines @@
   /// Returns `true` if the current element is an `async` function.
   bool get isBuildingAsyncFunction {
     Element element = sourceElement;
     return (element is FunctionElement &&
             element.asyncMarker == AsyncMarker.ASYNC);
   }
 
   SsaBuilder(JavaScriptBackend backend,
              CodegenWorkItem work,
              this.nativeEmitter,
-             SourceInformationFactory sourceInformationFactory)
+             SourceInformationStrategy sourceInformationFactory)
     : this.compiler = backend.compiler,
       this.backend = backend,
       this.constantSystem = backend.constantSystem,
       this.work = work,
       this.rti = backend.rti,
       super(work.resolutionTree) {
     localsHandler = new LocalsHandler(this, work.element, null);
     sourceElementStack.add(work.element);
     sourceInformationBuilder =
-        sourceInformationFactory.forContext(work.element.implementation);
+        sourceInformationFactory.createBuilderForContext(
+            work.element.implementation);
   }
 
   CodegenRegistry get registry => work.registry;
 
   /// Returns the current source element.
   ///
   /// The returned element is a declaration element.
   // TODO(johnniwinther): Check that all usages of sourceElement agree on
   // implementation/declaration distinction.
   Element get sourceElement => sourceElementStack.last;
@@ skipping 468 matching lines @@
     assert(elements.getFunctionDefinition(function) != null);
     openFunction(functionElement, function);
     String name = functionElement.name;
     // If [functionElement] is `operator==` we explicitely add a null check at
     // the beginning of the method. This is to avoid having call sites do the
     // null check.
     if (name == '==') {
       if (!backend.operatorEqHandlesNullArgument(functionElement)) {
         handleIf(
             function,
-            () {
+            visitCondition: () {
               HParameterValue parameter = parameters.values.first;
               push(new HIdentity(
                   parameter, graph.addConstantNull(compiler), null,
                   backend.boolType));
             },
-            () {
+            visitThen: () {
+              // TODO(johnniwinther): Add source information.
               closeAndGotoExit(new HReturn(
-                  graph.addConstantBool(false, compiler)));
+                  graph.addConstantBool(false, compiler),
+                  null));
             },
-            null);
+            visitElse: null);
       }
     }
     function.body.accept(this);
     return closeFunction();
   }
 
   HGraph buildCheckedSetter(VariableElement field) {
     openFunction(field, field.node);
     HInstruction thisInstruction = localsHandler.readThis();
     // Use dynamic type because the type computed by the inferrer is
     // narrowed to the type annotation.
     HInstruction parameter = new HParameterValue(field, backend.dynamicType);
     // Add the parameter as the last instruction of the entry block.
     // If the method is intercepted, we want the actual receiver
     // to be the first parameter.
     graph.entry.addBefore(graph.entry.last, parameter);
     HInstruction value = potentiallyCheckOrTrustType(parameter, field.type);
     add(new HFieldSet(field, thisInstruction, value));
     return closeFunction();
   }
 
   HGraph buildLazyInitializer(VariableElement variable) {
     inLazyInitializerExpression = true;
-    ast.Node node = variable.node;
+    ast.VariableDefinitions node = variable.node;
     openFunction(variable, node);
     assert(invariant(variable, variable.initializer != null,
         message: "Non-constant variable $variable has no initializer."));
     visit(variable.initializer);
     HInstruction value = pop();
     value = potentiallyCheckOrTrustType(value, variable.type);
-    closeAndGotoExit(new HReturn(value));
+    ast.SendSet sendSet = node.definitions.nodes.head;
+    closeAndGotoExit(new HReturn(value,
+        sourceInformationBuilder.buildReturn(sendSet.assignmentOperator)));
     return closeFunction();
   }
 
   /**
    * Returns the constructor body associated with the given constructor or
    * creates a new constructor body, if none can be found.
    *
    * Returns [:null:] if the constructor does not have a body.
    */
   ConstructorBodyElement getConstructorBody(FunctionElement constructor) {
@@ skipping 481 matching lines @@
     if (!currentInlinedInstantiations.isEmpty) {
       instantiatedTypes = new List<DartType>.from(currentInlinedInstantiations);
     }
 
     HInstruction newObject;
     if (!isNativeUpgradeFactory) {
       newObject = new HForeignNew(classElement,
           ssaType,
           constructorArguments,
           instantiatedTypes);
+      if (function != null) {
+        newObject.sourceInformation =
+            sourceInformationBuilder.buildGeneric(function);
+      }
       add(newObject);
     } else {
       // Bulk assign to the initialized fields.
       newObject = graph.explicitReceiverParameter;
       // Null guard ensures an error if we are being called from an explicit
       // 'new' of the constructor instead of via an upgrade. It is optimized out
       // if there are field initializers.
       add(new HFieldGet(
           null, newObject, backend.dynamicType, isAssignable: false));
       for (int i = 0; i < fields.length; i++) {
@@ skipping 133 matching lines @@
         pop();
       } else {
         HInvokeConstructorBody invoke = new HInvokeConstructorBody(
             body.declaration, bodyCallInputs, backend.nonNullType);
         invoke.sideEffects =
             compiler.world.getSideEffectsOfElement(constructor);
         add(invoke);
       }
     }
     if (inliningStack.isEmpty) {
-      closeAndGotoExit(new HReturn(newObject));
+      closeAndGotoExit(new HReturn(newObject,
+          sourceInformationBuilder.buildImplicitReturn(functionElement)));
       return closeFunction();
     } else {
       localsHandler.updateLocal(returnLocal, newObject);
       return null;
     }
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
@@ skipping 280 matching lines @@
       inExpressionOfThrow = old;
     }
   }
 
   visitExpressionStatement(ast.ExpressionStatement node) {
     if (!isReachable) return;
     ast.Throw throwExpression = node.expression.asThrow();
     if (throwExpression != null && inliningStack.isEmpty) {
       visitThrowExpression(throwExpression.expression);
       handleInTryStatement();
-      closeAndGotoExit(new HThrow(pop()));
+      closeAndGotoExit(
+          new HThrow(pop(), sourceInformationBuilder.buildThrow(node)));
     } else {
       visit(node.expression);
       pop();
     }
   }
 
   /**
    * Creates a new loop-header block. The previous [current] block
    * is closed with an [HGoto] and replaced by the newly created block.
    * Also notifies the locals handler that we're entering a loop.
@@ skipping 474 matching lines @@
     List<HInstruction> capturedVariables = <HInstruction>[];
     closureClassElement.closureFields.forEach((ClosureFieldElement field) {
       Local capturedLocal =
           nestedClosureData.getLocalVariableForClosureField(field);
       assert(capturedLocal != null);
       capturedVariables.add(localsHandler.readLocal(capturedLocal));
     });
 
     TypeMask type =
         new TypeMask.nonNullExact(compiler.functionClass, compiler.world);
-    push(new HForeignNew(closureClassElement, type, capturedVariables));
+    push(new HForeignNew(closureClassElement, type, capturedVariables)
+        ..sourceInformation = sourceInformationBuilder.buildGeneric(node));
 
     Element methodElement = nestedClosureData.closureElement;
     if (compiler.backend.methodNeedsRti(methodElement)) {
       registry.registerClosureWithFreeTypeVariables(methodElement);
     }
   }
 
   visitFunctionDeclaration(ast.FunctionDeclaration node) {
     assert(isReachable);
     visit(node.function);
     LocalFunctionElement localFunction =
         elements.getFunctionDefinition(node.function);
     localsHandler.updateLocal(localFunction, pop());
   }
 
   visitIdentifier(ast.Identifier node) {
     if (node.isThis()) {
       stack.add(localsHandler.readThis());
     } else {
       compiler.internalError(node,
           "SsaFromAstMixin.visitIdentifier on non-this.");
     }
   }
 
   visitIf(ast.If node) {
     assert(isReachable);
-    handleIf(node,
-             () => visit(node.condition),
-             () => visit(node.thenPart),
-             node.elsePart != null ? () => visit(node.elsePart) : null);
+    handleIf(
+        node,
+        visitCondition: () => visit(node.condition),
+        visitThen: () => visit(node.thenPart),
+        visitElse: node.elsePart != null ? () => visit(node.elsePart) : null,
+        sourceInformation: sourceInformationBuilder.buildIf(node));
   }
 
   void handleIf(ast.Node diagnosticNode,
-                void visitCondition(), void visitThen(), void visitElse()) {
+                {void visitCondition(),
+                 void visitThen(),
+                 void visitElse(),
+                 SourceInformation sourceInformation}) {
     SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, diagnosticNode);
-    branchBuilder.handleIf(visitCondition, visitThen, visitElse);
+    branchBuilder.handleIf(
+        visitCondition, visitThen, visitElse,
+        sourceInformation: sourceInformation);
   }
 
   @override
   void visitIfNull(ast.Send node, ast.Node left, ast.Node right, _) {
     SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
     brancher.handleIfNull(() => visit(left), () => visit(right));
   }
 
   @override
   void visitLogicalAnd(ast.Send node, ast.Node left, ast.Node right, _) {
@@ skipping 10 matching lines @@
     branchBuilder.handleLogicalAndOrWithLeftNode(
         left,
         () { visit(right); },
         isAnd: false);
   }
 
   @override
   void visitNot(ast.Send node, ast.Node expression, _) {
     assert(node.argumentsNode is ast.Prefix);
     visit(expression);
-    HNot not = new HNot(popBoolified(), backend.boolType);
-    pushWithPosition(not, node);
+    SourceInformation sourceInformation =
+        sourceInformationBuilder.buildGeneric(node);
+    push(new HNot(popBoolified(), backend.boolType)
+        ..sourceInformation = sourceInformation);
   }
 
   @override
   void visitUnary(ast.Send node,
                   UnaryOperator operator,
                   ast.Node expression,_) {
     assert(node.argumentsNode is ast.Prefix);
     HInstruction operand = visitAndPop(expression);
 
     // See if we can constant-fold right away. This avoids rewrites later on.
     if (operand is HConstant) {
       UnaryOperation operation = constantSystem.lookupUnary(operator);
       HConstant constant = operand;
       ConstantValue folded = operation.fold(constant.constant);
       if (folded != null) {
         stack.add(graph.addConstant(folded, compiler));
         return;
       }
     }
 
-    pushInvokeDynamic(node, elements.getSelector(node), [operand]);
+    pushInvokeDynamic(node, elements.getSelector(node), [operand],
+        sourceInformation: sourceInformationBuilder.buildGeneric(node));
   }
 
   @override
   void visitBinary(ast.Send node,
                    ast.Node left,
                    BinaryOperator operator,
                    ast.Node right, _) {
     handleBinary(node, left, right);
   }
 
@@ skipping 12 matching lines @@
     handleBinary(node, left, right);
     pushWithPosition(new HNot(popBoolified(), backend.boolType), node.selector);
   }
 
   void handleBinary(ast.Send node, ast.Node left, ast.Node right) {
     visitBinarySend(
         visitAndPop(left),
         visitAndPop(right),
         elements.getSelector(node),
         node,
-        location: node.selector);
+        sourceInformation:
+            sourceInformationBuilder.buildGeneric(node.selector));
   }
 
   /// TODO(johnniwinther): Merge [visitBinarySend] with [handleBinary] and
   /// remove use of [location] for source information.
   void visitBinarySend(HInstruction left,
                        HInstruction right,
                        Selector selector,
                        ast.Send send,
-                       {ast.Node location}) {
-    pushInvokeDynamic(send, selector, [left, right], location: location);
+                       {SourceInformation sourceInformation}) {
+    pushInvokeDynamic(send, selector, [left, right],
+        sourceInformation: sourceInformation);
   }
 
   HInstruction generateInstanceSendReceiver(ast.Send send) {
     assert(Elements.isInstanceSend(send, elements));
     if (send.receiver == null) {
       return localsHandler.readThis();
     }
     visit(send.receiver);
     return pop();
   }
 
   String noSuchMethodTargetSymbolString(Element error, [String prefix]) {
     String result = error.name;
     if (prefix == "set") return "$result=";
     return result;
   }
 
   /**
    * Returns a set of interceptor classes that contain the given
    * [selector].
    */
-  void generateInstanceGetterWithCompiledReceiver(ast.Send send,
-                                                  Selector selector,
-                                                  HInstruction receiver) {
+  void generateInstanceGetterWithCompiledReceiver(
+      ast.Send send,
+      Selector selector,
+      HInstruction receiver) {
     assert(Elements.isInstanceSend(send, elements));
     assert(selector.isGetter);
-    pushInvokeDynamic(send, selector, [receiver]);
+    pushInvokeDynamic(send, selector, [receiver],
+        sourceInformation: sourceInformationBuilder.buildGet(send));
   }
 
   /// Inserts a call to checkDeferredIsLoaded for [prefixElement].
   /// If [prefixElement] is [null] ndo nothing.
   void generateIsDeferredLoadedCheckIfNeeded(PrefixElement prefixElement,
                                              ast.Node location) {
     if (prefixElement == null) return;
     String loadId =
         compiler.deferredLoadTask.importDeferName[prefixElement.deferredImport];
     HInstruction loadIdConstant = addConstantString(loadId);
     String uri = prefixElement.deferredImport.uri.dartString.slowToString();
     HInstruction uriConstant = addConstantString(uri);
     Element helper = backend.getCheckDeferredIsLoaded();
     pushInvokeStatic(location, helper, [loadIdConstant, uriConstant]);
     pop();
   }
 
   /// Inserts a call to checkDeferredIsLoaded if the send has a prefix that
   /// resolves to a deferred library.
   void generateIsDeferredLoadedCheckOfSend(ast.Send node) {
     generateIsDeferredLoadedCheckIfNeeded(
         compiler.deferredLoadTask.deferredPrefixElement(node, elements),
         node);
   }
 
   void handleInvalidStaticGet(ast.Send node, Element element) {
+    SourceInformation sourceInformation =
+        sourceInformationBuilder.buildGet(node);
     generateThrowNoSuchMethod(
         node,
         noSuchMethodTargetSymbolString(element, 'get'),
-        argumentNodes: const Link<ast.Node>());
+        argumentNodes: const Link<ast.Node>(),
+        sourceInformation: sourceInformation);
   }
 
   /// Generate read access of an unresolved static or top level entity.
   void generateStaticUnresolvedGet(ast.Send node, Element element) {
     if (element is ErroneousElement) {
+      SourceInformation sourceInformation =
+          sourceInformationBuilder.buildGet(node);
       // An erroneous element indicates an unresolved static getter.
       handleInvalidStaticGet(node, element);
     } else {
       // This happens when [element] has parse errors.
       assert(invariant(node, element == null || element.isErroneous));
       // TODO(ahe): Do something like the above, that is, emit a runtime
       // error.
       stack.add(graph.addConstantNull(compiler));
     }
   }
 
   /// Read a static or top level [field] of constant value.
   void generateStaticConstGet(
       ast.Send node,
       FieldElement field,
-      ConstantExpression constant) {
+      ConstantExpression constant,
+      SourceInformation sourceInformation) {
     ConstantValue value = backend.constants.getConstantValue(constant);
     HConstant instruction;
     // Constants that are referred via a deferred prefix should be referred
     // by reference.
     PrefixElement prefix = compiler.deferredLoadTask
         .deferredPrefixElement(node, elements);
     if (prefix != null) {
-      instruction = graph.addDeferredConstant(value, prefix, compiler);
+      instruction =
+          graph.addDeferredConstant(value, prefix, sourceInformation, compiler);
     } else {
-      instruction = graph.addConstant(value, compiler);
+      instruction = graph.addConstant(
+          value, compiler, sourceInformation: sourceInformation);
     }
     stack.add(instruction);
     // The inferrer may have found a better type than the constant
     // handler in the case of lists, because the constant handler
     // does not look at elements in the list.
     TypeMask type =
         TypeMaskFactory.inferredTypeForElement(field, compiler);
     if (!type.containsAll(compiler.world) &&
         !instruction.isConstantNull()) {
       // TODO(13429): The inferrer should know that an element
       // cannot be null.
       instruction.instructionType = type.nonNullable();
     }
   }
 
   /// Read a static or top level [field].
   void generateStaticFieldGet(ast.Send node, FieldElement field) {
     generateIsDeferredLoadedCheckOfSend(node);
 
     ConstantExpression constant =
         backend.constants.getConstantForVariable(field);
+    SourceInformation sourceInformation =
+        sourceInformationBuilder.buildGet(node);
     if (constant != null) {
       if (!field.isAssignable) {
         // A static final or const. Get its constant value and inline it if
         // the value can be compiled eagerly.
-        generateStaticConstGet(node, field, constant);
+        generateStaticConstGet(node, field, constant, sourceInformation);
       } else {
         // TODO(5346): Try to avoid the need for calling [declaration] before
         // creating an [HStatic].
         HInstruction instruction = new HStatic(
             field.declaration,
-            TypeMaskFactory.inferredTypeForElement(field, compiler));
+            TypeMaskFactory.inferredTypeForElement(field, compiler))
+                ..sourceInformation = sourceInformation;
         push(instruction);
       }
     } else {
       HInstruction instruction = new HLazyStatic(
           field,
-          TypeMaskFactory.inferredTypeForElement(field, compiler));
+          TypeMaskFactory.inferredTypeForElement(field, compiler))
+              ..sourceInformation = sourceInformation;
       push(instruction);
     }
   }
 
   /// Generate a getter invocation of the static or top level [getter].
   void generateStaticGetterGet(ast.Send node, MethodElement getter) {
+    SourceInformation sourceInformation =
+        sourceInformationBuilder.buildGet(node);
     if (getter.isDeferredLoaderGetter) {
-      generateDeferredLoaderGet(node, getter);
+      generateDeferredLoaderGet(node, getter, sourceInformation);
     } else {
       generateIsDeferredLoadedCheckOfSend(node);
-      pushInvokeStatic(node, getter, <HInstruction>[]);
+      pushInvokeStatic(node, getter, <HInstruction>[],
+                       sourceInformation: sourceInformation);
     }
   }
 
   /// Generate a dynamic getter invocation.
   void generateDynamicGet(ast.Send node) {
     HInstruction receiver = generateInstanceSendReceiver(node);
     generateInstanceGetterWithCompiledReceiver(
         node, elements.getSelector(node), receiver);
   }
 
   /// Generate a closurization of the static or top level [function].
   void generateStaticFunctionGet(ast.Send node, MethodElement function) {
     generateIsDeferredLoadedCheckOfSend(node);
     // TODO(5346): Try to avoid the need for calling [declaration] before
     // creating an [HStatic].
-    push(new HStatic(function.declaration, backend.nonNullType));
+    SourceInformation sourceInformation =
+        sourceInformationBuilder.buildGet(node);
+    push(new HStatic(function.declaration, backend.nonNullType)
+        ..sourceInformation = sourceInformation);
     // TODO(ahe): This should be registered in codegen.
     registry.registerGetOfStaticFunction(function.declaration);
   }
 
   /// Read a local variable, function or parameter.
-  void handleLocalGet(LocalElement local) {
-    stack.add(localsHandler.readLocal(local));
+  void buildLocalGet(LocalElement local, SourceInformation sourceInformation) {
+    stack.add(localsHandler.readLocal(
+              local, sourceInformation: sourceInformation));
+  }
+
+  void handleLocalGet(ast.Send node, LocalElement local) {
+    buildLocalGet(local, sourceInformationBuilder.buildGet(node));
   }
 
   @override
   void visitDynamicPropertyGet(
       ast.Send node,
       ast.Node receiver,
       Selector selector,
       _) {
     generateDynamicGet(node);
   }
@@ skipping 23 matching lines @@
   }
 
   /// Pushes a boolean checking [expression] against null.
   pushCheckNull(HInstruction expression) {
     push(new HIdentity(expression, graph.addConstantNull(compiler),
           null, backend.boolType));
   }
 
   @override
   void visitLocalVariableGet(ast.Send node, LocalVariableElement variable, _) {
-    handleLocalGet(variable);
+    handleLocalGet(node, variable);
   }
 
   @override
   void visitParameterGet(ast.Send node, ParameterElement parameter, _) {
-    handleLocalGet(parameter);
+    handleLocalGet(node, parameter);
   }
 
   @override
   void visitLocalFunctionGet(ast.Send node, LocalFunctionElement function, _) {
-    handleLocalGet(function);
+    handleLocalGet(node, function);
   }
 
   @override
   void visitStaticFieldGet(
       ast.Send node,
       FieldElement field,
       _) {
     generateStaticFieldGet(node, field);
   }
 
@@ skipping 53 matching lines @@
     assert(send == null || Elements.isInstanceSend(send, elements));
     if (selector == null) {
       assert(send != null);
       selector = elements.getSelector(send);
     }
     if (location == null) {
       assert(send != null);
       location = send;
     }
     assert(selector.isSetter);
-    pushInvokeDynamic(location, selector, [receiver, value]);
+    pushInvokeDynamic(location, selector, [receiver, value],
+        sourceInformation: sourceInformationBuilder.buildAssignment(location));
     pop();
     stack.add(value);
   }
 
   void generateNonInstanceSetter(ast.SendSet send,
                                  Element element,
                                  HInstruction value,
                                  {ast.Node location}) {
     assert(send == null || !Elements.isInstanceSend(send, elements));
     if (location == null) {
@@ skipping 29 matching lines @@
       if (value.sourceElement == null) {
         value.sourceElement = local;
       }
       HInstruction checkedOrTrusted =
           potentiallyCheckOrTrustType(value, local.type);
       if (!identical(checkedOrTrusted, value)) {
         pop();
         stack.add(checkedOrTrusted);
       }
 
-      localsHandler.updateLocal(local, checkedOrTrusted);
+      localsHandler.updateLocal(local, checkedOrTrusted,
+          sourceInformation:
+              sourceInformationBuilder.buildAssignment(location));
     }
   }
 
   HInstruction invokeInterceptor(HInstruction receiver) {
     HInterceptor interceptor = new HInterceptor(receiver, backend.nonNullType);
     add(interceptor);
     return interceptor;
   }
 
   HLiteralList buildLiteralList(List<HInstruction> inputs) {
@@ skipping 186 matching lines @@
   }
 
   /// Generate a dynamic method, getter or setter invocation.
   void generateDynamicSend(ast.Send node) {
     HInstruction receiver = generateInstanceSendReceiver(node);
     _generateDynamicSend(node, receiver);
   }
 
   void _generateDynamicSend(ast.Send node, HInstruction receiver) {
     Selector selector = elements.getSelector(node);
+    SourceInformation sourceInformation =
+        sourceInformationBuilder.buildCall(node, node.selector);
 
     List<HInstruction> inputs = <HInstruction>[];
     inputs.add(receiver);
     addDynamicSendArgumentsToList(node, inputs);
 
-    pushInvokeDynamic(node, selector, inputs);
+    pushInvokeDynamic(node, selector, inputs,
+        sourceInformation: sourceInformation);
     if (selector.isSetter || selector.isIndexSet) {
       pop();
       stack.add(inputs.last);
     }
   }
 
   @override
   visitDynamicPropertyInvoke(
       ast.Send node,
       ast.Node receiver,
@@ skipping 31 matching lines @@
     generateDynamicSend(node);
   }
 
   @override
   visitExpressionInvoke(
       ast.Send node,
       ast.Node expression,
       ast.NodeList arguments,
       Selector selector,
       _) {
-    generateCallInvoke(node, visitAndPop(expression));
+    generateCallInvoke(
+        node,
+        visitAndPop(expression),
+        sourceInformationBuilder.buildCall(node, node.argumentsNode));
   }
 
   @override
   visitThisInvoke(
       ast.Send node,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
-    generateCallInvoke(node, localsHandler.readThis());
+    generateCallInvoke(
+        node,
+        localsHandler.readThis(),
+        sourceInformationBuilder.buildCall(node, node.argumentsNode));
   }
 
   @override
   visitParameterInvoke(
       ast.Send node,
       ParameterElement parameter,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
-    generateCallInvoke(node, localsHandler.readLocal(parameter));
+    generateCallInvoke(
+        node,
+            localsHandler.readLocal(parameter),
+        sourceInformationBuilder.buildCall(node, node.argumentsNode));
   }
 
   @override
   visitLocalVariableInvoke(
       ast.Send node,
       LocalVariableElement variable,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
-    generateCallInvoke(node, localsHandler.readLocal(variable));
+    generateCallInvoke(
+        node,
+        localsHandler.readLocal(variable),
+        sourceInformationBuilder.buildCall(node, node.argumentsNode));
   }
 
   @override
   visitLocalFunctionInvoke(
       ast.Send node,
       LocalFunctionElement function,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
-    generateCallInvoke(node, localsHandler.readLocal(function));
+    generateCallInvoke(
+        node,
+        localsHandler.readLocal(function),
+        sourceInformationBuilder.buildCall(node, node.argumentsNode));
   }
 
   @override
   visitLocalFunctionIncompatibleInvoke(
       ast.Send node,
       LocalFunctionElement function,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
-    generateCallInvoke(node, localsHandler.readLocal(function));
+    generateCallInvoke(node, localsHandler.readLocal(function),
+        sourceInformationBuilder.buildCall(node, node.argumentsNode));
   }
 
   void handleForeignJs(ast.Send node) {
     Link<ast.Node> link = node.arguments;
     // Don't visit the first argument, which is the type, and the second
     // argument, which is the foreign code.
     if (link.isEmpty || link.tail.isEmpty) {
       compiler.internalError(node.argumentsNode,
           'At least two arguments expected.');
     }
     native.NativeBehavior nativeBehavior =
         compiler.enqueuer.resolution.nativeEnqueuer.getNativeBehaviorOf(node);
 
     List<HInstruction> inputs = <HInstruction>[];
     addGenericSendArgumentsToList(link.tail.tail, inputs);
 
     TypeMask ssaType =
         TypeMaskFactory.fromNativeBehavior(nativeBehavior, compiler);
 
+    SourceInformation sourceInformation =
+        sourceInformationBuilder.buildCall(node, node.argumentsNode);
     if (nativeBehavior.codeTemplate.isExpression) {
       push(new HForeignCode(
           nativeBehavior.codeTemplate, ssaType, inputs,
           effects: nativeBehavior.sideEffects,
-          nativeBehavior: nativeBehavior));
+          nativeBehavior: nativeBehavior)
+              ..sourceInformation = sourceInformation);
     } else {
       push(new HForeignCode(
           nativeBehavior.codeTemplate, ssaType, inputs,
           isStatement: true,
           effects: nativeBehavior.sideEffects,
-          nativeBehavior: nativeBehavior));
+          nativeBehavior: nativeBehavior)
+              ..sourceInformation = sourceInformation);
     }
   }
 
   void handleJsStringConcat(ast.Send node) {
     List<HInstruction> inputs = <HInstruction>[];
     addGenericSendArgumentsToList(node.arguments, inputs);
     if (inputs.length != 2) {
       compiler.internalError(node.argumentsNode, 'Two arguments expected.');
     }
     push(new HStringConcat(inputs[0], inputs[1], node, backend.stringType));
@@ skipping 329 matching lines @@
       stack.add(graph.addConstantNull(compiler));
     } else if (name == 'JS_INTERCEPTOR_CONSTANT') {
       handleJsInterceptorConstant(node);
     } else if (name == 'JS_STRING_CONCAT') {
       handleJsStringConcat(node);
     } else {
       compiler.internalError(node, "Unknown foreign: ${element}");
     }
   }
 
-  generateDeferredLoaderGet(ast.Send node, FunctionElement deferredLoader) {
+  generateDeferredLoaderGet(ast.Send node,
+                            FunctionElement deferredLoader,
+                            SourceInformation sourceInformation) {
     // Until now we only handle these as getters.
     invariant(node, deferredLoader.isDeferredLoaderGetter);
     Element loadFunction = compiler.loadLibraryFunction;
     PrefixElement prefixElement = deferredLoader.enclosingElement;
     String loadId = compiler.deferredLoadTask
         .importDeferName[prefixElement.deferredImport];
     var inputs = [graph.addConstantString(
         new ast.DartString.literal(loadId), compiler)];
     push(new HInvokeStatic(loadFunction, inputs, backend.nonNullType,
-                           targetCanThrow: false));
+                           targetCanThrow: false)
+        ..sourceInformation = sourceInformation);
   }
 
   generateSuperNoSuchMethodSend(ast.Send node,
                                 Selector selector,
                                 List<HInstruction> arguments) {
     String name = selector.name;
 
     ClassElement cls = currentNonClosureClass;
     Element element = cls.lookupSuperMember(Compiler.NO_SUCH_METHOD);
     if (compiler.enabledInvokeOn
@@ skipping 30 matching lines @@
     ConstantValue kindConstant =
         constantSystem.createInt(selector.invocationMirrorKind);
 
     pushInvokeStatic(null,
                      createInvocationMirror,
                      [graph.addConstant(nameConstant, compiler),
                       graph.addConstant(internalNameConstant, compiler),
                       graph.addConstant(kindConstant, compiler),
                       argumentsInstruction,
                       argumentNamesInstruction],
-                      typeMask: backend.dynamicType);
+                     typeMask: backend.dynamicType);
 
     var inputs = <HInstruction>[pop()];
     push(buildInvokeSuper(compiler.noSuchMethodSelector, element, inputs));
   }
 
   /// Generate a call to a super method or constructor.
-  void generateSuperInvoke(ast.Send node, FunctionElement function) {
+  void generateSuperInvoke(ast.Send node,
+                           FunctionElement function,
+                           SourceInformation sourceInformation) {
     // TODO(5347): Try to avoid the need for calling [implementation] before
     // calling [makeStaticArgumentList].
     Selector selector = elements.getSelector(node);
     assert(invariant(node,
         selector.applies(function.implementation, compiler.world),
         message: "$selector does not apply to ${function.implementation}"));
     List<HInstruction> inputs =
         makeStaticArgumentList(selector.callStructure,
                                node.arguments,
                                function.implementation);
-    push(buildInvokeSuper(selector, function, inputs));
+    push(buildInvokeSuper(selector, function, inputs, sourceInformation));
   }
 
   /// Access the value from the super [element].
   void handleSuperGet(ast.Send node, Element element) {
     Selector selector = elements.getSelector(node);
-    push(buildInvokeSuper(selector, element, const <HInstruction>[]));
+    SourceInformation sourceInformation =
+        sourceInformationBuilder.buildGet(node);
+    push(buildInvokeSuper(
+        selector, element, const <HInstruction>[], sourceInformation));
   }
 
   /// Invoke .call on the value retrieved from the super [element].
   void handleSuperCallInvoke(ast.Send node, Element element) {
     Selector selector = elements.getSelector(node);
-    HInstruction target =
-        buildInvokeSuper(selector, element, const <HInstruction>[]);
+    HInstruction target = buildInvokeSuper(
+        selector, element, const <HInstruction>[],
+        sourceInformationBuilder.buildGet(node));
     add(target);
-    generateCallInvoke(node, target);
+    generateCallInvoke(
+        node,
+        target,
+        sourceInformationBuilder.buildCall(node, node.argumentsNode));
   }
 
   /// Invoke super [method].
   void handleSuperMethodInvoke(
       ast.Send node,
       MethodElement method) {
-    generateSuperInvoke(node, method);
+    generateSuperInvoke(node, method,
+        sourceInformationBuilder.buildCall(node, node.selector));
   }
 
   /// Access an unresolved super property.
   void handleUnresolvedSuperInvoke(ast.Send node) {
     Selector selector = elements.getSelector(node);
     List<HInstruction> arguments = <HInstruction>[];
     if (!node.isPropertyAccess) {
       addGenericSendArgumentsToList(node.arguments, arguments);
     }
     generateSuperNoSuchMethodSend(node, selector, arguments);
   }
 
   /// Handle super constructor invocation.
   @override
   void handleSuperConstructorInvoke(ast.Send node) {
     Selector selector = elements.getSelector(node);
     Element element = elements[node];
     if (selector.applies(element, compiler.world)) {
-      generateSuperInvoke(node, element);
+      generateSuperInvoke(node, element,
+          sourceInformationBuilder.buildCall(node, node.argumentsNode));
     } else {
       generateWrongArgumentCountError(node, element, node.arguments);
     }
   }
 
   @override
   void visitUnresolvedSuperIndex(
       ast.Send node,
       Element element,
       ast.Node index,
@@ skipping 169 matching lines @@
       return !rti.isTrivialSubstitution(subclass, cls);
     });
   }
 
   /**
    * Generate code to extract the type arguments from the object, substitute
    * them as an instance of the type we are testing against (if necessary), and
    * extract the type argument by the index of the variable in the list of type
    * variables for that class.
    */
-  HInstruction readTypeVariable(ClassElement cls,
-                                TypeVariableElement variable) {
+  HInstruction readTypeVariable(
+      ClassElement cls,
+      TypeVariableElement variable,
+      {SourceInformation sourceInformation}) {
     assert(sourceElement.isInstanceMember);
 
     HInstruction target = localsHandler.readThis();
     HConstant index = graph.addConstantInt(
         RuntimeTypes.getTypeVariableIndex(variable),
         compiler);
 
     if (needsSubstitutionForTypeVariableAccess(cls)) {
       // TODO(ahe): Creating a string here is unfortunate. It is slow (due to
       // string concatenation in the implementation), and may prevent
       // segmentation of '$'.
       String substitutionNameString = backend.namer.runtimeTypeName(cls);
       HInstruction substitutionName = graph.addConstantString(
           new ast.LiteralDartString(substitutionNameString), compiler);
       pushInvokeStatic(null,
                        backend.getGetRuntimeTypeArgument(),
                        [target, substitutionName, index],
-                       typeMask: backend.dynamicType);
+                       typeMask: backend.dynamicType,
+                       sourceInformation: sourceInformation);
     } else {
-      pushInvokeStatic(null, backend.getGetTypeArgumentByIndex(),
+      pushInvokeStatic(
+          null,
+          backend.getGetTypeArgumentByIndex(),
           [target, index],
-          typeMask: backend.dynamicType);
+          typeMask: backend.dynamicType,
+          sourceInformation: sourceInformation);
     }
     return pop();
   }
 
   // TODO(karlklose): this is needed to avoid a bug where the resolved type is
   // not stored on a type annotation in the closure translator. Remove when
   // fixed.
   bool hasDirectLocal(Local local) {
     return !localsHandler.isAccessedDirectly(local) ||
             localsHandler.directLocals[local] != null;
   }
 
   /**
    * Helper to create an instruction that gets the value of a type variable.
    */
-  HInstruction addTypeVariableReference(TypeVariableType type) {
+  HInstruction addTypeVariableReference(
+      TypeVariableType type,
+      {SourceInformation sourceInformation}) {
+
     assert(assertTypeInContext(type));
     Element member = sourceElement;
     bool isClosure = member.enclosingElement.isClosure;
     if (isClosure) {
       ClosureClassElement closureClass = member.enclosingElement;
       member = closureClass.methodElement;
       member = member.outermostEnclosingMemberOrTopLevel;
     }
     bool isInConstructorContext = member.isConstructor ||
         member.isGenerativeConstructorBody;
     Local typeVariableLocal = localsHandler.getTypeVariableAsLocal(type);
     if (isClosure) {
       if (member.isFactoryConstructor ||
           (isInConstructorContext && hasDirectLocal(typeVariableLocal))) {
         // The type variable is used from a closure in a factory constructor.
         // The value of the type argument is stored as a local on the closure
         // itself.
-        return localsHandler.readLocal(typeVariableLocal);
+        return localsHandler.readLocal(
+            typeVariableLocal, sourceInformation: sourceInformation);
       } else if (member.isFunction ||
                  member.isGetter ||
                  member.isSetter ||
                  isInConstructorContext) {
         // The type variable is stored on the "enclosing object" and needs to be
         // accessed using the this-reference in the closure.
-        return readTypeVariable(member.enclosingClass, type.element);
+        return readTypeVariable(
+            member.enclosingClass,
+            type.element,
+            sourceInformation: sourceInformation);
       } else {
         assert(member.isField);
         // The type variable is stored in a parameter of the method.
         return localsHandler.readLocal(typeVariableLocal);
       }
     } else if (isInConstructorContext ||
                // When [member] is a field, we can be either
                // generating a checked setter or inlining its
                // initializer in a constructor. An initializer is
                // never built standalone, so [isBuildingFor] will
                // always return true when seeing one.
                (member.isField && !isBuildingFor(member))) {
       // The type variable is stored in a parameter of the method.
-      return localsHandler.readLocal(typeVariableLocal);
+      return localsHandler.readLocal(
+          typeVariableLocal, sourceInformation: sourceInformation);
     } else if (member.isInstanceMember) {
       // The type variable is stored on the object.
-      return readTypeVariable(member.enclosingClass,
-                              type.element);
+      return readTypeVariable(
+          member.enclosingClass,
+          type.element,
+          sourceInformation: sourceInformation);
     } else {
       compiler.internalError(type.element,
           'Unexpected type variable in static context.');
       return null;
     }
   }
 
-  HInstruction analyzeTypeArgument(DartType argument) {
+  HInstruction analyzeTypeArgument(
+      DartType argument,
+      {SourceInformation sourceInformation}) {
+
     assert(assertTypeInContext(argument));
     if (argument.treatAsDynamic) {
       // Represent [dynamic] as [null].
       return graph.addConstantNull(compiler);
     }
 
     if (argument.isTypeVariable) {
-      return addTypeVariableReference(argument);
+      return addTypeVariableReference(
+          argument, sourceInformation: sourceInformation);
     }
 
     List<HInstruction> inputs = <HInstruction>[];
 
     js.Expression template =
         rti.getTypeRepresentationWithPlaceholders(argument, (variable) {
             inputs.add(addTypeVariableReference(variable));
         });
 
     js.Template code = new js.Template(null, template);
@@ skipping 14 matching lines @@
     type.typeArguments.forEach((DartType argument) {
       inputs.add(analyzeTypeArgument(argument));
     });
     // TODO(15489): Register at codegen.
     registry.registerInstantiatedType(type);
     return callSetRuntimeTypeInfo(type.element, inputs, newObject);
   }
 
   void copyRuntimeTypeInfo(HInstruction source, HInstruction target) {
     Element copyHelper = backend.getCopyTypeArguments();
-    pushInvokeStatic(null, copyHelper, [source, target]);
+    pushInvokeStatic(null, copyHelper, [source, target],
+        sourceInformation: target.sourceInformation);
     pop();
   }
 
   HInstruction callSetRuntimeTypeInfo(ClassElement element,
                                       List<HInstruction> rtiInputs,
                                       HInstruction newObject) {
     if (!backend.classNeedsRti(element) || element.typeVariables.isEmpty) {
       return newObject;
     }
 
     HInstruction typeInfo = buildLiteralList(rtiInputs);
     add(typeInfo);
 
     // Set the runtime type information on the object.
     Element typeInfoSetterElement = backend.getSetRuntimeTypeInfo();
     pushInvokeStatic(
         null,
         typeInfoSetterElement,
         <HInstruction>[newObject, typeInfo],
-        typeMask: backend.dynamicType);
+        typeMask: backend.dynamicType,
+        sourceInformation: newObject.sourceInformation);
 
     // The new object will now be referenced through the
     // `setRuntimeTypeInfo` call. We therefore set the type of that
     // instruction to be of the object's type.
     assert(stack.last is HInvokeStatic || stack.last == newObject);
     stack.last.instructionType = newObject.instructionType;
     return pop();
   }
 
   handleNewSend(ast.NewExpression node) {
@@ skipping 134 matching lines @@
         js.Template code = js.js.parseForeignJS(r'#.fixed$length = Array');
         // We set the instruction as [canThrow] to avoid it being dead code.
         // We need a finer grained side effect.
         add(new HForeignCode(code, backend.nullType, [stack.last],
                 throwBehavior: native.NativeThrowBehavior.MAY));
       }
     } else if (isGrowableListConstructorCall) {
       push(buildLiteralList(<HInstruction>[]));
       stack.last.instructionType = elementType;
     } else {
+      SourceInformation sourceInformation =
+          sourceInformationBuilder.buildNew(send);
       ClassElement cls = constructor.enclosingClass;
       if (cls.isAbstract && constructor.isGenerativeConstructor) {
         generateAbstractClassInstantiationError(send, cls.name);
         return;
       }
       potentiallyAddTypeArguments(inputs, cls, expectedType);
 
       addInlinedInstantiation(expectedType);
       pushInvokeStatic(node, constructor, inputs,
-          typeMask: elementType, instanceType: expectedType);
+          typeMask: elementType,
+          instanceType: expectedType,
+          sourceInformation: sourceInformation);
       removeInlinedInstantiation(expectedType);
     }
     HInstruction newInstance = stack.last;
     if (isFixedList) {
       // Overwrite the element type, in case the allocation site has
       // been inlined.
       newInstance.instructionType = elementType;
       JavaScriptItemCompilationContext context = work.compilationContext;
       context.allocatedFixedLists.add(newInstance);
     }
@@ skipping 13 matching lines @@
     if (isRedirected) {
       HInstruction checked = potentiallyCheckOrTrustType(newInstance, type);
       if (checked != newInstance) {
         pop();
         stack.add(checked);
       }
     }
   }
 
   void potentiallyAddTypeArguments(List<HInstruction> inputs, ClassElement cls,
-                                   InterfaceType expectedType) {
+                                   InterfaceType expectedType,
+                                   {SourceInformation sourceInformation}) {
     if (!backend.classNeedsRti(cls)) return;
     assert(expectedType.typeArguments.isEmpty ||
         cls.typeVariables.length == expectedType.typeArguments.length);
     expectedType.typeArguments.forEach((DartType argument) {
-      inputs.add(analyzeTypeArgument(argument));
+      inputs.add(analyzeTypeArgument(
+          argument, sourceInformation: sourceInformation));
     });
   }
 
   /// In checked mode checks the [type] of [node] to be well-bounded. The method
   /// returns [:true:] if an error can be statically determined.
   bool checkTypeVariableBounds(ast.NewExpression node, InterfaceType type) {
     if (!compiler.enableTypeAssertions) return false;
 
     Map<DartType, Set<DartType>> seenChecksMap =
         new Map<DartType, Set<DartType>>();
@@ skipping 72 matching lines @@
     List<HInstruction> inputs = makeStaticArgumentList(
         callStructure,
         node.arguments,
         function.implementation);
 
     if (function == compiler.identicalFunction) {
       pushWithPosition(
           new HIdentity(inputs[0], inputs[1], null, backend.boolType), node);
       return;
     } else {
-      pushInvokeStatic(node, function, inputs);
+      pushInvokeStatic(node, function, inputs,
+          sourceInformation: sourceInformationBuilder.buildCall(
+              node, node.selector));
     }
   }
 
   /// Generate an invocation to a static or top level function with the wrong
   /// number of arguments.
   void generateStaticFunctionIncompatibleInvoke(ast.Send node,
                                                 Element element) {
     generateWrongArgumentCountError(node, element, node.arguments);
   }
 
   @override
   void visitStaticFieldInvoke(
       ast.Send node,
       FieldElement field,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     generateStaticFieldGet(node, field);
-    generateCallInvoke(node, pop());
+    generateCallInvoke(
+        node,
+        pop(),
+        sourceInformationBuilder.buildCall(node, node.argumentsNode));
   }
 
   @override
   void visitStaticFunctionInvoke(
       ast.Send node,
       MethodElement function,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     generateStaticFunctionInvoke(node, function, callStructure);
@@ skipping 10 matching lines @@
   }
 
   @override
   void visitStaticGetterInvoke(
       ast.Send node,
       FunctionElement getter,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     generateStaticGetterGet(node, getter);
-    generateCallInvoke(node, pop());
+    generateCallInvoke(
+        node,
+        pop(),
+        sourceInformationBuilder.buildCall(node, node.argumentsNode));
   }
 
   @override
   void visitTopLevelFieldInvoke(
       ast.Send node,
       FieldElement field,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     generateStaticFieldGet(node, field);
-    generateCallInvoke(node, pop());
+    generateCallInvoke(
+        node,
+        pop(),
+        sourceInformationBuilder.buildCall(node, node.argumentsNode));
   }
 
   @override
   void visitTopLevelFunctionInvoke(
       ast.Send node,
       MethodElement function,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     if (backend.isForeign(function)) {
@@ skipping 14 matching lines @@
   }
 
   @override
   void visitTopLevelGetterInvoke(
       ast.Send node,
       FunctionElement getter,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     generateStaticGetterGet(node, getter);
-    generateCallInvoke(node, pop());
+    generateCallInvoke(
+        node,
+        pop(),
+        sourceInformationBuilder.buildCall(node, node.argumentsNode));
   }
 
   @override
   void visitTopLevelSetterGet(
       ast.Send node,
       MethodElement setter,
       _) {
     handleInvalidStaticGet(node, setter);
   }
 
@@ skipping 141 matching lines @@
       stack.add(addConstant(node.selector));
     } else {
       stack.add(addConstant(node));
     }
   }
 
   /// Generate the literal for [typeVariable] in the current context.
   void generateTypeVariableLiteral(ast.Send node,
                                    TypeVariableType typeVariable) {
     DartType type = localsHandler.substInContext(typeVariable);
-    HInstruction value = analyzeTypeArgument(type);
+    HInstruction value = analyzeTypeArgument(type,
+        sourceInformation: sourceInformationBuilder.buildGet(node));
     pushInvokeStatic(node,
                      backend.getRuntimeTypeToString(),
                      [value],
                      typeMask: backend.stringType);
     pushInvokeStatic(node,
                      backend.getCreateRuntimeType(),
                      [pop()]);
   }
 
   /// Generate a call to a type literal.
   void generateTypeLiteralCall(ast.Send node) {
     // This send is of the form 'e(...)', where e is resolved to a type
     // reference. We create a regular closure call on the result of the type
     // reference instead of creating a NoSuchMethodError to avoid pulling it
     // in if it is not used (e.g., in a try/catch).
     HInstruction target = pop();
-    generateCallInvoke(node, target);
+    generateCallInvoke(node, target,
+        sourceInformationBuilder.buildCall(node, node.argumentsNode));
   }
 
   /// Generate a '.call' invocation on [target].
-  void generateCallInvoke(ast.Send node, HInstruction target) {
+  void generateCallInvoke(ast.Send node,
+                          HInstruction target,
+                          SourceInformation sourceInformation) {
     Selector selector = elements.getSelector(node);
     List<HInstruction> inputs = <HInstruction>[target];
     addDynamicSendArgumentsToList(node, inputs);
     Selector closureSelector = new Selector.callClosureFrom(selector);
-    pushWithPosition(
-        new HInvokeClosure(closureSelector, inputs, backend.dynamicType), node);
+    push(new HInvokeClosure(closureSelector, inputs, backend.dynamicType)
+        ..sourceInformation = sourceInformation);
   }
 
   visitGetterSend(ast.Send node) {
     internalError(node, "Unexpected visitGetterSend");
   }
 
   // TODO(antonm): migrate rest of SsaFromAstMixin to internalError.
   internalError(Spannable node, String reason) {
     compiler.internalError(node, reason);
   }
@@ skipping 14 matching lines @@
   void generateAbstractClassInstantiationError(ast.Node node, String message) {
     generateError(node,
                   message,
                   backend.getThrowAbstractClassInstantiationError());
   }
 
   void generateThrowNoSuchMethod(ast.Node diagnosticNode,
                                  String methodName,
                                  {Link<ast.Node> argumentNodes,
                                   List<HInstruction> argumentValues,
-                                  List<String> existingArguments}) {
+                                  List<String> existingArguments,
+                                  SourceInformation sourceInformation}) {
     Element helper = backend.getThrowNoSuchMethod();
     ConstantValue receiverConstant =
         constantSystem.createString(new ast.DartString.empty());
     HInstruction receiver = graph.addConstant(receiverConstant, compiler);
     ast.DartString dartString = new ast.DartString.literal(methodName);
     ConstantValue nameConstant = constantSystem.createString(dartString);
     HInstruction name = graph.addConstant(nameConstant, compiler);
     if (argumentValues == null) {
       argumentValues = <HInstruction>[];
       argumentNodes.forEach((argumentNode) {
@@ skipping 12 matching lines @@
             graph.addConstantString(new ast.DartString.literal(name), compiler);
         existingNames.add(nameConstant);
       }
       existingNamesList = buildLiteralList(existingNames);
       add(existingNamesList);
     } else {
       existingNamesList = graph.addConstantNull(compiler);
     }
     pushInvokeStatic(diagnosticNode,
                      helper,
-                     [receiver, name, arguments, existingNamesList]);
+                     [receiver, name, arguments, existingNamesList],
+                     sourceInformation: sourceInformation);
   }
 
   /**
    * Generate code to throw a [NoSuchMethodError] exception for calling a
    * method with a wrong number of arguments or mismatching named optional
    * arguments.
    */
   void generateWrongArgumentCountError(ast.Node diagnosticNode,
                                        FunctionElement function,
                                        Link<ast.Node> argumentNodes) {
@@ skipping 41 matching lines @@
         registry.registerConstSymbol(nameString);
       }
     } else {
       handleNewSend(node);
     }
   }
 
   void pushInvokeDynamic(ast.Node node,
                          Selector selector,
                          List<HInstruction> arguments,
-                         {ast.Node location}) {
-    if (location == null) location = node;
+                         {SourceInformation sourceInformation}) {
 
     // We prefer to not inline certain operations on indexables,
     // because the constant folder will handle them better and turn
     // them into simpler instructions that allow further
     // optimizations.
     bool isOptimizableOperationOnIndexable(Selector selector, Element element) {
       bool isLength = selector.isGetter
           && selector.name == "length";
       if (isLength || selector.isIndex) {
         TypeMask type = new TypeMask.nonNullExact(
@@ skipping 37 matching lines @@
 
     HInstruction receiver = arguments[0];
     List<HInstruction> inputs = <HInstruction>[];
     bool isIntercepted = backend.isInterceptedSelector(selector);
     if (isIntercepted) {
       inputs.add(invokeInterceptor(receiver));
     }
     inputs.addAll(arguments);
     TypeMask type = TypeMaskFactory.inferredTypeForSelector(selector, compiler);
     if (selector.isGetter) {
-      pushWithPosition(
-          new HInvokeDynamicGetter(selector, null, inputs, type),
-          location);
+      push(
+          new HInvokeDynamicGetter(selector, null, inputs, type)
+              ..sourceInformation = sourceInformation);
     } else if (selector.isSetter) {
-      pushWithPosition(
-          new HInvokeDynamicSetter(selector, null, inputs, type),
-          location);
+      push(
+          new HInvokeDynamicSetter(selector, null, inputs, type)
+          ..sourceInformation = sourceInformation);
     } else {
-      pushWithPosition(
-          new HInvokeDynamicMethod(selector, inputs, type, isIntercepted),
-          location);
+      push(
+          new HInvokeDynamicMethod(selector, inputs, type, isIntercepted)
+              ..sourceInformation = sourceInformation);
     }
   }
 
   void pushInvokeStatic(ast.Node location,
                         Element element,
                         List<HInstruction> arguments,
                         {TypeMask typeMask,
-                         InterfaceType instanceType}) {
+                         InterfaceType instanceType,
+                         SourceInformation sourceInformation}) {
+    // TODO(johnniwinther): Use [sourceInformation] instead of [location].
     if (tryInlineMethod(element, null, arguments, location,
                         instanceType: instanceType)) {
       return;
     }
 
     if (typeMask == null) {
       typeMask =
           TypeMaskFactory.inferredReturnTypeForElement(element, compiler);
     }
     bool targetCanThrow = !compiler.world.getCannotThrow(element);
     // TODO(5346): Try to avoid the need for calling [declaration] before
     // creating an [HInvokeStatic].
     HInvokeStatic instruction = new HInvokeStatic(
         element.declaration, arguments, typeMask,
-        targetCanThrow: targetCanThrow);
+        targetCanThrow: targetCanThrow)
+            ..sourceInformation = sourceInformation;
     if (!currentInlinedInstantiations.isEmpty) {
       instruction.instantiatedTypes = new List<DartType>.from(
           currentInlinedInstantiations);
     }
     instruction.sideEffects = compiler.world.getSideEffectsOfElement(element);
     if (location == null) {
       push(instruction);
     } else {
       pushWithPosition(instruction, location);
     }
   }
 
   HInstruction buildInvokeSuper(Selector selector,
                                 Element element,
-                                List<HInstruction> arguments) {
+                                List<HInstruction> arguments,
+                                [SourceInformation sourceInformation]) {
     HInstruction receiver = localsHandler.readThis();
     // TODO(5346): Try to avoid the need for calling [declaration] before
     // creating an [HStatic].
     List<HInstruction> inputs = <HInstruction>[];
     if (backend.isInterceptedSelector(selector) &&
         // Fields don't need an interceptor; consider generating HFieldGet/Set
         // instead.
         element.kind != ElementKind.FIELD) {
       inputs.add(invokeInterceptor(receiver));
     }
     inputs.add(receiver);
     inputs.addAll(arguments);
     TypeMask type;
     if (!element.isGetter && selector.isGetter) {
       type = TypeMaskFactory.inferredTypeForElement(element, compiler);
     } else {
       type = TypeMaskFactory.inferredReturnTypeForElement(element, compiler);
     }
     HInstruction instruction = new HInvokeSuper(
         element,
         currentNonClosureClass,
         selector,
         inputs,
         type,
+        sourceInformation,
         isSetter: selector.isSetter || selector.isIndexSet);
     instruction.sideEffects = compiler.world.getSideEffectsOfSelector(selector);
     return instruction;
   }
 
   void handleComplexOperatorSend(ast.SendSet node,
                                  HInstruction receiver,
                                  Link<ast.Node> arguments) {
     HInstruction rhs;
     if (node.isPrefix || node.isPostfix) {
       rhs = graph.addConstantInt(1, compiler);
     } else {
       visit(arguments.head);
       assert(arguments.tail.isEmpty);
       rhs = pop();
     }
-    visitBinarySend(receiver, rhs,
-                    elements.getOperatorSelectorInComplexSendSet(node),
-                    node,
-                    location: node.assignmentOperator);
+    visitBinarySend(
+        receiver,
+        rhs,
+        elements.getOperatorSelectorInComplexSendSet(node),
+        node,
+        sourceInformation:
+            sourceInformationBuilder.buildGeneric(node.assignmentOperator));
   }
 
   void handleSuperSendSet(ast.SendSet node) {
     Element element = elements[node];
     List<HInstruction> setterInputs = <HInstruction>[];
     void generateSuperSendSet() {
       Selector setterSelector = elements.getSelector(node);
       if (Elements.isUnresolved(element)
           || !setterSelector.applies(element, compiler.world)) {
         generateSuperNoSuchMethodSend(
@@ skipping 432 matching lines @@
 
     if (getter.isErroneous) {
       generateStaticUnresolvedGet(node, getter);
     } else if (getter.isField) {
       generateStaticFieldGet(node, getter);
     } else if (getter.isGetter) {
       generateStaticGetterGet(node, getter);
     } else if (getter.isFunction) {
       generateStaticFunctionGet(node, getter);
     } else if (getter.isLocal) {
-      handleLocalGet(getter);
+      handleLocalGet(node, getter);
     } else {
       internalError(node, "Unexpected getter: $getter");
     }
     HInstruction getterInstruction = pop();
     if (node.isIfNullAssignment) {
       SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
       brancher.handleIfNull(() => stack.add(getterInstruction),
           () {
             visit(node.arguments.head);
             generateNonInstanceSetter(node, element, pop());
@@ skipping 110 matching lines @@
   }
 
   visitRethrow(ast.Rethrow node) {
     HInstruction exception = rethrowableException;
     if (exception == null) {
       exception = graph.addConstantNull(compiler);
       compiler.internalError(node,
           'rethrowableException should not be null.');
     }
     handleInTryStatement();
-    closeAndGotoExit(new HThrow(exception, isRethrow: true));
+    closeAndGotoExit(
+        new HThrow(exception,
+                   sourceInformationBuilder.buildThrow(node),
+                   isRethrow: true));
   }
 
   visitRedirectingFactoryBody(ast.RedirectingFactoryBody node) {
     ConstructorElement targetConstructor =
         elements.getRedirectingTargetConstructor(node).implementation;
     ConstructorElement redirectingConstructor = sourceElement.implementation;
     List<HInstruction> inputs = <HInstruction>[];
     FunctionSignature targetSignature = targetConstructor.functionSignature;
     FunctionSignature redirectingSignature =
         redirectingConstructor.functionSignature;
@@ skipping 76 matching lines @@
     }
 
     handleInTryStatement();
     emitReturn(value, node);
   }
 
   visitThrow(ast.Throw node) {
     visitThrowExpression(node.expression);
     if (isReachable) {
       handleInTryStatement();
-      push(new HThrowExpression(pop()));
+      push(new HThrowExpression(
+          pop(), sourceInformationBuilder.buildThrow(node)));
       isReachable = false;
     }
   }
 
   visitYield(ast.Yield node) {
     visit(node.expression);
     HInstruction yielded = pop();
     add(new HYield(yielded, node.hasStar));
   }
 
@@ skipping 743 matching lines @@
       // If the switch statement has no default case, surround the loop with
       // a test of the target.
       void buildCondition() {
         js.Template code = js.js.parseForeignJS('#');
         push(new HForeignCode(
             code,
             backend.boolType,
             [localsHandler.readLocal(switchTarget)],
             nativeBehavior: native.NativeBehavior.PURE));
       }
-      handleIf(node, buildCondition, buildLoop, () => {});
+      handleIf(node,
+          visitCondition: buildCondition,
+          visitThen: buildLoop,
+          visitElse: () => {});
     }
   }
 
   /**
    * Creates a switch statement.
    *
    * [jumpHandler] is the [JumpHandler] for the created switch statement.
    * [buildExpression] creates the switch expression.
    * [switchCases] must be either an [Iterable] of [ast.SwitchCase] nodes or
    *   a [Link] or a [ast.NodeList] of [ast.SwitchCase] nodes.
@@ skipping 42 matching lines @@
         expressionEnd.addSuccessor(block);
         hasDefault = true;
       }
       open(block);
       localsHandler = new LocalsHandler.from(savedLocals);
       buildSwitchCase(switchCase);
       if (!isAborted()) {
         if (caseIterator.hasNext) {
           pushInvokeStatic(switchCase, getFallThroughErrorElement, []);
           HInstruction error = pop();
-          closeAndGotoExit(new HThrow(error));
+          closeAndGotoExit(new HThrow(error, error.sourceInformation));
         } else if (!isDefaultCase(switchCase)) {
           // If there is no default, we will add one later to avoid
           // the critical edge. So we generate a break statement to make
           // sure the last case does not fall through to the default case.
           jumpHandler.generateBreak();
         }
       }
       statements.add(
           new HSubGraphBlockInformation(new SubGraph(block, lastOpenedBlock)));
     }
@@ skipping 255 matching lines @@
           pushInvokeStatic(trace, backend.getTraceFromException(), [exception]);
           HInstruction traceInstruction = pop();
           LocalVariableElement traceVariable = elements[trace];
           localsHandler.updateLocal(traceVariable, traceInstruction);
         }
         visit(catchBlock);
       }
 
       void visitElse() {
         if (link.isEmpty) {
-          closeAndGotoExit(new HThrow(exception, isRethrow: true));
+          closeAndGotoExit(
+              new HThrow(exception,
+                         exception.sourceInformation,
+                         isRethrow: true));
         } else {
           ast.CatchBlock newBlock = link.head;
           handleIf(node,
-                   () { pushCondition(newBlock); },
-                   visitThen, visitElse);
+                   visitCondition: () { pushCondition(newBlock); },
+                   visitThen: visitThen,
+                   visitElse: visitElse);
         }
       }
 
       ast.CatchBlock firstBlock = link.head;
-      handleIf(node, () { pushCondition(firstBlock); }, visitThen, visitElse);
+      handleIf(node,
+          visitCondition: () { pushCondition(firstBlock); },
+          visitThen: visitThen,
+          visitElse: visitElse);
       if (!isAborted()) endCatchBlock = close(new HGoto());
 
       rethrowableException = oldRethrowableException;
       tryInstruction.catchBlock = startCatchBlock;
       catchGraph = new SubGraph(startCatchBlock, lastOpenedBlock);
     }
 
     SubGraph finallyGraph = null;
     if (node.finallyBlock != null) {
       localsHandler = new LocalsHandler.from(savedLocals);
@@ skipping 110 matching lines @@
     restoreState(state);
     stack.add(result);
   }
 
   void doInline(FunctionElement function) {
     visitInlinedFunction(function);
   }
 
   void emitReturn(HInstruction value, ast.Node node) {
     if (inliningStack.isEmpty) {
-      closeAndGotoExit(attachPosition(new HReturn(value), node));
+      closeAndGotoExit(new HReturn(value,
+          sourceInformationBuilder.buildReturn(node)));
     } else {
       localsHandler.updateLocal(returnLocal, value);
     }
   }
 }
 
 /**
  * Visitor that handles generation of string literals (LiteralString,
  * StringInterpolation), and otherwise delegates to the given visitor for
  * non-literal subexpressions.
@@ skipping 264 matching lines @@
 
   void checkNotAborted() {
     if (builder.isAborted()) {
       compiler.unimplemented(diagnosticNode, "aborted control flow");
     }
   }
 
   void buildCondition(void visitCondition(),
                       SsaBranch conditionBranch,
                       SsaBranch thenBranch,
-                      SsaBranch elseBranch) {
+                      SsaBranch elseBranch,
+                      SourceInformation sourceInformation) {
     startBranch(conditionBranch);
     visitCondition();
     checkNotAborted();
     assert(identical(builder.current, builder.lastOpenedBlock));
     HInstruction conditionValue = builder.popBoolified();
-    HIf branch = new HIf(conditionValue);
+    HIf branch = new HIf(conditionValue)..sourceInformation = sourceInformation;
     HBasicBlock conditionExitBlock = builder.current;
     builder.close(branch);
     conditionBranch.exitLocals = builder.localsHandler;
     conditionExitBlock.addSuccessor(thenBranch.block);
     conditionExitBlock.addSuccessor(elseBranch.block);
     bool conditionBranchLocalsCanBeReused =
         mergeLocals(conditionBranch, thenBranch, mayReuseFromLocals: true);
     mergeLocals(conditionBranch, elseBranch,
                 mayReuseFromLocals: conditionBranchLocalsCanBeReused);
 
@@ skipping 40 matching lines @@
       builder.goto(builder.current, joinBranch.block);
       mergeLocals(branch, joinBranch, mayReuseFromLocals: true);
     }
     if (isExpression) {
       checkNotAborted();
       return builder.pop();
     }
     return null;
   }
 
-  handleIf(void visitCondition(), void visitThen(), void visitElse()) {
+  handleIf(void visitCondition(),
+           void visitThen(),
+           void visitElse(),
+           {SourceInformation sourceInformation}) {
     if (visitElse == null) {
       // Make sure to have an else part to avoid a critical edge. A
       // critical edge is an edge that connects a block with multiple
       // successors to a block with multiple predecessors. We avoid
       // such edges because they prevent inserting copies during code
       // generation of phi instructions.
       visitElse = () {};
     }
 
-    _handleDiamondBranch(visitCondition, visitThen, visitElse, false);
+    _handleDiamondBranch(
+        visitCondition, visitThen, visitElse, isExpression: false,
+        sourceInformation: sourceInformation);
   }
 
-  handleConditional(void visitCondition(), void visitThen(), void visitElse()) {
+  handleConditional(void visitCondition(),
+                    void visitThen(),
+                    void visitElse()) {
     assert(visitElse != null);
-    _handleDiamondBranch(visitCondition, visitThen, visitElse, true);
+    _handleDiamondBranch(
+        visitCondition, visitThen, visitElse, isExpression: true);
   }
 
   handleIfNull(void left(), void right()) {
     // x ?? y is transformed into: x == null ? y : x
     HInstruction leftExpression;
     handleConditional(
         () {
           left();
           leftExpression = builder.pop();
           builder.pushCheckNull(leftExpression);
@@ skipping 74 matching lines @@
                                                isAnd: isAnd),
           isAnd: isAnd);
     } else {
       handleLogicalAndOr(() => builder.visit(left), visitRight, isAnd: isAnd);
     }
   }
 
   void _handleDiamondBranch(void visitCondition(),
                             void visitThen(),
                             void visitElse(),
-                            bool isExpression) {
+                            {bool isExpression,
+                             SourceInformation sourceInformation}) {
     SsaBranch conditionBranch = new SsaBranch(this);
     SsaBranch thenBranch = new SsaBranch(this);
     SsaBranch elseBranch = new SsaBranch(this);
     SsaBranch joinBranch = new SsaBranch(this);
 
     conditionBranch.startLocals = builder.localsHandler;
     builder.goto(builder.current, conditionBranch.block);
 
-    buildCondition(visitCondition, conditionBranch, thenBranch, elseBranch);
+    buildCondition(visitCondition, conditionBranch, thenBranch, elseBranch,
+                   sourceInformation);
     HInstruction thenValue =
         buildBranch(thenBranch, visitThen, joinBranch, isExpression);
     HInstruction elseValue =
         buildBranch(elseBranch, visitElse, joinBranch, isExpression);
 
     if (isExpression) {
       assert(thenValue != null && elseValue != null);
       JavaScriptBackend backend = builder.backend;
       HPhi phi = new HPhi.manyInputs(
           null, <HInstruction>[thenValue, elseValue], backend.dynamicType);
@@ skipping 109 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }