Extract BuilderContext from ASTEmitter

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 '../cps_ir/cps_ir_nodes.dart' as cps_ir;
 import '../dart_types.dart' show DartType, GenericType;
@@ skipping 24 matching lines @@
  * The base class of all Tree nodes.
  */
 abstract class Node {
 }
 
 /**
  * The base class of [Expression]s.
  */
 abstract class Expression extends Node {
   accept(ExpressionVisitor v);
+  accept1(ExpressionVisitor1 v, arg);
 
   /// Temporary variable used by [StatementRewriter].
   /// If set to true, this expression has already had enclosing assignments
   /// propagated into its variables, and should not be processed again.
   /// It is only set for expressions that are known to be in risk of redundant
   /// processing.
   bool processed = false;
 }
 
 abstract class Statement extends Node {
   Statement get next;
   void set next(Statement s);
   accept(StatementVisitor v);
+  accept1(StatementVisitor1 v, arg);
 }
 
 /**
  * Labels name [LabeledStatement]s.
  */
 class Label {
   // A counter used to generate names.  The counter is reset to 0 for each
   // function emitted.
   static int counter = 0;
   static String _newName() => 'L${counter++}';
@@ skipping 31 matching lines @@
   /// - left-hand of an [Assign]
   /// - left-hand of a [FunctionDeclaration]
   /// - parameter in a [FunctionDefinition]
   int writeCount = 0;
 
   Variable(this.host, this.element) {
     assert(host != null);
   }
 
   accept(ExpressionVisitor visitor) => visitor.visitVariable(this);
+  accept1(ExpressionVisitor1 visitor, arg) => visitor.visitVariable(this, arg);
 }
 
 /**
  * Common interface for invocations with arguments.
  */
 abstract class Invoke {
   List<Expression> get arguments;
   Selector get selector;
 }
 
 /**
  * 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;
 
   InvokeStatic(this.target, this.selector, this.arguments);
 
   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.
  *
  * In contrast to the CPS-based IR, the receiver and arguments can be
  * arbitrary expressions.
  */
 class InvokeMethod extends Expression implements Invoke {
   Expression receiver;
   final Selector selector;
   final List<Expression> arguments;
 
   InvokeMethod(this.receiver, this.selector, this.arguments) {
     assert(receiver != null);
   }
 
   accept(ExpressionVisitor visitor) => visitor.visitInvokeMethod(this);
+  accept1(ExpressionVisitor1 visitor, arg) {
+    return visitor.visitInvokeMethod(this, arg);
+  }
 }
 
 class InvokeSuperMethod extends Expression implements Invoke {
   final Selector selector;
   final List<Expression> arguments;
 
   InvokeSuperMethod(this.selector, this.arguments);
 
   accept(ExpressionVisitor visitor) => visitor.visitInvokeSuperMethod(this);
+  accept1(ExpressionVisitor1 visitor, arg) {
+    return visitor.visitInvokeSuperMethod(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 values.ConstantValue constant;
 
   InvokeConstructor(this.type, this.target, this.selector, this.arguments,
       [this.constant]);
 
   ClassElement get targetClass => target.enclosingElement;
 
   accept(ExpressionVisitor visitor) => visitor.visitInvokeConstructor(this);
+  accept1(ExpressionVisitor1 visitor, arg) {
+    return visitor.visitInvokeConstructor(this, arg);
+  }
 }
 
 /// Calls [toString] on each argument and concatenates the results.
 class ConcatenateStrings extends Expression {
   final List<Expression> arguments;
   final values.ConstantValue constant;
 
   ConcatenateStrings(this.arguments, [this.constant]);
 
   accept(ExpressionVisitor visitor) => visitor.visitConcatenateStrings(this);
+  accept1(ExpressionVisitor1 visitor, arg) {
+    return visitor.visitConcatenateStrings(this, arg);
+  }
 }
 
 /**
  * A constant.
  */
 class Constant extends Expression {
   final ConstantExpression expression;
 
   Constant(this.expression);
 
   Constant.primitive(values.PrimitiveConstantValue primitiveValue)
       : expression = new PrimitiveConstantExpression(primitiveValue);
 
   accept(ExpressionVisitor visitor) => visitor.visitConstant(this);
+  accept1(ExpressionVisitor1 visitor, arg) => visitor.visitConstant(this, arg);
 
   values.ConstantValue get value => expression.value;
 }
 
 class This extends Expression {
   accept(ExpressionVisitor visitor) => visitor.visitThis(this);
+  accept1(ExpressionVisitor1 visitor, arg) => visitor.visitThis(this, arg);
 }
 
 class ReifyTypeVar extends Expression {
   TypeVariableElement typeVariable;
 
   ReifyTypeVar(this.typeVariable);
 
   accept(ExpressionVisitor visitor) => visitor.visitReifyTypeVar(this);
+  accept1(ExpressionVisitor1 visitor, arg) {
+    return visitor.visitReifyTypeVar(this, arg);
+  }
 }
 
 class LiteralList extends Expression {
   final GenericType type;
   final List<Expression> values;
 
   LiteralList(this.type, this.values);
 
   accept(ExpressionVisitor visitor) => visitor.visitLiteralList(this);
+  accept1(ExpressionVisitor1 visitor, arg) {
+    return visitor.visitLiteralList(this, arg);
+  }
 }
 
 class LiteralMapEntry {
   Expression key;
   Expression value;
 
   LiteralMapEntry(this.key, this.value);
 }
 
 class LiteralMap extends Expression {
   final GenericType type;
   final List<LiteralMapEntry> entries;
 
   LiteralMap(this.type, this.entries);
 
   accept(ExpressionVisitor visitor) => visitor.visitLiteralMap(this);
+  accept1(ExpressionVisitor1 visitor, arg) {
+    return visitor.visitLiteralMap(this, arg);
+  }
 }
 
 class TypeOperator extends Expression {
   Expression receiver;
   final DartType type;
   final bool isTypeTest;
 
   TypeOperator(this.receiver, this.type, {bool this.isTypeTest});
 
   accept(ExpressionVisitor visitor) => visitor.visitTypeOperator(this);
+  accept1(ExpressionVisitor1 visitor, arg) {
+    return visitor.visitTypeOperator(this, arg);
+  }
 
   String get operator => isTypeTest ? 'is' : 'as';
 }
 
 /// 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);
+  }
 }
 
 /// 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);
