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

pkg/compiler/lib/src/tree_ir/tree_ir_builder.dart

 // Copyright (c) 2014, 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 tree_ir_builder;
 
+import 'package:js_ast/js_ast.dart' as js;
+
 import '../common.dart';
 import '../constants/values.dart';
 import '../cps_ir/cps_ir_nodes.dart' as cps_ir;
 import '../elements/elements.dart';
-import 'package:js_ast/js_ast.dart' as js;
+import '../io/source_information.dart';
 import '../js_backend/codegen/glue.dart';
 
 import 'tree_ir_nodes.dart';
 
 typedef Statement NodeCallback(Statement next);
 
 /**
  * Builder translates from CPS-based IR to direct-style Tree.
  *
  * A call `Invoke(fun, cont, args)`, where cont is a singly-referenced
@@ skipping 56 matching lines @@
     Variable variable = new Variable(currentElement, irVariable.hint);
     mutable2variable[irVariable] = variable;
     return variable;
   }
 
   Variable getMutableVariable(cps_ir.MutableVariable mutableVariable) {
     return mutable2variable[mutableVariable];
   }
 
   VariableUse getMutableVariableUse(
-        cps_ir.Reference<cps_ir.MutableVariable> reference) {
+        cps_ir.Reference<cps_ir.MutableVariable> reference,
+        SourceInformation sourceInformation) {
     Variable variable = getMutableVariable(reference.definition);
-    return new VariableUse(variable);
+    return new VariableUse(variable, sourceInformation: sourceInformation);
   }
 
   /// Obtains the variable representing the given primitive. Returns null for
   /// primitives that have no reference and do not need a variable.
   Variable getVariable(cps_ir.Primitive primitive) {
     primitive = primitive.effectiveDefinition;
     return primitive2variable.putIfAbsent(primitive,
         () => new Variable(currentElement, primitive.hint));
   }
 
@@ skipping 375 matching lines @@
 
 
   /************************** PRIMITIVES  **************************/
   //
   // Visit methods for primitives must return an expression.
   //
 
   Expression visitSetField(cps_ir.SetField node) {
     return new SetField(getVariableUse(node.objectRef),
                         node.field,
-                        getVariableUse(node.valueRef));
+                        getVariableUse(node.valueRef),
+                        node.sourceInformation);
   }
 
   Expression visitInterceptor(cps_ir.Interceptor node) {
     return new Interceptor(getVariableUse(node.inputRef),
                            node.interceptedClasses,
                            node.sourceInformation);
   }
 
   Expression visitCreateInstance(cps_ir.CreateInstance node) {
     return new CreateInstance(
         node.classElement,
         translateArguments(node.argumentRefs),
         getVariableUseOrNull(node.typeInformationRef),
         node.sourceInformation);
   }
 
   Expression visitGetField(cps_ir.GetField node) {
     return new GetField(getVariableUse(node.objectRef), node.field,
-        objectIsNotNull: !node.object.type.isNullable);
+        node.sourceInformation, objectIsNotNull: !node.object.type.isNullable);
   }
 
   Expression visitCreateBox(cps_ir.CreateBox node) {
     return new CreateBox();
   }
 
   Expression visitCreateInvocationMirror(cps_ir.CreateInvocationMirror node) {
     return new CreateInvocationMirror(
         node.selector,
         translateArguments(node.argumentRefs));
   }
 
   Expression visitGetMutable(cps_ir.GetMutable node) {
-    return getMutableVariableUse(node.variableRef);
+    return getMutableVariableUse(node.variableRef, node.sourceInformation);
   }
 
   Expression visitSetMutable(cps_ir.SetMutable node) {
     Variable variable = getMutableVariable(node.variable);
     Expression value = getVariableUse(node.valueRef);
-    return new Assign(variable, value);
+    return new Assign(
+        variable, value, sourceInformation: node.sourceInformation);
   }
 
   Expression visitConstant(cps_ir.Constant node) {
     return new Constant(node.value, sourceInformation: node.sourceInformation);
   }
 
   Expression visitLiteralList(cps_ir.LiteralList node) {
     return new LiteralList(
             node.dartType,
             translateArguments(node.valueRefs));
@@ skipping 181 matching lines @@
     List<bool> nullableArguments = node.argumentRefs
         .map((argument) => argument.definition.type.isNullable)
         .toList(growable: false);
     if (node.codeTemplate.isExpression) {
       return new ForeignExpression(
           node.codeTemplate,
           node.type,
           arguments,
           node.nativeBehavior,
           nullableArguments,
-          node.dependency);
+          node.dependency,
+          node.sourceInformation);
     } else {
       return (Statement next) {
         assert(next is Unreachable); // We are not using the `next` statement.
         return new ForeignStatement(
             node.codeTemplate,
             node.type,
             arguments,
             node.nativeBehavior,
             nullableArguments,
-            node.dependency);
+            node.dependency,
+            node.sourceInformation);
       };
     }
   }
 
   visitReceiverCheck(cps_ir.ReceiverCheck node) => (Statement next) {
     // The CPS IR uses 'isNullCheck' because the semantics are important.
     // In the Tree IR, syntax is more important, so the receiver check uses
     // "useInvoke" to denote if an invocation should be emitted.
     return new ReceiverCheck(
         condition: getVariableUseOrNull(node.conditionRef),
@@ skipping 34 matching lines @@
 
   visitFunctionDefinition(cps_ir.FunctionDefinition node) {
     unexpectedNode(node);
   }
   visitParameter(cps_ir.Parameter node) => unexpectedNode(node);
   visitContinuation(cps_ir.Continuation node) => unexpectedNode(node);
   visitMutableVariable(cps_ir.MutableVariable node) => unexpectedNode(node);
   visitRethrow(cps_ir.Rethrow node) => unexpectedNode(node);
   visitBoundsCheck(cps_ir.BoundsCheck node) => unexpectedNode(node);
 }