Make source information mandatory for building send-like node in CPS

pkg/compiler/lib/src/cps_ir/cps_ir_builder.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;
 
 import '../closure.dart' as closure;
 import '../common.dart';
 import '../common/names.dart' show
     Names,
@@ skipping 677 matching lines @@
   }
 
   ir.Primitive buildInvokeStatic(Element element,
                                  Selector selector,
                                  List<ir.Primitive> arguments,
                                  SourceInformation sourceInformation) {
     assert(!element.isLocal);
     assert(!element.isInstanceMember);
     assert(isOpen);
     if (program.isJsInterop(element)) {
-      return buildInvokeJsInteropMember(element, arguments);
+      return buildInvokeJsInteropMember(element, arguments, sourceInformation);
     }
     return addPrimitive(
         new ir.InvokeStatic(element, selector, arguments, sourceInformation));
   }
 
   ir.Primitive _buildInvokeSuper(Element target,
                                  Selector selector,
                                  List<ir.Primitive> arguments,
                                  SourceInformation sourceInformation) {
     assert(target.isInstanceMember);
@@ skipping 10 matching lines @@
     assert(isOpen);
     return addPrimitive(new ir.InvokeMethod(
         receiver, selector, mask, arguments,
         sourceInformation: sourceInformation));
   }
 
   ir.Primitive _buildInvokeCall(ir.Primitive target,
                                 CallStructure callStructure,
                                 TypeMask mask,
                                 List<ir.Definition> arguments,
-                                {SourceInformation sourceInformation}) {
+                                SourceInformation sourceInformation) {
     Selector selector = callStructure.callSelector;
     return _buildInvokeDynamic(
         target, selector, mask, arguments, sourceInformation);
   }
 
-  ir.Primitive buildStaticNoSuchMethod(Selector selector,
-                                       List<ir.Primitive> arguments) {
+  ir.Primitive buildStaticNoSuchMethod(
+      Selector selector,
+      List<ir.Primitive> arguments,
+      SourceInformation sourceInformation) {
     ir.Primitive receiver = buildStringConstant('');
     ir.Primitive name = buildStringConstant(selector.name);
     ir.Primitive argumentList = buildListLiteral(null, arguments);
     ir.Primitive expectedArgumentNames = buildNullConstant();
     return buildStaticFunctionInvocation(
         program.throwNoSuchMethod,
-        <ir.Primitive>[receiver, name, argumentList, expectedArgumentNames]);
+        <ir.Primitive>[receiver, name, argumentList, expectedArgumentNames],
+        sourceInformation);
   }
 
   /// Create a [ir.Constant] from [value] and add it to the CPS term.
   ir.Constant buildConstant(ConstantValue value,
                             {SourceInformation sourceInformation}) {
     assert(isOpen);
     return addPrimitive(
         new ir.Constant(value, sourceInformation: sourceInformation));
   }
 