+  }
 }
 
 /// Logical negation.
 class Not extends Expression {
   Expression operand;
 
   Not(this.operand);
 
   accept(ExpressionVisitor visitor) => visitor.visitNot(this);
+  accept1(ExpressionVisitor1 visitor, arg) => visitor.visitNot(this, arg);
 }
 
 class FunctionExpression extends Expression {
   final FunctionDefinition definition;
 
   FunctionExpression(this.definition) {
     assert(definition.element.type.returnType.treatAsDynamic);
   }
 
   accept(ExpressionVisitor visitor) => visitor.visitFunctionExpression(this);
+  accept1(ExpressionVisitor1 visitor, arg) {
+    return visitor.visitFunctionExpression(this, arg);
+  }
 }
 
 /// Declares a local function.
 /// Used for functions that may not occur in expression context due to
 /// being recursive or having a return type.
 /// The [variable] must not occur as the left-hand side of an [Assign] or
 /// any other [FunctionDeclaration].
 class FunctionDeclaration extends Statement {
   Variable variable;
   final FunctionDefinition definition;
   Statement next;
 
   FunctionDeclaration(this.variable, this.definition, this.next) {
     ++variable.writeCount;
   }
 
   accept(StatementVisitor visitor) => visitor.visitFunctionDeclaration(this);
+  accept1(StatementVisitor1 visitor, arg) {
+    return visitor.visitFunctionDeclaration(this, arg);
+  }
 }
 
 /// A [LabeledStatement] or [WhileTrue] or [WhileCondition].
 abstract class JumpTarget extends Statement {
   Label get label;
   Statement get body;
 }
 
 /**
  * A labeled statement.  Breaks to the label within the labeled statement
  * target the successor statement.
  */
 class LabeledStatement extends JumpTarget {
   Statement next;
   final Label label;
   Statement body;
 
   LabeledStatement(this.label, this.body, this.next) {
     assert(label.binding == null);
     label.binding = this;
   }
 
   accept(StatementVisitor visitor) => visitor.visitLabeledStatement(this);
+  accept1(StatementVisitor1 visitor, arg) {
+    return visitor.visitLabeledStatement(this, arg);
+  }
 }
 
 /// A [WhileTrue] or [WhileCondition] loop.
 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);
     label.binding = this;
   }
 
   Statement get next => null;
   void set next(Statement s) => throw 'UNREACHABLE';
 
   accept(StatementVisitor visitor) => visitor.visitWhileTrue(this);
