Fix field initialization order for forwarding constructors.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.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_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 3177 matching lines @@
         element);
   }
 
   /// Builds the IR for a given constructor.
   ///
   /// 1. Evaluates all own or inherited field initializers.
   /// 2. Creates the object and assigns its fields.
   /// 3. Calls constructor body and super constructor bodies.
   /// 4. Returns the created object.
   ir.FunctionDefinition buildConstructor(ConstructorElement constructor) {
+    // TODO(asgerf): Optimization: If constructor is redirecting, then just
+    //               evaluate arguments and call the target constructor.
     constructor = constructor.implementation;
     ClassElement classElement = constructor.enclosingClass.implementation;
 
     JsIrBuilder builder = getBuilderFor(constructor);
 
     final bool requiresTypeInformation =
         builder.program.requiresRuntimeTypesFor(classElement);
 
     return withBuilder(builder, () {
       // Setup parameters and create a box if anything is captured.
@@ skipping 80 matching lines @@
   ///
   /// 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
   /// 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 c, FieldElement field) {
-      if (field.initializer != null) {
-        fieldValues[field] = inlineExpression(field, field.initializer);
-      } else {
-        if (Elements.isNativeOrExtendsNative(c)) {
-          // Native field is initialized elsewhere.
+    // Evaluate declaration-site field initializers, unless this constructor
+    // redirects to another using a `this()` initializer. In that case, these
+    // will be initialized by the effective target constructor.
+    if (!constructor.isRedirectingGenerative) {
+      enclosingClass.forEachInstanceField((ClassElement c, FieldElement field) {
+        if (field.initializer != null) {
+          fieldValues[field] = inlineExpression(field, field.initializer);
         } else {
-          // Fields without an initializer default to null.
-          // This value will be overwritten below if an initializer is found.
-          fieldValues[field] = irBuilder.buildNullConstant();
+          if (Elements.isNativeOrExtendsNative(c)) {
+            // 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.buildNullConstant();
+          }
         }
-      }
-    });
+      });
+    }
     // Evaluate initializing parameters, e.g. `Foo(this.x)`.
     constructor.functionSignature.orderedForEachParameter(
         (ParameterElement parameter) {
       if (parameter.isInitializingFormal) {
         InitializingFormalElement fieldParameter = parameter;
         fieldValues[fieldParameter.fieldElement] =
             irBuilder.buildLocalVariableGet(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);
+          ir.Primitive evaluateArgument(ast.Node arg) {
+            return inlineExpression(constructor, arg);
+          }
+          List<ir.Primitive> arguments =
+              initializer.arguments.mapToList(evaluateArgument);
           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.
@@ skipping 410 matching lines @@
     node.body = replacementFor(node.body);
   }
 }
 
 /// Visit a just-deleted subterm and unlink all [Reference]s in it.
 class RemovalVisitor extends ir.RecursiveVisitor {
   processReference(ir.Reference reference) {
     reference.unlink();
   }
 }