@@ skipping 113 matching lines @@
         sourceInformation: sourceInformation);
   }
 
   /// Create a invocation of the [method] on the super class where the call
   /// structure is defined [callStructure] and the argument values are defined
   /// by [arguments].
   ir.Primitive buildSuperMethodInvocation(
       MethodElement method,
       CallStructure callStructure,
       List<ir.Primitive> arguments,
-      {SourceInformation sourceInformation}) {
+      SourceInformation sourceInformation) {
     // TODO(johnniwinther): This shouldn't be necessary.
     SelectorKind kind = Elements.isOperatorName(method.name)
         ? SelectorKind.OPERATOR : SelectorKind.CALL;
     Selector selector =
         new Selector(kind, method.memberName, callStructure);
     return _buildInvokeSuper(method, selector, arguments, sourceInformation);
   }
 
   /// Create a read access of the [method] on the super class, i.e. a
   /// closurization of [method].
   ir.Primitive buildSuperMethodGet(MethodElement method,
-                                   {SourceInformation sourceInformation}) {
+                                   SourceInformation sourceInformation) {
     // TODO(johnniwinther): This should have its own ir node.
     return _buildInvokeSuper(
         method,
         new Selector.getter(method.memberName),
         const <ir.Primitive>[],
         sourceInformation);
   }
 
   /// Create a getter invocation of the [getter] on the super class.
   ir.Primitive buildSuperGetterGet(MethodElement getter,
                                    SourceInformation sourceInformation) {
     // TODO(johnniwinther): This should have its own ir node.
     return _buildInvokeSuper(
         getter,
         new Selector.getter(getter.memberName),
         const <ir.Primitive>[],
         sourceInformation);
   }
 
   /// Create an setter invocation of the [setter] on the super class with
   /// [value].
   ir.Primitive buildSuperSetterSet(MethodElement setter,
                                    ir.Primitive value,
-                                   {SourceInformation sourceInformation}) {
+                                   SourceInformation sourceInformation) {
     // TODO(johnniwinther): This should have its own ir node.
     _buildInvokeSuper(
         setter,
         new Selector.setter(setter.memberName),
         <ir.Primitive>[value],
         sourceInformation);
     return value;
   }
 
   /// Create an invocation of the index [method] on the super class with
   /// the provided [index].
   ir.Primitive buildSuperIndex(MethodElement method,
                                ir.Primitive index,
-                               {SourceInformation sourceInformation}) {
+                               SourceInformation sourceInformation) {
     return _buildInvokeSuper(
         method, new Selector.index(), <ir.Primitive>[index],
         sourceInformation);
   }
 
   /// Create an invocation of the index set [method] on the super class with
   /// the provided [index] and [value].
   ir.Primitive buildSuperIndexSet(MethodElement method,
                                   ir.Primitive index,
                                   ir.Primitive value,
-                                  {SourceInformation sourceInformation}) {
+                                  SourceInformation sourceInformation) {
     _buildInvokeSuper(method, new Selector.indexSet(),
         <ir.Primitive>[index, value], sourceInformation);
     return value;
   }
 
   /// Create a dynamic invocation on [receiver] where the method name and
   /// argument structure are defined by [selector] and the argument values are
   /// defined by [arguments].
   ir.Primitive buildDynamicInvocation(ir.Primitive receiver,
                                       Selector selector,
                                       TypeMask mask,
                                       List<ir.Primitive> arguments,
-                                      {SourceInformation sourceInformation}) {
+                                      SourceInformation sourceInformation) {
     return _buildInvokeDynamic(
         receiver, selector, mask, arguments, sourceInformation);
   }
 
   /// Create a dynamic getter invocation on [receiver] where the getter name is
   /// defined by [selector].
   ir.Primitive buildDynamicGet(ir.Primitive receiver,
                                Selector selector,
                                TypeMask mask,
                                SourceInformation sourceInformation) {
     assert(selector.isGetter);
     FieldElement field = program.locateSingleField(selector, mask);
     if (field != null) {
       // If the world says this resolves to a unique field, then it MUST be
       // treated as a field access, since the getter might not be emitted.
-      return buildFieldGet(receiver, field);
+      return buildFieldGet(receiver, field, sourceInformation);
     } else {
       return _buildInvokeDynamic(
           receiver, selector, mask, const <ir.Primitive>[], sourceInformation);
     }
   }
 
   /// Create a dynamic setter invocation on [receiver] where the setter name and
   /// argument are defined by [selector] and [value], respectively.
   ir.Primitive buildDynamicSet(ir.Primitive receiver,
                                Selector selector,
                                TypeMask mask,
                                ir.Primitive value,
-                               {SourceInformation sourceInformation}) {
+                               SourceInformation sourceInformation) {
     assert(selector.isSetter);
     FieldElement field = program.locateSingleField(selector, mask);
     if (field != null) {
       // If the world says this resolves to a unique field, then it MUST be
       // treated as a field access, since the setter might not be emitted.
-      buildFieldSet(receiver, field, value);
+      buildFieldSet(receiver, field, value, sourceInformation);
     } else {
       _buildInvokeDynamic(receiver, selector, mask, <ir.Primitive>[value],
                           sourceInformation);
     }
     return value;
   }
 
   /// Create a dynamic index set invocation on [receiver] with the provided
   /// [index] and [value].
   ir.Primitive buildDynamicIndexSet(ir.Primitive receiver,
                                     TypeMask mask,
                                     ir.Primitive index,
                                     ir.Primitive value,
-                                    {SourceInformation sourceInformation}) {
+                                    SourceInformation sourceInformation) {
     _buildInvokeDynamic(
         receiver, new Selector.indexSet(), mask, <ir.Primitive>[index, value],
         sourceInformation);
     return value;
   }
 
   /// Create an invocation of the local [function] where argument structure is
   /// defined by [callStructure] and the argument values are defined by
   /// [arguments].
   ir.Primitive buildLocalFunctionInvocation(
       LocalFunctionElement function,
       CallStructure callStructure,
       List<ir.Primitive> arguments,
       SourceInformation sourceInformation) {
     // TODO(johnniwinther): Maybe this should have its own ir node.
     return buildCallInvocation(
         buildLocalGet(function), callStructure, arguments,
-        sourceInformation: sourceInformation);
+        sourceInformation);
   }
 
   /// Create a static invocation of [function].
   ///
   /// The arguments are not named and their values are defined by [arguments].
   ir.Primitive buildStaticFunctionInvocation(
       MethodElement function,
       List<ir.Primitive> arguments,
-      {SourceInformation sourceInformation}) {
+      SourceInformation sourceInformation) {
     Selector selector = new Selector.call(
         function.memberName, new CallStructure(arguments.length));
     return buildInvokeStatic(function, selector, arguments, sourceInformation);
   }
 
   /// Create a getter invocation of the static [getter].
   ir.Primitive buildStaticGetterGet(MethodElement getter,
                                     SourceInformation sourceInformation) {
     Selector selector = new Selector.getter(getter.memberName);
     return buildInvokeStatic(
         getter, selector, const <ir.Primitive>[], sourceInformation);
   }
 
   /// Create a write access to the static [field] with the [value].
   ir.Primitive buildStaticFieldSet(FieldElement field,
                                    ir.Primitive value,
-                                   [SourceInformation sourceInformation]) {
+                                   SourceInformation sourceInformation) {
     addPrimitive(new ir.SetStatic(field, value, sourceInformation));
     return value;
   }
 
   /// Create a setter invocation of the static [setter] with the [value].
   ir.Primitive buildStaticSetterSet(MethodElement setter,
                                     ir.Primitive value,
-                                    {SourceInformation sourceInformation}) {
+                                    SourceInformation sourceInformation) {
     Selector selector = new Selector.setter(setter.memberName);
     buildInvokeStatic(
         setter, selector, <ir.Primitive>[value], sourceInformation);
     return value;
   }
 
   /// Create an erroneous invocation where argument structure is defined by
   /// [selector] and the argument values are defined by [arguments].
   // TODO(johnniwinther): Make this more fine-grained.
   ir.Primitive buildErroneousInvocation(
       Element element,
       Selector selector,
-      List<ir.Primitive> arguments) {
+      List<ir.Primitive> arguments,
+      SourceInformation sourceInformation) {
     // TODO(johnniwinther): This should have its own ir node.
-    return buildInvokeStatic(element, selector, arguments, null);
+    return buildInvokeStatic(element, selector, arguments, sourceInformation);
   }
 
   /// Concatenate string values.  The arguments must be strings.
   ir.Primitive buildStringConcatenation(List<ir.Primitive> arguments,
-                                        {SourceInformation sourceInformation}) {
+                                        SourceInformation sourceInformation) {
     assert(isOpen);
     return addPrimitive(new ir.ApplyBuiltinOperator(
         ir.BuiltinOperator.StringConcatenate,
         arguments,
         sourceInformation));
   }
 
   /// Create an invocation of the `call` method of [functionExpression], where
   /// the structure of arguments are given by [callStructure].
   // TODO(johnniwinther): This should take a [TypeMask].
   ir.Primitive buildCallInvocation(
       ir.Primitive functionExpression,
       CallStructure callStructure,
       List<ir.Definition> arguments,
-      {SourceInformation sourceInformation}) {
-    return _buildInvokeCall(functionExpression, callStructure, null, arguments,
-        sourceInformation: sourceInformation);
+      SourceInformation sourceInformation) {
+    return _buildInvokeCall(
+        functionExpression, callStructure, null, arguments, sourceInformation);
   }
 
   /// Creates an if-then-else statement with the provided [condition] where the
   /// then and else branches are created through the [buildThenPart] and
   /// [buildElsePart] functions, respectively.
   ///
   /// An if-then statement is created if [buildElsePart] is a no-op.
   // TODO(johnniwinther): Unify implementation with [buildConditional] and
   // [_buildLogicalOperator].
   void buildIf(ir.Primitive condition,
@@ skipping 230 matching lines @@
   ///     3) `v` is an instance variable in which case [variableSelector]
   ///        defines its write access.
   /// [buildBody] creates the body, `b`, of the loop. The jump [target] is used
   /// to identify which `break` and `continue` statements that have this for-in
   /// statement as their target.
   void buildForIn({SubbuildFunction buildExpression,
                    SubbuildFunction buildVariableDeclaration,
                    Element variableElement,
                    Selector variableSelector,
                    TypeMask variableMask,
+                   SourceInformation variableSetSourceInformation,
                    TypeMask currentMask,
+                   SourceInformation currentSourceInformation,
                    TypeMask iteratorMask,
+                   SourceInformation iteratorSourceInformation,
                    TypeMask moveNextMask,
+                   SourceInformation moveNextSourceInformation,
                    SubbuildFunction buildBody,
                    JumpTarget target,
                    ClosureScope closureScope}) {
     // The for-in loop
     //
     // for (a in e) s;
     //
     // Is compiled analogously to:
     //
     // it = e.iterator;
@@ skipping 40 matching lines @@
     IrBuilder bodyBuilder = makeDelimitedBuilder();
     bodyBuilder._enterScope(closureScope);
     if (buildVariableDeclaration != null) {
       buildVariableDeclaration(bodyBuilder);
     }
     ir.Primitive currentValue = bodyBuilder.addPrimitive(
         new ir.InvokeMethod(
             iterator,
             Selectors.current,
             currentMask,
-            emptyArguments));
+            emptyArguments,
+            sourceInformation: currentSourceInformation));
     // TODO(johnniwinther): Extract this as a provided strategy.
     if (Elements.isLocal(variableElement)) {
-      bodyBuilder.buildLocalVariableSet(variableElement, currentValue);
+      bodyBuilder.buildLocalVariableSet(
+          variableElement,
+          currentValue,
+          variableSetSourceInformation);
     } else if (Elements.isError(variableElement) ||
                Elements.isMalformed(variableElement)) {
       Selector selector = new Selector.setter(
           new Name(variableElement.name, variableElement.library));
       List<ir.Primitive> value = <ir.Primitive>[currentValue];
       // Note the comparison below.  It can be the case that an element isError
       // and isMalformed.
       if (Elements.isError(variableElement)) {
-        bodyBuilder.buildStaticNoSuchMethod(selector, value);
+        bodyBuilder.buildStaticNoSuchMethod(selector, value,
+            variableSetSourceInformation);
       } else {
-        bodyBuilder.buildErroneousInvocation(variableElement, selector, value);
+        bodyBuilder.buildErroneousInvocation(
+            variableElement, selector, value, variableSetSourceInformation);
       }
     } else if (Elements.isStaticOrTopLevel(variableElement)) {
       if (variableElement.isField) {
         bodyBuilder.addPrimitive(
-            new ir.SetStatic(variableElement, currentValue));
+            new ir.SetStatic(
+                variableElement, currentValue, variableSetSourceInformation));
       } else {
-        bodyBuilder.buildStaticSetterSet(variableElement, currentValue);
+        bodyBuilder.buildStaticSetterSet(
+            variableElement, currentValue, variableSetSourceInformation);
       }
     } else {
       ir.Primitive receiver = bodyBuilder.buildThis();
       assert(receiver != null);
       bodyBuilder.buildDynamicSet(
-          receiver, variableSelector, variableMask, currentValue);
+          receiver, variableSelector, variableMask, currentValue,
+          variableSetSourceInformation);
     }
 
     // Translate the body in the hole in the delimited term above, and add
     // a jump to the loop if control flow is live after the body.
     JumpCollector breakCollector =
         new ForwardJumpCollector(environment, target: target);
     state.breakCollectors.add(breakCollector);
     state.continueCollectors.add(loop);
     buildBody(bodyBuilder);
     assert(state.breakCollectors.last == breakCollector);