+  accept1(StatementVisitor1 visitor, arg) => visitor.visitWhileTrue(this, arg);
 }
 
 /**
  * A while loop with a condition. If the condition is false, control resumes
  * at the [next] statement.
  *
  * It is NOT valid to target this statement with a [Break].
  * The only way to reach [next] is for the condition to evaluate to false.
  *
  * [WhileCondition] statements are introduced in the [LoopRewriter] and is
  * assumed not to occur before then.
  */
 class WhileCondition extends Loop {
   final Label label;
   Expression condition;
   Statement body;
   Statement next;
 
   WhileCondition(this.label, this.condition, this.body,
                  this.next) {
     assert(label.binding == null);
     label.binding = this;
   }
 
   accept(StatementVisitor visitor) => visitor.visitWhileCondition(this);
+  accept1(StatementVisitor1 visitor, arg) {
+    return visitor.visitWhileCondition(this, arg);
+  }
 }
 
 /// A [Break] or [Continue] statement.
 abstract class Jump extends Statement {
   Label get target;
 }
 
 /**
  * A break from an enclosing [LabeledStatement].  The break targets the
  * labeled statement's successor statement.
  */
 class Break extends Jump {
   final Label target;
 
   Statement get next => null;
   void set next(Statement s) => throw 'UNREACHABLE';
 
   Break(this.target) {
     ++target.useCount;
   }
 
   accept(StatementVisitor visitor) => visitor.visitBreak(this);
+  accept1(StatementVisitor1 visitor, arg) => visitor.visitBreak(this, arg);
 }
 
 /**
  * A continue to an enclosing [WhileTrue] or [WhileCondition] loop.
  * The continue targets the loop's body.
  */
 class Continue extends Jump {
   final Label target;
 
   Statement get next => null;
   void set next(Statement s) => throw 'UNREACHABLE';
 
   Continue(this.target) {
     ++target.useCount;
   }
 
   accept(StatementVisitor visitor) => visitor.visitContinue(this);
+  accept1(StatementVisitor1 visitor, arg) => visitor.visitContinue(this, arg);
 }
 
 /**
  * An assignments of an [Expression] to a [Variable].
  *
  * In contrast to the CPS-based IR, non-primitive expressions can be assigned
  * to variables.
  */
 class Assign extends Statement {
   Statement next;
   Variable variable;
   Expression definition;
 
   /// If true, this declares a new copy of the closure variable.
   /// The consequences are similar to [cps_ir.SetClosureVariable].
   /// All uses of the variable must be nested inside the [next] statement.
   bool isDeclaration;
 
   Assign(this.variable, this.definition, this.next,
          { this.isDeclaration: false }) {
     variable.writeCount++;
   }
 
   bool get hasExactlyOneUse => variable.readCount == 1;
 
   accept(StatementVisitor visitor) => visitor.visitAssign(this);
+  accept1(StatementVisitor1 visitor, arg) => visitor.visitAssign(this, arg);
 }
 
 /**
  * A return exit from the function.
  *
  * 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.
   Expression value;
 
   Statement get next => null;
   void set next(Statement s) => throw 'UNREACHABLE';
 
   Return(this.value);
 
   accept(StatementVisitor visitor) => visitor.visitReturn(this);
+  accept1(StatementVisitor1 visitor, arg) => visitor.visitReturn(this, arg);
 }
 
 /**
  * A conditional branch based on the true value of an [Expression].
  */
 class If extends Statement {
   Expression condition;
   Statement thenStatement;
   Statement elseStatement;
 
   Statement get next => null;
   void set next(Statement s) => throw 'UNREACHABLE';
 
   If(this.condition, this.thenStatement, this.elseStatement);
 
   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);
 
   accept(StatementVisitor visitor) => visitor.visitExpressionStatement(this);
