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

pkg/compiler/lib/src/cps_ir/cps_ir_builder_visitor.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.
 
 part of dart2js.ir_builder;
 
 /**
  * This task iterates through all resolved elements and builds [ir.Node]s. The
  * nodes are stored in the [nodes] map and accessible through [hasIr] and
  * [getIr].
@@ skipping 24 matching lines @@
     return nodes[element.implementation];
   }
 
   ir.ExecutableDefinition buildNode(AstElement element) {
     if (!canBuild(element)) return null;
     TreeElements elementsMapping = element.resolvedAst.elements;
     element = element.implementation;
     return compiler.withCurrentElement(element, () {
       SourceFile sourceFile = elementSourceFile(element);
       IrBuilderVisitor builder =
-          new IrBuilderVisitor(elementsMapping, compiler, sourceFile);
+          compiler.backend is JavaScriptBackend
+          ? new JsIrBuilderVisitor(elementsMapping, compiler, sourceFile)
+          : new DartIrBuilderVisitor(elementsMapping, compiler, sourceFile);
       return builder.buildExecutable(element);
     });
   }
 
   void buildNodes() {
     measure(() {
       Set<Element> resolved = compiler.enqueuer.resolution.resolvedElements;
       resolved.forEach((AstElement element) {
         ir.ExecutableDefinition definition = buildNode(element);
         if (definition != null) {
@@ skipping 19 matching lines @@
     }
     return compiler.backend.shouldOutput(element);
   }
 
   bool get inCheckedMode {
     bool result = false;
     assert((result = true));
     return result;
   }
 
-  SourceFile elementSourceFile(Element element) {
-    if (element is FunctionElement) {
-      FunctionElement functionElement = element;
-      if (functionElement.patch != null) element = functionElement.patch;
-    }
-    return element.compilationUnit.script.file;
+}
+
+SourceFile elementSourceFile(Element element) {
+  if (element is FunctionElement) {
+    FunctionElement functionElement = element;
+    if (functionElement.patch != null) element = functionElement.patch;
   }
+  return element.compilationUnit.script.file;
 }
 
 class _GetterElements {
   ir.Primitive result;
   ir.Primitive index;
   ir.Primitive receiver;
 
   _GetterElements({this.result, this.index, this.receiver}) ;
 }
 
 /**
  * A tree visitor that builds [IrNodes]. The visit methods add statements using
  * to the [builder] and return the last added statement for trees that represent
  * an expression.
  */
-class IrBuilderVisitor extends ResolvedVisitor<ir.Primitive>
+abstract class IrBuilderVisitor extends ResolvedVisitor<ir.Primitive>
     with IrBuilderMixin<ast.Node> {
   final Compiler compiler;
   final SourceFile sourceFile;
-  ClosureClassMap closureMap;
 
   // In SSA terms, join-point continuation parameters are the phis and the
   // continuation invocation arguments are the corresponding phi inputs.  To
   // support name introduction and renaming for source level variables, we use
   // nested (delimited) visitors for constructing subparts of the IR that will
   // need renaming.  Each source variable is assigned an index.
   //
   // Each nested visitor maintains a list of free variable uses in the body.
   // These are implemented as a list of parameters, each with their own use
   // list of references.  When the delimited subexpression is plugged into the
   // surrounding context, the free occurrences can be captured or become free
   // occurrences in the next outer delimited subexpression.
   //
   // Each nested visitor maintains a list that maps indexes of variables
   // assigned in the delimited subexpression to their reaching definition ---
   // that is, the definition in effect at the hole in 'current'.  These are
   // used to determine if a join-point continuation needs to be passed
   // arguments, and what the arguments are.
 
   /// Construct a top-level visitor.
   IrBuilderVisitor(TreeElements elements, this.compiler, this.sourceFile)
       : super(elements);
 
-  /// True if using the JavaScript backend; we use this to determine how
-  /// closures should be translated.
-  bool get isJavaScriptBackend => compiler.backend is JavaScriptBackend;
-
   /**
    * Builds the [ir.ExecutableDefinition] for an executable element. In case the
    * function uses features that cannot be expressed in the IR, this element
    * returns `null`.
    */
-  ir.ExecutableDefinition buildExecutable(ExecutableElement element) {
-    return nullIfGiveup(() {
-      if (element is FieldElement) {
-        return buildField(element);
-      } else if (element is FunctionElement) {
-        return buildFunction(element);
-      } else {
-        compiler.internalError(element, "Unexpected element type $element");
-      }
-    });
-  }
+  ir.ExecutableDefinition buildExecutable(ExecutableElement element);
 
-  Map mapValues(Map map, dynamic fn(dynamic)) {
-    Map result = {};
-    map.forEach((key,value) {
-      result[key] = fn(value);
-    });
-    return result;
-  }
+  ClosureScope getClosureScope(ast.Node node);
+  ClosureEnvironment getClosureEnvironment();
 
-  // Converts closure.dart's CapturedVariable into a ClosureLocation.
-  // There is a 1:1 corresponce between these; we do this because the IR builder
-  // should not depend on synthetic elements.
-  ClosureLocation getLocation(CapturedVariable v) {
-    if (v is BoxFieldElement) {
-      return new ClosureLocation(v.box, v);
-    } else {
-      ClosureFieldElement field = v;
-      return new ClosureLocation(null, field);
-    }
-  }
 
-  /// If the current function is a nested function with free variables (or a
-  /// captured reference to `this`), this returns a [ClosureEnvironment]
-  /// indicating how to access these.
-  ClosureEnvironment getClosureEnvironment() {
-    if (closureMap == null) return null; // dart2dart does not use closureMap.
-    if (closureMap.closureElement == null) return null;
-    return new ClosureEnvironment(
-        closureMap.closureElement,
-        closureMap.thisLocal,
-        mapValues(closureMap.freeVariableMap, getLocation));
-  }
-
-  /// If [node] has declarations for variables that should be boxed, this
-  /// returns a [ClosureScope] naming a box to create, and enumerating the
-  /// variables that should be stored in the box.
-  ///
-  /// Also see [ClosureScope].
-  ClosureScope getClosureScope(ast.Node node) {
-    if (closureMap == null) return null; // dart2dart does not use closureMap.
-    closurelib.ClosureScope scope = closureMap.capturingScopes[node];
-    if (scope == null) return null;
-    // We translate a ClosureScope from closure.dart into IR builder's variant
-    // because the IR builder should not depend on the synthetic elements
-    // created in closure.dart.
-    return new ClosureScope(scope.boxElement,
-                            mapValues(scope.capturedVariables, getLocation),
-                            scope.boxedLoopVariables);
-  }
-
-  IrBuilder makeIRBuilder(ast.Node node, ExecutableElement element) {
-    if (isJavaScriptBackend) {
-      closureMap = compiler.closureToClassMapper.computeClosureToClassMapping(
-          element,
-          node,
-          elements);
-      return new JsIrBuilder(compiler.backend.constantSystem, element);
-    } else {
-      DetectClosureVariables closures = new DetectClosureVariables(elements);
-      if (!element.isSynthesized) {
-        closures.visit(node);
-      }
-      return new DartIrBuilder(compiler.backend.constantSystem,
-                               element,
-                               closures);
-    }
-  }
-
-  /// Returns a [ir.FieldDefinition] describing the initializer of [element].
-  ir.FieldDefinition buildField(FieldElement element) {
-    assert(invariant(element, element.isImplementation));
-    ast.VariableDefinitions definitions = element.node;
-    ast.Node fieldDefinition =
-        definitions.definitions.nodes.first;
-    if (definitions.modifiers.isConst) {
-      // TODO(sigurdm): Just return const value.
-    }
-    assert(fieldDefinition != null);
-    assert(elements[fieldDefinition] != null);
-
-    IrBuilder builder = makeIRBuilder(fieldDefinition, element);
-
-    return withBuilder(builder, () {
-      builder.buildFieldInitializerHeader(
-          closureScope: getClosureScope(fieldDefinition));
-      ir.Primitive initializer;
-      if (fieldDefinition is ast.SendSet) {
-        ast.SendSet sendSet = fieldDefinition;
-        initializer = visit(sendSet.arguments.first);
-      }
-      return builder.makeFieldDefinition(initializer);
-    });
-  }
 
   ir.FunctionDefinition _makeFunctionBody(FunctionElement element,
                                           ast.FunctionExpression node) {
     FunctionSignature signature = element.functionSignature;
     List<ParameterElement> parameters = [];
     signature.orderedForEachParameter(parameters.add);
 
     irBuilder.buildFunctionHeader(parameters,
                                   closureScope: getClosureScope(node),
-                                  closureEnvironment: getClosureEnvironment());
+                                  env: getClosureEnvironment());
 
     List<ConstantExpression> defaults = new List<ConstantExpression>();
     signature.orderedOptionalParameters.forEach((ParameterElement element) {
       defaults.add(getConstantForVariable(element));
     });
 
     List<ir.Initializer> initializers;
     if (element.isSynthesized) {
       assert(element is ConstructorElement);
       return irBuilder.makeConstructorDefinition(const <ConstantExpression>[],
@@ skipping 77 matching lines @@
               "No default constructor available.");
         }
         result.add(irBuilder.makeSuperInitializer(target,
                                                   <ir.RunnableBody>[],
                                                   selector));
       }
     }
     return result;
   }
 