@@ skipping 409 matching lines @@
         thenContinuation.body = buildCatchClause(clause);
         elseContinuation.body = catchBody;
 
         // Build the type test guarding this clause. We can share the
         // environment with the nested builder because this part cannot mutate
         // it.
         IrBuilder checkBuilder = builder.makeDelimitedBuilder(environment);
         ir.Primitive typeMatches =
             checkBuilder.buildTypeOperator(exceptionParameter,
                 clause.type,
+                clause.sourceInformation,
                 isTypeTest: true);
         checkBuilder.add(new ir.LetCont.two(thenContinuation, elseContinuation,
             new ir.Branch.strict(typeMatches,
                                  thenContinuation,
                                  elseContinuation)));
         catchBody = checkBuilder.root;
       }
       builder.add(catchBody);
 
       return <ir.Parameter>[exceptionParameter, traceParameter];
@@ skipping 132 matching lines @@
     // Return without a subexpression is translated as if it were return null.
     assert(isOpen);
     if (value == null) {
       value = buildNullConstant();
     }
     jumpTo(state.returnCollector, value, sourceInformation);
   }
 
   /// Generate the body for a native function [function] that is annotated with
   /// an implementation in JavaScript (provided as string in [javaScriptCode]).
-  void buildNativeFunctionBody(FunctionElement function,
-                               String javaScriptCode) {
+  void buildNativeFunctionBody(
+      FunctionElement function,
+      String javaScriptCode,
+      SourceInformation sourceInformation) {
     NativeBehavior behavior = new NativeBehavior();
     behavior.sideEffects.setAllSideEffects();
     // Generate a [ForeignCode] statement from the given native code.
     buildForeignCode(
         js.js.statementTemplateYielding(
             new js.LiteralStatement(javaScriptCode)),
         <ir.Primitive>[],
-        behavior);
+        behavior,
+        sourceInformation);
   }
 
   /// Generate the body for a native function that redirects to a native
   /// JavaScript function, getter, or setter.
   ///
   /// Generates a call to the real target, which is given by [functions]'s
   /// `fixedBackendName`, passing all parameters as arguments.  The target can
   /// be the JavaScript implementation of a function, getter, or setter.
   void buildRedirectingNativeFunctionBody(FunctionElement function,
                                           String name,
-                                          SourceInformation source) {
+                                          SourceInformation sourceInformation) {
     List<ir.Primitive> arguments = <ir.Primitive>[];
     NativeBehavior behavior = new NativeBehavior();
     behavior.sideEffects.setAllSideEffects();
     program.addNativeMethod(function);
     // Construct the access of the target element.
     String code = function.isInstanceMember ? '#.$name' : name;
     if (function.isInstanceMember) {
       arguments.add(state.thisParameter);
     }
     // Collect all parameters of the function and templates for them to be
     // inserted into the JavaScript code.
     List<String> argumentTemplates = <String>[];
     function.functionSignature.forEachParameter((ParameterElement parameter) {
       ir.Primitive input = environment.lookup(parameter);
       DartType type = program.unaliasType(parameter.type);
       if (type is FunctionType) {
         // The parameter type is a function type either directly or through
         // typedef(s).
         ir.Constant arity = buildIntegerConstant(type.computeArity());
         input = buildStaticFunctionInvocation(
-            program.closureConverter, <ir.Primitive>[input, arity]);
+            program.closureConverter, <ir.Primitive>[input, arity],
+            sourceInformation);
       }
       arguments.add(input);
       argumentTemplates.add('#');
     });
     // Construct the application of parameters for functions and setters.
     if (function.kind == ElementKind.FUNCTION) {
       code = "$code(${argumentTemplates.join(', ')})";
     } else if (function.kind == ElementKind.SETTER) {
       code = "$code = ${argumentTemplates.single}";
     } else {
       assert(argumentTemplates.isEmpty);
       assert(function.kind == ElementKind.GETTER);
     }
     // Generate the [ForeignCode] expression and a return statement to return
     // its value.
     ir.Primitive value = buildForeignCode(
         js.js.uncachedExpressionTemplate(code),
         arguments,
         behavior,
+        sourceInformation,
         type: program.getTypeMaskForNativeFunction(function));
