Generated source mapping through CPS.

pkg/compiler/lib/src/tree_ir/tree_ir_nodes.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_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
@@ skipping 183 matching lines @@
  * A call to a method, operator, getter, setter or index getter/setter.
  *
  * If [receiver] is `null`, an error is thrown before the arguments are
  * evaluated. This corresponds to the JS evaluation order.
  */
 class InvokeMethod extends Expression implements Invoke {
   Expression receiver;
   final Selector selector;
   final TypeMask mask;
   final List<Expression> arguments;
+  final SourceInformation sourceInformation;
 
   /// If true, it is known that the receiver cannot be `null`.
   bool receiverIsNotNull = false;
 
-  InvokeMethod(this.receiver, this.selector, this.mask, this.arguments) {
+  InvokeMethod(this.receiver,
+               this.selector,
+               this.mask,
+               this.arguments,
+               this.sourceInformation) {
     assert(receiver != null);
   }
 
   accept(ExpressionVisitor visitor) => visitor.visitInvokeMethod(this);
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitInvokeMethod(this, arg);
   }
 }
 
 /// Invoke [target] on [receiver], bypassing ordinary dispatch semantics.
 ///
 /// Since the [receiver] is not used for method lookup, it may be `null`
 /// without an error being thrown.
 class InvokeMethodDirectly extends Expression implements Invoke {
   Expression receiver;
   final Element target;
   final Selector selector;
   final List<Expression> arguments;
+  final SourceInformation sourceInformation;
 
   InvokeMethodDirectly(this.receiver, this.target, this.selector,
-      this.arguments);
+      this.arguments, this.sourceInformation);
 
   accept(ExpressionVisitor visitor) => visitor.visitInvokeMethodDirectly(this);
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitInvokeMethodDirectly(this, arg);
   }
 }
 
 /**
  * Call to a factory or generative constructor.
  */
 class InvokeConstructor extends Expression implements Invoke {
   final DartType type;
   final FunctionElement target;
   final List<Expression> arguments;
   final Selector selector;
+  final SourceInformation sourceInformation;
   /// TODO(karlklose): get rid of this field.  Instead use the constant's
   /// expression to find the constructor to be called in dart2dart.
   final values.ConstantValue constant;
 
   InvokeConstructor(this.type, this.target, this.selector, this.arguments,
-                    [this.constant]);
+                    this.sourceInformation, [this.constant]);
 
   ClassElement get targetClass => target.enclosingElement;
 
   accept(ExpressionVisitor visitor) {
     return visitor.visitInvokeConstructor(this);
   }
 
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitInvokeConstructor(this, arg);
   }
 }
 
 /**
  * A constant.
  */
 class Constant extends Expression {
   final values.ConstantValue value;
+  final SourceInformation sourceInformation;
 
-  Constant(this.value);
+  Constant(this.value, {this.sourceInformation});
 
   Constant.bool(values.BoolConstantValue constantValue)
-      : value = constantValue;
+      : value = constantValue,
+        sourceInformation = null;
 
   accept(ExpressionVisitor visitor) => visitor.visitConstant(this);
   accept1(ExpressionVisitor1 visitor, arg) => visitor.visitConstant(this, arg);
+
+  String toString() => 'Constant(value=${value.toStructuredString()})';
 }
 
 class This extends Expression {
   accept(ExpressionVisitor visitor) => visitor.visitThis(this);
   accept1(ExpressionVisitor1 visitor, arg) => visitor.visitThis(this, arg);
 }
 
 class LiteralList extends Expression {
   final InterfaceType type;
   final List<Expression> values;
@@ skipping 71 matching lines @@
   Expression condition;
   Expression thenExpression;
   Expression elseExpression;
 
   Conditional(this.condition, this.thenExpression, this.elseExpression);
 
   accept(ExpressionVisitor visitor) => visitor.visitConditional(this);
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitConditional(this, arg);
   }
