Make source information on conditions mandatory in CPS

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.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_task;
 
 import '../closure.dart' as closure;
 import '../common.dart';
 import '../common/names.dart' show
     Identifiers,
@@ skipping 1072 matching lines @@
         buildUpdate: subbuildSequence(node.update),
         closureScope: getClosureScopeForNode(node),
         loopVariables: loopVariables,
         target: target);
   }
 
   visitIf(ast.If node) {
     irBuilder.buildIf(
         build(node.condition),
         subbuild(node.thenPart),
-        subbuild(node.elsePart));
+        subbuild(node.elsePart),
+        sourceInformationBuilder.buildIf(node));
   }
 
   visitLabeledStatement(ast.LabeledStatement node) {
     ast.Statement body = node.statement;
     if (body is ast.Loop) {
       visit(body);
     } else {
       JumpTarget target = elements.getTargetDefinition(body);
       irBuilder.buildLabeledStatement(
           buildBody: subbuild(body),
@@ skipping 382 matching lines @@
               ir.Primitive buildComparison() {
                 ir.Primitive constant =
                     translateConstant(labelOrCase.expression);
                 return irBuilder.buildIdentical(value, constant);
               }
 
               if (condition == null) {
                 condition = buildComparison();
               } else {
                 condition = irBuilder.buildLogicalOperator(condition,
-                    nested(buildComparison), isLazyOr: true);
+                    nested(buildComparison),
+                    sourceInformationBuilder.buildSwitchCase(switchCase),
+                    isLazyOr: true);
               }
             }
           }
           return condition;
         });
       }
 
       SubbuildFunction buildBody;
       if (nextContinueTarget != null &&
           switchCase == nextContinueTarget.statement) {
@@ skipping 20 matching lines @@
                     <ir.Primitive>[],
                     sourceInformationBuilder.buildGeneric(node));
                 irBuilder.buildThrow(exception);
               }
             }
           });
           return null;
         };
       }
 
-      cases.add(new SwitchCaseInfo(buildCondition, buildBody));
+      cases.add(new SwitchCaseInfo(buildCondition, buildBody,
+          sourceInformationBuilder.buildSwitchCase(switchCase)));
     }
 
     irBuilder.buildSimpleSwitch(join, cases, buildDefaultBody);
     irBuilder.state.breakCollectors.removeLast();
     irBuilder.state.continueCollectors.length -= continueTargets.length;
     if (continueTargets.isEmpty) return;
 
     // If there were recursive cases build a while loop whose body is a
     // switch containing (only) the recursive cases.  The condition is
     // 'state != initialValue' so the loop is not taken when the state variable
@@ skipping 33 matching lines @@
                   new Selector.fromElement(error),
                   <ir.Primitive>[],
                   sourceInformationBuilder.buildGeneric(node));
               irBuilder.buildThrow(exception);
             }
           }
         });
         return null;
       }
 
-      cases.add(new SwitchCaseInfo(buildCondition, buildBody));
+      cases.add(new SwitchCaseInfo(buildCondition, buildBody,
+          sourceInformationBuilder.buildSwitch(node)));
     }
 
     // A loop with a simple switch in the body.
     IrBuilder whileBuilder = irBuilder.makeDelimitedBuilder();
     whileBuilder.buildWhile(
         buildCondition: (IrBuilder builder) {
           ir.Primitive condition = builder.buildIdentical(
               builder.environment.index2value[stateIndex], initial);
-          return builder.buildNegation(condition);
+          return builder.buildNegation(condition,
+              sourceInformationBuilder.buildSwitch(node));
         },
         buildBody: (IrBuilder builder) {
           builder.buildSimpleSwitch(loop, cases, null);
         });
     // Jump to the exit continuation.  This jump is the body of the loop exit
     // continuation, so the loop exit continuation can be eta-reduced.  The
     // jump is here for simplicity because `buildWhile` does not expose the
     // loop's exit continuation directly and has already emitted all jumps
     // to it anyway.
     whileBuilder.jumpTo(exit);
