Use closure conversion in new dart2js backend.

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.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.
 
 // IrNodes are kept in a separate library to have precise control over their
 // dependencies on other parts of the system.
 library dart2js.ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values show ConstantValue;
 import '../dart2jslib.dart' as dart2js show invariant;
 import '../elements/elements.dart';
 import '../universe/universe.dart' show Selector, SelectorKind;
 import '../dart_types.dart' show DartType, GenericType;
 import '../cps_ir/optimizers.dart';
+import '../closure.dart' show ClosureClassElement;
 
 abstract class Node {
   /// A pointer to the parent node. Is null until set by optimization passes.
   Node parent;
 
   accept(Visitor visitor);
 }
 
 abstract class Expression extends Node {
   Expression plug(Expression expr) => throw 'impossible';
@@ skipping 26 matching lines @@
 
 /// An expression that cannot throw or diverge and has no side-effects.
 /// All primitives are named using the identity of the [Primitive] object.
 ///
 /// Primitives may allocate objects, this is not considered side-effect here.
 ///
 /// Although primitives may not mutate state, they may depend on state.
 abstract class Primitive extends Definition<Primitive> {
   /// The [VariableElement] or [ParameterElement] from which the primitive
   /// binding originated.
-  Element hint;
+  Entity hint;
 
   /// Register in which the variable binding this primitive can be allocated.
   /// Separate register spaces are used for primitives with different [element].
   /// Assigned by [RegisterAllocator], is null before that phase.
   int registerIndex;
 
   /// Use the given element as a hint for naming this primitive.
   ///
   /// Has no effect if this primitive already has a non-null [element].
-  void useElementAsHint(Element hint) {
+  void useElementAsHint(Entity hint) {
     if (this.hint == null) {
       this.hint = hint;
     }
   }
 }
 
 /// Operands to invocations and primitives are always variables.  They point to
 /// their definition and are doubly-linked into a list of occurrences.
 class Reference<T extends Definition<T>> {
   T definition;
@@ skipping 370 matching lines @@
 
   accept(Visitor visitor) => visitor.visitBranch(this);
 }
 
 /// Marker interface for nodes that are only handled in the JavaScript backend.
 ///
 /// These nodes are generated by the unsugar step and need special translation
 /// to the Tree IR, which is implemented in JsTreeBuilder.
 abstract class JsSpecificNode {}
 
+/// Directly assigns to a field on a given object.
+class SetField extends Expression implements InteriorNode, JsSpecificNode {
+  final Reference<Primitive> object;
+  Element field;
+  final Reference<Primitive> value;
+  Expression body;
+
+  SetField(Primitive object, this.field, Primitive value)
+      : this.object = new Reference<Primitive>(object),
+        this.value = new Reference<Primitive>(value);
+
+  Expression plug(Expression expr) {
+    assert(body == null);
+    return body = expr;
+  }
+
+  accept(Visitor visitor) => visitor.visitSetField(this);
+}
+
+/// Directly reads from a field on a given object.
+class GetField extends Primitive implements JsSpecificNode {
+  final Reference<Primitive> object;
+  Element field;
+
+  GetField(Primitive object, this.field)
+      : this.object = new Reference<Primitive>(object);
+
+  accept(Visitor visitor) => visitor.visitGetField(this);
+}
+
+/// Creates an object for holding boxed variables captured by a closure.
+class CreateBox extends Primitive implements JsSpecificNode {
+  accept(Visitor visitor) => visitor.visitCreateBox(this);
+}
+
+/// Instantiates a synthetic class created by closure conversion.
+class CreateClosureClass extends Primitive implements JsSpecificNode {
+  final ClosureClassElement classElement;
+
+  /// Values and boxes for locals captured by the closure.
+  /// The order corresponds to [ClosureClassElement.closureFields].
+  final List<Reference<Primitive>> arguments;
+
+  CreateClosureClass(this.classElement, List<Primitive> arguments)
+      : this.arguments = _referenceList(arguments);
+
+  accept(Visitor visitor) => visitor.visitCreateClosureClass(this);
+}
+
 class Identical extends Primitive implements JsSpecificNode {
   final Reference<Primitive> left;
   final Reference<Primitive> right;
   Identical(Primitive left, Primitive right)
       : left = new Reference<Primitive>(left),
         right = new Reference<Primitive>(right);
   accept(Visitor visitor) => visitor.visitIdentical(this);
 }
 
 class Interceptor extends Primitive implements JsSpecificNode {
@@ skipping 64 matching lines @@
 /// Create a non-recursive function.
 class CreateFunction extends Primitive {
   final FunctionDefinition definition;
 
   CreateFunction(this.definition);
 
   accept(Visitor visitor) => visitor.visitCreateFunction(this);
 }
 
 class Parameter extends Primitive {
-  Parameter(Element element) {
-    super.hint = element;
+  Parameter(Entity hint) {
+    super.hint = hint;
   }
 
   accept(Visitor visitor) => visitor.visitParameter(this);
 }
 
 /// Continuations are normally bound by 'let cont'.  A continuation with one
 /// parameter and no body is used to represent a function's return continuation.
 /// The return continuation is bound by the Function, not by 'let cont'.
 class Continuation extends Definition<Continuation> implements InteriorNode {
   final List<Parameter> parameters;
@@ skipping 191 matching lines @@
   T visitInvokeStatic(InvokeStatic node) => visitExpression(node);
   T visitInvokeContinuation(InvokeContinuation node) => visitExpression(node);
   T visitInvokeMethod(InvokeMethod node) => visitExpression(node);
   T visitInvokeSuperMethod(InvokeSuperMethod node) => visitExpression(node);
   T visitInvokeConstructor(InvokeConstructor node) => visitExpression(node);
   T visitConcatenateStrings(ConcatenateStrings node) => visitExpression(node);
   T visitBranch(Branch node) => visitExpression(node);
   T visitTypeOperator(TypeOperator node) => visitExpression(node);
   T visitSetClosureVariable(SetClosureVariable node) => visitExpression(node);
   T visitDeclareFunction(DeclareFunction node) => visitExpression(node);
+  T visitSetField(SetField node) => visitExpression(node);
 
   // Definitions.
   T visitLiteralList(LiteralList node) => visitPrimitive(node);
   T visitLiteralMap(LiteralMap node) => visitPrimitive(node);
   T visitConstant(Constant node) => visitPrimitive(node);
   T visitThis(This node) => visitPrimitive(node);
   T visitReifyTypeVar(ReifyTypeVar node) => visitPrimitive(node);
   T visitCreateFunction(CreateFunction node) => visitPrimitive(node);
   T visitGetClosureVariable(GetClosureVariable node) => visitPrimitive(node);
   T visitParameter(Parameter node) => visitPrimitive(node);
   T visitContinuation(Continuation node) => visitDefinition(node);
   T visitClosureVariable(ClosureVariable node) => visitDefinition(node);
+  T visitGetField(GetField node) => visitDefinition(node);
+  T visitCreateBox(CreateBox node) => visitDefinition(node);
+  T visitCreateClosureClass(CreateClosureClass node) => visitDefinition(node);
 
   // Conditions.
   T visitIsTrue(IsTrue node) => visitCondition(node);
 
   // JavaScript specific nodes.
   T visitIdentical(Identical node) => visitPrimitive(node);
   T visitInterceptor(Interceptor node) => visitPrimitive(node);
 }
 
 /// Recursively visits the entire CPS term, and calls abstract `process*`
@@ skipping 209 matching lines @@
     processIdentical(node);
     processReference(node.left);
     processReference(node.right);
   }
 
   processInterceptor(Interceptor node) {}
   visitInterceptor(Interceptor node) {
     processInterceptor(node);
     processReference(node.input);
   }
+
+  processCreateClosureClass(CreateClosureClass node) {}
+  visitCreateClosureClass(CreateClosureClass node) {
+    processCreateClosureClass(node);
+    node.arguments.forEach(processReference);
+  }
+
+  processSetField(SetField node) {}
+  visitSetField(SetField node) {
+    processSetField(node);
+    processReference(node.object);
+    processReference(node.value);
+    visit(node.body);
+  }
+
+  processGetField(GetField node) {}
+  visitGetField(GetField node) {
+    processGetField(node);
+    processReference(node.object);
+  }
+
+  processCreateBox(CreateBox node) {}
+  visitCreateBox(CreateBox node) {
+    processCreateBox(node);
+  }
 }
 
 /// Keeps track of currently unused register indices.
 class RegisterArray {
   int nextIndex = 0;
   final List<int> freeStack = <int>[];
 
   /// Returns an index that is currently unused.
   int makeIndex() {
     if (freeStack.isEmpty) {
       return nextIndex++;
     } else {
       return freeStack.removeLast();
     }
   }
 
   void releaseIndex(int index) {
     freeStack.add(index);
   }
 }
 
 /// Assigns indices to each primitive in the IR such that primitives that are
 /// live simultaneously never get assigned the same index.
 /// This information is used by the dart tree builder to generate fewer
 /// redundant variables.
 /// Currently, the liveness analysis is very simple and is often inadequate
 /// for removing all of the redundant variables.
 class RegisterAllocator extends Visitor {
   /// Separate register spaces for each source-level variable/parameter.
-  /// Note that null is used as key for primitives without elements.
-  final Map<Element, RegisterArray> elementRegisters =
-      <Element, RegisterArray>{};
+  /// Note that null is used as key for primitives without hints.
+  final Map<Local, RegisterArray> elementRegisters = <Local, RegisterArray>{};
 
-  RegisterArray getRegisterArray(Element element) {
-    RegisterArray registers = elementRegisters[element];
+  RegisterArray getRegisterArray(Local local) {
+    RegisterArray registers = elementRegisters[local];
     if (registers == null) {
       registers = new RegisterArray();
-      elementRegisters[element] = registers;
+      elementRegisters[local] = registers;
     }
     return registers;
   }
 
   void allocate(Primitive primitive) {
     if (primitive.registerIndex == null) {
       primitive.registerIndex = getRegisterArray(primitive.hint).makeIndex();
     }
   }
 
@@ skipping 147 matching lines @@
       release(node.parameters[i]);
     }
   }
 
   void visitIsTrue(IsTrue node) {
     visitReference(node.value);
   }
 
   // JavaScript specific nodes.
 
+  void visitSetField(SetField node) {
+    visit(node.body);
+    visitReference(node.value);
+    visitReference(node.object);
+  }
+
+  void visitGetField(GetField node) {
+    visitReference(node.object);
+  }
+
+  void visitCreateBox(CreateBox node) {
+  }
+
+  void visitCreateClosureClass(CreateClosureClass node) {
+    node.arguments.forEach(visitReference);
+  }
+
   void visitIdentical(Identical node) {
     visitReference(node.left);
     visitReference(node.right);
   }
 
   void visitInterceptor(Interceptor node) {
     visitReference(node.input);
   }
 }