Make source information on conditions mandatory 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 783 matching lines @@
     return addPrimitive(new ir.LiteralList(type, values.toList(),
         allocationSiteType: allocationSiteType));
   }
 
   /// Creates a conditional expression with the provided [condition] where the
   /// then and else expression are created through the [buildThenExpression]
   /// and [buildElseExpression] functions, respectively.
   ir.Primitive buildConditional(
       ir.Primitive condition,
       ir.Primitive buildThenExpression(IrBuilder builder),
-      ir.Primitive buildElseExpression(IrBuilder builder)) {
+      ir.Primitive buildElseExpression(IrBuilder builder),
+      SourceInformation sourceInformation) {
     assert(isOpen);
 
     // The then and else expressions are delimited.
     IrBuilder thenBuilder = makeDelimitedBuilder();
     IrBuilder elseBuilder = makeDelimitedBuilder();
     ir.Primitive thenValue = buildThenExpression(thenBuilder);
     ir.Primitive elseValue = buildElseExpression(elseBuilder);
 
     // Treat the values of the subexpressions as named values in the
     // environment, so they will be treated as arguments to the join-point
@@ skipping 13 matching lines @@
     //   in
     //     if condition (then, else)
     ir.Continuation thenContinuation = new ir.Continuation([]);
     ir.Continuation elseContinuation = new ir.Continuation([]);
     thenContinuation.body = thenBuilder.root;
     elseContinuation.body = elseBuilder.root;
     add(new ir.LetCont(join.continuation,
             new ir.LetCont.two(thenContinuation, elseContinuation,
                 new ir.Branch.strict(condition,
                                      thenContinuation,
-                                     elseContinuation))));
+                                     elseContinuation,
+                                     sourceInformation))));
     environment = join.environment;
     return environment.discard(1);
   }
 
   /**
    * Add an explicit `return null` for functions that don't have a return
    * statement on each branch. This includes functions with an empty body,
    * such as `foo(){ }`.
    */
   void _ensureReturn() {
@@ skipping 246 matching lines @@
 
   /// 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,
                void buildThenPart(IrBuilder builder),
-               void buildElsePart(IrBuilder builder)) {
+               void buildElsePart(IrBuilder builder),
+               SourceInformation sourceInformation) {
     assert(isOpen);
 
     // The then and else parts are delimited.
     IrBuilder thenBuilder = makeDelimitedBuilder();
     IrBuilder elseBuilder = makeDelimitedBuilder();
     buildThenPart(thenBuilder);
     buildElsePart(elseBuilder);
 
     // Build the term
     // (Result =) let cont then() = [[thenPart]]
     //                 and else() = [[elsePart]]
     //            in
     //              if condition (then, else)
     ir.Continuation thenContinuation = new ir.Continuation([]);
     ir.Continuation elseContinuation = new ir.Continuation([]);
     // If exactly one of the then and else continuation bodies is open (i.e.,
     // the other one has an exit on all paths), then Continuation.plug expects
     // that continuation to be listed first.  Arbitrarily use [then, else]
     // order otherwise.
     List<ir.Continuation> arms = !thenBuilder.isOpen && elseBuilder.isOpen
         ? <ir.Continuation>[elseContinuation, thenContinuation]
         : <ir.Continuation>[thenContinuation, elseContinuation];
 
     ir.Expression result =
         new ir.LetCont.many(arms,
             new ir.Branch.strict(condition,
                                  thenContinuation,
-                                 elseContinuation));
+                                 elseContinuation,
+                                 sourceInformation));
 
     JumpCollector join;  // Null if there is no join.
     if (thenBuilder.isOpen && elseBuilder.isOpen) {
       // There is a join-point continuation.  Build the term
       // 'let cont join(x, ...) = [] in Result' and plug invocations of the
       // join-point continuation into the then and else continuations.
       join = new ForwardJumpCollector(environment);
       thenBuilder.jumpTo(join);
       elseBuilder.jumpTo(join);
       result = new ir.LetCont(join.continuation, result);
@@ skipping 47 matching lines @@
   /// statements that have this `for` statement as their target.
   ///
   /// The [closureScope] identifies variables that should be boxed in this loop.
   /// This includes variables declared inside the body of the loop as well as
   /// in the for-loop initializer.
   ///
   /// [loopVariables] is the list of variables declared in the for-loop
   /// initializer.
   void buildFor({SubbuildFunction buildInitializer,
                  SubbuildFunction buildCondition,
+                 SourceInformation conditionSourceInformation,
                  SubbuildFunction buildBody,
                  SubbuildFunction buildUpdate,
                  JumpTarget target,
                  ClosureScope closureScope,
                  List<LocalElement> loopVariables}) {
     assert(isOpen);
 
     // For loops use four named continuations: the entry to the condition,
     // the entry to the body, the loop exit, and the loop successor (break).
     // The CPS translation of
@@ skipping 84 matching lines @@
     // Create loop exit and body entry continuations and a branch to them.
     ir.Continuation exitContinuation = new ir.Continuation([]);
     ir.Continuation bodyContinuation = new ir.Continuation([]);
     bodyContinuation.body = outerBodyBuilder.root;
     // Note the order of continuations: the first one is the one that will
     // be filled by LetCont.plug.
     ir.LetCont branch =
         new ir.LetCont.two(exitContinuation, bodyContinuation,
             new ir.Branch.strict(condition,
                                  bodyContinuation,
-                                 exitContinuation));
+                                 exitContinuation,
+                                 conditionSourceInformation));
     // If there are breaks in the body, then there must be a join-point
     // continuation for the normal exit and the breaks.  Otherwise, the
     // successor is translated in the hole in the exit continuation.
     bool hasBreaks = !breakCollector.isEmpty;
     ir.LetCont letBreak;
     if (hasBreaks) {
       IrBuilder exitBuilder = makeDelimitedBuilder();
       exitBuilder.jumpTo(breakCollector);
       exitContinuation.body = exitBuilder.root;
       letBreak = new ir.LetCont(breakCollector.continuation, branch);
@@ skipping 27 matching lines @@
                    TypeMask variableMask,
                    SourceInformation variableSetSourceInformation,
                    TypeMask currentMask,
                    SourceInformation currentSourceInformation,
                    TypeMask iteratorMask,
                    SourceInformation iteratorSourceInformation,
                    TypeMask moveNextMask,
                    SourceInformation moveNextSourceInformation,
                    SubbuildFunction buildBody,
                    JumpTarget target,
-                   ClosureScope closureScope}) {
+                   ClosureScope closureScope,
+                   SourceInformation conditionSourceInformation}) {
     // The for-in loop
     //
     // for (a in e) s;
     //
     // Is compiled analogously to:
     //
     // it = e.iterator;
     // while (it.moveNext()) {
     //   var a = it.current;
     //   s;
@@ skipping 103 matching lines @@
     // in branch condition (body, exit)
     ir.Continuation exitContinuation = new ir.Continuation([]);
     ir.Continuation bodyContinuation = new ir.Continuation([]);
     bodyContinuation.body = bodyBuilder.root;
     // Note the order of continuations: the first one is the one that will
     // be filled by LetCont.plug.
     ir.LetCont branch =
         new ir.LetCont.two(exitContinuation, bodyContinuation,
             new ir.Branch.strict(condition,
                                  bodyContinuation,
-                                 exitContinuation));
+                                 exitContinuation,
+                                 conditionSourceInformation));
     // If there are breaks in the body, then there must be a join-point
     // continuation for the normal exit and the breaks.  Otherwise, the
     // successor is translated in the hole in the exit continuation.
     bool hasBreaks = !breakCollector.isEmpty;
     ir.LetCont letBreak;
     if (hasBreaks) {
       IrBuilder exitBuilder = makeDelimitedBuilder();
       exitBuilder.jumpTo(breakCollector);
       exitContinuation.body = exitBuilder.root;
       letBreak = new ir.LetCont(breakCollector.continuation, branch);
       add(letBreak);
       environment = breakCollector.environment;
     } else {
       add(branch);
     }
   }
 
   /// Creates a while loop in which the condition and body are created by
   /// [buildCondition] and [buildBody], respectively.
   ///
   /// The jump [target] is used to identify which `break` and `continue`
   /// statements that have this `while` statement as their target.
   void buildWhile({SubbuildFunction buildCondition,
                    SubbuildFunction buildBody,
                    JumpTarget target,
-                   ClosureScope closureScope}) {
+                   ClosureScope closureScope,
+                   SourceInformation sourceInformation}) {
     assert(isOpen);
     // While loops use four named continuations: the entry to the body, the
     // loop exit, the loop back edge (continue), and the loop exit (break).
     // The CPS translation of [[while (condition) body; successor]] is:
     //
     // let cont continue(x, ...) =
     //     let prim cond = [[condition]] in
     //     let cont break(x, ...) = [[successor]] in
     //     let cont exit() = break(v, ...)
     //          and body() =
@@ skipping 28 matching lines @@
     // Create body entry and loop exit continuations and a branch to them.
     ir.Continuation exitContinuation = new ir.Continuation([]);
     ir.Continuation bodyContinuation = new ir.Continuation([]);
     bodyContinuation.body = bodyBuilder.root;
     // Note the order of continuations: the first one is the one that will
     // be filled by LetCont.plug.
     ir.LetCont branch =
         new ir.LetCont.two(exitContinuation, bodyContinuation,
             new ir.Branch.strict(condition,
                                  bodyContinuation,
-                                 exitContinuation));
+                                 exitContinuation,
+                                 sourceInformation));
     // If there are breaks in the body, then there must be a join-point
     // continuation for the normal exit and the breaks.  Otherwise, the
     // successor is translated in the hole in the exit continuation.
     bool hasBreaks = !breakCollector.isEmpty;
     ir.LetCont letBreak;
     if (hasBreaks) {
       IrBuilder exitBuilder = makeDelimitedBuilder();
       exitBuilder.jumpTo(breakCollector);
       exitContinuation.body = exitBuilder.root;
       letBreak = new ir.LetCont(breakCollector.continuation, branch);
       add(letBreak);
       environment = breakCollector.environment;
     } else {
       add(branch);
     }
   }
 
 
   /// Creates a do-while loop.
   ///
   /// The body and condition are created by [buildBody] and [buildCondition].
   /// The jump target [target] is the target of `break` and `continue`
   /// statements in the body that have the loop as their target.
   /// [closureScope] contains all the variables declared in the loop (but not
   /// declared in some inner closure scope).
   void buildDoWhile({SubbuildFunction buildBody,
                      SubbuildFunction buildCondition,
                      JumpTarget target,
-                     ClosureScope closureScope}) {
+                     ClosureScope closureScope,
+                     SourceInformation sourceInformation}) {
     assert(isOpen);
     // The CPS translation of [[do body; while (condition); successor]] is:
     //
     // let cont break(x, ...) = [[successor]] in
     // let cont rec loop(x, ...) =
     //   let cont continue(x, ...) =
     //     let prim cond = [[condition]] in
     //       let cont exit() = break(v, ...)
     //            and repeat() = loop(v, ...)
     //       in branch cond (repeat, exit)
@@ skipping 36 matching lines @@
     exitContinuation.body = exitBuilder.root;
     ir.Continuation repeatContinuation = new ir.Continuation([]);
     IrBuilder repeatBuilder = continueBuilder.makeDelimitedBuilder();
     repeatBuilder.jumpTo(loop);
     repeatContinuation.body = repeatBuilder.root;
 
     continueBuilder.add(
         new ir.LetCont.two(exitContinuation, repeatContinuation,
             new ir.Branch.strict(condition,
                                  repeatContinuation,
-                                 exitContinuation)));
+                                 exitContinuation,
+                                 sourceInformation)));
     continueCollector.continuation.body = continueBuilder.root;
 
     // Construct the loop continuation (i.e., the body and condition).
     // <Loop> =
     // let cont continue(x, ...) =
     //   <Continue>
     // in [[body]]; continue(v, ...)
     loopBuilder.add(
         new ir.LetCont(continueCollector.continuation,
             bodyBuilder.root));