-    buildReturn(value: value, sourceInformation: source);
+    buildReturn(value: value, sourceInformation: sourceInformation);
   }
 
   static _isNotNull(ir.Primitive value) =>
       !(value is ir.Constant && value.value.isNull);
 
   /// Builds a call to a resolved js-interop element.
-  ir.Primitive buildInvokeJsInteropMember(FunctionElement element,
-      List<ir.Primitive> arguments) {
+  ir.Primitive buildInvokeJsInteropMember(
+      FunctionElement element,
+      List<ir.Primitive> arguments,
+      SourceInformation sourceInformation) {
     program.addNativeMethod(element);
     String target = program.getJsInteropTargetPath(element);
     // Strip off trailing arguments that were not specified.
     // TODO(jacobr,sigmund): assert that the trailing arguments are all null.
     // TODO(jacobr): rewrite named arguments to an object literal matching
     // the factory constructor case.
     var inputs = arguments.where(_isNotNull).toList();
 
     var behavior = new NativeBehavior()..sideEffects.setAllSideEffects();
     DartType type = element.isConstructor ?
@@ skipping 19 matching lines @@
 
     String code;
     if (element.isGetter) {
       code = target;
     } else if (element.isSetter) {
       code = "$target = #";
     } else {
       var args = new List.filled(inputs.length, '#').join(',');
       code = element.isConstructor ? "new $target($args)" : "$target($args)";
     }
-    return buildForeignCode(js.js.parseForeignJS(code), inputs, behavior);
+    return buildForeignCode(js.js.parseForeignJS(code),
+        inputs, behavior, sourceInformation);
     // TODO(sigmund): should we record the source-information here?
   }
 
   /// Builds an object literal that results from invoking a factory constructor
   /// of a js-interop anonymous type.
-  ir.Primitive buildJsInteropObjectLiteral(ConstructorElement constructor,
-      List<ir.Primitive> arguments, {SourceInformation source}) {
+  ir.Primitive buildJsInteropObjectLiteral(
+      ConstructorElement constructor,
+      List<ir.Primitive> arguments,
+      SourceInformation sourceInformation) {
     assert(program.isJsInteropAnonymous(constructor));
     program.addNativeMethod(constructor);
     FunctionSignature params = constructor.functionSignature;
     int i = 0;
     var filteredArguments = <ir.Primitive>[];
     var entries = new Map<String, js.Expression>();
     params.orderedForEachParameter((ParameterElement parameter) {
       // TODO(jacobr): throw if parameter names do not match names of property
       // names in the class.
       assert (parameter.isNamed);
       ir.Primitive argument = arguments[i++];
       if (_isNotNull(argument)) {
         filteredArguments.add(argument);
         entries[parameter.name] =
             new js.InterpolatedExpression(filteredArguments.length - 1);
       }
     });
     var code = new js.Template(null, js.objectLiteral(entries));
     var behavior = new NativeBehavior();
     if (program.trustJSInteropTypeAnnotations) {
       behavior.typesReturned.add(constructor.enclosingClass.thisType);
     }
 
-    // TODO(sigmund): should we record the source-information here?
-    return buildForeignCode(code, filteredArguments, behavior);
+    return buildForeignCode(
+        code, filteredArguments, behavior, sourceInformation);
   }
 
   /// Create a blocks of [statements] by applying [build] to all reachable
   /// statements. The first statement is assumed to be reachable.
   // TODO(johnniwinther): Type [statements] as `Iterable` when `NodeList` uses
   // `List` instead of `Link`.
   void buildBlock(var statements, BuildFunction build) {
     // Build(Block(stamements), C) = C'
     //   where C' = statements.fold(Build, C)
     assert(isOpen);
@@ skipping 331 matching lines @@
       } else {
         value = environment.lookup(field.local);
       }
       arguments.add(value);
     }
     return addPrimitive(new ir.CreateInstance(
         classElement, arguments, null, sourceInformation));
   }
 
   /// Create a read access of [local] function, variable, or parameter.
