Generated source mapping through CPS.

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

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library dart2js.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 266 matching lines @@
           redirectingConstructor.computeEffectiveTargetType(cls.thisType);
     CallStructure callStructure = new CallStructure(
         redirectingSignature.parameterCount,
         namedParameters);
     arguments = normalizeStaticArguments(callStructure, targetConstructor,
         arguments);
     ir.Primitive instance = irBuilder.buildConstructorInvocation(
         targetConstructor,
         callStructure,
         targetType,
-        arguments);
-    irBuilder.buildReturn(instance);
+        arguments,
+        sourceInformationBuilder.buildNew(node));
+    irBuilder.buildReturn(
+        value: instance,
+        sourceInformation: sourceInformationBuilder.buildReturn(node));
   }
 
   visitFor(ast.For node) {
     List<LocalElement> loopVariables = <LocalElement>[];
     if (node.initializer is ast.VariableDefinitions) {
       ast.VariableDefinitions definitions = node.initializer;
       for (ast.Node node in definitions.definitions.nodes) {
         LocalElement loopVariable = elements[node];
         loopVariables.add(loopVariable);
       }
@@ skipping 93 matching lines @@
     return null;
   }
 
   // Build(Return(e), C) = C'[InvokeContinuation(return, x)]
   //   where (C', x) = Build(e, C)
   //
   // Return without a subexpression is translated as if it were return null.
   ir.Primitive visitReturn(ast.Return node) {
     assert(irBuilder.isOpen);
     assert(invariant(node, node.beginToken.value != 'native'));
-    irBuilder.buildReturn(build(node.expression));
+    irBuilder.buildReturn(
+        value: build(node.expression),
+        sourceInformation: sourceInformationBuilder.buildReturn(node));
     return null;
   }
 
   visitSwitchStatement(ast.SwitchStatement node) {
     assert(irBuilder.isOpen);
     // We do not handle switch statements with continue to labeled cases.
     for (ast.SwitchCase switchCase in node.cases) {
       for (ast.Node labelOrCase in switchCase.labelsAndCases) {
         if (labelOrCase is ast.Label) {
           LabelDefinition definition = elements.getLabelDefinition(labelOrCase);
@@ skipping 113 matching lines @@
   }
 
   ConstantValue getConstantForNode(ast.Node node) {
     return irBuilder.state.constants.getConstantValueForNode(node, elements);
   }
 
   ConstantValue getConstantForVariable(VariableElement element) {
     return irBuilder.state.constants.getConstantValueForVariable(element);
   }
 
-  ir.Primitive buildConstantExpression(ConstantExpression expression) {
+  ir.Primitive buildConstantExpression(ConstantExpression expression,
+                                       SourceInformation sourceInformation) {
     return irBuilder.buildConstant(
-        irBuilder.state.constants.getConstantValue(expression));
+        irBuilder.state.constants.getConstantValue(expression),
+        sourceInformation: sourceInformation);
   }
 
   ir.Primitive visitLiteralList(ast.LiteralList node) {
     if (node.isConst) {
       return translateConstant(node);
     }
     List<ir.Primitive> values = node.elements.nodes.mapToList(visit);
     InterfaceType type = elements.getType(node);
     return irBuilder.buildListLiteral(type, values);
   }
@@ skipping 43 matching lines @@
 
   // ## Sends ##
   @override
   ir.Primitive visitAssert(ast.Send node, ast.Node condition, _) {
     assert(irBuilder.isOpen);
     if (compiler.enableUserAssertions) {
       return giveup(node, 'assert in checked mode not implemented');
     } else {
       // The call to assert and its argument expression must be ignored
       // in production mode.
-      // Assertions can only occur in expression statements, so no value needs
+      // Assertions can onl)y occur in expression statements, so no value needs
       // to be returned.
       return null;
     }
   }
 
   ir.Primitive visitNamedArgument(ast.NamedArgument node) {
     assert(irBuilder.isOpen);
     return visit(node.expression);
   }
 
   @override
   ir.Primitive visitExpressionInvoke(ast.Send node,
                                      ast.Node expression,
-                                     ast.NodeList arguments,
+                                     ast.NodeList argumentsNode,
                                      Selector selector, _) {
     ir.Primitive receiver = visit(expression);
     List<ir.Primitive> arguments = node.arguments.mapToList(visit);
     arguments = normalizeDynamicArguments(selector.callStructure, arguments);
     return irBuilder.buildCallInvocation(
-        receiver, selector.callStructure, arguments);
+        receiver, selector.callStructure, arguments,
+        sourceInformation:
+            sourceInformationBuilder.buildCall(node, argumentsNode));
   }
 
   /// Returns `true` if [node] is a super call.
   // TODO(johnniwinther): Remove the need for this.
   bool isSuperCall(ast.Send node) {
     return node != null && node.receiver != null && node.receiver.isSuper();
   }
 
   @override
   ir.Primitive handleConstantGet(
       ast.Node node,
       ConstantExpression constant, _) {
-    return buildConstantExpression(constant);
+    return buildConstantExpression(constant,
+        sourceInformationBuilder.buildGet(node));
   }
 
   /// If [node] is null, returns this.
   /// Otherwise visits [node] and returns the result.
   ir.Primitive translateReceiver(ast.Expression node) {
     return node != null ? visit(node) : irBuilder.buildThis();
   }
 
   @override
   ir.Primitive handleDynamicGet(
@@ skipping 18 matching lines @@
         target,
         nested(() => irBuilder.buildDynamicGet(
             target, selector, elements.getTypeMask(node))));
   }
 
   @override
   ir.Primitive visitDynamicTypeLiteralGet(
       ast.Send node,
       ConstantExpression constant,
       _) {
-    return buildConstantExpression(constant);
+    return buildConstantExpression(constant,
+        sourceInformationBuilder.buildGet(node));
   }
 
   @override
   ir.Primitive visitLocalVariableGet(
       ast.Send node,
       LocalVariableElement element,
       _) {
     return element.isConst
-        ? irBuilder.buildConstant(getConstantForVariable(element))
+        ? irBuilder.buildConstant(getConstantForVariable(element),
+            sourceInformation: sourceInformationBuilder.buildGet(node))
         : irBuilder.buildLocalVariableGet(element);
   }
 
   @override
   ir.Primitive handleLocalGet(
       ast.Send node,
       LocalElement element,
       _) {
     return irBuilder.buildLocalVariableGet(element);
   }
@@ skipping 16 matching lines @@
       return giveup(node, 'handleStaticFunctionGet: foreign: $function');
     }
     return irBuilder.buildStaticFunctionGet(function);
   }
 
   @override
   ir.Primitive handleStaticGetterGet(
       ast.Send node,
       FunctionElement getter,
       _) {
-    return irBuilder.buildStaticGetterGet(getter);
+    return irBuilder.buildStaticGetterGet(
+        getter, sourceInformationBuilder.buildGet(node));
   }
 
   @override
   ir.Primitive visitSuperFieldGet(
       ast.Send node,
       FieldElement field,
       _) {
     return irBuilder.buildSuperFieldGet(field);
   }
 
   @override
   ir.Primitive visitSuperGetterGet(
       ast.Send node,
       FunctionElement getter,
       _) {
-    return irBuilder.buildSuperGetterGet(getter);
+    return irBuilder.buildSuperGetterGet(
+        getter, sourceInformationBuilder.buildGet(node));
   }
 
   @override
   ir.Primitive visitSuperMethodGet(
       ast.Send node,
       MethodElement method,
       _) {
     return irBuilder.buildSuperMethodGet(method);
   }
 
   @override
   ir.Primitive visitUnresolvedSuperGet(
       ast.Send node,
       Element element, _) {
     return buildInstanceNoSuchMethod(
         elements.getSelector(node), elements.getTypeMask(node), []);
   }
 
   @override
   ir.Primitive visitThisGet(ast.Identifier node, _) {
     if (irBuilder.state.thisParameter == null) {
       // TODO(asgerf,johnniwinther): Should be in a visitInvalidThis method.
       // 'this' in static context. Just translate to null.
       assert(compiler.compilationFailed);
       return irBuilder.buildNullConstant();
     }
     return irBuilder.buildThis();
   }
 
