super and this in compile-time constants.

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 520 matching lines @@
       initialVariableValues[element] = value;
       pendingVariables.remove(element);
       return value;
     });
   }
 
   Constant compileNodeWithDefinitions(Node node, TreeElements definitions) {
     return measure(() {
       assert(node !== null);
       CompileTimeConstantEvaluator evaluator =
-          new CompileTimeConstantEvaluator(this, definitions, compiler);
+          new CompileTimeConstantEvaluator(definitions, compiler);
       return evaluator.evaluate(node);
     });
   }
 
   /**
    * Returns a [List] of static non final fields that need to be initialized.
    * The list must be evaluated in order since the fields might depend on each
    * other.
    */
   List<VariableElement> getStaticNonFinalFieldsForEmission() {
@@ skipping 113 matching lines @@
       }
     }
   }
 
   String getJsConstructor(ClassElement element) {
     return compiler.namer.isolatePropertyAccess(element);
   }
 }
 
 class CompileTimeConstantEvaluator extends AbstractVisitor {
-  final ConstantHandler constantHandler;
   final TreeElements elements;
   final Compiler compiler;
-  final Map<Element, Constant> definitions = null;
 
-  CompileTimeConstantEvaluator(this.constantHandler,
-                               this.elements,
-                               this.compiler);
+  CompileTimeConstantEvaluator(this.elements, this.compiler);
 
-  CompileTimeConstantEvaluator.insideConstructor(this.constantHandler,
-                                                 this.elements,
-                                                 this.compiler,
-                                                 this.definitions);
-
-  bool insideConstructor() => definitions !== null;
+  bool get insideConstructor() => false;
+  Map<Element, Constant> get definitions() => null;

[ngeoffray, 2012/03/27 11:30:33]

Please consider removing these getters, and override visitSend in
ConstructorEvaluator. The visitSend in ConstructorEvaluator could look like:

Constant visitSend(Send send) {
  Element element = elements[send];
  if (!Elements.isLocal(element)) {
    return super.visitSend(send);
  }
  ...
}

[floitsch, 2012/03/28 00:10:58]

I was afraid that a local could be a Prefix too. But test confirmed that this is
not the case.
done.

 
   Constant evaluate(Node node) {
     return node.accept(this);
   }
 
   visitNode(Node node) {
     error(node);
   }
 
   Constant visitLiteralBool(LiteralBool node) {
@@ skipping 14 matching lines @@
     if (!node.isConst()) error(node);
     List<Constant> arguments = <Constant>[];
     for (Link<Node> link = node.elements.nodes;
          !link.isEmpty();
          link = link.tail) {
       arguments.add(evaluate(link.head));
     }
     // TODO(floitsch): get type from somewhere.
     Type type = null;
     Constant constant = new ListConstant(type, arguments);
-    constantHandler.registerCompileTimeConstant(constant);
+    compiler.constantHandler.registerCompileTimeConstant(constant);
     return constant;
   }
 
   Constant visitLiteralMap(LiteralMap node) {
     // TODO(floitsch): check for isConst, once the parser adds it into the node.
     // if (!node.isConst()) error(node);
     List<StringConstant> keys = <StringConstant>[];
     List<Constant> values = <Constant>[];
     bool hasProtoKey = false;
     for (Link<Node> link = node.entries.nodes;
@@ skipping 13 matching lines @@
       keys.add(key);
       values.add(evaluate(entry.value));
     }
     if (hasProtoKey) {
       compiler.unimplemented("visitLiteralMap with __proto__ key",
                              node: node);
     }
     // TODO(floitsch): this should be a List<String> type.
     Type keysType = null;
     ListConstant keysList = new ListConstant(keysType, keys);
-    constantHandler.registerCompileTimeConstant(keysList);
+    compiler.constantHandler.registerCompileTimeConstant(keysList);
     ClassElement classElement =
         compiler.jsHelperLibrary.find(MapConstant.DART_CLASS);
     classElement.ensureResolved(compiler);
     // TODO(floitsch): copy over the generic type.
     Type type = new SimpleType(classElement.name, classElement);
     compiler.registerInstantiatedClass(classElement);
     Constant constant = new MapConstant(type, keysList, values);
-    constantHandler.registerCompileTimeConstant(constant);
+    compiler.constantHandler.registerCompileTimeConstant(constant);
     return constant;
   }
 
   Constant visitLiteralNull(LiteralNull node) {
     return new NullConstant();
   }
 
   Constant visitLiteralString(LiteralString node) {
     return new StringConstant(node.dartString);
   }
@@ skipping 26 matching lines @@
   }
 
   // TODO(floitsch): provide better error-messages.
   Constant visitSend(Send send) {
     Element element = elements[send];
     if (Elements.isStaticOrTopLevelField(element)) {
       if (element.modifiers === null ||
           !element.modifiers.isFinal()) {
         error(send);
       }
-      return constantHandler.compileVariable(element);
+      return compiler.compileVariable(element);
     } else if (send.isPrefix) {
       assert(send.isOperator);
       Constant receiverConstant = evaluate(send.receiver);
       Operator op = send.selector;
       Constant folded;
       switch (op.source.stringValue) {
         case "!":
           folded = const NotOperation().fold(receiverConstant);
           break;
         case "-":
           folded = const NegateOperation().fold(receiverConstant);
           break;
         case "~":
           folded = const BitNotOperation().fold(receiverConstant);
           break;
         default:
           compiler.internalError("Unexpected operator.", node: op);
           break;
       }
       if (folded === null) error(send);
       return folded;
     } else if (Elements.isLocal(element)) {
-      if (!insideConstructor()) error(send);
+      if (!insideConstructor) error(send);
       Constant constant = definitions[element];
       if (constant === null) {
         compiler.internalError("Local variable without value", node: send);
       }
       return constant;
     } else if (send.isOperator && !send.isPostfix) {
       assert(send.argumentCount() == 1);
       Constant left = evaluate(send.receiver);
       Constant right = evaluate(send.argumentsNode.nodes.head);
       Operator op = send.selector.asOperator();
@@ skipping 79 matching lines @@
       if (folded === null) error(send);
       return folded;
     }
     return super.visitSend(send);
   }
 
   visitSendSet(SendSet node) {
     error(node);
   }
 