-  ir.Primitive buildLocalGet(LocalElement local) {
+  // TODO(johnniwinther): Make [sourceInformation] mandatory.
+  ir.Primitive buildLocalGet(
+      LocalElement local,
+      {SourceInformation sourceInformation}) {
     assert(isOpen);
     ClosureLocation location = state.boxedVariables[local];
     if (location != null) {
-      ir.Primitive result = new ir.GetField(environment.lookup(location.box),
-                                            location.field);
+      ir.Primitive result = new ir.GetField(
+          environment.lookup(location.box),
+          location.field,
+          sourceInformation: sourceInformation);
       result.useElementAsHint(local);
       return addPrimitive(result);
     } else if (isInMutableVariable(local)) {
-      return addPrimitive(new ir.GetMutable(getMutableVariable(local)));
+      return addPrimitive(
+          new ir.GetMutable(
+              getMutableVariable(local), sourceInformation: sourceInformation));
     } else {
       return environment.lookup(local);
     }
   }
 
   /// Create a write access to [local] variable or parameter with the provided
   /// [value].
-  ir.Primitive buildLocalVariableSet(LocalElement local, ir.Primitive value) {
+  ir.Primitive buildLocalVariableSet(
+      LocalElement local,
+      ir.Primitive value,
+      SourceInformation sourceInformation) {
     assert(isOpen);
     ClosureLocation location = state.boxedVariables[local];
     if (location != null) {
       addPrimitive(new ir.SetField(
           environment.lookup(location.box),
           location.field,
-          value));
+          value,
+          sourceInformation: sourceInformation));
     } else if (isInMutableVariable(local)) {
       addPrimitive(new ir.SetMutable(
-          getMutableVariable(local), value));
+          getMutableVariable(local),
+          value,
+          sourceInformation: sourceInformation));
     } else {
       value.useElementAsHint(local);
       environment.update(local, value);
     }
     return value;
   }
 
   /// Called before building the initializer of a for-loop.
   ///
   /// The loop variables will subsequently be declared using
