Use closure conversion in new dart2js backend.

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;
 import '../elements/elements.dart';
 import '../universe/universe.dart';
 import '../universe/universe.dart' show Selector;
 import 'optimization/optimization.dart';
+import '../closure.dart' show ClosureClassElement;
 
 // The Tree language is the target of translation out of the CPS-based IR.
 //
 // The translation from CPS to Dart consists of several stages.  Among the
 // stages are translation to direct style, translation out of SSA, eliminating
 // unnecessary names, recognizing high-level control constructs.  Combining
 // these separate concerns is complicated and the constraints of the CPS-based
 // language do not permit a multi-stage translation.
 //
 // For that reason, CPS is translated to the direct-style language Tree.
@@ skipping 618 matching lines @@
                         Statement body,
                         this.initializers,
                         List<ConstDeclaration> localConstants,
                         List<ConstantExpression> defaultParameterValues)
       : super(element, parameters, body, localConstants,
               defaultParameterValues);
 
   applyPass(Pass pass) => pass.rewriteConstructorDefinition(this);
 }
 
+abstract class JsSpecificNode implements Node {}
+
+class CreateBox extends Expression implements JsSpecificNode {
+  accept(ExpressionVisitor visitor) => visitor.visitCreateBox(this);
+  accept1(ExpressionVisitor1 visitor, arg) => visitor.visitCreateBox(this, arg);
+}
+
+class CreateClosureClass extends Expression implements JsSpecificNode {
+  ClosureClassElement classElement;
+  List<Expression> arguments;
+
+  CreateClosureClass(this.classElement, this.arguments);
+
+  accept(ExpressionVisitor visitor) => visitor.visitCreateClosureClass(this);
+  accept1(ExpressionVisitor1 visitor, arg) {
+    return visitor.visitCreateClosureClass(this, arg);
+  }
+}
+
+class GetField extends Expression implements JsSpecificNode {
+  Expression object;
+  Element field;
+
+  GetField(this.object, this.field);
+
+  accept(ExpressionVisitor visitor) => visitor.visitGetField(this);
+  accept1(ExpressionVisitor1 visitor, arg) => visitor.visitGetField(this, arg);
+}
+
+class SetField extends Statement implements JsSpecificNode {
+  Expression object;
+  Element field;
+  Expression value;
+  Statement next;
+
+  SetField(this.object, this.field, this.value, this.next);
+
+  accept(StatementVisitor visitor) => visitor.visitSetField(this);
+  accept1(StatementVisitor1 visitor, arg) => visitor.visitSetField(this, arg);
+}
+
 abstract class ExpressionVisitor<E> {
   E visitExpression(Expression e) => e.accept(this);
   E visitVariable(Variable node);
   E visitInvokeStatic(InvokeStatic node);
   E visitInvokeMethod(InvokeMethod node);
   E visitInvokeSuperMethod(InvokeSuperMethod node);
   E visitInvokeConstructor(InvokeConstructor node);
   E visitConcatenateStrings(ConcatenateStrings node);
   E visitConstant(Constant node);
   E visitThis(This node);
   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);
   E visitFieldInitializer(FieldInitializer node);
   E visitSuperInitializer(SuperInitializer node);
+  E visitGetField(GetField node);
+  E visitCreateBox(CreateBox node);
+  E visitCreateClosureClass(CreateClosureClass 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);
   E visitFieldInitializer(FieldInitializer node, A arg);
   E visitSuperInitializer(SuperInitializer node, A arg);
+  E visitGetField(GetField node, A arg);
+  E visitCreateBox(CreateBox node, A arg);
+  E visitCreateClosureClass(CreateClosureClass 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);
+  S visitSetField(SetField 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);
+  S visitSetField(SetField 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> {
@@ skipping 114 matching lines @@
     visitStatement(node.next);
   }
 
   visitFieldInitializer(FieldInitializer node) {
     visitStatement(node.body);
   }
 
   visitSuperInitializer(SuperInitializer node) {
     node.arguments.forEach(visitStatement);
   }
+
+  visitGetField(GetField node) {
+    visitExpression(node.object);
+  }
+
+  visitSetField(SetField node) {
+    visitExpression(node.object);
+    visitExpression(node.value);
+    visitStatement(node.next);
+  }
+
+  visitCreateBox(CreateBox node) {
+  }
+
+  visitCreateClosureClass(CreateClosureClass node) {
+    node.arguments.forEach(visitExpression);
+  }
 }