Generative constructors in the new dart 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 48 matching lines @@
     });
   }
 
   bool canBuild(Element element) {
     if (element is TypedefElement) return false;
     if (element is FunctionElement) {
       // TODO(sigurdm): Support native functions for dart2js.
       assert(invariant(element, !element.isNative));
 
       // TODO(kmillikin,sigurdm): Support constructors.
-      if (element is ConstructorElement) return false;
+      if (element is ConstructorElement && !element.isGenerativeConstructor) {
+        return false;
+      }
 
     } else if (element is! FieldElement) {
       compiler.internalError(element, "Unexpected elementtype $element");
     }
     return compiler.backend.shouldOutput(element);
   }
 
   bool get inCheckedMode {
     bool result = false;
     assert((result = true));
@@ skipping 100 matching lines @@
     FunctionSignature signature = element.functionSignature;
     signature.orderedForEachParameter((ParameterElement parameterElement) {
       irBuilder.createFunctionParameter(parameterElement);
     });
 
     List<ConstantExpression> defaults = new List<ConstantExpression>();
     signature.orderedOptionalParameters.forEach((ParameterElement element) {
       defaults.add(getConstantForVariable(element));
     });
 
-    visit(node.body);
+    List<ir.Initializer> initializers;
+    if (element.isGenerativeConstructor) {
+      initializers = buildConstructorInitializers(node, element);
+      visit(node.body);
+      return irBuilder.makeConstructorDefinition(defaults, initializers);
+    } else {
+      visit(node.body);
+      return irBuilder.makeFunctionDefinition(defaults);
+    }
+  }
 
-    return irBuilder.makeFunctionDefinition(defaults);
+  List<ir.Initializer> buildConstructorInitializers(
+      ast.FunctionExpression function, ConstructorElement element) {
+    List<ir.Initializer> result = <ir.Initializer>[];
+    FunctionSignature signature = element.functionSignature;
+
+    void tryAddInitializingFormal(ParameterElement parameterElement) {
+      if (parameterElement.isInitializingFormal) {
+        InitializingFormalElement initializingFormal = parameterElement;
+        withBuilder(new IrBuilder.delimited(irBuilder), () {
+          ir.Primitive value = irBuilder.buildLocalGet(parameterElement);
+          result.add(irBuilder.makeFieldInitializer(
+              initializingFormal.fieldElement,
+              irBuilder.makeRunnableBody(value)));
+        });
+      }
+    }
+
+    // TODO(sigurdm): Preserve initializing formals as initializing formals.
+    signature.orderedForEachParameter(tryAddInitializingFormal);
+
+    if (function.initializers == null) return result;
+    bool explicitSuperInitializer = false;
+    for(ast.Node initializer in function.initializers) {
+      if (initializer is ast.SendSet) {
+        // Field initializer.
+        FieldElement field = elements[initializer];
+        withBuilder(new IrBuilder.delimited(irBuilder), () {
+          ir.Primitive value = visit(initializer.arguments.head);
+          ir.RunnableBody body = irBuilder.makeRunnableBody(value);
+          result.add(irBuilder.makeFieldInitializer(field, body));
+        });
+      } else if (initializer is ast.Send) {
+        // Super or this initializer.
+        if (ast.Initializers.isConstructorRedirect(initializer)) {
+          giveup(initializer, "constructor redirect (this) initializer");
+        }
+        ConstructorElement constructor = elements[initializer].implementation;
+        Selector selector = elements.getSelector(initializer);
+        List<ir.RunnableBody> arguments =
+            initializer.arguments.mapToList((ast.Node argument) {
+          return withBuilder(new IrBuilder.delimited(irBuilder), () {
+            ir.Primitive value = visit(argument);
+            return irBuilder.makeRunnableBody(value);
+          });
+        });
+        result.add(irBuilder.makeSuperInitializer(constructor,
+                                                  arguments,
+                                                  selector));
+        explicitSuperInitializer = true;
+      } else {
+        compiler.internalError(initializer,
+                               "Unexpected initializer type $initializer");
+      }
+
+    }
+    if (!explicitSuperInitializer) {
+      // No super initializer found. Try to find the default constructor if
+      // the class is not Object.
+      ClassElement enclosingClass = element.enclosingClass;
+      if (!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.");
+        }
+        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;
     assert(node != null);
     assert(elements[node] != null);
 
     DetectClosureVariables closureLocals = new DetectClosureVariables(elements);
     closureLocals.visit(node);
@@ skipping 687 matching lines @@
 }
 
 /// Classifies local variables and local functions as 'closure variables'.
 /// A closure variable is one that is accessed from an inner function nested
 /// one or more levels inside the one that declares it.
 class DetectClosureVariables extends ast.Visitor {
   final TreeElements elements;
   DetectClosureVariables(this.elements);
 
   FunctionElement currentFunction;
+  bool insideInitializer = false;
   Set<Local> usedFromClosure = new Set<Local>();
   Set<FunctionElement> recursiveFunctions = new Set<FunctionElement>();
 
   bool isClosureVariable(Entity entity) => usedFromClosure.contains(entity);
 
   void markAsClosureVariable(Local local) {
     usedFromClosure.add(local);
   }
 
   visit(ast.Node node) => node.accept(this);
 
   visitNode(ast.Node node) {
     node.visitChildren(this);
   }
 
-  visitSend(ast.Send node) {
+  void handleSend(ast.Send node) {
     Element element = elements[node];
     if (Elements.isLocal(element) &&
         !element.isConst &&
         element.enclosingElement != currentFunction) {
       LocalElement local = element;
       markAsClosureVariable(local);
     }
+  }
+
+  visitSend(ast.Send node) {
+    handleSend(node);
+    node.visitChildren(this);
+  }
+
+  visitSendSet(ast.SendSet node) {
+    handleSend(node);
+    Element element = elements[node];
+    // Initializers in an initializer-list can communicate via parameters.
+    // If a parameter is stored in an initializer list we box it.
+    if (insideInitializer &&
+        Elements.isLocal(element) &&
+        element.isParameter) {
+      LocalElement local = element;
+      // TODO(sigurdm): Fix this.
+      // Though these variables do not outlive the activation of the function,
+      // they still need to be boxed.  As a simplification, we treat them as if
+      // they are captured by a closure (i.e., they do outlive the activation of
+      // the function).
+      markAsClosureVariable(local);
+    }
     node.visitChildren(this);
   }
 
   visitFunctionExpression(ast.FunctionExpression node) {
     FunctionElement oldFunction = currentFunction;
     currentFunction = elements[node];
+    if (node.initializers != null) {
+      insideInitializer = true;
+      visit(node.initializers);
+      insideInitializer = false;
+    }
     visit(node.body);
     currentFunction = oldFunction;
   }
 }