+  /** Returns the list of constants that are passed to the static function. */
+  List<Constant> evaluateStaticSendArguments(Send send,

[ngeoffray, 2012/03/27 11:30:33]

Since this is only used by the ConstructorEvaluator, you could move it there.

[floitsch, 2012/03/28 00:10:58]

It is actually used by the normal evaluator too (in visitNewExpression). I had
already moved it, but it doesn't really work, because the arguments need to be
evaluated in the context of the original expression.

+                                             FunctionElement target) {
+    FunctionParameters parameters = target.computeParameters(compiler);
+    List<Constant> arguments = <Constant>[];
+    Selector selector = elements.getSelector(send);
+
+    Function compileArgument = evaluate;
+    Function compileConstant = compiler.compileVariable;
+    bool succeeded = selector.addSendArgumentsToList(
+        send, arguments, parameters, compileArgument, compileConstant);
+    if (!succeeded) error(send);
+    return arguments;
+  }
+
   Constant visitNewExpression(NewExpression node) {
-    Element currentElement = compiler.currentElement;
-
-    void assignArgumentsToParameters(
-        FunctionParameters parameters,
-        Map<Element, Constant> constructorDefinitions,
-        Map<Element, Constant> fieldValues) {
-      Send send = node.send;
-      if (send.arguments.isEmpty() && parameters.parameterCount == 0) return;
-      List<Constant> arguments = <Constant>[];
-      Selector selector = elements.getSelector(send);
-
-      Function compileArgument = evaluate;
-      Function compileConstant = constantHandler.compileVariable;
-      bool succeeded = selector.addSendArgumentsToList(
-          send, arguments, parameters, compileArgument, compileConstant);
-      if (!succeeded) error(node);
-
-      int index = 0;
-      parameters.forEachParameter((Element parameter) {
-        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> 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);
-          fieldValues[constructorElements[init]] = fieldValue;
-        }
-      }
-    }
-
-    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 = fieldValues[member];
-          if (fieldValue === null) {
-            // Use the default value.
-            fieldValue = constantHandler.compileVariable(member);
-          }
-          jsNewArguments.add(fieldValue);
-        }
-      }
-      if (classElement.superclass != compiler.coreLibrary.find(Types.OBJECT)) {
-        compiler.withCurrentElement(currentElement, () {
-          compiler.unimplemented("ConstantHandler with super", node: node);
-        });
-      }
-      return jsNewArguments;
-    }
-
     if (!node.isConst()) error(node);
 
     FunctionElement constructor = elements[node.send];
