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 the [element] is a field-parameter (such as [:this.x:] then
+      // initialize the field element with its value.
+      // Note that in the constructor factory we treat fields as if they were
+      // locals.

[ngeoffray, 2012/03/15 10:06:01]

It looks like you should have an if/else here:
if (element.kind == PARAMETER) {
} else {
  // field parameter.
}

[floitsch, 2012/03/15 14:11:04]

Done.

+      if (element.kind == ElementKind.FIELD_PARAMETER) {
+        FieldParameterElement fieldParameterElement = element;
+        directLocals[fieldParameterElement.fieldElement] = 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.
       HInstruction thisInstruction = new HThis();
@@ skipping 492 matching lines @@
                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);

[ngeoffray, 2012/03/15 10:06:01]

ditto for the if/else. The field parameter element should not be referenced.

[floitsch, 2012/03/15 14:11:04]

Done.

+          if (parameter.kind == ElementKind.FIELD_PARAMETER) {
+            FieldParameterElement fieldParameterElement = parameter;
+            localsHandler.updateLocal(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());
       }
     }
     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);
 
     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;
@@ skipping 1686 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);
   }
 }