@@ skipping 50 matching lines @@
           subbuild(node.tryBlock),
           subbuild(node.finallyBlock));
     }
   }
 
   // ## Expressions ##
   ir.Primitive visitConditional(ast.Conditional node) {
     return irBuilder.buildConditional(
         build(node.condition),
         subbuild(node.thenExpression),
-        subbuild(node.elseExpression));
+        subbuild(node.elseExpression),
+        sourceInformationBuilder.buildIf(node));
   }
 
   // For all simple literals:
   // Build(Literal(c), C) = C[let val x = Constant(c) in [], x]
   ir.Primitive visitLiteralBool(ast.LiteralBool node) {
     assert(irBuilder.isOpen);
     return irBuilder.buildBooleanConstant(node.value);
   }
 
   ir.Primitive visitLiteralDouble(ast.LiteralDouble node) {
@@ skipping 238 matching lines @@
       ast.Node receiver,
       Name name,
       _) {
     ir.Primitive target = visit(receiver);
     return irBuilder.buildIfNotNullSend(
         target,
         nested(() => irBuilder.buildDynamicGet(
             target,
             new Selector.getter(name),
             elements.getTypeMask(node),
-            sourceInformationBuilder.buildGet(node))));
+            sourceInformationBuilder.buildGet(node))),
+        sourceInformationBuilder.buildIf(node));
   }
 
   @override
   ir.Primitive visitDynamicTypeLiteralGet(
       ast.Send node,
       ConstantExpression constant,
       _) {
     return buildConstantExpression(constant,
         sourceInformationBuilder.buildGet(node));
   }