-    TreeElements constructorElements =
-        compiler.resolver.resolveMethodElement(constructor);
-    if (constructor != constructor.defaultImplementation) {
+    ClassElement classElement = constructor.enclosingElement;
+    if (classElement.isInterface()) {
+      compiler.resolver.resolveMethodElement(constructor);
       constructor = constructor.defaultImplementation;
-      constructorElements =
-          compiler.resolver.resolveMethodElement(constructor);
+      classElement = constructor.enclosingElement;
     }
 
-    List<Constant> jsNewArguments;
-    ClassElement classElement = constructor.enclosingElement;
-    compiler.withCurrentElement(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>();
-
-      assignArgumentsToParameters(parameters, constructorDefinitions,
-                                  fieldValues);
-      CompileTimeConstantEvaluator initializerEvaluator =
-          new CompileTimeConstantEvaluator.insideConstructor(
-              constantHandler, constructorElements, compiler,
-              constructorDefinitions);
-      if (initializerList !== null) {
-        Link<Node> initializers = functionNode.initializers.nodes;
-        compileInitializers(initializers,
-                            initializerEvaluator,
-                            constructorElements,
-                            constructorDefinitions,
-                            fieldValues);
-      }
-      jsNewArguments = buildJsNewArguments(classElement, fieldValues);
-    });
-
+    Send send = node.send;
+    List<Constant> arguments = evaluateStaticSendArguments(send, constructor);

[ngeoffray, 2012/03/27 11:30:33]

evaluateStaticSendArguments -> evaluateArgumentsToConstructor ?

[floitsch, 2012/03/28 00:10:58]

Done.

+    ConstructorEvaluator evaluator =
+        new ConstructorEvaluator(constructor, compiler);
+    evaluator.evaluateConstructorFieldValues(arguments);

[ngeoffray, 2012/03/27 11:30:33]

Instead of passing arguments, I would pass the node and let CosntructorEvaluator
call evaluateStaticSendArguments.

[floitsch, 2012/03/28 00:10:58]

Can't do that, because there is no Send for implicit super calls to the
default-constructor.

+    List<Constant>jsNewArguments = evaluator.buildJsNewArguments(classElement);
 
     compiler.registerInstantiatedClass(classElement);
     // TODO(floitsch): take generic types into account.
     Type type = classElement.computeType(compiler);
     Constant constant = new ConstructedConstant(type, jsNewArguments);
-    constantHandler.registerCompileTimeConstant(constant);
+    compiler.constantHandler.registerCompileTimeConstant(constant);
     return constant;
   }
 
   Constant visitParenthesizedExpression(ParenthesizedExpression node) {
     return node.expression.accept(this);
   }
 
   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 []));
   }
 }