+
+  String toString() => 'Conditional(condition=$condition,thenExpression='
+                       '$thenExpression,elseExpression=$elseExpression)';
 }
 
 /// An && or || expression. The operator is internally represented as a boolean
 /// [isAnd] to simplify rewriting of logical operators.
 class LogicalOperator extends Expression {
   Expression left;
   bool isAnd;
   Expression right;
 
   LogicalOperator(this.left, this.right, this.isAnd);
   LogicalOperator.and(this.left, this.right) : isAnd = true;
   LogicalOperator.or(this.left, this.right) : isAnd = false;
 
   String get operator => isAnd ? '&&' : '||';
 
   accept(ExpressionVisitor visitor) => visitor.visitLogicalOperator(this);
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitLogicalOperator(this, arg);
   }
+
+  String toString() => 'LogicalOperator(left=$left,right=$right,isAnd=$isAnd)';
 }
 
 /// Logical negation.
 // TODO(asgerf): Replace this class with the IsFalsy builtin operator?
 //               Right now the tree builder compiles IsFalsy to Not.
 class Not extends Expression {
   Expression operand;
 
   Not(this.operand);
 
@@ skipping 138 matching lines @@
  *
  * In contrast to the CPS-based IR, the return value is an arbitrary
  * expression.
  */
 class Return extends Statement {
   /// Should not be null. Use [Constant] with [NullConstantValue] for void
   /// returns.
   /// Even in constructors this holds true. Take special care when translating
   /// back to dart, where `return null;` in a constructor is an error.
   Expression value;
+  SourceInformation sourceInformation;
 
   Statement get next => null;
   void set next(Statement s) => throw 'UNREACHABLE';
 
-  Return(this.value);
+  Return(this.value, {this.sourceInformation});
 
   accept(StatementVisitor visitor) => visitor.visitReturn(this);
   accept1(StatementVisitor1 visitor, arg) => visitor.visitReturn(this, arg);
 }
 
 /// A throw statement.
 ///
 /// In the Tree IR, throw is a statement (like JavaScript and unlike Dart).
 /// It does not have a successor statement.
 class Throw extends Statement {
@@ skipping 98 matching lines @@
 
 class CreateBox extends Expression {
   accept(ExpressionVisitor visitor) => visitor.visitCreateBox(this);
   accept1(ExpressionVisitor1 visitor, arg) => visitor.visitCreateBox(this, arg);
 }
 
 class CreateInstance extends Expression {
   ClassElement classElement;
   List<Expression> arguments;
   List<Expression> typeInformation;
+  SourceInformation sourceInformation;
 
-  CreateInstance(this.classElement, this.arguments, this.typeInformation);
+  CreateInstance(this.classElement, this.arguments,
+                 this.typeInformation, this.sourceInformation);
 
   accept(ExpressionVisitor visitor) => visitor.visitCreateInstance(this);
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitCreateInstance(this, arg);
   }
 }
 
 class GetField extends Expression {
   Expression object;
   Element field;
@@ skipping 63 matching lines @@
   Expression value;
 
   SetIndex(this.object, this.index, this.value);
 
   accept(ExpressionVisitor v) => v.visitSetIndex(this);
   accept1(ExpressionVisitor1 v, arg) => v.visitSetIndex(this, arg);
 }
 
 class ReifyRuntimeType extends Expression {
   Expression value;
+  SourceInformation sourceInformation;
 
-  ReifyRuntimeType(this.value);
+  ReifyRuntimeType(this.value, this.sourceInformation);
 
   accept(ExpressionVisitor visitor) {
     return visitor.visitReifyRuntimeType(this);
   }
 
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitReifyRuntimeType(this, arg);
   }
 }
 
 class ReadTypeVariable extends Expression {
   final TypeVariableType variable;
   Expression target;
+  final SourceInformation sourceInformation;
 
-  ReadTypeVariable(this.variable, this.target);
+  ReadTypeVariable(this.variable, this.target, this.sourceInformation);
 
   accept(ExpressionVisitor visitor) {
     return visitor.visitReadTypeVariable(this);
   }
 
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitReadTypeVariable(this, arg);
   }
 }
 
@@ skipping 652 matching lines @@
 
   /// Number of uses of the current fallthrough target.
   int get useCount => _stack.last.useCount;
 
   /// Indicate that a statement will fall through to the current fallthrough
   /// target.
   void use() {
     ++_stack.last.useCount;
   }
 }