-  ir.Primitive translateTypeVariableTypeLiteral(TypeVariableElement element) {
-    return irBuilder.buildReifyTypeVariable(element.type);
+  ir.Primitive translateTypeVariableTypeLiteral(
+      TypeVariableElement element,
+      SourceInformation sourceInformation) {
+    return irBuilder.buildReifyTypeVariable(element.type, sourceInformation);
   }
 
   @override
   ir.Primitive visitTypeVariableTypeLiteralGet(ast.Send node,
                                                TypeVariableElement element, _) {
-    return translateTypeVariableTypeLiteral(element);
+    return translateTypeVariableTypeLiteral(element,
+        sourceInformationBuilder.buildGet(node));
   }
 
   ir.Primitive translateLogicalOperator(ast.Expression left,
                                         ast.Expression right,
                                         {bool isLazyOr}) {
     ir.Primitive leftValue = visit(left);
 
     ir.Primitive buildRightValue(IrBuilder rightBuilder) {
       return withBuilder(rightBuilder, () => visit(right));
     }
@@ skipping 51 matching lines @@
 
   ir.Primitive translateBinary(ast.Send node,
                                ast.Node left,
                                op.BinaryOperator operator,
                                ast.Node right) {
     Selector selector = new Selector.binaryOperator(operator.selectorName);
     ir.Primitive receiver = visit(left);
     List<ir.Primitive> arguments = <ir.Primitive>[visit(right)];
     arguments = normalizeDynamicArguments(selector.callStructure, arguments);
     return irBuilder.buildDynamicInvocation(
-        receiver, selector, elements.getTypeMask(node), arguments);
+        receiver, selector, elements.getTypeMask(node), arguments,
+        sourceInformation:
+            sourceInformationBuilder.buildCall(node, node.selector));
   }
 
   @override
   ir.Primitive visitBinary(ast.Send node,
                            ast.Node left,
                            op.BinaryOperator operator,
                            ast.Node right, _) {
     return translateBinary(node, left, operator, right);
   }
 
@@ skipping 116 matching lines @@
   // semantic correlation between arguments and invocation.
   List<ir.Primitive> translateStaticArguments(ast.NodeList nodeList,
                                               Element element,
                                               CallStructure callStructure) {
     List<ir.Primitive> arguments = nodeList.nodes.mapToList(visit);
     return normalizeStaticArguments(callStructure, element, arguments);
   }
 
   ir.Primitive translateCallInvoke(ir.Primitive target,
                                    ast.NodeList arguments,
-                                   CallStructure callStructure) {
+                                   CallStructure callStructure,
+                                   SourceInformation sourceInformation) {
 
     return irBuilder.buildCallInvocation(target, callStructure,
-        translateDynamicArguments(arguments, callStructure));
+        translateDynamicArguments(arguments, callStructure),
+        sourceInformation: sourceInformation);
   }
 
   @override
   ir.Primitive handleConstantInvoke(
       ast.Send node,
       ConstantExpression constant,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
-    ir.Primitive target = buildConstantExpression(constant);
-    return translateCallInvoke(target, arguments, callStructure);
+    ir.Primitive target = buildConstantExpression(constant,
+        sourceInformationBuilder.buildGet(node));
+    return translateCallInvoke(target, arguments, callStructure,
+        sourceInformationBuilder.buildCall(node, arguments));
   }
 
   @override
   ir.Primitive handleDynamicInvoke(
       ast.Send node,
       ast.Node receiver,
       ast.NodeList arguments,
       Selector selector,
       _) {
     return irBuilder.buildDynamicInvocation(
         translateReceiver(receiver), selector, elements.getTypeMask(node),
-        translateDynamicArguments(arguments, selector.callStructure));
+        translateDynamicArguments(arguments, selector.callStructure),
+        sourceInformation:
+            sourceInformationBuilder.buildCall(node, node.selector));
   }
 
   @override
   ir.Primitive visitIfNotNullDynamicPropertyInvoke(
       ast.Send node,
       ast.Node receiver,
       ast.NodeList arguments,
       Selector selector,
       _) {
     ir.Primitive target = visit(receiver);
     return irBuilder.buildIfNotNullSend(
         target,
         nested(() => irBuilder.buildDynamicInvocation(
             target, selector, elements.getTypeMask(node),
             translateDynamicArguments(arguments, selector.callStructure))));
   }
 
   ir.Primitive handleLocalInvoke(
       ast.Send node,
       LocalElement element,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     return irBuilder.buildLocalVariableInvocation(element, callStructure,
-        translateDynamicArguments(arguments, callStructure));
+        translateDynamicArguments(arguments, callStructure),
+        callSourceInformation:
+            sourceInformationBuilder.buildCall(node, arguments));
   }
 
   @override
   ir.Primitive visitLocalFunctionInvoke(
       ast.Send node,
       LocalFunctionElement function,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     return irBuilder.buildLocalFunctionInvocation(function, callStructure,
-        translateDynamicArguments(arguments, callStructure));
+        translateDynamicArguments(arguments, callStructure),
+        sourceInformationBuilder.buildCall(node, arguments));
   }
 
   @override
   ir.Primitive handleStaticFieldGet(ast.Send node, FieldElement field, _) {
     return buildStaticFieldGet(field, sourceInformationBuilder.buildGet(node));
   }
 
   @override
   ir.Primitive handleStaticFieldInvoke(
       ast.Send node,
       FieldElement field,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     SourceInformation src = sourceInformationBuilder.buildGet(node);
     ir.Primitive target = buildStaticFieldGet(field, src);
     return irBuilder.buildCallInvocation(target,
         callStructure,
-        translateDynamicArguments(arguments, callStructure));
+        translateDynamicArguments(arguments, callStructure),
+        sourceInformation:
+            sourceInformationBuilder.buildCall(node, arguments));
   }
 
   @override
   ir.Primitive handleStaticFunctionInvoke(
       ast.Send node,
       MethodElement function,
       ast.NodeList arguments,
       CallStructure callStructure,
       _);
 
