Implement constructor bodies and initializers in CPS->JS backend.

pkg/compiler/lib/src/cps_ir/cps_ir_builder.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.
 
 library dart2js.ir_builder;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_types.dart';
 import '../dart2jslib.dart';
 import '../elements/elements.dart';
 import '../io/source_file.dart';
 import '../tree/tree.dart' as ast;
 import '../scanner/scannerlib.dart' show Token, isUserDefinableOperator;
 import '../universe/universe.dart' show SelectorKind;
 import 'cps_ir_nodes.dart' as ir;
-import '../elements/modelx.dart' show SynthesizedConstructorElementX;
-import '../closure.dart';
+import '../elements/modelx.dart' show SynthesizedConstructorElementX,
+    ConstructorBodyElementX, FunctionSignatureX;
+import '../closure.dart' hide ClosureScope;
 import '../closure.dart' as closurelib;
 import '../js_backend/js_backend.dart' show JavaScriptBackend;
 
 part 'cps_ir_builder_visitor.dart';
 
 /// A mapping from variable elements to their compile-time values.
 ///
 /// Map elements denoted by parameters and local variables to the
 /// [ir.Primitive] that is their value.  Parameters and locals are
 /// assigned indexes which can be used to refer to them.
@@ skipping 173 matching lines @@
 
 /// A factory for building the cps IR.
 ///
 /// [DartIrBuilder] and [JsIrBuilder] implement nested functions and captured
 /// variables in different ways.
 abstract class IrBuilder {
   IrBuilder _makeInstance();
 
   void declareLocalVariable(LocalVariableElement element,
                             {ir.Primitive initialValue});
-  void declareLocalFunction(LocalFunctionElement element, Object function);
-  ir.Primitive buildFunctionExpression(Object function);
   ir.Primitive buildLocalGet(LocalElement element);
   ir.Primitive buildLocalSet(LocalElement element, ir.Primitive value);
 
   /// Called when entering a nested function with free variables.
   ///
   /// The free variables must subsequently be accessible using [buildLocalGet]
   /// and [buildLocalSet].
   void _enterClosureEnvironment(ClosureEnvironment env);
 
   /// Called when entering a function body or loop body.
@@ skipping 116 matching lines @@
         ..environment = new Environment.empty();
   }
 
   bool get isOpen => _root == null || _current != null;
 
 
   void buildFieldInitializerHeader({ClosureScope closureScope}) {
     _enterScope(closureScope);
   }
 
-  void buildFunctionHeader(Iterable<ParameterElement> parameters,
-                          {ClosureScope closureScope,
-                           ClosureEnvironment closureEnvironment}) {
-    _enterClosureEnvironment(closureEnvironment);
+  List<ir.Primitive> buildFunctionHeader(Iterable<ParameterElement> parameters,
+                                        {ClosureScope closureScope,
+                                         ClosureEnvironment env}) {
+    _enterClosureEnvironment(env);
     _enterScope(closureScope);
     parameters.forEach(_createFunctionParameter);
+    return _parameters;
   }
 
   /// Creates a parameter for [local] and adds it to the current environment.
   ir.Parameter createLocalParameter(Local local) {
     ir.Parameter parameter = new ir.Parameter(local);
     _parameters.add(parameter);
     environment.extend(local, parameter);
     return parameter;
   }
 
@@ skipping 27 matching lines @@
   }
 
   ir.Primitive _buildInvokeStatic(Element element,
                                   Selector selector,
                                   List<ir.Primitive> arguments) {
     assert(isOpen);
     return _continueWithExpression(
         (k) => new ir.InvokeStatic(element, selector, k, arguments));
   }
 
-  ir.Primitive _buildInvokeDirectly(Element target,
-                                    Selector selector,
-                                    List<ir.Primitive> arguments) {
+  ir.Primitive _buildInvokeSuper(Element target,
+                                 Selector selector,
+                                 List<ir.Primitive> arguments) {
     assert(isOpen);
     return _continueWithExpression(
         (k) => new ir.InvokeMethodDirectly(
             buildThis(), target, selector, k, arguments));
   }
 
   ir.Primitive _buildInvokeDynamic(ir.Primitive receiver,
                                    Selector selector,
                                    List<ir.Primitive> arguments) {
     assert(isOpen);
@@ skipping 227 matching lines @@
   /// argument are defined by [selector] and [value], respectively.
   void buildSuperSet(Element target, Selector selector, ir.Primitive value) {
     buildSuperInvocation(target, selector, [value]);
   }
 
   /// Create an index set invocation on the super class with the provided
   /// [index] and [value].
   ir.Primitive buildSuperIndexSet(Element target,
                                   ir.Primitive index,
                                   ir.Primitive value) {
-    _buildInvokeDirectly(target, new Selector.indexSet(),
+    _buildInvokeSuper(target, new Selector.indexSet(),
         <ir.Primitive>[index, value]);
     return value;
   }
 
   /// Create a dynamic invocation on [receiver] where the method name and
   /// argument structure are defined by [selector] and the argument values are
   /// defined by [arguments].
   ir.Primitive buildDynamicInvocation(ir.Primitive receiver,
                                       Selector selector,
                                       List<ir.Primitive> arguments) {
@@ skipping 866 matching lines @@
 /// Shared state between DartIrBuilders within the same method.
 class DartIrBuilderSharedState {
   /// Maps local variables to their corresponding [ClosureVariable] object.
   final Map<Local, ir.ClosureVariable> local2closure =
       <Local, ir.ClosureVariable>{};
 
   /// Maps functions to the list of closure variables declared in that function.
   final Map<ExecutableElement, List<ir.ClosureVariable>> function2closures =
       <ExecutableElement, List<ir.ClosureVariable>>{};
 
-  final ClosureVariableInfo closureVariables;
+  final DartCapturedVariableInfo closureVariables;
 
   /// Returns the closure variables declared in the given function.
   List<ir.ClosureVariable> getClosureList(ExecutableElement element) {
     return function2closures.putIfAbsent(element, () => <ir.ClosureVariable>[]);
   }
 
   /// Creates a closure variable for the given local.
   void makeClosureVariable(Local local) {
     ir.ClosureVariable variable =
         new ir.ClosureVariable(local.executableContext, local);
@@ skipping 17 matching lines @@
 /// Captured variables are translated to ref cells (see [ClosureVariable])
 /// using [GetClosureVariable] and [SetClosureVariable].
 class DartIrBuilder extends IrBuilder {
   final DartIrBuilderSharedState dartState;
 
   IrBuilder _makeInstance() => new DartIrBuilder._blank(dartState);
   DartIrBuilder._blank(this.dartState);
 
   DartIrBuilder(ConstantSystem constantSystem,
                 ExecutableElement currentElement,
-                ClosureVariableInfo  closureVariables)
+                DartCapturedVariableInfo  closureVariables)
       : dartState = new DartIrBuilderSharedState(closureVariables) {
     _init(constantSystem, currentElement);
   }
 
   /// True if [local] should currently be accessed from a [ClosureVariable].
   bool isInClosureVariable(Local local) {
     return dartState.local2closure.containsKey(local) &&
            !dartState.registerizedClosureVariables.contains(local);
   }
 
@@ skipping 138 matching lines @@
 
   ir.Primitive buildThis() {
     ir.Primitive thisPrim = new ir.This();
     add(new ir.LetPrim(thisPrim));
     return thisPrim;
   }
 
   ir.Primitive buildSuperInvocation(Element target,
                                     Selector selector,
                                     List<ir.Primitive> arguments) {
-    return _buildInvokeDirectly(target, selector, arguments);
+    return _buildInvokeSuper(target, selector, arguments);
   }
 
 }
 
 /// State shared between JsIrBuilders within the same function.
 ///
 /// Note that this is not shared between builders of nested functions.
 class JsIrBuilderSharedState {
   /// Maps boxed locals to their location. These locals are not part of
   /// the environment.
@@ skipping 101 matching lines @@
                             ClosureClassElement classElement) {
     ir.Primitive closure = buildFunctionExpression(classElement);
     declareLocalVariable(functionElement, initialValue: closure);
   }
 
   ir.Primitive buildFunctionExpression(ClosureClassElement classElement) {
     List<ir.Primitive> arguments = <ir.Primitive>[];
     for (ClosureFieldElement field in classElement.closureFields) {
       arguments.add(environment.lookup(field.local));
     }
-    ir.Primitive closure = new ir.CreateClosureClass(classElement, arguments);
+    ir.Primitive closure = new ir.CreateInstance(classElement, arguments);
     add(new ir.LetPrim(closure));
     return closure;
   }
 
   /// Create a read access of [local].
   ir.Primitive buildLocalGet(LocalElement local) {
     assert(isOpen);
     ClosureLocation location = jsState.boxedVariables[local];
     if (location != null) {
       ir.Primitive result = new ir.GetField(environment.lookup(location.box),
@@ skipping 82 matching lines @@
       if (selector.isGetter) {
         ir.Primitive get = new ir.GetField(buildThis(), target);
         add(new ir.LetPrim(get));
         return get;
       } else {
         assert(selector.isSetter);
         add(new ir.SetField(buildThis(), target, arguments.single));
         return arguments.single;
       }
     } else {
-      return _buildInvokeDirectly(target, selector, arguments);
+      return _buildInvokeSuper(target, selector, arguments);
+    }
+  }
+
+  ir.Primitive buildInvokeDirectly(FunctionElement target,
+                                   ir.Primitive receiver,
+                                   List<ir.Primitive> arguments) {
+    assert(isOpen);
+    Selector selector =
+        new Selector.call(target.name, target.library, arguments.length);
+    return _continueWithExpression(
+        (k) => new ir.InvokeMethodDirectly(
+            receiver, target, selector, k, arguments));
+  }
+
+  /// Loads parameters to a constructor body into the environment.
+  ///
+  /// The header for a constructor body differs from other functions in that
+  /// some parameters are already boxed, and the box is passed as an argument
+  /// instead of being created in the header.
+  void buildConstructorBodyHeader(Iterable<Local> parameters,
+                                  ClosureScope closureScope) {
+    for (Local param in parameters) {
+      ir.Parameter parameter = createLocalParameter(param);
+      state.functionParameters.add(parameter);
+    }
+    if (closureScope != null) {
+      jsState.boxedVariables.addAll(closureScope.capturedVariables);
     }
   }
 }
 
 
 /// Location of a variable relative to a given closure.
 class ClosureLocation {
   /// If not `null`, this location is [box].[field].
   /// The location of [box] can be obtained separately from an
   /// enclosing [ClosureEnvironment] or [ClosureScope].
@@ skipping 37 matching lines @@
   /// If non-null, [thisLocal] has an entry in [freeVariables] describing where
   /// to find the captured value of `this`.
   final ThisLocal thisLocal;
 
   /// Maps [LocalElement]s, [BoxLocal]s and [ThisLocal] to their location.
   final Map<Local, ClosureLocation> freeVariables;
 
   ClosureEnvironment(this.selfReference, this.thisLocal, this.freeVariables);
 }
 
-/// Information about which variables are captured in a closure.
+/// Information about which variables are captured by a nested function.
 ///
 /// This is used by the [DartIrBuilder] instead of [ClosureScope] and
 /// [ClosureEnvironment].
-abstract class ClosureVariableInfo {
+abstract class DartCapturedVariableInfo {
   Iterable<Local> get capturedVariables;
 }