dartfmt pkg/compiler

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/values.dart' as values;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
@@ skipping 132 matching lines @@
   Expression value;
   SourceInformation sourceInformation;
 
   Assign(this.variable, this.value, {this.sourceInformation}) {
     variable.writeCount++;
   }
 
   accept(ExpressionVisitor v) => v.visitAssign(this);
   accept1(ExpressionVisitor1 v, arg) => v.visitAssign(this, arg);
 
-  static ExpressionStatement makeStatement(Variable variable,
-                                           Expression value,
-                                           [Statement next]) {
+  static ExpressionStatement makeStatement(Variable variable, Expression value,
+      [Statement next]) {
     return new ExpressionStatement(new Assign(variable, value), next);
   }
 }
 
 /**
  * Common interface for invocations with arguments.
  */
 abstract class Invoke {
   List<Expression> get arguments;
 }
 
 /**
  * A call to a static function or getter/setter to a static field.
  *
  * In contrast to the CPS-based IR, the arguments can be arbitrary expressions.
  */
 class InvokeStatic extends Expression implements Invoke {
   final Entity target;
   final List<Expression> arguments;
   final Selector selector;
   final SourceInformation sourceInformation;
 
   InvokeStatic(this.target, this.selector, this.arguments,
-               [this.sourceInformation]);
+      [this.sourceInformation]);
 
   accept(ExpressionVisitor visitor) => visitor.visitInvokeStatic(this);
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitInvokeStatic(this, arg);
   }
 }
 
 /**
  * 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,
-               this.sourceInformation) {
+  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.
@@ skipping 20 matching lines @@
 
 /**
  * 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.sourceInformation, [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);
   }
 }
 
 /// Call a method using a one-shot interceptor.
 ///
 /// There is no explicit receiver, the first argument serves that purpose.
 class OneShotInterceptor extends Expression implements Invoke {
   final Selector selector;
   final TypeMask mask;
   final List<Expression> arguments;
   final SourceInformation sourceInformation;
 
-  OneShotInterceptor(this.selector,
-                     this.mask,
-                     this.arguments,
-                     this.sourceInformation);
+  OneShotInterceptor(
+      this.selector, this.mask, this.arguments, this.sourceInformation);
 
   accept(ExpressionVisitor visitor) => visitor.visitOneShotInterceptor(this);
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitOneShotInterceptor(this, arg);
   }
 }
 
 /**
  * A constant.
  */
@@ skipping 34 matching lines @@
 ///
 /// Note that if this is a type test, then [type] cannot be `Object`, `dynamic`,
 /// or the `Null` type. These cases are compiled to other node types.
 class TypeOperator extends Expression {
   Expression value;
   final DartType type;
   final List<Expression> typeArguments;
   final bool isTypeTest;
 
   TypeOperator(this.value, this.type, this.typeArguments,
-               {bool this.isTypeTest});
+      {bool this.isTypeTest});
 
   accept(ExpressionVisitor visitor) => visitor.visitTypeOperator(this);
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitTypeOperator(this, arg);
   }
 
   String get operator => isTypeTest ? 'is' : 'as';
 }
 
 /**
  * Apply a built-in operator.
  *
  * It must be known that the arguments have the proper types.
  * Null is not a valid argument to any of the built-in operators.
  */
 class ApplyBuiltinOperator extends Expression {
   BuiltinOperator operator;
   List<Expression> arguments;
   SourceInformation sourceInformation;
 
   ApplyBuiltinOperator(this.operator, this.arguments, this.sourceInformation);
 
   accept(ExpressionVisitor visitor) {
     return visitor.visitApplyBuiltinOperator(this);
   }
+
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitApplyBuiltinOperator(this, arg);
   }
 }
 
 class ApplyBuiltinMethod extends Expression {
   BuiltinMethod method;
   Expression receiver;
   List<Expression> arguments;
 
   bool receiverIsNotNull;
 
-  ApplyBuiltinMethod(this.method,
-                     this.receiver,
-                     this.arguments,
-                     {this.receiverIsNotNull: false});
+  ApplyBuiltinMethod(this.method, this.receiver, this.arguments,
+      {this.receiverIsNotNull: false});
 
   accept(ExpressionVisitor visitor) {
     return visitor.visitApplyBuiltinMethod(this);
   }
+
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitApplyBuiltinMethod(this, arg);
   }
 }
 
 /// A conditional expression.
 class Conditional extends Expression {
   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)';
+      '$thenExpression,elseExpression=$elseExpression)';
 }
 
 /// An && or || expression. The operator is internally represented as a boolean
 /// [isAnd] to simplify rewriting of logical operators.
 /// Note the the result of && and || is one of the arguments, which might not be
 /// boolean. 'ShortCircuitOperator' might have been a better name.
 class LogicalOperator extends Expression {
   Expression left;
   bool isAnd;
   Expression right;
@@ skipping 44 matching lines @@
     label.binding = this;
   }
 
   accept(StatementVisitor visitor) => visitor.visitLabeledStatement(this);
   accept1(StatementVisitor1 visitor, arg) {
     return visitor.visitLabeledStatement(this, arg);
   }
 }
 
 /// A [WhileTrue] or [For] loop.
-abstract class Loop extends JumpTarget {
-}
+abstract class Loop extends JumpTarget {}
 
 /**
  * A labeled while(true) loop.
  */
 class WhileTrue extends Loop {
   final Label label;
   Statement body;
 
   WhileTrue(this.label, this.body) {
     assert(label.binding == null);
@@ skipping 19 matching lines @@
  * [For] statements are introduced in the [LoopRewriter] and are
  * assumed not to occur before then.
  */
 class For extends Loop {
   final Label label;
   Expression condition;
   List<Expression> updates;
   Statement body;
   Statement next;
 
-  For(this.label,
-      this.condition,
-      this.updates,
-      this.body,
-      this.next) {
+  For(this.label, this.condition, this.updates, this.body, this.next) {
     assert(label.binding == null);
     label.binding = this;
   }
 
   accept(StatementVisitor visitor) => visitor.visitFor(this);
   accept1(StatementVisitor1 visitor, arg) {
     return visitor.visitFor(this, arg);
   }
 }
 
@@ skipping 82 matching lines @@
  */
 class If extends Statement {
   Expression condition;
   Statement thenStatement;
   Statement elseStatement;
   SourceInformation sourceInformation;
 
   Statement get next => null;
   void set next(Statement s) => throw 'UNREACHABLE';
 
-  If(this.condition,
-     this.thenStatement,
-     this.elseStatement,
-     this.sourceInformation);
+  If(this.condition, this.thenStatement, this.elseStatement,
+      this.sourceInformation);
 
   accept(StatementVisitor visitor) => visitor.visitIf(this);
   accept1(StatementVisitor1 visitor, arg) => visitor.visitIf(this, arg);
 }
 
 class ExpressionStatement extends Statement {
   Statement next;
   Expression expression;
 
   ExpressionStatement(this.expression, this.next);
@@ skipping 35 matching lines @@
   }
 }
 
 class FunctionDefinition extends Node {
   final ExecutableElement element;
   final List<Variable> parameters;
   final SourceInformation sourceInformation;
   Statement body;
 
   /// Creates a function definition and updates `writeCount` for [parameters].
-  FunctionDefinition(
-      this.element,
-      this.parameters,
-      this.body,
+  FunctionDefinition(this.element, this.parameters, this.body,
       {this.sourceInformation}) {
     for (Variable param in parameters) {
       param.writeCount++; // Being a parameter counts as a write.
     }
   }
 }
 
 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;
   Expression typeInformation;
   SourceInformation sourceInformation;
 
-  CreateInstance(this.classElement, this.arguments,
-                 this.typeInformation, this.sourceInformation);
+  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;
   bool objectIsNotNull;
   SourceInformation sourceInformation;
 
-  GetField(
-      this.object,
-      this.field,
-      this.sourceInformation,
+  GetField(this.object, this.field, this.sourceInformation,
       {this.objectIsNotNull: false});
 
   accept(ExpressionVisitor visitor) => visitor.visitGetField(this);
   accept1(ExpressionVisitor1 visitor, arg) => visitor.visitGetField(this, arg);
 }
 
 class SetField extends Expression {
   Expression object;
   Element field;
   Expression value;
   SourceInformation sourceInformation;
 
   /// If non-null, this is a compound assignment to the field, using the given
   /// operator.  The operator must be a compoundable operator.
   BuiltinOperator compound;
 
-  SetField(
-      this.object,
-      this.field,
-      this.value,
-      this.sourceInformation,
+  SetField(this.object, this.field, this.value, this.sourceInformation,
       {this.compound});
 
   accept(ExpressionVisitor visitor) => visitor.visitSetField(this);
   accept1(ExpressionVisitor1 visitor, arg) => visitor.visitSetField(this, arg);
 }
 
-
 /// Read the type test property from [object]. The value is truthy/fasly rather
 /// than bool. [object] must not be `null`.
 class GetTypeTestProperty extends Expression {
   Expression object;
   DartType dartType;
 
   GetTypeTestProperty(this.object, this.dartType);
 
-  accept(ExpressionVisitor visitor) =>
-      visitor.visitGetTypeTestProperty(this);
+  accept(ExpressionVisitor visitor) => visitor.visitGetTypeTestProperty(this);
   accept1(ExpressionVisitor1 visitor, arg) =>
       visitor.visitGetTypeTestProperty(this, arg);
 }
 
 /// Read the value of a field, possibly provoking its initializer to evaluate,
 /// or tear off a static method.
 class GetStatic extends Expression {
   Element element;
   SourceInformation sourceInformation;
   bool useLazyGetter = false;
@@ skipping 109 matching lines @@
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitInterceptor(this, arg);
   }
 }
 
 class ForeignCode extends Node {
   final js.Template codeTemplate;
   final types.TypeMask type;
   final List<Expression> arguments;
   final native.NativeBehavior nativeBehavior;
-  final List<bool> nullableArguments;  // One 'bit' per argument.
+  final List<bool> nullableArguments; // One 'bit' per argument.
   final Element dependency;
   final SourceInformation sourceInformation;
 
-  ForeignCode(
-      this.codeTemplate,
-      this.type,
-      this.arguments,
-      this.nativeBehavior,
-      this.nullableArguments,
-      this.dependency,
-      this.sourceInformation) {
+  ForeignCode(this.codeTemplate, this.type, this.arguments, this.nativeBehavior,
+      this.nullableArguments, this.dependency, this.sourceInformation) {
     assert(arguments.length == nullableArguments.length);
   }
 }
 
 class ForeignExpression extends ForeignCode implements Expression {
   ForeignExpression(
-      js.Template codeTemplate, types.TypeMask type,
-      List<Expression> arguments, native.NativeBehavior nativeBehavior,
+      js.Template codeTemplate,
+      types.TypeMask type,
+      List<Expression> arguments,
+      native.NativeBehavior nativeBehavior,
       List<bool> nullableArguments,
       Element dependency,
       SourceInformation sourceInformation)
       : super(codeTemplate, type, arguments, nativeBehavior, nullableArguments,
-          dependency, sourceInformation);
+            dependency, sourceInformation);
 
   accept(ExpressionVisitor visitor) {
     return visitor.visitForeignExpression(this);
   }
 
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitForeignExpression(this, arg);
   }
 }
 
 class ForeignStatement extends ForeignCode implements Statement {
   ForeignStatement(
-      js.Template codeTemplate, types.TypeMask type,
-      List<Expression> arguments, native.NativeBehavior nativeBehavior,
+      js.Template codeTemplate,
+      types.TypeMask type,
+      List<Expression> arguments,
+      native.NativeBehavior nativeBehavior,
       List<bool> nullableArguments,
       Element dependency,
       SourceInformation sourceInformation)
       : super(codeTemplate, type, arguments, nativeBehavior, nullableArguments,
-          dependency, sourceInformation);
+            dependency, sourceInformation);
 
   accept(StatementVisitor visitor) {
     return visitor.visitForeignStatement(this);
   }
 
   accept1(StatementVisitor1 visitor, arg) {
     return visitor.visitForeignStatement(this, arg);
   }
 
   @override
@@ skipping 54 matching lines @@
 
 class ReceiverCheck extends Statement {
   Expression condition;
   Expression value;
   Selector selector;
   bool useSelector;
   bool useInvoke;
   Statement next;
   SourceInformation sourceInformation;
 
-  ReceiverCheck({this.condition, this.value, this.selector, this.useSelector,
-      this.useInvoke, this.next, this.sourceInformation});
+  ReceiverCheck(
+      {this.condition,
+      this.value,
+      this.selector,
+      this.useSelector,
+      this.useInvoke,
+      this.next,
+      this.sourceInformation});
 
   accept(StatementVisitor visitor) {
     return visitor.visitReceiverCheck(this);
   }
 
   accept1(StatementVisitor1 visitor, arg) {
     return visitor.visitReceiverCheck(this, arg);
   }
 }
 
@@ skipping 224 matching lines @@
 
   visitGetField(GetField node) {
     visitExpression(node.object);
   }
 
   visitSetField(SetField node) {
     visitExpression(node.object);
     visitExpression(node.value);
   }
 
-  visitGetStatic(GetStatic node) {
-  }
+  visitGetStatic(GetStatic node) {}
 
   visitSetStatic(SetStatic node) {
     visitExpression(node.value);
   }
 
   visitGetTypeTestProperty(GetTypeTestProperty node) {
     visitExpression(node.object);
   }
 
-  visitCreateBox(CreateBox node) {
-  }
+  visitCreateBox(CreateBox node) {}
 
   visitCreateInstance(CreateInstance node) {
     node.arguments.forEach(visitExpression);
     if (node.typeInformation != null) visitExpression(node.typeInformation);
   }
 
   visitReifyRuntimeType(ReifyRuntimeType node) {
     visitExpression(node.value);
   }
 
   visitReadTypeVariable(ReadTypeVariable node) {
     visitExpression(node.target);
   }
 
   visitTypeExpression(TypeExpression node) {
     node.arguments.forEach(visitExpression);
   }
 
   visitCreateInvocationMirror(CreateInvocationMirror node) {
     node.arguments.forEach(visitExpression);
   }
 
-  visitUnreachable(Unreachable node) {
-  }
+  visitUnreachable(Unreachable node) {}
 
   visitApplyBuiltinOperator(ApplyBuiltinOperator node) {
     node.arguments.forEach(visitExpression);
   }
 
   visitApplyBuiltinMethod(ApplyBuiltinMethod node) {
     visitExpression(node.receiver);
     node.arguments.forEach(visitExpression);
   }
 
@@ skipping 32 matching lines @@
     visitStatement(node.next);
   }
 
   visitReceiverCheck(ReceiverCheck node) {
     if (node.condition != null) visitExpression(node.condition);
     visitExpression(node.value);
     visitStatement(node.next);
   }
 }
 