@@ skipping 14 matching lines @@
       ir.Continuation thenContinuation = new ir.Continuation([]);
       thenContinuation.body = thenBuilder.root;
       ir.Continuation elseContinuation = new ir.Continuation([]);
       // A LetCont.two term has a hole as the body of the first listed
       // continuation, to be plugged by the translation.  Therefore put the
       // else continuation first.
       casesBuilder.add(
           new ir.LetCont.two(elseContinuation, thenContinuation,
               new ir.Branch.strict(condition,
                                    thenContinuation,
-                                   elseContinuation)));
+                                   elseContinuation,
+                                   caseInfo.sourceInformation)));
     }
 
     if (buildDefaultBody == null) {
       casesBuilder.jumpTo(join);
     } else {
       buildDefaultBody(casesBuilder);
     }
 
     if (!join.isEmpty) {
       add(new ir.LetCont(join.continuation, casesBuilder.root));
@@ skipping 188 matching lines @@
         // 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)));
+                                 elseContinuation,
+                                 clause.sourceInformation)));
         catchBody = checkBuilder.root;
       }
       builder.add(catchBody);
 
       return <ir.Parameter>[exceptionParameter, traceParameter];
     }
 
     void leaveTryCatch(IrBuilder builder, JumpCollector join,
                        ir.Expression body) {
       // Add the binding for the join-point continuation and continue the
@@ skipping 376 matching lines @@
     return param;
   }
 
   void buildRethrow() {
     assert(isOpen);
     add(new ir.Rethrow());
     _current = null;
   }
 
   /// Create a negation of [condition].