-  ir.FunctionDefinition buildFunction(FunctionElement element) {
-    assert(invariant(element, element.isImplementation));
-    ast.FunctionExpression node = element.node;
-
-    Iterable<Entity> usedFromClosure;
-    if (!element.isSynthesized) {
-      assert(node != null);
-      assert(elements[node] != null);
-    } else {
-      SynthesizedConstructorElementX constructor = element;
-      if (!constructor.isDefaultConstructor) {
-        giveup(null, 'cannot handle synthetic forwarding constructors');
-      }
-
-      usedFromClosure = <Entity>[];
-    }
-
-    IrBuilder builder = makeIRBuilder(node, element);
-
-    return withBuilder(builder, () => _makeFunctionBody(element, node));
-  }
-
   ir.Primitive visit(ast.Node node) => node.accept(this);
 
   // ==== Statements ====
   visitBlock(ast.Block node) {
     irBuilder.buildBlock(node.statements.nodes, build);
   }
 
   ir.Primitive visitBreakStatement(ast.BreakStatement node) {
     if (!irBuilder.buildBreak(elements.getTargetOf(node))) {
       compiler.internalError(node, "'break' target not found");
@@ skipping 624 matching lines @@
   }
 
   ir.Primitive translateConstant(ast.Node node, [ConstantExpression constant]) {
     assert(irBuilder.isOpen);
     if (constant == null) {
       constant = getConstantForNode(node);
     }
     return irBuilder.buildConstantLiteral(constant);
   }
 
-  /// Returns the backend-specific representation of an inner function.
-  Object makeSubFunction(ast.FunctionExpression node) {
-    if (isJavaScriptBackend) {
-      ClosureClassMap innerMap =
-          compiler.closureToClassMapper.getMappingForNestedFunction(node);
-      ClosureClassElement closureClass = innerMap.closureClassElement;
-      return closureClass;
-    } else {
-      FunctionElement element = elements[node];
-      assert(invariant(element, element.isImplementation));
-
-      IrBuilder builder = irBuilder.makeInnerFunctionBuilder(element);
-
-      return withBuilder(builder, () => _makeFunctionBody(element, node));
-    }
-  }
-
-  ir.Primitive visitFunctionExpression(ast.FunctionExpression node) {
-    return irBuilder.buildFunctionExpression(makeSubFunction(node));
-  }
-
-  visitFunctionDeclaration(ast.FunctionDeclaration node) {
-    LocalFunctionElement element = elements[node.function];
-    Object inner = makeSubFunction(node.function);
-    irBuilder.declareLocalFunction(element, inner);
-  }
-
   ir.ExecutableDefinition nullIfGiveup(ir.ExecutableDefinition action()) {
     try {
       return action();
     } catch(e, tr) {
       if (e == ABORT_IRNODE_BUILDER) {
         return null;
       }
       rethrow;
     }
   }
@@ skipping 93 matching lines @@
     currentFunction = elements[node];
     if (node.initializers != null) {
       insideInitializer = true;
       visit(node.initializers);
       insideInitializer = false;
     }
     visit(node.body);
     currentFunction = oldFunction;
   }
 }
+
+/// IR builder specific to the Dart backend, coupled to the [DartIrBuilder].
+class DartIrBuilderVisitor extends IrBuilderVisitor {
+  /// Promote the type of [irBuilder] to [DartIrBuilder].
+  DartIrBuilder get irBuilder => super.irBuilder;
+
+  DartIrBuilderVisitor(TreeElements elements,
+                   Compiler compiler,
+                   SourceFile sourceFile)
+      : super(elements, compiler, sourceFile);
+
+  DartIrBuilder makeIRBuilder(ast.Node node, ExecutableElement element) {
+    DetectClosureVariables closures = new DetectClosureVariables(elements);

[floitsch, 2015/01/21 16:29:34]

This does not sound like a class name.
Is this a ClosureVariableDetector?

[asgerf, 2015/01/22 10:18:58]

I don't really buy into the "classes are nouns, methods are verbs" way of naming
things, but this does seems to be the trend here.

This is just code that got moved here because of the separation into Dart- and
JS-specific visitors, but I'll just do the rename here so we're done with it.

I've changed it to DartCapturedVariables to indicate that it is specific to the
Dart backend, and got rid of the misleading use of the word "closure".

+    if (!element.isSynthesized) {
+      closures.visit(node);
+    }
+    return new DartIrBuilder(compiler.backend.constantSystem,
+                             element,
+                             closures);
+  }
+
+  /// Recursively builds the IR for the given nested function.
+  ir.FunctionDefinition makeSubFunction(ast.FunctionExpression node) {
+    FunctionElement element = elements[node];
+    assert(invariant(element, element.isImplementation));
+
+    IrBuilder builder = irBuilder.makeInnerFunctionBuilder(element);
+
+    return withBuilder(builder, () => _makeFunctionBody(element, node));
+  }
+
+  ir.Primitive visitFunctionExpression(ast.FunctionExpression node) {
+    return irBuilder.buildFunctionExpression(makeSubFunction(node));
+  }
+
+  visitFunctionDeclaration(ast.FunctionDeclaration node) {
+    LocalFunctionElement element = elements[node.function];
+    Object inner = makeSubFunction(node.function);
+    irBuilder.declareLocalFunction(element, inner);
+  }
+
+  ClosureScope getClosureScope(ast.Node node) => null;
+  ClosureEnvironment getClosureEnvironment() => null;
+
+  ir.ExecutableDefinition buildExecutable(ExecutableElement element) {
+    return nullIfGiveup(() {
+      if (element is FieldElement) {
+        return buildField(element);
+      } else if (element is FunctionElement) {
+        return buildFunction(element);
+      } else {
+        compiler.internalError(element, "Unexpected element type $element");
+      }
+    });
+  }
+
+  /// Returns a [ir.FieldDefinition] describing the initializer of [element].
+  ir.FieldDefinition buildField(FieldElement element) {
+    assert(invariant(element, element.isImplementation));
+    ast.VariableDefinitions definitions = element.node;
+    ast.Node fieldDefinition = definitions.definitions.nodes.first;
+    if (definitions.modifiers.isConst) {
+      // TODO(sigurdm): Just return const value.
+    }
+    assert(fieldDefinition != null);
+    assert(elements[fieldDefinition] != null);
+
+    IrBuilder builder = makeIRBuilder(fieldDefinition, element);
+
+    return withBuilder(builder, () {
+      builder.buildFieldInitializerHeader(
+          closureScope: getClosureScope(fieldDefinition));
+      ir.Primitive initializer;
+      if (fieldDefinition is ast.SendSet) {
+        ast.SendSet sendSet = fieldDefinition;
+        initializer = visit(sendSet.arguments.first);
+      }
+      return builder.makeFieldDefinition(initializer);
+    });
+  }
+
+  ir.FunctionDefinition buildFunction(FunctionElement element) {
+    assert(invariant(element, element.isImplementation));
+    ast.FunctionExpression node = element.node;
+
+    if (!element.isSynthesized) {
+      assert(node != null);
+      assert(elements[node] != null);
+    } else {
+      SynthesizedConstructorElementX constructor = element;
+      if (!constructor.isDefaultConstructor) {
+        giveup(null, 'cannot handle synthetic forwarding constructors');
+      }
+    }
+
+    IrBuilder builder = makeIRBuilder(node, element);
+
+    return withBuilder(builder, () => _makeFunctionBody(element, node));
+  }
+}
+
+/// IR builder specific to the JavaScript backend, coupled to the [JsIrBuilder].
+class JsIrBuilderVisitor extends IrBuilderVisitor {
+  /// Promote the type of [irBuilder] to [JsIrBuilder].
+  JsIrBuilder get irBuilder => super.irBuilder;
+  ClosureClassMap closureMap;
+
+  /// During construction of a constructor factory, [fieldValues] maps fields
+  /// to the primitive containing their initial value.
+  Map<FieldElement, ir.Primitive> fieldValues = <FieldElement, ir.Primitive>{};
+
+  JsIrBuilderVisitor(TreeElements elements,
+                   Compiler compiler,

[floitsch, 2015/01/21 16:29:35]

indentation.

[asgerf, 2015/01/22 10:18:57]

Done.

+                   SourceFile sourceFile)
+      : super(elements, compiler, sourceFile);
+
+  JsIrBuilder makeIRBuilder(ast.Node node, ExecutableElement element) {
+    closureMap = compiler.closureToClassMapper.computeClosureToClassMapping(

[floitsch, 2015/01/21 16:29:35]

This requires comments, and potentially a refactoring.

If I understand correctly `makeIRBuilder` is only called from the super-class,
when the irBuilder is set.
However, the way it's currently done is brittle.
What about making "withFreshBuilder" an abstract class? Then irBuilder should be
set by the sub class, and it makes sense to set an independent local.

In short: setting the closureMap variable has nothing to do with creating a new
builder, and seems to happen under the assumption that the new builder is used
immediately. We should not just depend on the assumption.

[asgerf, 2015/01/22 10:18:57]

It's a leftover from before the separate subclasses were made. closureMap is
supposed to be initialized before entering a body of code.

The method is only called once; from the subclass. It does not implement any
abstract method. I've inlined this one to clarify things a bit.

I understand the initial confusion, but it should be better now, and I don't
think there is need for more scaffolding code to manage this one field.

+        element,
+        node,
+        elements);
+    return new JsIrBuilder(compiler.backend.constantSystem, element);
+  }
+
+  /// Builds the IR for creating an instance of the closure class corresponding
+  /// to the given nested function.
+  ClosureClassElement makeSubFunction(ast.FunctionExpression node) {
+    ClosureClassMap innerMap =
+        compiler.closureToClassMapper.getMappingForNestedFunction(node);
+    ClosureClassElement closureClass = innerMap.closureClassElement;
+    return closureClass;
+  }
+
+  ir.Primitive visitFunctionExpression(ast.FunctionExpression node) {
+    return irBuilder.buildFunctionExpression(makeSubFunction(node));
+  }
+
+  visitFunctionDeclaration(ast.FunctionDeclaration node) {
+    LocalFunctionElement element = elements[node.function];
+    Object inner = makeSubFunction(node.function);
+    irBuilder.declareLocalFunction(element, inner);
+  }
+
+  Map mapValues(Map map, dynamic fn(dynamic)) {
+    Map result = {};
+    map.forEach((key,value) {

[floitsch, 2015/01/21 16:29:34]

space after ','

[asgerf, 2015/01/22 10:18:58]

Done.

+      result[key] = fn(value);
+    });
+    return result;
+  }
+
+  /// Converts closure.dart's CapturedVariable into a ClosureLocation.
+  /// There is a 1:1 corresponce between these; we do this because the
+  /// IR builder should not depend on synthetic elements.
+  ClosureLocation getLocation(CapturedVariable v) {
+    if (v is BoxFieldElement) {
+      return new ClosureLocation(v.box, v);
+    } else {
+      ClosureFieldElement field = v;
+      return new ClosureLocation(null, field);
+    }
+  }
+
+  /// If the current function is a nested function with free variables (or a
+  /// captured reference to `this`), this returns a [ClosureEnvironment]

[floitsch, 2015/01/21 16:29:34]

-this-

[asgerf, 2015/01/22 10:18:58]

Done.

+  /// indicating how to access these.
+  ClosureEnvironment getClosureEnvironment() {
+    if (closureMap.closureElement == null) return null;
+    return new ClosureEnvironment(
+        closureMap.closureElement,
+        closureMap.thisLocal,
+        mapValues(closureMap.freeVariableMap, getLocation));
+  }
+
+  /// If [node] has declarations for variables that should be boxed, this

[floitsch, 2015/01/21 16:29:35]

-this-

[asgerf, 2015/01/22 10:18:58]

Done.

+  /// returns a [ClosureScope] naming a box to create, and enumerating the
+  /// variables that should be stored in the box.
+  ///
+  /// Also see [ClosureScope].
+  ClosureScope getClosureScope(ast.Node node) {
+    closurelib.ClosureScope scope = closureMap.capturingScopes[node];

[floitsch, 2015/01/21 16:29:34]

This is weird: there is an import without the prefix.
It feels like ClosureScope should at least give you a warning (but maybe
shadowing from within a library doesn't need one).

If the import without the prefix stays (which I'm ok with), it should have a
"hide ClosureScope" clause.

[asgerf, 2015/01/22 10:18:57]

Done.

+    if (scope == null) return null;
+    // We translate a ClosureScope from closure.dart into IR builder's variant
+    // because the IR builder should not depend on the synthetic elements
+    // created in closure.dart.
+    return new ClosureScope(scope.boxElement,
+                            mapValues(scope.capturedVariables, getLocation),
+                            scope.boxedLoopVariables);
+  }
+
+  /// Returns the [ClosureScope] for any function, possibly different from the
+  /// one currently being built.
+  ClosureScope getFunctionScope(FunctionElement function) {

[floitsch, 2015/01/21 16:29:35]

Naming feels weird.

I would have a tendency to call the nested functions "closure" and the outer one
less.

maybe?
getClosureScopeForNode
getClosureScopeForFunction

[asgerf, 2015/01/22 10:18:58]

Yes the naming wasn't that great. Changed to the names you suggested.

+    ClosureClassMap map =
+        compiler.closureToClassMapper.computeClosureToClassMapping(
+            function,
+            function.node,
+            elements);
+    closurelib.ClosureScope scope = map.capturingScopes[function.node];
+    if (scope == null) return null;
+    return new ClosureScope(scope.boxElement,
+                            mapValues(scope.capturedVariables, getLocation),
+                            scope.boxedLoopVariables);
+  }
+
+  ir.ExecutableDefinition buildExecutable(ExecutableElement element) {
+    return nullIfGiveup(() {
+      switch (element.kind) {
+        case ElementKind.GENERATIVE_CONSTRUCTOR:
+          return buildConstructor(element);
+
+        case ElementKind.GENERATIVE_CONSTRUCTOR_BODY:
+          return buildConstructorBody(element);
+
+        case ElementKind.FUNCTION:
+        case ElementKind.GETTER:
+        case ElementKind.SETTER:
+          return buildFunction(element);
+
+        default:
+          compiler.internalError(element, "Unexpected element type $element");
+      }
+    });
+  }
+
+  /// Builds the IR for an [expression] taken from a different [context].
+  ///
+  /// Such expressions need to be compiled with a different [sourceFile] and
+  /// [elements] mapping.
+  ir.Primitive inlineExpression(AstElement context, ast.Expression expression) {
+    JsIrBuilderVisitor visitor = new JsIrBuilderVisitor(
+        context.resolvedAst.elements,
+        compiler,
+        elementSourceFile(context));
+    return visitor.withBuilder(irBuilder, () => visitor.visit(expression));
+  }
+
+  /// Builds the IR for a given constructor. The performs the following tasks:

[floitsch, 2015/01/21 16:29:35]

Remove the part after the "."

(It's pretty clear that the enumerated list is what it does).

[asgerf, 2015/01/22 10:18:57]

Done.

+  ///
+  /// 1. Evaluate all own or inherited field initializers.

[floitsch, 2015/01/21 16:29:35]

Evaluates

[asgerf, 2015/01/22 10:18:58]

Done.

+  /// 2. Create the object and assign its fields.

[floitsch, 2015/01/21 16:29:34]

Creates  ... assigns

[asgerf, 2015/01/22 10:18:58]

Done.

+  /// 3. Call constructor body and super constructor bodies.

[floitsch, 2015/01/21 16:29:35]

Calls

[asgerf, 2015/01/22 10:18:57]

Done.

+  /// 4. Return the created object.

[floitsch, 2015/01/21 16:29:35]

Returns

[asgerf, 2015/01/22 10:18:57]

Done.

+  ir.FunctionDefinition buildConstructor(ConstructorElement constructor) {
+    constructor = constructor.implementation;
+    ClassElement classElement = constructor.enclosingClass.implementation;
+
+    JsIrBuilder builder =
+        new JsIrBuilder(compiler.backend.constantSystem, constructor);
+
+    return withBuilder(builder, () {
+      // Setup parameters and create a box if anything is captured.
+      List<ParameterElement> parameters = [];
+      constructor.functionSignature.orderedForEachParameter(parameters.add);
+      builder.buildFunctionHeader(parameters,
+          closureScope: getFunctionScope(constructor));
+
+      // -- Step 1: evaluate field initializers ---
+      // Evaluate field initializers in constructor and super constructors.
+      List<ConstructorElement> constructorList = <ConstructorElement>[];
+      evaluateConstructorFieldInitializers(constructor, constructorList);
+
+      // All parameters in all constructors are now bound in the environment.
+      // BoxLocals for captured parameters are also in the environment.
+      // The initial value of all fields are now bound in [fieldValues].
+
+      // --- Step 2: create the object ---
+      // Get the initial field values in the canonical order.
+      List<ir.Primitive> instanceArguments = <ir.Primitive>[];
+      classElement.forEachInstanceField((ClassElement _, FieldElement field) {
+        ir.Primitive value = fieldValues[field];
+        if (value != null) {
+          instanceArguments.add(fieldValues[field]);
+        } else {
+          // Native fields are initialized elsewhere.

[floitsch, 2015/01/21 16:29:34]

can we assert that the field comes from a native class?
assert(Elements.isNativeOrExtendsNative(field.enclosingElement)) ?

[asgerf, 2015/01/22 10:18:57]

Done.

+        }
+      }, includeSuperAndInjectedMembers: true);
+      ir.Primitive instance =
+          new ir.CreateInstance(classElement, instanceArguments);
+      irBuilder.add(new ir.LetPrim(instance));
+
+      // --- Step 3: call constructor bodies ---
+      for (ConstructorElement target in constructorList) {
+        ConstructorBodyElement bodyElement = getConstructorBody(target);
+        if (bodyElement == null) continue;

[floitsch, 2015/01/21 16:29:34]

Comment when this can happen.

I'm guessing when the constructor does not have any body?
(E.g. `A(this.x);`)

[asgerf, 2015/01/22 10:18:58]

Done.

+        List<ir.Primitive> bodyArguments = <ir.Primitive>[];
+        for (Local param in getConstructorBodyParameters(bodyElement)) {
+          bodyArguments.add(irBuilder.environment.lookup(param));
+        }
+        irBuilder.buildInvokeDirectly(bodyElement, instance, bodyArguments);
+      }
+
+      // --- step 4: return the created object ----
+      irBuilder.buildReturn(instance);
+
+      return irBuilder.makeFunctionDefinition([]);
+    });
+  }
+
+  /// Evaluates all field initializers on [constructor] and all constructors
+  /// invoked through `this()` or `super()` ("superconstructors").
+  ///
+  /// The resulting field values will be available in [fieldValues]. The values
+  /// are not stored in any fields.
+  ///
+  /// This procedure assumes that the parameters to [constructor] are available
+  /// in the IR builder's environment.
+  ///
+  /// The parameters to superconstructors are, however, assumed NOT to be in

[floitsch, 2015/01/21 16:29:35]

*not*

[asgerf, 2015/01/22 10:18:58]

Done.

+  /// the environment, but will be put there by this procedure.
+  ///
+  /// All constructors will be added to [supers], with superconstructors first.
+  void evaluateConstructorFieldInitializers(ConstructorElement constructor,
+                                            List<ConstructorElement> supers) {
+    // Evaluate declaration-site field initializers.
+    ClassElement enclosingClass = constructor.enclosingClass.implementation;
+    enclosingClass.forEachInstanceField((ClassElement _, FieldElement field) {
+      if (field.initializer != null) {
+        fieldValues[field] = inlineExpression(field, field.initializer);
+      } else {
+        if (Elements.isNativeOrExtendsNative(enclosingClass)) {
+          // Native field is initialized elsewhere.
+        } else {
+          // Fields without an initializer default to null.
+          // This value will be overwritten below if an initializer is found.
+          fieldValues[field] = irBuilder.buildNullLiteral();
+        }
+      }
+    });
+    // Evaluate initializing parameters, e.g. `Foo(this.x)`.
+    constructor.functionSignature.orderedForEachParameter(
+        (ParameterElement parameter) {
+      if (parameter.isInitializingFormal) {
+        InitializingFormalElement fieldParameter = parameter;
+        fieldValues[fieldParameter.fieldElement] =
+            irBuilder.buildLocalGet(parameter);
+      }
+    });
+    // Evaluate constructor initializers, e.g. `Foo() : x = 50`.
+    ast.FunctionExpression node = constructor.node;
+    bool hasConstructorCall = false; // Has this() or super() initializer?
+    if (node != null && node.initializers != null) {
+      for(ast.Node initializer in node.initializers) {
+        if (initializer is ast.SendSet) {
+          // Field initializer.
+          FieldElement field = elements[initializer];
+          fieldValues[field] =
+              inlineExpression(constructor, initializer.arguments.head);
+        } else if (initializer is ast.Send) {
+          // Super or this initializer.
+          ConstructorElement target = elements[initializer].implementation;
+          Selector selector = elements.getSelector(initializer);
+          List<ir.Primitive> arguments = initializer.arguments.mapToList(visit);
+          loadArguments(target, selector, arguments);
+          evaluateConstructorFieldInitializers(target, supers);
+          hasConstructorCall = true;
+        } else {
+          compiler.internalError(initializer,
+                                 "Unexpected initializer type $initializer");
+        }
+      }
+    }
+    // If no super() or this() was found, also call default superconstructor.
+    if (!hasConstructorCall && !enclosingClass.isObject) {
+      ClassElement superClass = enclosingClass.superclass;
+      Selector selector =
+          new Selector.callDefaultConstructor(enclosingClass.library);
+      FunctionElement target = superClass.lookupConstructor(selector);
+      if (target == null) {
+        compiler.internalError(superClass, "No default constructor available.");
+      }
+      evaluateConstructorFieldInitializers(target, supers);
+    }
+    // Add this constructor after the superconstructors.
+    supers.add(constructor);
+  }
+
+  /// In preparation of inlining (part of) [target], the [arguments] are moved
+  /// into the environment bindings for the corresponding parameters.
+  ///
+  /// Defaults for optional arguments are evaluated in order to ensure
+  /// all parameters are available in the environment.
+  void loadArguments(FunctionElement target,
+                     Selector selector,
+                     List<ir.Primitive> arguments) {
+    target = target.implementation;
+    FunctionSignature signature = target.functionSignature;
+
+    // Establish a scope in case parameters are captured.
+    ClosureScope scope = getFunctionScope(target);
+    irBuilder._enterScope(scope);
+
+    // Load required parameters
+    int index = 0;
+    signature.forEachRequiredParameter((ParameterElement param) {
+      irBuilder.declareLocalVariable(param, initialValue: arguments[index]);
+      ++index;

[floitsch, 2015/01/21 16:29:34]

tiny nit: we generally use index++.

[asgerf, 2015/01/22 10:18:58]

I prefer that too, but have been told the exact opposite in another review.

+    });
+
+    // Load optional parameters, evaluating default values for omitted ones.
+    signature.forEachOptionalParameter((ParameterElement param) {
+      ir.Primitive value;
+      // Load argument if provided.
+      if (signature.optionalParametersAreNamed) {
+        int translatedIndex = selector.namedArguments.indexOf(param.name);
+        if (translatedIndex != -1) {
+          value = arguments[translatedIndex];
+        }
+      } else if (index < arguments.length) {
+        value = arguments[index];
+      }
+      // Load default if argument was not provided.
+      if (value == null) {
+        if (param.initializer != null) {
+          value = visit(param.initializer);
+        } else {
+          value = irBuilder.buildNullLiteral();
+        }
+      }
+      irBuilder.declareLocalVariable(param, initialValue: value);
+      ++index;

[floitsch, 2015/01/21 16:29:34]

ditto.

[asgerf, 2015/01/22 10:18:57]

Done.

+    });
+  }
+
+  /**
+   * Returns the constructor body associated with the given constructor or
+   * creates a new constructor body, if none can be found.
+   *
+   * Returns `null` if the constructor does not have a body.
+   */
+  ConstructorBodyElement getConstructorBody(FunctionElement constructor) {
+    // TODO(asgerf): This is largely inherited from the SSA builder.
+    // The ConstructorBodyElement has an invalid function signature, but we
+    // cannot add a BoxLocal as parameter, because BoxLocal is not an element.
+    // Instead of forging ParameterElements to forge a FunctionSignature, we
+    // need a way to create backend methods without creating more fake elements.
+
+    assert(constructor.isGenerativeConstructor);
+    assert(invariant(constructor, constructor.isImplementation));
+    if (constructor.isSynthesized) return null;
+    ast.FunctionExpression node = constructor.node;
+    // If we know the body doesn't have any code, we don't generate it.
+    if (!node.hasBody()) return null;
+    if (node.hasEmptyBody()) return null;
+    ClassElement classElement = constructor.enclosingClass;
+    ConstructorBodyElement bodyElement;
+    classElement.forEachBackendMember((Element backendMember) {
+      if (backendMember.isGenerativeConstructorBody) {
+        ConstructorBodyElement body = backendMember;
+        if (body.constructor == constructor) {
+          bodyElement = backendMember;
+        }
+      }
+    });
+    if (bodyElement == null) {
+      List<Local> parameters = getConstructorBodyParameters(constructor);

[floitsch, 2015/01/21 16:29:34]

leftover?

getConstructorBodyParameters shouldn't have a side-effect. (If it has, we should
change the name).

[asgerf, 2015/01/22 10:18:57]

You are right, it was a leftover (I previously stored the parameter list of the
element, created below, but then decided against it).

+
+      bodyElement = new ConstructorBodyElementX(constructor);
+      classElement.addBackendMember(bodyElement);
+
+      if (constructor.isPatch) {
+        // Create origin body element for patched constructors.
+        ConstructorBodyElementX patch = bodyElement;
+        ConstructorBodyElementX origin =
+            new ConstructorBodyElementX(constructor.origin);
+        origin.applyPatch(patch);
+        classElement.origin.addBackendMember(bodyElement.origin);
+      }
+    }
+    assert(bodyElement.isGenerativeConstructorBody);
+    return bodyElement;
+  }
+
+  /// The list of parameters to send from the generative constructor
+  /// to the generative constructor body.

[floitsch, 2015/01/21 16:29:34]

Maybe add note that the returned list may contain boxes, and has the boxed
variables removed.

Ideally give an example of why/what we are doing.

[asgerf, 2015/01/22 10:18:57]

Done.

I also changed the parameter to ConstructorBodyElement to clarify that the
body's element should be given, not the generative constructor.

+  List<Local> getConstructorBodyParameters(FunctionElement constructor) {
+    List<Local> parameters = <Local>[];
+    ClosureScope scope = getFunctionScope(constructor);
+    if (scope != null) {
+      parameters.add(scope.box);
+    }
+    constructor.functionSignature.orderedForEachParameter(
+        (ParameterElement param) {
+      if (scope != null && scope.capturedVariables.containsKey(param)) {
+        // Do not pass this parameter; the box will carry its value.
+      } else {
+        parameters.add(param);
+      }
+    });
+    return parameters;
+  }
+
+  /// Builds the IR for the body of a constructor.
+  ///
+  /// This function is invoked from one or more "factory" constructors built by
+  /// [buildConstructor].
+  ir.FunctionDefinition buildConstructorBody(ConstructorBodyElement body) {
+    ConstructorElement constructor = body.constructor;
+    ast.FunctionExpression node = constructor.node;
+    closureMap = compiler.closureToClassMapper.computeClosureToClassMapping(
+        constructor,
+        node,
+        elements);
+
+    JsIrBuilder builder = new JsIrBuilder(

[floitsch, 2015/01/21 16:29:35]

nit:
I prefer not to break expressions:

JsIrBuilder builder =
    new JsIrBuilder(...);

[asgerf, 2015/01/22 10:18:57]

Done.

+        compiler.backend.constantSystem, body);
+
+    return withBuilder(builder, () {
+      irBuilder.buildConstructorBodyHeader(getConstructorBodyParameters(body),
+                                           getClosureScope(node));
+      visit(node.body);
+      return irBuilder.makeFunctionDefinition([]);
+    });
+  }
+
+  ir.FunctionDefinition buildFunction(FunctionElement element) {
+    assert(invariant(element, element.isImplementation));
+    ast.FunctionExpression node = element.node;
+
+    assert(!element.isSynthesized);
+    assert(node != null);
+    assert(elements[node] != null);
+
+    IrBuilder builder = makeIRBuilder(node, element);
+    return withBuilder(builder, () => _makeFunctionBody(element, node));
+  }
+
+}
+