@@ skipping 11 matching lines @@
   @override
   ir.Primitive handleStaticGetterInvoke(
       ast.Send node,
       FunctionElement getter,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     if (compiler.backend.isForeign(getter)) {
       return giveup(node, 'handleStaticGetterInvoke: foreign: $getter');
     }
-    ir.Primitive target = irBuilder.buildStaticGetterGet(getter);
+    ir.Primitive target = irBuilder.buildStaticGetterGet(
+        getter, sourceInformationBuilder.buildGet(node));
     return irBuilder.buildCallInvocation(target,
         callStructure,
-        translateDynamicArguments(arguments, callStructure));
+        translateDynamicArguments(arguments, callStructure),
+        sourceInformation:
+            sourceInformationBuilder.buildCall(node, arguments));
   }
 
   @override
   ir.Primitive visitSuperFieldInvoke(
       ast.Send node,
       FieldElement field,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     ir.Primitive target = irBuilder.buildSuperFieldGet(field);
     return irBuilder.buildCallInvocation(target,
         callStructure,
-        translateDynamicArguments(arguments, callStructure));
+        translateDynamicArguments(arguments, callStructure),
+        sourceInformation:
+            sourceInformationBuilder.buildCall(node, arguments));
   }
 
   @override
   ir.Primitive visitSuperGetterInvoke(
       ast.Send node,
       FunctionElement getter,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
-    ir.Primitive target = irBuilder.buildSuperGetterGet(getter);
+    ir.Primitive target = irBuilder.buildSuperGetterGet(
+        getter, sourceInformationBuilder.buildGet(node));
     return irBuilder.buildCallInvocation(target,
         callStructure,
-        translateDynamicArguments(arguments, callStructure));
+        translateDynamicArguments(arguments, callStructure),
+        sourceInformation:
+            sourceInformationBuilder.buildCall(node, arguments));
   }
 
   @override
   ir.Primitive visitSuperMethodInvoke(
       ast.Send node,
       MethodElement method,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     return irBuilder.buildSuperMethodInvocation(method, callStructure,
-        translateDynamicArguments(arguments, callStructure));
+        translateDynamicArguments(arguments, callStructure),
+        sourceInformation:
+            sourceInformationBuilder.buildCall(node, node.selector));
   }
 
   @override
   ir.Primitive visitSuperMethodIncompatibleInvoke(
       ast.Send node,
       MethodElement method,
       ast.NodeList arguments,
       CallStructure callStructure, _) {
     return buildInstanceNoSuchMethod(
         elements.getSelector(node),
@@ skipping 12 matching lines @@
         elements.getTypeMask(node),
         translateDynamicArguments(arguments, selector.callStructure));
   }
 
   @override
   ir.Primitive visitThisInvoke(
       ast.Send node,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
-    return translateCallInvoke(irBuilder.buildThis(), arguments, callStructure);
+    return translateCallInvoke(
+        irBuilder.buildThis(),
+        arguments,
+        callStructure,
+        sourceInformationBuilder.buildCall(node, arguments));
   }
 
   @override
   ir.Primitive visitTypeVariableTypeLiteralInvoke(
       ast.Send node,
       TypeVariableElement element,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     return translateCallInvoke(
-        translateTypeVariableTypeLiteral(element),
+        translateTypeVariableTypeLiteral(
+            element, sourceInformationBuilder.buildGet(node)),
         arguments,
-        callStructure);
+        callStructure,
+        sourceInformationBuilder.buildCall(node, arguments));
   }
 
   @override
   ir.Primitive visitIndexSet(
        ast.SendSet node,
        ast.Node receiver,
        ast.Node index,
        ast.Node rhs,
        _) {
     return irBuilder.buildDynamicIndexSet(
@@ skipping 128 matching lines @@
     return irBuilder.buildStaticSetterSet(setter, visit(rhs));
   }
 
   @override
   ir.Primitive handleTypeLiteralConstantCompounds(
       ast.SendSet node,
       ConstantExpression constant,
       CompoundRhs rhs,
       arg) {
     return translateCompounds(
-        getValue: () => buildConstantExpression(constant),
+        getValue: () {
+          return buildConstantExpression(constant,
+            sourceInformationBuilder.buildGet(node));
+        },
         rhs: rhs,
         setValue: (value) {}, // The binary operator will throw before this.
         operatorTypeMask: elements.getOperatorTypeMaskInComplexSendSet(node));
   }
 
   @override
   ir.Primitive handleDynamicCompounds(
       ast.SendSet node,
       ast.Node receiver,
       CompoundRhs rhs,
@@ skipping 71 matching lines @@
       CompoundSetter setterKind,
       CompoundRhs rhs,
       arg) {
     return translateCompounds(
         getValue: () {
           switch (getterKind) {
             case CompoundGetter.FIELD:
               SourceInformation src = sourceInformationBuilder.buildGet(node);
               return irBuilder.buildStaticFieldGet(getter, src);
             case CompoundGetter.GETTER:
-              return irBuilder.buildStaticGetterGet(getter);
+              return irBuilder.buildStaticGetterGet(
+                  getter, sourceInformationBuilder.buildGet(node));
             case CompoundGetter.METHOD:
               return irBuilder.buildStaticFunctionGet(getter);
             case CompoundGetter.UNRESOLVED:
               return buildStaticNoSuchGetter(getter);
           }
         },
         rhs: rhs,
         setValue: (ir.Primitive result) {
           switch (setterKind) {
             case CompoundSetter.FIELD:
@@ skipping 33 matching lines @@
       Element setter,
       CompoundSetter setterKind,
       CompoundRhs rhs,
       arg) {
     return translateCompounds(
         getValue: () {
           switch (getterKind) {
             case CompoundGetter.FIELD:
               return irBuilder.buildSuperFieldGet(getter);
             case CompoundGetter.GETTER:
-              return irBuilder.buildSuperGetterGet(getter);
+              return irBuilder.buildSuperGetterGet(
+                  getter, sourceInformationBuilder.buildGet(node));
             case CompoundGetter.METHOD:
               return irBuilder.buildSuperMethodGet(getter);
             case CompoundGetter.UNRESOLVED:
               // TODO(johnniwinther): Ensure [getter] is not null.
               return buildSuperNoSuchGetter(
                   getter != null ? getter : setter,
                   elements.getGetterTypeMaskInComplexSendSet(node));
           }
         },
         rhs: rhs,
@@ skipping 11 matching lines @@
         operatorTypeMask: elements.getOperatorTypeMaskInComplexSendSet(node));
   }
 
   @override
   ir.Primitive handleTypeVariableTypeLiteralCompounds(
       ast.SendSet node,
       TypeVariableElement typeVariable,
       CompoundRhs rhs,
       arg) {
     return translateCompounds(
-        getValue: () => irBuilder.buildReifyTypeVariable(typeVariable.type),
+        getValue: () {
+          return irBuilder.buildReifyTypeVariable(
+            typeVariable.type,
+            sourceInformationBuilder.buildGet(node));
+        },
         rhs: rhs,
         setValue: (value) {}, // The binary operator will throw before this.
         operatorTypeMask: elements.getOperatorTypeMaskInComplexSendSet(node));
   }
 
   @override
   ir.Primitive handleIndexCompounds(
       ast.SendSet node,
       ast.Node receiver,
       ast.Node index,
@@ skipping 95 matching lines @@
 
   ir.Primitive visitStringInterpolation(ast.StringInterpolation node) {
     assert(irBuilder.isOpen);
     List<ir.Primitive> parts = <ir.Primitive>[];
     buildStringParts(node, parts);
     return irBuilder.buildStringConcatenation(parts);
   }
 
   ir.Primitive translateConstant(ast.Node node) {
     assert(irBuilder.isOpen);
-    return irBuilder.buildConstant(getConstantForNode(node));
+    return irBuilder.buildConstant(
+        getConstantForNode(node),
+        sourceInformation: sourceInformationBuilder.buildGet(node));
   }
 
   ir.Primitive visitThrow(ast.Throw node) {
     assert(irBuilder.isOpen);
     // This function is not called for throw expressions occurring as
     // statements.
     return irBuilder.buildNonTailThrow(visit(node.expression));
   }
 
   ir.Primitive buildStaticNoSuchMethod(
@@ skipping 613 matching lines @@
   /// Builds the IR for creating an instance of the closure class corresponding
   /// to the given nested function.
   ClosureClassElement makeSubFunction(ast.FunctionExpression node) {
     ClosureClassMap innerMap =
         compiler.closureToClassMapper.getMappingForNestedFunction(node);
     ClosureClassElement closureClass = innerMap.closureClassElement;
     return closureClass;
   }
 
   ir.Primitive visitFunctionExpression(ast.FunctionExpression node) {
-    return irBuilder.buildFunctionExpression(makeSubFunction(node));
+    return irBuilder.buildFunctionExpression(makeSubFunction(node),
+        sourceInformationBuilder.buildCreate(node));
   }
 
   visitFunctionDeclaration(ast.FunctionDeclaration node) {
     LocalFunctionElement element = elements[node.function];
     Object inner = makeSubFunction(node.function);
-    irBuilder.declareLocalFunction(element, inner);
+    irBuilder.declareLocalFunction(element, inner,
+        sourceInformationBuilder.buildCreate(node.function));
   }
 
   Map mapValues(Map map, dynamic fn(dynamic)) {
     Map result = {};
     map.forEach((key, value) {
       result[key] = fn(value);
     });
     return result;
   }
 
@@ skipping 94 matching lines @@
     }
     closureClassMap =
         compiler.closureToClassMapper.computeClosureToClassMapping(
             element,
             element.node,
             elements);
     IrBuilder builder = getBuilderFor(element);
     return withBuilder(builder, () {
       irBuilder.buildFunctionHeader(<Local>[]);
       ir.Primitive initialValue = visit(element.initializer);
-      irBuilder.buildReturn(initialValue);
+      ast.VariableDefinitions node = element.node;
+      ast.SendSet sendSet = node.definitions.nodes.head;
+      irBuilder.buildReturn(
+          value: initialValue,
+          sourceInformation:
+              sourceInformationBuilder.buildReturn(sendSet.assignmentOperator));
       return irBuilder.makeFunctionDefinition();
     });
   }
 
   /// Make a visitor suitable for translating ASTs taken from [context].
   ///
   /// Every visitor can only be applied to nodes in one context, because
   /// the [elements] field is specific to that context.
   JsIrBuilderVisitor makeVisitorForContext(AstElement context) {
     return new JsIrBuilderVisitor(
@@ skipping 104 matching lines @@
       List<ir.Primitive> instanceArguments = <ir.Primitive>[];
       classElement.forEachInstanceField((ClassElement c, FieldElement field) {
         ir.Primitive value = fieldValues[field];
         if (value != null) {
           instanceArguments.add(value);
         } else {
           assert(Elements.isNativeOrExtendsNative(c));
           // Native fields are initialized elsewhere.
         }
       }, includeSuperAndInjectedMembers: true);
+
       ir.Primitive instance = new ir.CreateInstance(
           classElement,
           instanceArguments,
-          typeInformation);
+          typeInformation,
+          constructor.hasNode
+              ? sourceInformationBuilder.buildCreate(constructor.node)
+              // TODO(johnniwinther): Provide source information for creation
+              // through synthetic constructors.
+              : null);
       irBuilder.add(new ir.LetPrim(instance));
 
       // --- Call constructor bodies ---
       for (ConstructorElement target in constructorList) {
         ConstructorBodyElement bodyElement = getConstructorBody(target);
         if (bodyElement == null) continue; // Skip if constructor has no body.
         List<ir.Primitive> bodyArguments = <ir.Primitive>[];
         for (Local param in getConstructorBodyParameters(bodyElement)) {
           bodyArguments.add(irBuilder.environment.lookup(param));
         }
         irBuilder.buildInvokeDirectly(bodyElement, instance, bodyArguments);
       }
 
       // --- step 4: return the created object ----
-      irBuilder.buildReturn(instance);
+      irBuilder.buildReturn(
+          value: instance,
+          sourceInformation:
+            sourceInformationBuilder.buildImplicitReturn(constructor));
 
       return irBuilder.makeFunctionDefinition();
     });
   }
 
   /// Evaluates all field initializers on [constructor] and all constructors
   /// invoked through `this()` or `super()` ("superconstructors").
   ///
   /// The resulting field values will be available in [fieldValues]. The values
   /// are not stored in any fields.
@@ skipping 434 matching lines @@
       _) {
     List<ir.Primitive> arguments =
         node.send.arguments.mapToList(visit, growable:false);
     // Use default values from the effective target, not the immediate target.
     ConstructorElement target = constructor.effectiveTarget;
     arguments = normalizeStaticArguments(callStructure, target, arguments);
     return irBuilder.buildConstructorInvocation(
         target,
         callStructure,
         constructor.computeEffectiveTargetType(type),
-        arguments);
+        arguments,
+        sourceInformationBuilder.buildNew(node));
   }
 
   @override
   ir.Primitive buildStaticNoSuchMethod(Selector selector,
                                        List<ir.Primitive> arguments) {
     Element thrower = backend.getThrowNoSuchMethod();
     ir.Primitive receiver = irBuilder.buildStringConstant('');
     ir.Primitive name = irBuilder.buildStringConstant(selector.name);
     ir.Primitive argumentList = irBuilder.buildListLiteral(null, arguments);
     ir.Primitive expectedArgumentNames = irBuilder.buildNullConstant();
@@ skipping 32 matching lines @@
 
   @override
   ir.Primitive handleStaticFieldGet(ast.Send node, FieldElement field, _) {
     SourceInformation src = sourceInformationBuilder.buildGet(node);
     return buildStaticFieldGet(field, src);
   }
 
   ir.Primitive buildStaticFieldGet(FieldElement field, SourceInformation src) {
     ConstantValue constant = getConstantForVariable(field);
     if (constant != null && !field.isAssignable) {
-      return irBuilder.buildConstant(constant);
+      return irBuilder.buildConstant(constant, sourceInformation: src);
     } else if (backend.constants.lazyStatics.contains(field)) {
       return irBuilder.buildStaticFieldLazyGet(field, src);
     } else {
       return irBuilder.buildStaticFieldGet(field, src);
     }
   }
 
   /// Build code to handle foreign code, that is, native JavaScript code, or
   /// builtin values and operations of the backend.
   ir.Primitive handleForeignCode(ast.Send node,
@@ skipping 278 matching lines @@
   }
 
   processSetStatic(ir.SetStatic node) {
     node.body = replacementFor(node.body);
   }
 
   processContinuation(ir.Continuation node) {
     node.body = replacementFor(node.body);
   }
 }