@@ skipping 118 matching lines @@
 
   @override
   ir.Primitive visitTypeVariableTypeLiteralGet(ast.Send node,
                                                TypeVariableElement element, _) {
     return translateTypeVariableTypeLiteral(element,
         sourceInformationBuilder.buildGet(node));
   }
 
   ir.Primitive translateLogicalOperator(ast.Expression left,
                                         ast.Expression right,
+                                        SourceInformation sourceInformation,
                                         {bool isLazyOr}) {
     ir.Primitive leftValue = visit(left);
 
     ir.Primitive buildRightValue(IrBuilder rightBuilder) {
       return withBuilder(rightBuilder, () => visit(right));
     }
 
     return irBuilder.buildLogicalOperator(
-        leftValue, buildRightValue, isLazyOr: isLazyOr);
+        leftValue, buildRightValue, sourceInformation, isLazyOr: isLazyOr);
   }
 
   @override
   ir.Primitive visitIfNull(
       ast.Send node, ast.Node left, ast.Node right, _) {
-    return irBuilder.buildIfNull(build(left), subbuild(right));
+    return irBuilder.buildIfNull(build(left), subbuild(right),
+        sourceInformationBuilder.buildIf(node));
   }
 
   @override
   ir.Primitive visitLogicalAnd(
       ast.Send node, ast.Node left, ast.Node right, _) {
-    return translateLogicalOperator(left, right, isLazyOr: false);
+    return translateLogicalOperator(left, right,
+        sourceInformationBuilder.buildIf(node), isLazyOr: false);
   }
 
   @override
   ir.Primitive visitLogicalOr(
       ast.Send node, ast.Node left, ast.Node right, _) {
-    return translateLogicalOperator(left, right, isLazyOr: true);
+    return translateLogicalOperator(left, right,
+        sourceInformationBuilder.buildIf(node), isLazyOr: true);
   }
 
   @override
   ir.Primitive visitAs(
       ast.Send node,
       ast.Node expression,
       DartType type,
       _) {
     ir.Primitive receiver = visit(expression);
     return irBuilder.buildTypeOperator(
@@ skipping 19 matching lines @@
 
   @override
   ir.Primitive visitIsNot(ast.Send node,
                           ast.Node expression, DartType type, _) {
     ir.Primitive value = visit(expression);
     ir.Primitive check = irBuilder.buildTypeOperator(
         value,
         type,
         sourceInformationBuilder.buildIs(node),
         isTypeTest: true);
-    return irBuilder.buildNegation(check);
+    return irBuilder.buildNegation(check,
+        sourceInformationBuilder.buildIf(node));
   }
 
   ir.Primitive translateBinary(ast.Send node,
                                ast.Node left,
                                op.BinaryOperator operator,
                                ast.Node right) {
     ir.Primitive receiver = visit(left);
     Selector selector = new Selector.binaryOperator(operator.selectorName);
     List<ir.Primitive> arguments = <ir.Primitive>[visit(right)];
     CallStructure callStructure =
@@ skipping 78 matching lines @@
       _) {
     return translateSuperBinary(function, op.BinaryOperator.EQ, argument,
         sourceInformationBuilder.buildBinary(node));
   }
 
   @override
   ir.Primitive visitNot(
       ast.Send node,
       ast.Node expression,
       _) {
-    return irBuilder.buildNegation(visit(expression));
+    return irBuilder.buildNegation(visit(expression),
+        sourceInformationBuilder.buildIf(node));
   }
 
   @override
   ir.Primitive visitNotEquals(
       ast.Send node,
       ast.Node left,
       ast.Node right,
       _) {
     return irBuilder.buildNegation(
-        translateBinary(node, left, op.BinaryOperator.NOT_EQ, right));
+        translateBinary(node, left, op.BinaryOperator.NOT_EQ, right),
+        sourceInformationBuilder.buildIf(node));
   }
 
   @override
   ir.Primitive visitSuperNotEquals(
       ast.Send node,
       FunctionElement function,
       ast.Node argument,
       _) {
     return irBuilder.buildNegation(
         translateSuperBinary(function, op.BinaryOperator.NOT_EQ, argument,
-            sourceInformationBuilder.buildBinary(node)));
+            sourceInformationBuilder.buildBinary(node)),
+        sourceInformationBuilder.buildIf(node));
   }
 
   @override
   ir.Primitive visitUnary(ast.Send node,
                           op.UnaryOperator operator, ast.Node expression, _) {
     // TODO(johnniwinther): Clean up the creation of selectors.
     Selector selector = operator.selector;
     ir.Primitive receiver = translateReceiver(expression);
     return irBuilder.buildDynamicInvocation(
         receiver, selector, elements.getTypeMask(node), const [],
@@ skipping 154 matching lines @@
         nested(() {
           List<ir.Primitive> arguments = <ir.Primitive>[];
           CallStructure callStructure = translateDynamicArguments(
               argumentsNode, selector.callStructure, arguments);
           return irBuilder.buildDynamicInvocation(
               target,
               new Selector(selector.kind, selector.memberName, callStructure),
               elements.getTypeMask(node),
               arguments,
               sourceInformationBuilder.buildCall(node, node.selector));
-        }));
+        }),
+        sourceInformationBuilder.buildIf(node));
   }
 
   ir.Primitive handleLocalInvoke(
       ast.Send node,
       LocalElement element,
       ast.NodeList argumentsNode,
       CallStructure callStructure,
       _) {
     ir.Primitive function = irBuilder.buildLocalGet(element);
     List<ir.Primitive> arguments = <ir.Primitive>[];
@@ skipping 233 matching lines @@
       void setValue(ir.Primitive value)) {
     ir.Primitive value = getValue();
     op.BinaryOperator operator = rhs.operator;
     if (operator.kind == op.BinaryOperatorKind.IF_NULL) {
       // Unlike other compound operators if-null conditionally will not do the
       // assignment operation.
       return irBuilder.buildIfNull(value, nested(() {
         ir.Primitive newValue = build(rhs.rhs);
         setValue(newValue);
         return newValue;
-      }));
+      }),
+      sourceInformationBuilder.buildIf(node));
     }
 
     Selector operatorSelector =
         new Selector.binaryOperator(operator.selectorName);
     ir.Primitive rhsValue;
     if (rhs.kind == CompoundKind.ASSIGNMENT) {
       rhsValue = visit(rhs.rhs);
     } else {
       rhsValue = irBuilder.buildIntegerConstant(1);
     }
