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

pkg/compiler/lib/src/js_backend/codegen/codegen.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 code_generator;
 
 import 'glue.dart';
 
 import '../../closure.dart' show
     ClosureClassElement;
@@ skipping 479 matching lines @@
     DartType dartType = node.dartType;
     assert(dartType.isInterfaceType);
     registry.registerTypeUse(new TypeUse.isCheck(dartType));
     //glue.registerIsCheck(dartType, registry);
     js.Expression property = glue.getTypeTestTag(dartType);
     return js.js(r'#.#', [object, property]);
   }
 
   @override
   js.Expression visitVariableUse(tree_ir.VariableUse node) {
-    return buildVariableAccess(node.variable);
+    return buildVariableAccess(node.variable)
+        .withSourceInformation(node.sourceInformation);
   }
 
   js.Expression buildVariableAccess(tree_ir.Variable variable) {
     return new js.VariableUse(getVariableName(variable));
   }
 
   /// Returns the JS operator for the given built-in operator for use in a
   /// compound assignment (not including the '=' sign).
   String getAsCompoundOperator(BuiltinOperator operator) {
     switch (operator) {
@@ skipping 19 matching lines @@
            isCompoundableOperator(exp.operator);
   }
 
   bool isOneConstant(tree_ir.Expression exp) {
     return exp is tree_ir.Constant && exp.value.isOne;
   }
 
   js.Expression makeAssignment(
       js.Expression leftHand,
       tree_ir.Expression value,
-      {BuiltinOperator compound}) {
+      {SourceInformation sourceInformation,
+       BuiltinOperator compound}) {
     if (isOneConstant(value)) {
       if (compound == BuiltinOperator.NumAdd) {
-        return new js.Prefix('++', leftHand);
+        return new js.Prefix('++', leftHand)
+            .withSourceInformation(sourceInformation);
       }
       if (compound == BuiltinOperator.NumSubtract) {
-        return new js.Prefix('--', leftHand);
+        return new js.Prefix('--', leftHand)
+            .withSourceInformation(sourceInformation);
       }
     }
     if (compound != null) {
       return new js.Assignment.compound(leftHand,
-          getAsCompoundOperator(compound), visitExpression(value));
+          getAsCompoundOperator(compound), visitExpression(value))
+          .withSourceInformation(sourceInformation);
     }
-    return new js.Assignment(leftHand, visitExpression(value));
+    return new js.Assignment(leftHand, visitExpression(value))
+        .withSourceInformation(sourceInformation);
   }
 
   @override
   js.Expression visitAssign(tree_ir.Assign node) {
     js.Expression variable = buildVariableAccess(node.variable);
     if (isCompoundableBuiltin(node.value)) {
       tree_ir.ApplyBuiltinOperator rhs = node.value;
       tree_ir.Expression left = rhs.arguments[0];
       tree_ir.Expression right = rhs.arguments[1];
       if (left is tree_ir.VariableUse && left.variable == node.variable) {
-        return makeAssignment(variable, right, compound: rhs.operator);
+        return makeAssignment(variable, right, compound: rhs.operator,
+            sourceInformation: node.sourceInformation);
       }
     }
-    return makeAssignment(variable, node.value);
+    return makeAssignment(
+        variable, node.value, sourceInformation: node.sourceInformation);
   }
 
   @override
   void visitContinue(tree_ir.Continue node) {
     tree_ir.Statement next = fallthrough.target;
     if (node.target.binding == next ||
         next is tree_ir.Continue && node.target == next.target) {
       // Fall through to continue target or to equivalent continue.
       fallthrough.use();
     } else if (node.target.binding == shortContinue.target) {
@@ skipping 35 matching lines @@
     } else {
       accumulator.add(new js.Break(makeLabel(node.target)));
     }
   }
 
   @override
   visitExpressionStatement(tree_ir.ExpressionStatement node) {
     js.Expression exp = visitExpression(node.expression);
     if (node.next is tree_ir.Unreachable && emitUnreachableAsReturn.last) {
       // Emit as 'return exp' to assist local analysis in the VM.
-      accumulator.add(new js.Return(exp));
+      SourceInformation sourceInformation = node.expression.sourceInformation;
+      accumulator.add(
+          new js.Return(exp).withSourceInformation(sourceInformation));
       return null;
     } else {
       accumulator.add(new js.ExpressionStatement(exp));
       return node.next;
     }
   }
 
   bool isNullReturn(tree_ir.Statement node) {
     return node is tree_ir.Return && isNull(node.value);
   }
