Introduce FieldParameterElement.

frog/leg/compile_time_constants.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 Constant implements Hashable {
   const Constant();
 
   bool isNull() => false;
   bool isBool() => false;
   bool isTrue() => false;
@@ skipping 468 matching lines @@
 
   /**
    * Compiles the initial value of the given field and stores it in an internal
    * map.
    *
    * [WorkItem] must contain a [VariableElement] refering to a global or
    * static field.
    */
   void compileWorkItem(WorkItem work) {
     assert(work.element.kind == ElementKind.FIELD
-           || work.element.kind == ElementKind.PARAMETER);
+           || work.element.kind == ElementKind.PARAMETER
+           || work.element.kind == ElementKind.FIELD_PARAMETER);
     VariableElement element = work.element;
     // Shortcut if it has already been compiled.
     if (initialVariableValues.containsKey(element)) return;
     compileVariableWithDefinitions(element, work.resolutionTree);
     assert(pendingVariables.isEmpty());
   }
 
   compileVariable(VariableElement element) {
     if (initialVariableValues.containsKey(element)) {
       Constant result = initialVariableValues[element];
@@ skipping 413 matching lines @@
              link = link.tail) {
           arguments.add(evaluate(link.head));
         }
       }
       return arguments;
     }
 
     void assignArgumentsToParameters(
         List<Constant> arguments,
         FunctionParameters parameters,
-        Map<Element, Constant> constructorDefinitions) {
+        Map<Element, Constant> constructorDefinitions,

[ngeoffray, 2012/03/15 15:16:25]

constructorDefinitions -> parameterValues ?

[floitsch, 2012/03/15 15:37:24]

I want to rename some elements in this file anyways. I will see if this makes
sense then.

+        Map<Element, Constant> fieldValues) {
       if (arguments.length != parameters.parameterCount) {
         if (arguments.length < parameters.parameterCount &&
             arguments.length >= parameters.requiredParameterCount) {
           compiler.unimplemented("ConstantHandler with optional arguments",
                                  node: node);
         } else {
           error(node);
         }
       }
       int index = 0;
       parameters.forEachParameter((Element parameter) {
-        constructorDefinitions[parameter] = arguments[index++];
+        Constant argument = arguments[index++];
+        constructorDefinitions[parameter] = argument;
+        if (parameter.kind == ElementKind.FIELD_PARAMETER) {
+          FieldParameterElement fieldParameterElement = parameter;
+          fieldValues[fieldParameterElement.fieldElement] = argument;
+        }
       });
     }
 
     void compileInitializers(Link<Node> initializers,
                              CompileTimeConstantEvaluator evaluator,
                              TreeElements constructorElements,
-                             Map<Element, Constant> constructorDefinitions) {
+                             Map<Element, Constant> constructorDefinitions,
+                             Map<Element, Constant> fieldValues) {
       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));
           compiler.unimplemented("ConstantHandler with this or super",
                                  node: call);
         } else {
           // A field initializer.
           SendSet init = link.head;
           Link<Node> arguments = init.arguments;
           assert(!arguments.isEmpty() && arguments.tail.isEmpty());
           Constant fieldValue = evaluator.evaluate(arguments.head);
-          constructorDefinitions[constructorElements[init]] = fieldValue;
+          fieldValues[constructorElements[init]] = fieldValue;
         }
       }
     }
 
-    List<Constant> buildJsConstructorArguments(
-        ClassElement classElement,
-        Map<Element, Constant> constructorDefinitions) {
-      List<Constant> fieldValues = <Constant>[];
+    List<Constant> buildJsNewArguments(ClassElement classElement,
+                                       Map<Element, Constant> fieldValues) {
+      List<Constant> jsNewArguments = <Constant>[];
       for (Element member in classElement.members) {
         if (member.isInstanceMember() && member.kind == ElementKind.FIELD) {
-          Constant fieldValue = constructorDefinitions[member];
+          Constant fieldValue = fieldValues[member];
           if (fieldValue === null) {
             // Use the default value.
             fieldValue = constantHandler.compileVariable(member);
           }
-          fieldValues.add(fieldValue);
+          jsNewArguments.add(fieldValue);
         }
       }
       if (classElement.superclass != compiler.coreLibrary.find(Types.OBJECT)) {
         compiler.unimplemented("ConstantHandler with super", node: node);
       }
-      return fieldValues;
+      return jsNewArguments;
     }
 
     // TODO(floitsch): get the type from somewhere.
     FunctionElement constructor = elements[node.send];
     ClassElement classElement = constructor.enclosingElement;
     TreeElements constructorElements =
         compiler.resolver.resolveMethodElement(constructor);
     FunctionExpression functionNode = constructor.parseNode(compiler);
     NodeList initializerList = functionNode.initializers;
     FunctionParameters parameters = constructor.computeParameters(compiler);
 
+    Map<Element, Constant> fieldValues = new Map<Element, Constant>();
     Map<Element, Constant> constructorDefinitions =
         new Map<Element, Constant>();
 
     List<Constant> arguments = compileArguments();
-    assignArgumentsToParameters(arguments, parameters, constructorDefinitions);
+    assignArgumentsToParameters(arguments, parameters,
+                                constructorDefinitions, fieldValues);

[ngeoffray, 2012/03/15 15:16:25]

This is all happening in the same function, so you should not need to pass them
all as parameters.

[floitsch, 2012/03/15 15:37:24]

I think I will need separate arguments when implementing super calls. Maybe I'm
wrong in which case I will change it then.

     CompileTimeConstantEvaluator initializerEvaluator =
         new CompileTimeConstantEvaluator.insideConstructor(
             constantHandler, constructorElements, compiler,
             constructorDefinitions);
     if (initializerList !== null) {
       Link<Node> initializers = functionNode.initializers.nodes;
       compileInitializers(initializers,
                           initializerEvaluator,
                           constructorElements,
-                          constructorDefinitions);
+                          constructorDefinitions,
+                          fieldValues);
     }
-    List<Constant> fieldValues =
-        buildJsConstructorArguments(classElement, constructorDefinitions);
+    List<Constant> jsNewArguments =
+        buildJsNewArguments(classElement, fieldValues);
 
     compiler.registerInstantiatedClass(classElement);
     Type type = new SimpleType(classElement.name, classElement);
-    Constant constant = new ConstructedConstant(type, fieldValues);
+    Constant constant = new ConstructedConstant(type, jsNewArguments);
     constantHandler.registerCompileTimeConstant(constant);
     return constant;
   }
 
   error(Node node) {
     // TODO(floitsch): get the list of constants that are currently compiled
     // and present some kind of stack-trace.
     MessageKind kind = MessageKind.NOT_A_COMPILE_TIME_CONSTANT;
     compiler.reportError(node, new CompileTimeConstantError(kind, const []));
   }
 }