Make source information on conditions mandatory 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';
@@ skipping 87 matching lines @@
   Variable getVariable(cps_ir.Primitive primitive) {
     primitive = primitive.effectiveDefinition;
     return primitive2variable.putIfAbsent(primitive,
         () => new Variable(currentElement, primitive.hint));
   }
 
   /// Obtains a reference to the tree Variable corresponding to the IR primitive
   /// referred to by [reference].
   /// This increments the reference count for the given variable, so the
   /// returned expression must be used in the tree.
-  Expression getVariableUse(cps_ir.Reference<cps_ir.Primitive> reference) {
+  Expression getVariableUse(cps_ir.Reference<cps_ir.Primitive> reference,
+                            {SourceInformation sourceInformation}) {
     cps_ir.Primitive prim = reference.definition.effectiveDefinition;
     if (prim is cps_ir.Constant && inlinedConstants.contains(prim)) {
       return new Constant(prim.value);
     }
     if (thisParameter != null && prim == thisParameter) {
       return new This();
     }
-    return new VariableUse(getVariable(prim));
+    return new VariableUse(
+        getVariable(prim), sourceInformation: sourceInformation);
   }
 
   Expression getVariableUseOrNull(
         cps_ir.Reference<cps_ir.Primitive> reference) {
     return reference == null ? null : getVariableUse(reference);
   }
 
   Label getLabel(cps_ir.Continuation cont) {
     return labels.putIfAbsent(cont, () => new Label());
   }
@@ skipping 317 matching lines @@
               return cont.hasExactlyOneUse && !node.isEscapingTry
                   ? translateExpression(cont.body)
                   : new Break(getLabel(cont));
             }
           });
     }
   }
 
   /// Translates a branch condition to a tree expression.
   Expression translateCondition(cps_ir.Branch branch) {
-    Expression value = getVariableUse(branch.conditionRef);
+    Expression value = getVariableUse(
+        branch.conditionRef, sourceInformation: branch.sourceInformation);
     if (branch.isStrictCheck) {
       return new ApplyBuiltinOperator(
           BuiltinOperator.StrictEq,
-          <Expression>[value, new Constant(new TrueConstantValue())]);
+          <Expression>[value, new Constant(new TrueConstantValue())],
+          branch.sourceInformation);
     } else {
       return value;
     }
   }
 
   Statement visitBranch(cps_ir.Branch node) {
     Expression condition = translateCondition(node);
     Statement thenStatement, elseStatement;
     cps_ir.Continuation cont = node.trueContinuation;
     assert(cont.parameters.isEmpty);
     thenStatement = cont.hasExactlyOneUse
         ? translateExpression(cont.body)
         : new Break(labels[cont]);
     cont = node.falseContinuation;
     assert(cont.parameters.isEmpty);
     elseStatement = cont.hasExactlyOneUse
         ? translateExpression(cont.body)
         : new Break(labels[cont]);
-    return new If(condition, thenStatement, elseStatement);
+    return new If(
+        condition, thenStatement, elseStatement, node.sourceInformation);
   }
 
 
   /************************** PRIMITIVES  **************************/
   //
   // Visit methods for primitives must return an expression.
   //
 
   Expression visitSetField(cps_ir.SetField node) {
     return new SetField(getVariableUse(node.objectRef),
@@ skipping 91 matching lines @@
     return new SetStatic(
         node.element,
         getVariableUse(node.valueRef),
         node.sourceInformation);
   }
 
   Expression visitApplyBuiltinOperator(cps_ir.ApplyBuiltinOperator node) {
     if (node.operator == BuiltinOperator.IsFalsy) {
       return new Not(getVariableUse(node.argumentRefs.single));
     }
-    return new ApplyBuiltinOperator(node.operator,
-                                    translateArguments(node.argumentRefs));
+    return new ApplyBuiltinOperator(
+        node.operator,
+        translateArguments(node.argumentRefs),
+        node.sourceInformation);
   }
 
   Expression visitApplyBuiltinMethod(cps_ir.ApplyBuiltinMethod node) {
     return new ApplyBuiltinMethod(node.method,
         getVariableUse(node.receiverRef),
         translateArguments(node.argumentRefs),
         receiverIsNotNull: !node.receiver.type.isNullable);
   }
 
   Expression visitGetLength(cps_ir.GetLength node) {
@@ skipping 188 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);
 }