Compile initializers in right order.

frog/leg/ssa/builder.dart

 // Copyright (c) 2012, 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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 750 matching lines @@
           compiler.resolver.resolveMethodElement(constructor);
       compiler.enqueue(new WorkItem.toCodegen(bodyElement, treeElements));
       classElement.backendMembers =
           classElement.backendMembers.prepend(bodyElement);
     }
     assert(bodyElement.kind === ElementKind.GENERATIVE_CONSTRUCTOR_BODY);
     return bodyElement;
   }
 
   /**
-   * Run through the initializers and inline all field initializers. Returns the
-   * next constructor to analyze.
+   * Run through the initializers and inline all field initializers. Recursively
+   * inlines super initializers.
+   *
+   * The constructors of the inlined initializers is added to [constructors]
+   * with sub constructors having a lower index then super constructors.

[ngeoffray, 2012/03/18 14:00:44]

then -> than

[floitsch, 2012/03/18 15:36:10]

Done.

    */
-  FunctionElement analyzeInitializers(Link<Node> initializers,
-                                      Map<Element, HInstruction> fieldValues) {
-    FunctionElement nextConstructor;
-    for (Link<Node> link = initializers; !link.isEmpty(); link = link.tail) {
-      assert(link.head is Send);
-      if (link.head is !SendSet) {
-        // A super initializer or constructor redirection.
-        Send call = link.head;
-        assert(Initializers.isSuperConstructorCall(call) ||
-               Initializers.isConstructorRedirect(call));
-        assert(nextConstructor === null);
-        nextConstructor = elements[call];
-        // Visit arguments and map the corresponding parameter value to
-        // the resulting HInstruction value.
-        List<HInstruction> arguments = new List<HInstruction>();
-        addStaticSendArgumentsToList(call, nextConstructor, arguments);
-        int index = 0;
-        FunctionParameters parameters =
-            nextConstructor.computeParameters(compiler);
-        parameters.forEachParameter((Element parameter) {
-          HInstruction argument = arguments[index++];
-          localsHandler.updateLocal(parameter, argument);
-          // Don't forget to update the field, if the parameter is of the
-          // form [:this.x:].
-          if (parameter.kind == ElementKind.FIELD_PARAMETER) {
-            FieldParameterElement fieldParameterElement = parameter;
-            fieldValues[fieldParameterElement.fieldElement] = argument;
-          }
-        });
-      } else {
-        // A field initializer.
-        SendSet init = link.head;
-        Link<Node> arguments = init.arguments;
-        assert(!arguments.isEmpty() && arguments.tail.isEmpty());
-        visit(arguments.head);
-        fieldValues[elements[init]] = pop();
+  void inlineInitializers(FunctionElement constructor,
+                          List<FunctionElement> constructors,
+                          Map<Element, HInstruction> fieldValues) {
+    TreeElements oldElements = elements;
+    constructors.addLast(constructor);
+    bool initializedSuper = false;
+    elements = compiler.resolver.resolveMethodElement(constructor);
+    FunctionExpression functionNode = constructor.parseNode(compiler);
+
+    if (functionNode.initializers !== null) {
+      Link<Node> initializers = functionNode.initializers.nodes;
+      for (Link<Node> link = initializers; !link.isEmpty(); link = link.tail) {
+        assert(link.head is Send);
+        if (link.head is !SendSet) {
+          // A super initializer or constructor redirection.
+          Send call = link.head;
+          assert(Initializers.isSuperConstructorCall(call) ||
+                 Initializers.isConstructorRedirect(call));
+          FunctionElement nextConstructor = elements[call];
+          // Visit arguments and map the corresponding parameter value to
+          // the resulting HInstruction value.
+          List<HInstruction> arguments = new List<HInstruction>();
+          addStaticSendArgumentsToList(call, nextConstructor, arguments);
+          int index = 0;
+          FunctionParameters parameters =
+              nextConstructor.computeParameters(compiler);
+          parameters.forEachParameter((Element parameter) {
+            HInstruction argument = arguments[index++];
+            localsHandler.updateLocal(parameter, argument);
+            // Don't forget to update the field, if the parameter is of the
+            // form [:this.x:].
+            if (parameter.kind == ElementKind.FIELD_PARAMETER) {
+              FieldParameterElement fieldParameterElement = parameter;
+              fieldValues[fieldParameterElement.fieldElement] = argument;
+            }
+          });
+          inlineInitializers(nextConstructor, constructors, fieldValues);
+          initializedSuper = true;
+        } else {
+          // A field initializer.
+          SendSet init = link.head;
+          Link<Node> arguments = init.arguments;
+          assert(!arguments.isEmpty() && arguments.tail.isEmpty());
+          visit(arguments.head);
+          fieldValues[elements[init]] = pop();
+        }
       }
     }
-    return nextConstructor;
+
+    if (!initializedSuper) {
+      // No super initializer found. Try to find the default constructor if

[ngeoffray, 2012/03/18 14:00:44]

default -> super

[floitsch, 2012/03/18 15:36:10]

I think 'default' is correct here. We are trying to find the unnamed constructor
without arguments.

[ngeoffray, 2012/03/18 15:44:53]

Right. 'default' bothers me because it makes me think it's the synthesized one.
Maybe that's just me.

+      // the class is not Object.
+      ClassElement enclosingClass = constructor.enclosingElement;
+      ClassElement superClass = enclosingClass.superclass;
+      ClassElement objectElement = compiler.coreLibrary.find(Types.OBJECT);

[ngeoffray, 2012/03/18 14:00:44]

compiler.objectClass

[floitsch, 2012/03/18 15:36:10]

Done.

+      if (enclosingClass != objectElement) {
+        assert(superClass !== null);
+        assert(superClass.isResolved);
+        FunctionElement nextConstructor =
+            superClass.lookupConstructor(superClass.name);
+        if (nextConstructor === null) {
+          compiler.internalError("no default constructor available");

[ngeoffray, 2012/03/18 14:00:44]

default -> super

[floitsch, 2012/03/18 15:36:10]

ditto.

+        }
+        inlineInitializers(nextConstructor, constructors, fieldValues);
+      }
+    }
+
+    elements = oldElements;
   }
 
   /**
    * Build the factory function corresponding to the constructor
    * [functionElement]:
    *  - Initialize fields with the values of the field initializers of the
    *    current constructor and super constructors or constructors redirected
    *    to, starting from the current constructor.
    *  - Call the the constructor bodies, starting from the constructor(s) in the
    *    super class(es).
@@ skipping 19 matching lines @@
         fieldValues[fieldParameterElement.fieldElement] = parameterValue;
       }
     });
     
     final Map<FunctionElement, TreeElements> constructorElements =
         compiler.resolver.constructorElements;
     List<FunctionElement> constructors = new List<FunctionElement>();
 
     // Analyze the constructor and all referenced constructors and collect
     // initializers and constructor bodies.
-    FunctionElement nextConstructor = functionElement;
-    while (nextConstructor != null) {
-      FunctionElement constructor = nextConstructor;
-      constructors.addLast(constructor);
-      nextConstructor = null;
-      elements = compiler.resolver.resolveMethodElement(constructor);
-      FunctionExpression functionNode = constructor.parseNode(compiler);
-      Link<Node> initializers = const EmptyLink<Node>();
-      if (functionNode.initializers !== null) {
-        nextConstructor =
-            analyzeInitializers(functionNode.initializers.nodes, fieldValues);
-      }
-      if (nextConstructor === null) {
-        // No super initializer found. Try to find the default constructor if
-        // the class is not Object.
-        ClassElement enclosingClass = constructor.enclosingElement;
-        ClassElement superClass = enclosingClass.superclass;
-        ClassElement objectElement = compiler.coreLibrary.find(Types.OBJECT);
-        if (enclosingClass != objectElement) {
-          assert(superClass !== null);
-          assert(superClass.isResolved);
-          nextConstructor = superClass.lookupConstructor(superClass.name);
-          if (nextConstructor === null) {
-            compiler.internalError("no default constructor available");
-          }
-        }
-      }
-    }
+    inlineInitializers(functionElement, constructors, fieldValues);
+
     // Call the JavaScript constructor with the fields as argument.
     // TODO(floitsch,karlklose): move this code to ClassElement and share with
     //                           the emitter.
     List<HInstruction> constructorArguments = <HInstruction>[];
     ClassElement element = classElement;
     while (element != null) {
       for (Element member in element.members) {
         if (member.isInstanceMember() && member.kind == ElementKind.FIELD) {
           HInstruction value = fieldValues[member];
           if (value === null) {
@@ skipping 1656 matching lines @@
     buildBody() {
       // TODO(lrn): Make sure to take continue into account.
       visit(body);
       if (isAborted()) {
         compiler.reportWarning(body, "aborting loop body");
       }
     }
     handleIf(buildBody, null);
   }
 }