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 '../elements/modelx.dart' show SynthesizedConstructorElementX,
+    ConstructorBodyElementX, FunctionSignatureX;
 import '../closure.dart';
 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
@@ skipping 174 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}) {
+  List<ir.Primitive> buildFunctionHeader(Iterable<ParameterElement> parameters,
+                                      {ClosureScope closureScope,

[floitsch, 2015/01/20 17:26:26]

indentation

+                                       ClosureEnvironment closureEnvironment}) {
     _enterClosureEnvironment(closureEnvironment);
     _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 226 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 1058 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) {

[floitsch, 2015/01/20 17:26:26]

indentation

+    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 44 matching lines @@
   ClosureEnvironment(this.selfReference, this.thisLocal, this.freeVariables);
 }
 
 /// Information about which variables are captured in a closure.
 ///
 /// This is used by the [DartIrBuilder] instead of [ClosureScope] and
 /// [ClosureEnvironment].
 abstract class ClosureVariableInfo {
   Iterable<Local> get capturedVariables;
 }