Implement constructor bodies and initializers in CPS->JS 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;
@@ skipping 510 matching lines @@
       : 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;
+/// Creates an instance of a class and initializes its fields.
+class CreateInstance extends Primitive implements JsSpecificNode {
+  final ClassElement classElement;
 
-  /// Values and boxes for locals captured by the closure.
-  /// The order corresponds to [ClosureClassElement.closureFields].
+  /// Initial values for the fields on the class.
+  /// The order corresponds to the order of fields on the class.
   final List<Reference<Primitive>> arguments;
 
-  CreateClosureClass(this.classElement, List<Primitive> arguments)
+  CreateInstance(this.classElement, List<Primitive> arguments)
       : this.arguments = _referenceList(arguments);
 
-  accept(Visitor visitor) => visitor.visitCreateClosureClass(this);
+  accept(Visitor visitor) => visitor.visitCreateInstance(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);
 }
@@ skipping 296 matching lines @@
   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);
+  T visitCreateInstance(CreateInstance 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 211 matching lines @@
     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);
+  processCreateInstance(CreateInstance node) {}
+  visitCreateInstance(CreateInstance node) {
+    processCreateInstance(node);
     node.arguments.forEach(processReference);
   }
 
   processSetField(SetField node) {}
   visitSetField(SetField node) {
     processSetField(node);
     processReference(node.object);
     processReference(node.value);
     visit(node.body);
   }
@@ skipping 219 matching lines @@
     visitReference(node.object);
   }
 
   void visitGetField(GetField node) {
     visitReference(node.object);
   }
 
   void visitCreateBox(CreateBox node) {
   }
 
-  void visitCreateClosureClass(CreateClosureClass node) {
+  void visitCreateInstance(CreateInstance node) {
     node.arguments.forEach(visitReference);
   }
 
   void visitIdentical(Identical node) {
     visitReference(node.left);
     visitReference(node.right);
   }
 
   void visitInterceptor(Interceptor node) {
     visitReference(node.input);
   }
 }