-  ir.Primitive buildNegation(ir.Primitive condition) {
+  ir.Primitive buildNegation(
+      ir.Primitive condition,
+      SourceInformation sourceInformation) {
     // ! e is translated as e ? false : true
 
     // Add a continuation parameter for the result of the expression.
     ir.Parameter resultParameter = new ir.Parameter(null);
 
     ir.Continuation joinContinuation = new ir.Continuation([resultParameter]);
     ir.Continuation thenContinuation = new ir.Continuation([]);
     ir.Continuation elseContinuation = new ir.Continuation([]);
 
     ir.Constant makeBoolConstant(bool value) {
       return new ir.Constant(state.constantSystem.createBool(value));
     }
 
     ir.Constant trueConstant = makeBoolConstant(true);
     ir.Constant falseConstant = makeBoolConstant(false);
 
     thenContinuation.body = new ir.LetPrim(falseConstant)
         ..plug(new ir.InvokeContinuation(joinContinuation, [falseConstant]));
     elseContinuation.body = new ir.LetPrim(trueConstant)
         ..plug(new ir.InvokeContinuation(joinContinuation, [trueConstant]));
 
     add(new ir.LetCont(joinContinuation,
           new ir.LetCont.two(thenContinuation, elseContinuation,
               new ir.Branch.strict(condition,
                                    thenContinuation,
-                                   elseContinuation))));
+                                   elseContinuation,
+                                   sourceInformation))));
     return resultParameter;
   }
 
   /// Create a lazy and/or expression. [leftValue] is the value of the left
   /// operand and [buildRightValue] is called to process the value of the right
   /// operand in the context of its own [IrBuilder].
   ir.Primitive buildLogicalOperator(
       ir.Primitive leftValue,
       ir.Primitive buildRightValue(IrBuilder builder),
+      SourceInformation sourceInformation,
       {bool isLazyOr: false}) {
     // e0 && e1 is translated as if e0 ? (e1 == true) : false.
     // e0 || e1 is translated as if e0 ? true : (e1 == true).
     // The translation must convert both e0 and e1 to booleans and handle
     // local variable assignments in e1.
     IrBuilder rightBuilder = makeDelimitedBuilder();
     ir.Primitive rightValue = buildRightValue(rightBuilder);
     // A dummy empty target for the branch on the left subexpression branch.
     // This enables using the same infrastructure for join-point continuations
     // as in visitIf and visitConditional.  It will hold a definition of the
@@ skipping 30 matching lines @@
     ir.Continuation leftFalseContinuation = new ir.Continuation([]);
     ir.Continuation rightTrueContinuation = new ir.Continuation([]);
     ir.Continuation rightFalseContinuation = new ir.Continuation([]);
     rightTrueContinuation.body = rightTrueBuilder.root;
     rightFalseContinuation.body = rightFalseBuilder.root;
     // The right subexpression has two continuations.
     rightBuilder.add(
         new ir.LetCont.two(rightTrueContinuation, rightFalseContinuation,
             new ir.Branch.strict(rightValue,
                                  rightTrueContinuation,
-                                 rightFalseContinuation)));
+                                 rightFalseContinuation,
+                                 sourceInformation)));
     // Depending on the operator, the left subexpression's continuations are
     // either the right subexpression or an invocation of the join-point
     // continuation.
     if (isLazyOr) {
       leftTrueContinuation.body = emptyBuilder.root;
       leftFalseContinuation.body = rightBuilder.root;
     } else {
       leftTrueContinuation.body = rightBuilder.root;
       leftFalseContinuation.body = emptyBuilder.root;
     }
 
     add(new ir.LetCont(join.continuation,
             new ir.LetCont.two(leftTrueContinuation, leftFalseContinuation,
                 new ir.Branch.strict(leftValue,
                                      leftTrueContinuation,
-                                     leftFalseContinuation))));
+                                     leftFalseContinuation,
+                                     sourceInformation))));
     environment = join.environment;
     return environment.discard(1);
   }
 
   ir.Primitive buildIdentical(ir.Primitive x, ir.Primitive y,
                               {SourceInformation sourceInformation}) {
     return addPrimitive(new ir.ApplyBuiltinOperator(
         ir.BuiltinOperator.Identical, <ir.Primitive>[x, y],
         sourceInformation));
   }