+
+class ConstructorEvaluator extends CompileTimeConstantEvaluator {
+  FunctionElement constructor;
+  final Map<Element, Constant> definitions;
+  final Map<Element, Constant> fieldValues;
+
+  ConstructorEvaluator(FunctionElement constructor, Compiler compiler)
+      : this.constructor = constructor,
+        this.definitions = new Map<Element, Constant>(),
+        this.fieldValues = new Map<Element, Constant>(),
+        super(compiler.resolver.resolveMethodElement(constructor),
+              compiler);
+
+  bool get insideConstructor() => true;
+
+  /**
+   * Given the arguments (a list of constants) assigns them to the parameters,
+   * updating the definitions map. If the constructor has field-initializer
+   * parameters (like [:this.x:]), also updates the [fieldValues] map.
+   */ 
+  void assignArgumentsToParameters(List<Constant> arguments) {
+    // Assign arguments to parameters.
+    FunctionParameters parameters = constructor.computeParameters(compiler);
+    int index = 0;
+    parameters.forEachParameter((Element parameter) {
+      Constant argument = arguments[index++];
+      definitions[parameter] = argument;
+      if (parameter.kind == ElementKind.FIELD_PARAMETER) {
+        FieldParameterElement fieldParameterElement = parameter;
+        fieldValues[fieldParameterElement.fieldElement] = argument;
+      }
+    });    
+  }
+
+  void evaluateSuperOrRedirectSend(FunctionElement targetConstructor,
+                                   List<Constant> targetArguments) {
+    ConstructorEvaluator evaluator =
+        new ConstructorEvaluator(targetConstructor, compiler);
+    evaluator.evaluateConstructorFieldValues(targetArguments);
+    // Copy over the fieldValues from the super/redirect-constructor.
+    evaluator.fieldValues.forEach((key, value) => fieldValues[key] = value);
+  }
+
+  /**
+   * Runs through the initializers of the given [constructor] and updates
+   * the [fieldValues] map.
+   */
+  void evaluateConstructorInitializers() {
+    FunctionExpression functionNode = constructor.parseNode(compiler);
+    NodeList initializerList = functionNode.initializers;
+
+    bool foundSuperOrRedirect = false;
+
+    if (initializerList !== null) {
+      for (Link<Node> link = initializerList.nodes;
+           !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;
+          FunctionElement targetConstructor = elements[call];
+          List<Constant> targetArguments =
+              evaluateStaticSendArguments(call, targetConstructor);
+          evaluateSuperOrRedirectSend(targetConstructor, targetArguments);
+          foundSuperOrRedirect = true;
+        } else {
+          // A field initializer.
+          SendSet init = link.head;
+          Link<Node> initArguments = init.arguments;
+          assert(!initArguments.isEmpty() && initArguments.tail.isEmpty());
+          Constant fieldValue = evaluate(initArguments.head);
+          fieldValues[elements[init]] = fieldValue;
+        }
+      }
+    }
+
+    if (!foundSuperOrRedirect) {
+      // No super initializer found. Try to find the default constructor if
+      // the class is not Object.
+      ClassElement enclosingClass = constructor.enclosingElement;
+      ClassElement superClass = enclosingClass.superclass;
+      if (enclosingClass != compiler.objectClass) {
+        assert(superClass !== null);
+        assert(superClass.isResolved);
+        FunctionElement targetConstructor =
+            superClass.lookupConstructor(superClass.name);
+        if (targetConstructor === null) {
+          compiler.internalError("no default constructor available");
+        }
+        evaluateSuperOrRedirectSend(targetConstructor, const <Constant>[]);
+      }
+    }
+  }
+
+  /**
+   * Simulates the execution of the [constructor] with the given
+   * [arguments] to obtain the field values that need to be passed to the
+   * native JavaScript constructor.
+   */
+  void evaluateConstructorFieldValues(List<Constant> arguments) {
+    compiler.withCurrentElement(constructor, () {
+      assignArgumentsToParameters(arguments);
+      evaluateConstructorInitializers();
+    });
+  }
+
+  List<Constant> buildJsNewArguments(ClassElement classElement) {
+    List<Constant> jsNewArguments = <Constant>[];
+    // TODO(floitsch): share this code with the emitter, so that we don't
+    // need to care about the order of fields here.
+    while (classElement != compiler.objectClass) {
+      for (Element member in classElement.members) {
+        if (member.isInstanceMember() && member.kind == ElementKind.FIELD) {
+          Constant fieldValue = fieldValues[member];
+          if (fieldValue === null) {
+            // Use the default value.
+            fieldValue = compiler.compileVariable(member);
+          }
+          jsNewArguments.add(fieldValue);
+        }
+      }
+      classElement = classElement.superclass;
+    } 
+    return jsNewArguments;
+  }
+}