@@ skipping 38 matching lines @@
   /// Creates an access to the receiver from the current (or enclosing) method.
   ///
   /// If inside a closure class, [buildThis] will redirect access through
   /// closure fields in order to access the receiver from the enclosing method.
   ir.Primitive buildThis() {
     if (state.enclosingThis != null) return state.enclosingThis;
     assert(state.thisParameter != null);
     return state.thisParameter;
   }
 
-  ir.Primitive buildFieldGet(ir.Primitive receiver, FieldElement target) {
+  ir.Primitive buildFieldGet(
+      ir.Primitive receiver,
+      FieldElement target,
+      SourceInformation sourceInformation) {
     return addPrimitive(new ir.GetField(receiver, target,
+        sourceInformation: sourceInformation,
         isFinal: program.fieldNeverChanges(target)));
   }
 
   void buildFieldSet(ir.Primitive receiver,
                      FieldElement target,
-                     ir.Primitive value) {
-    addPrimitive(new ir.SetField(receiver, target, value));
+                     ir.Primitive value,
+                     SourceInformation sourceInformation) {
+    addPrimitive(new ir.SetField(
+        receiver, target, value, sourceInformation: sourceInformation));
   }
 
-  ir.Primitive buildSuperFieldGet(FieldElement target) {
-    return addPrimitive(new ir.GetField(buildThis(), target));
+  ir.Primitive buildSuperFieldGet(
+      FieldElement target,
+      SourceInformation sourceInformation) {
+    return addPrimitive(
+        new ir.GetField(
+            buildThis(), target, sourceInformation: sourceInformation));
   }
 
-  ir.Primitive buildSuperFieldSet(FieldElement target, ir.Primitive value) {
-    addPrimitive(new ir.SetField(buildThis(), target, value));
+  ir.Primitive buildSuperFieldSet(
+      FieldElement target,
+      ir.Primitive value,
+      SourceInformation sourceInformation) {
+    addPrimitive(
+        new ir.SetField(
+            buildThis(), target, value, sourceInformation: sourceInformation));
     return value;
   }
 
   /// Loads parameters to a constructor body into the environment.
   ///
   /// The header for a constructor body differs from other functions in that
   /// some parameters are already boxed, and the box is passed as an argument
   /// instead of being created in the header.
   void buildConstructorBodyHeader(Iterable<Local> parameters,
                                   ClosureScope closureScope) {
@@ skipping 16 matching lines @@
       DartType type,
       List<ir.Primitive> arguments,
       SourceInformation sourceInformation,
       {TypeMask allocationSiteType}) {
     assert(isOpen);
     Selector selector =
         new Selector(SelectorKind.CALL, element.memberName, callStructure);
     ClassElement cls = element.enclosingClass;
     if (program.isJsInterop(element)) {
       if (program.isJsInteropAnonymous(element)) {
-        return buildJsInteropObjectLiteral(element, arguments,
-            source: sourceInformation);
+        return buildJsInteropObjectLiteral(
+            element, arguments, sourceInformation);
       }
-      return buildInvokeJsInteropMember(element, arguments);
+      return buildInvokeJsInteropMember(element, arguments, sourceInformation);
     }
     if (program.requiresRuntimeTypesFor(cls)) {
       InterfaceType interface = type;
       Iterable<ir.Primitive> typeArguments =
           interface.typeArguments.map((DartType argument) {
         return type.treatAsRaw
             ? buildNullConstant()
             : buildTypeExpression(argument);
       });
       arguments = new List<ir.Primitive>.from(arguments)
@@ skipping 65 matching lines @@
   }
 
   ir.Primitive buildInvocationMirror(Selector selector,
                                      List<ir.Primitive> arguments) {
     return addPrimitive(new ir.CreateInvocationMirror(selector, arguments));
   }
 
   ir.Primitive buildForeignCode(js.Template codeTemplate,
                                 List<ir.Primitive> arguments,
                                 NativeBehavior behavior,
+                                SourceInformation sourceInformation,
                                 {Element dependency,
                                  TypeMask type}) {
     assert(behavior != null);
     if (type == null) {
       type = program.getTypeMaskForForeign(behavior);
     }
     if (js.isIdentityTemplate(codeTemplate) && !program.isArrayType(type)) {
       // JS expression is just a refinement.
       // Do not do this for arrays - those are special because array types can
       // change after creation.  The input and output must therefore be modeled
       // as distinct values.
       return addPrimitive(new ir.Refinement(arguments.single, type));
     }
     ir.Primitive result = addPrimitive(new ir.ForeignCode(
         codeTemplate,
         type,
         arguments,
         behavior,
+        sourceInformation,
         dependency: dependency));
     if (!codeTemplate.isExpression) {
       // Close the term if this is a "throw" expression or native body.
       add(new ir.Unreachable());
       _current = null;
     }
     return result;
   }
 
   /// Creates a type test or type cast of [value] against [type].
   ir.Primitive buildTypeOperator(ir.Primitive value,
                                  DartType type,
+                                 SourceInformation sourceInformation,
                                  {bool isTypeTest}) {
     assert(isOpen);
     assert(isTypeTest != null);
 
     type = program.unaliasType(type);
 
     if (type.isMalformed) {
       ErroneousElement element = type.element;
       ir.Primitive message = buildStringConstant(element.message);
       return buildStaticFunctionInvocation(
           program.throwTypeErrorHelper,
-          <ir.Primitive>[message]);
+          <ir.Primitive>[message],
+          sourceInformation);
     }
 
     List<ir.Primitive> typeArguments = const <ir.Primitive>[];
     if (type is GenericType && type.typeArguments.isNotEmpty) {
       typeArguments = type.typeArguments.map(buildTypeExpression).toList();
     } else if (type is TypeVariableType) {
       typeArguments = <ir.Primitive>[buildTypeVariableAccess(type)];
     } else if (type is FunctionType) {
       typeArguments = <ir.Primitive>[buildTypeExpression(type)];
     }
@@ skipping 140 matching lines @@
   final Set<LocalVariableElement> declared = new Set<LocalVariableElement>();
   final Set<LocalVariableElement> boxedOnEntry =
       new Set<LocalVariableElement>();
 }
 
 class CatchClauseInfo {
   final DartType type;
   final LocalVariableElement exceptionVariable;
   final LocalVariableElement stackTraceVariable;
   final SubbuildFunction buildCatchBlock;
+  final SourceInformation sourceInformation;
 
   CatchClauseInfo({this.type,
                    this.exceptionVariable,
                    this.stackTraceVariable,
-                   this.buildCatchBlock});
+                   this.buildCatchBlock,
+                   this.sourceInformation});
 }
 
 class SwitchCaseInfo {
   final SubbuildFunction buildCondition;
   final SubbuildFunction buildBody;
 
   SwitchCaseInfo(this.buildCondition, this.buildBody);
 }