Introduce FieldParameterElement.

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 258 matching lines @@
                      FunctionExpression node) {
 
     ClosureTranslator translator =
         new ClosureTranslator(builder.compiler, builder.elements);
     closureData = translator.translate(node);
 
     FunctionParameters params = function.computeParameters(builder.compiler);
     params.forEachParameter((Element element) {
       HParameterValue parameter = new HParameterValue(element);
       builder.add(parameter);
-      // Note that for constructors [element] could be a field-element which we
-      // treat as if it was a local.
       directLocals[element] = parameter;
     });
     if (closureData.thisElement !== null) {
       // Once closures have been mapped to classes their instance members might
       // not have any thisElement if the closure was created inside a static
       // context.
       assert(function.isInstanceMember() || function.isGenerativeConstructor());
       // We have to introduce 'this' before we enter the scope, since it might
       // need to be copied into a box (if it is captured). This is similar
       // to all other parameters that are introduced.
@@ skipping 475 matching lines @@
           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.
    */
-  FunctionElement analyzeInitializers(Link<Node> initializers) {
+  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((parameter) {
-          localsHandler.updateLocal(parameter, arguments[index++]);
+        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);
-        // We treat the init field-elements like locals. In the context of
-        // the factory this is correct, and simplifies dealing with
-        // parameter-initializers (like A(this.x)).
-        localsHandler.updateLocal(elements[init], pop());
+        fieldValues[elements[init]] = pop();
       }
     }
     return nextConstructor;
   }
 
   /**
    * 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>();
+    FunctionParameters parameters = functionElement.computeParameters(compiler);
+    parameters.forEachParameter((Element element) {
+      if (element.kind == ElementKind.FIELD_PARAMETER) {
+        // If the [element] is a field-parameter (such as [:this.x:] then
+        // initialize the field element with its value.
+        FieldParameterElement fieldParameterElement = element;
+        HInstruction parameterValue = localsHandler.readLocal(element);
+        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);
+        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");
           }
         }
       }
     }
     // 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;
-          if (localsHandler.hasValueForDirectLocal(member)) {
-            value = localsHandler.readLocal(member);
-          } else {
+          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);
         }
       }
       element = element.superclass;
     }
     HForeignNew newObject = new HForeignNew(classElement, constructorArguments);
@@ skipping 1638 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);
   }
 }