-abstract class Transformer implements ExpressionVisitor<Expression>,
-                                      StatementVisitor<Statement> {
-   Expression visitExpression(Expression e) => e.accept(this);
-   Statement visitStatement(Statement s) => s.accept(this);
+abstract class Transformer
+    implements ExpressionVisitor<Expression>, StatementVisitor<Statement> {
+  Expression visitExpression(Expression e) => e.accept(this);
+  Statement visitStatement(Statement s) => s.accept(this);
 }
 
 class RecursiveTransformer extends Transformer {
   void _replaceExpressions(List<Expression> list) {
     for (int i = 0; i < list.length; i++) {
       list[i] = visitExpression(list[i]);
     }
   }
 
   visitVariableUse(VariableUse node) => node;
@@ skipping 248 matching lines @@
 
 class FallthroughTarget {
   final Statement target;
   int useCount = 0;
 
   FallthroughTarget(this.target);
 }
 
 /// A stack machine for tracking fallthrough while traversing the Tree IR.
 class FallthroughStack {
-  final List<FallthroughTarget> _stack =
-    <FallthroughTarget>[new FallthroughTarget(null)];
+  final List<FallthroughTarget> _stack = <FallthroughTarget>[
+    new FallthroughTarget(null)
+  ];
 
   /// Set a new fallthrough target.
   void push(Statement newFallthrough) {
     _stack.add(new FallthroughTarget(newFallthrough));
   }
 
   /// Remove the current fallthrough target.
   void pop() {
     _stack.removeLast();
   }
 
   /// The current fallthrough target, or `null` if control will fall over
   /// the end of the method.
   Statement get target => _stack.last.target;
 
   /// 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;
   }
 }