@@ skipping 456 matching lines @@
       // For type tests, we must treat specially the rare cases where `null`
       // satisfies the test (which otherwise never satisfies a type test).
       // This is not an optimization: the TypeOperator assumes that `null`
       // cannot satisfy the type test unless the type is a type variable.
       if (type.isObject || type.isDynamic) {
         // `x is Object` and `x is dynamic` are always true, even if x is null.
         return buildBooleanConstant(true);
       }
       if (type is InterfaceType && type.element == program.nullClass) {
         // `x is Null` is true if and only if x is null.
-        return _buildCheckNull(value);
+        return _buildCheckNull(value, sourceInformation);
       }
       return addPrimitive(new ir.TypeTest(value, type, typeArguments));
     } else {
       if (type.isObject || type.isDynamic) {
         // `x as Object` and `x as dynamic` are the same as `x`.
         return value;
       }
       return addPrimitive(new ir.TypeCast(value, type, typeArguments));
     }
   }
 
   /// Create an if-null expression. This is equivalent to a conditional
   /// expression whose result is either [value] if [value] is not null, or
   /// `right` if [value] is null. Only when [value] is null, [buildRight] is
   /// evaluated to produce the `right` value.
   ir.Primitive buildIfNull(ir.Primitive value,
                            ir.Primitive buildRight(IrBuilder builder),
-                           {SourceInformation sourceInformation}) {
+                           SourceInformation sourceInformation) {
     ir.Primitive condition =
-        _buildCheckNull(value, sourceInformation: sourceInformation);
-    return buildConditional(condition, buildRight, (_) => value);
+        _buildCheckNull(value, sourceInformation);
+    return buildConditional(
+        condition, buildRight, (_) => value, sourceInformation);
   }
 
   /// Create a conditional send. This is equivalent to a conditional expression
   /// that checks if [receiver] is null, if so, it returns null, otherwise it
   /// evaluates the [buildSend] expression.
   ir.Primitive buildIfNotNullSend(ir.Primitive receiver,
                                   ir.Primitive buildSend(IrBuilder builder),
-                                  {SourceInformation sourceInformation}) {
+                                  SourceInformation sourceInformation) {
     ir.Primitive condition =
-        _buildCheckNull(receiver, sourceInformation: sourceInformation);
-    return buildConditional(condition, (_) => receiver, buildSend);
+        _buildCheckNull(receiver, sourceInformation);
+    return buildConditional(
+        condition, (_) => receiver, buildSend, sourceInformation);
   }
 
   /// Creates a type test checking whether [value] is null.
   ir.Primitive _buildCheckNull(ir.Primitive value,
-                               {SourceInformation sourceInformation}) {
+                               SourceInformation sourceInformation) {
     assert(isOpen);
     return buildIdentical(value, buildNullConstant(),
         sourceInformation: sourceInformation);
   }
 }
 
 /// Location of a variable relative to a given closure.
 class ClosureLocation {
   /// If not `null`, this location is [box].[field].
   /// The location of [box] can be obtained separately from an
@@ skipping 92 matching lines @@
   CatchClauseInfo({this.type,
                    this.exceptionVariable,
                    this.stackTraceVariable,
                    this.buildCatchBlock,
                    this.sourceInformation});
 }
 
 class SwitchCaseInfo {
   final SubbuildFunction buildCondition;
   final SubbuildFunction buildBody;
+  final SourceInformation sourceInformation;
 
-  SwitchCaseInfo(this.buildCondition, this.buildBody);
+  SwitchCaseInfo(this.buildCondition, this.buildBody, this.sourceInformation);
 }