+  accept1(StatementVisitor1 visitor, arg) {
+    return visitor.visitExpressionStatement(this, arg);
+  }
 }
 
 abstract class ExecutableDefinition {
   ExecutableElement get element;
   Statement body;
 
   applyPass(Pass pass);
 }
 
 class FieldDefinition extends Node implements ExecutableDefinition {
@@ skipping 35 matching lines @@
   E visitReifyTypeVar(ReifyTypeVar node);
   E visitConditional(Conditional node);
   E visitLogicalOperator(LogicalOperator node);
   E visitNot(Not node);
   E visitLiteralList(LiteralList node);
   E visitLiteralMap(LiteralMap node);
   E visitTypeOperator(TypeOperator node);
   E visitFunctionExpression(FunctionExpression node);
 }
 
+abstract class ExpressionVisitor1<E, A> {
+  E visitExpression(Expression e, A arg) => e.accept1(this, arg);
+  E visitVariable(Variable node, A arg);
+  E visitInvokeStatic(InvokeStatic node, A arg);
+  E visitInvokeMethod(InvokeMethod node, A arg);
+  E visitInvokeSuperMethod(InvokeSuperMethod node, A arg);
+  E visitInvokeConstructor(InvokeConstructor node, A arg);
+  E visitConcatenateStrings(ConcatenateStrings node, A arg);
+  E visitConstant(Constant node, A arg);
+  E visitThis(This node, A arg);
+  E visitReifyTypeVar(ReifyTypeVar node, A arg);
+  E visitConditional(Conditional node, A arg);
+  E visitLogicalOperator(LogicalOperator node, A arg);
+  E visitNot(Not node, A arg);
+  E visitLiteralList(LiteralList node, A arg);
+  E visitLiteralMap(LiteralMap node, A arg);
+  E visitTypeOperator(TypeOperator node, A arg);
+  E visitFunctionExpression(FunctionExpression node, A arg);
+}
+
 abstract class StatementVisitor<S> {
   S visitStatement(Statement s) => s.accept(this);
   S visitLabeledStatement(LabeledStatement node);
   S visitAssign(Assign node);
   S visitReturn(Return node);
   S visitBreak(Break node);
   S visitContinue(Continue node);
   S visitIf(If node);
   S visitWhileTrue(WhileTrue node);
   S visitWhileCondition(WhileCondition node);
   S visitFunctionDeclaration(FunctionDeclaration node);
   S visitExpressionStatement(ExpressionStatement node);
 }
 
+abstract class StatementVisitor1<S, A> {
+  S visitStatement(Statement s, A arg) => s.accept1(this, arg);
+  S visitLabeledStatement(LabeledStatement node, A arg);
+  S visitAssign(Assign node, A arg);
+  S visitReturn(Return node, A arg);
+  S visitBreak(Break node, A arg);
+  S visitContinue(Continue node, A arg);
+  S visitIf(If node, A arg);
+  S visitWhileTrue(WhileTrue node, A arg);
+  S visitWhileCondition(WhileCondition node, A arg);
+  S visitFunctionDeclaration(FunctionDeclaration node, A arg);
+  S visitExpressionStatement(ExpressionStatement node, A arg);
+}
+
 abstract class Visitor<S, E> implements ExpressionVisitor<E>,
                                         StatementVisitor<S> {
    E visitExpression(Expression e) => e.accept(this);
    S visitStatement(Statement s) => s.accept(this);
 }
 
+abstract class Visitor1<S, E, A> implements ExpressionVisitor1<E, A>,
+                                            StatementVisitor1<S, A> {
+   E visitExpression(Expression e, A arg) => e.accept1(this, arg);
+   S visitStatement(Statement s, A arg) => s.accept1(this, arg);
+}
+
 class RecursiveVisitor extends Visitor {
   visitFunctionDefinition(FunctionDefinition node) {
     visitStatement(node.body);
   }
 
   visitVariable(Variable node) {}
 
   visitInvokeStatic(InvokeStatic node) {
     node.arguments.forEach(visitExpression);
   }
@@ skipping 93 matching lines @@
   visitFunctionDeclaration(FunctionDeclaration node) {
     visitFunctionDefinition(node.definition);
     visitStatement(node.next);
   }
 
   visitExpressionStatement(ExpressionStatement node) {
     visitExpression(node.expression);
     visitStatement(node.next);
   }
 }