@@ skipping 20 matching lines @@
       ir.Primitive getValue(),
       ast.Node rhs,
       void setValue(ir.Primitive value)) {
     ir.Primitive value = getValue();
     // Unlike other compound operators if-null conditionally will not do the
     // assignment operation.
     return irBuilder.buildIfNull(value, nested(() {
       ir.Primitive newValue = build(rhs);
       setValue(newValue);
       return newValue;
-    }));
+    }),
+    sourceInformationBuilder.buildIf(node));
   }
 
   @override
   ir.Primitive handleDynamicSet(
       ast.SendSet node,
       ast.Node receiver,
       Name name,
       ast.Node rhs,
       _) {
     return irBuilder.buildDynamicSet(
@@ skipping 12 matching lines @@
       ast.Node rhs,
       _) {
     ir.Primitive target = visit(receiver);
     return irBuilder.buildIfNotNullSend(
         target,
         nested(() => irBuilder.buildDynamicSet(
             target,
             new Selector.setter(name),
             elements.getTypeMask(node),
             visit(rhs),
-            sourceInformationBuilder.buildAssignment(node))));
+            sourceInformationBuilder.buildAssignment(node))),
+        sourceInformationBuilder.buildIf(node));
   }
 
   @override
   ir.Primitive handleLocalSet(
       ast.SendSet node,
       LocalElement element,
       ast.Node rhs,
       _) {
     ir.Primitive value = visit(rhs);
     value = checkTypeVsElement(value, element);
@@ skipping 96 matching lines @@
       }, rhs, (ir.Primitive result) {
         irBuilder.buildDynamicSet(
             target,
             new Selector.setter(name),
             elements.getTypeMask(node),
             result,
             sourceInformationBuilder.buildAssignment(node));
       });
     }
     return node.isConditional
-        ? irBuilder.buildIfNotNullSend(target, nested(helper))
+        ? irBuilder.buildIfNotNullSend(
+            target, nested(helper), sourceInformationBuilder.buildIf(node))
         : helper();
   }
 
   @override
   ir.Primitive handleDynamicSetIfNulls(
       ast.Send node,
       ast.Node receiver,
       Name name,
       ast.Node rhs,
       _) {
     ir.Primitive target = translateReceiver(receiver);
     ir.Primitive helper() {
       return translateSetIfNull(node, () {
         return irBuilder.buildDynamicGet(
             target,
             new Selector.getter(name),
             elements.getGetterTypeMaskInComplexSendSet(node),
             sourceInformationBuilder.buildGet(node));
       }, rhs, (ir.Primitive result) {
         irBuilder.buildDynamicSet(
             target,
             new Selector.setter(name),
             elements.getTypeMask(node),
             result,
             sourceInformationBuilder.buildAssignment(node));
       });
     }
     return node.isConditional
-        ? irBuilder.buildIfNotNullSend(target, nested(helper))
+        ? irBuilder.buildIfNotNullSend(
+            target, nested(helper), sourceInformationBuilder.buildIf(node))
         : helper();
   }
 
   ir.Primitive buildLocalNoSuchSetter(
       LocalElement local,
       ir.Primitive value,
       SourceInformation sourceInformation) {
     Selector selector = new Selector.setter(
         new Name(local.name, local.library, isSetter: true));
     return irBuilder.buildStaticNoSuchMethod(
@@ skipping 1287 matching lines @@
     _backend.jsInteropAnalysis.hasAnonymousAnnotation(element.contextClass);
 
   String getJsInteropTargetPath(FunctionElement element) {
     return '${_backend.namer.fixedBackendPath(element)}.'
       '${_backend.getFixedBackendName(element)}';
   }
 
   DartType get jsJavascriptObjectType =>
     _backend.helpers.jsJavaScriptObjectClass.thisType;
 }