@@ skipping 239 matching lines @@
     return js.js('#.#(#)',
         [globalHolder, helperName, visitExpression(node.input)])
             .withSourceInformation(node.sourceInformation);
   }
 
   @override
   js.Expression visitGetField(tree_ir.GetField node) {
     registry.registerStaticUse(new StaticUse.fieldGet(node.field));
     return new js.PropertyAccess(
         visitExpression(node.object),
-        glue.instanceFieldPropertyName(node.field));
+        glue.instanceFieldPropertyName(node.field))
+        .withSourceInformation(node.sourceInformation);
   }
 
   @override
   js.Expression visitSetField(tree_ir.SetField node) {
     registry.registerStaticUse(new StaticUse.fieldSet(node.field));
     js.PropertyAccess field =
         new js.PropertyAccess(
             visitExpression(node.object),
             glue.instanceFieldPropertyName(node.field));
-    return makeAssignment(field, node.value, compound: node.compound);
+    return makeAssignment(field, node.value, compound: node.compound,
+        sourceInformation: node.sourceInformation);
   }
 
   @override
   js.Expression visitGetStatic(tree_ir.GetStatic node) {
     assert(node.element is FieldElement || node.element is FunctionElement);
     if (node.element is FunctionElement) {
       // Tear off a method.
       registry.registerStaticUse(
           new StaticUse.staticTearOff(node.element.declaration));
-      return glue.isolateStaticClosureAccess(node.element);
+      return glue.isolateStaticClosureAccess(node.element)
+        .withSourceInformation(node.sourceInformation);
     }
     if (node.useLazyGetter) {
       // Read a lazily initialized field.
       registry.registerStaticUse(
           new StaticUse.staticInit(node.element.declaration));
       js.Expression getter = glue.isolateLazyInitializerAccess(node.element);
       return new js.Call(getter, <js.Expression>[],
           sourceInformation: node.sourceInformation);
     }
     // Read an eagerly initialized field.
     registry.registerStaticUse(
         new StaticUse.staticGet(node.element.declaration));
-    return glue.staticFieldAccess(node.element);
+    return glue.staticFieldAccess(node.element)
+        .withSourceInformation(node.sourceInformation);
   }
 
   @override
   js.Expression visitSetStatic(tree_ir.SetStatic node) {
     assert(node.element is FieldElement);
     registry.registerStaticUse(
         new StaticUse.staticSet(node.element.declaration));
     js.Expression field = glue.staticFieldAccess(node.element);
-    return makeAssignment(field, node.value, compound: node.compound);
+    return makeAssignment(field, node.value, compound: node.compound,
+        sourceInformation: node.sourceInformation);
   }
 
   @override
   js.Expression visitGetLength(tree_ir.GetLength node) {
     return new js.PropertyAccess.field(visitExpression(node.object), 'length');
   }
 
   @override
   js.Expression visitGetIndex(tree_ir.GetIndex node) {
     return new js.PropertyAccess(
@@ skipping 68 matching lines @@
     if (node.dependency != null) {
       // Dependency is only used if [node] calls a Dart function. Currently only
       // through foreign function `RAW_DART_FUNCTION_REF`.
       registry.registerStaticUse(
           new StaticUse.staticInvoke(
               node.dependency,
               new CallStructure.unnamed(node.arguments.length)));
     }
     // TODO(sra,johnniwinther): Should this be in CodegenRegistry?
     glue.registerNativeBehavior(node.nativeBehavior, node);
-    return node.codeTemplate.instantiate(visitExpressionList(node.arguments));
+    return node.codeTemplate.instantiate(visitExpressionList(node.arguments))
+        .withSourceInformation(node.sourceInformation);
   }
 
   @override
   js.Expression visitForeignExpression(tree_ir.ForeignExpression node) {
     return handleForeignCode(node);
   }
 
   @override
   void visitForeignStatement(tree_ir.ForeignStatement node) {
     accumulator.add(handleForeignCode(node));
@@ skipping 219 matching lines @@
   void registerDefaultParameterValues(ExecutableElement element) {
     if (element is! FunctionElement) return;
     FunctionElement function = element;
     if (function.isStatic) return; // Defaults are inlined at call sites.
     function.functionSignature.forEachOptionalParameter((param) {
       ConstantValue constant = glue.getDefaultParameterValue(param);
       registry.registerCompileTimeConstant(constant);
     });
   }
 }