Support non-const instance field initializers.

lib/compiler/implementation/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 986 matching lines @@
                                                   constructor,
                                                   compiledArguments);
     if (!succeeded) {
       // Non-matching super and redirects are compile-time errors and thus
       // checked by the resolver.
       compiler.internalError(
           "Parameters and arguments didn't match for super/redirect call",
           element: constructor);
     }
 
+    buildFieldInitializers(constructor.enclosingElement, fieldValues);
+
     int index = 0;
     FunctionSignature params = constructor.computeSignature(compiler);
     params.forEachParameter((Element parameter) {
       HInstruction argument = compiledArguments[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;
@@ skipping 64 matching lines @@
         inlineSuperOrRedirect(target,
                               selector,
                               const EmptyLink<Node>(),
                               constructors,
                               fieldValues);
       }
     }
   }
 
   /**
+   * Run through the fields of [cls] and add their potential
+   * initializers.
+   */
+  void buildFieldInitializers(ClassElement classElement,
+                              Map<Element, HInstruction> fieldValues) {
+    classElement.forEachInstanceField(
+        includeBackendMembers: true,
+        includeSuperMembers: false,
+        f: (ClassElement enclosingClass, Element member) {
+      TreeElements definitions = compiler.analyzeElement(member);
+      Node node = member.parseNode(compiler);
+      SendSet assignment = node.asSendSet();
+      HInstruction value;
+      if (assignment === null) {
+        value = graph.addConstantNull();
+      } else {
+        Node right = assignment.arguments.head;
+        TreeElements savedElements = elements;
+        elements = definitions;
+        right.accept(this);
+        elements = savedElements;
+        value = pop();
+      }
+      fieldValues[member] = value;
+    });
+  }
+
+
+  /**
    * 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).
    */
   HGraph buildFactory(ClassElement classElement,
                       FunctionElement functionElement) {
     FunctionExpression function = functionElement.parseNode(compiler);
     // Note that constructors (like any other static function) do not need
     // to deal with optional arguments. It is the callers job to provide all
     // arguments as if they were positional.
 
     // The initializer list could contain closures.
     openFunction(functionElement, function);
 
     Map<Element, HInstruction> fieldValues = new Map<Element, HInstruction>();
+
+    // Compile the possible initialization code for local fields and
+    // super fields.
+    buildFieldInitializers(classElement, fieldValues);
+
+    // Compile field-parameters such as [:this.x:].
     FunctionSignature params = functionElement.computeSignature(compiler);
     params.forEachParameter((Element element) {
       if (element.kind == ElementKind.FIELD_PARAMETER) {
-        // If the [element] is a field-parameter (such as [:this.x:] then
+        // If the [element] is a field-parameter then
         // initialize the field element with its value.
         FieldParameterElement fieldParameterElement = element;
         HInstruction parameterValue = localsHandler.readLocal(element);
         fieldValues[fieldParameterElement.fieldElement] = parameterValue;
       }
     });
 
-    List<FunctionElement> constructors = <FunctionElement>[functionElement];
-
     // Analyze the constructor and all referenced constructors and collect
     // initializers and constructor bodies.
+    List<FunctionElement> constructors = <FunctionElement>[functionElement];
     buildInitializers(functionElement, constructors, fieldValues);
 
     // Call the JavaScript constructor with the fields as argument.
     List<HInstruction> constructorArguments = <HInstruction>[];
     classElement.forEachInstanceField(
         includeBackendMembers: true,
         includeSuperMembers: true,
         f: (ClassElement enclosingClass, Element member) {
-      HInstruction value = fieldValues[member];
-      if (value === null) {
-        // The field has no value in the initializer list. Initialize it
-        // with the declaration-site constant (if any).
-        Constant fieldValue = compiler.constantHandler.compileVariable(member);
-        value = graph.addConstant(fieldValue);
-      }
-      constructorArguments.add(value);
+      constructorArguments.add(fieldValues[member]);
     });
 
     HForeignNew newObject = new HForeignNew(classElement, constructorArguments);
     add(newObject);
     // Generate calls to the constructor bodies.
     for (int index = constructors.length - 1; index >= 0; index--) {
       FunctionElement constructor = constructors[index];
       ConstructorBodyElement body = getConstructorBody(constructor);
       if (body === null) continue;
       List bodyCallInputs = <HInstruction>[];
@@ skipping 2694 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }