Lazy implementation of final variables.

lib/compiler/implementation/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 459 matching lines @@
     }
     return true;
   }
 
   int hashCode() => _hashCode;
   List<Constant> getDependencies() => fields;
 }
 
 /**
  * The [ConstantHandler] keeps track of compile-time constants,
- * initializations of global and static fields, and default values of
+ * initializations of global and static const fields, and default values of
  * optional parameters.
  */
 class ConstantHandler extends CompilerTask {
-  // Contains the initial value of fields. Must contain all static and global
-  // initializations of used fields. May contain caches for instance fields.
+  /**
+   * Contains the initial value of fields. Must contain all static and global
+   * initializations of const fields. May contain eagerly compiled values for
+   * statics and instance fields.
+   */
   final Map<VariableElement, Constant> initialVariableValues;
 
-  // Map from compile-time constants to their JS name.
+  /** Map from compile-time constants to their JS name. */
   final Map<Constant, String> compiledConstants;
 
-  // The set of variable elements that are in the process of being computed.
+  /** The set of variable elements that are in the process of being computed. */
   final Set<VariableElement> pendingVariables;
 
+  /** Caches the statics where the initial value cannot be eagerly compiled. */
+  final Set<VariableElement> lazyStatics;
+
+
   ConstantHandler(Compiler compiler)
       : initialVariableValues = new Map<VariableElement, Dynamic>(),
         compiledConstants = new Map<Constant, String>(),
         pendingVariables = new Set<VariableElement>(),
+        lazyStatics = new Set<VariableElement>(),
         super(compiler);
   String get name() => 'ConstantHandler';
 
   void registerCompileTimeConstant(Constant constant) {
     Function ifAbsentThunk = (() => compiler.namer.getFreshGlobalName("CTC"));
     compiledConstants.putIfAbsent(constant, ifAbsentThunk);
   }
 
   /**
    * Compiles the initial value of the given field and stores it in an internal
-   * map.
+   * map. Returns the initial value (a constant) if it can be computed
+   * statically. Returns [:null:] if the variable must be initialized lazily.
    *
    * [WorkItem] must contain a [VariableElement] refering to a global or
    * static field.
    */
-  void compileWorkItem(WorkItem work) {
-    measure(() {
+  Constant compileWorkItem(WorkItem work) {
+    return measure(() {
       assert(work.element.kind == ElementKind.FIELD
              || work.element.kind == ElementKind.PARAMETER
              || work.element.kind == ElementKind.FIELD_PARAMETER);
       VariableElement element = work.element;
+      Constant result;

[kasperl, 2012/08/17 09:30:04]

Constant result = initial... ?

[floitsch, 2012/09/04 17:32:21]

Done.

       // Shortcut if it has already been compiled.
-      if (initialVariableValues.containsKey(element)) return;
-      compileVariableWithDefinitions(element, work.resolutionTree);
+      result = initialVariableValues[element];
+      if (result != null) return result;
+      if (lazyStatics.contains(element)) return null;
+      result = compileVariableWithDefinitions(element, work.resolutionTree);
       assert(pendingVariables.isEmpty());
+      return result;
     });
   }
 
-  Constant compileVariable(VariableElement element) {
+  /**
+   * Returns a compile-time constant, or reports an error if the element is not
+   * a compile-time constant.
+   */
+  Constant compileConstant(VariableElement element) {
+    return compileVariable(element, isConst: true);
+  }
+
+  /**
+   * Returns the a compile-time constant if the variable could be compiled
+   * eagerly. Otherwise returns `null`.
+   */
+  Constant compileVariable(VariableElement element, [bool isConst = false]) {
     return measure(() {
       if (initialVariableValues.containsKey(element)) {
         Constant result = initialVariableValues[element];
         return result;
       }
       TreeElements definitions = compiler.analyzeElement(element);
-      Constant constant = compileVariableWithDefinitions(element, definitions);
+      Constant constant = compileVariableWithDefinitions(
+          element, definitions, isConst: isConst);
       return constant;
     });
   }
 
+  /**
+   * Returns the a compile-time constant if the variable could be compiled
+   * eagerly. If the variable needs to be initialized lazily returns `null`.
+   * If the variable is `const` but cannot be compiled eagerly reports an
+   * error.
+   */
   Constant compileVariableWithDefinitions(VariableElement element,
-                                          TreeElements definitions) {
+                                          TreeElements definitions,
+                                          [bool isConst = false]) {
     return measure(() {
+      // Initializers for fields, or parameters must be const.
+      isConst = isConst || !element.modifiers.isFinal();
+      if (!isConst && lazyStatics.contains(element)) return null;
+
       Node node = element.parseNode(compiler);
       if (pendingVariables.contains(element)) {
-        MessageKind kind = MessageKind.CYCLIC_COMPILE_TIME_CONSTANTS;
-        compiler.reportError(node,
-                             new CompileTimeConstantError(kind, const []));
+        if (isConst) {
+          MessageKind kind = MessageKind.CYCLIC_COMPILE_TIME_CONSTANTS;
+          compiler.reportError(node,
+                               new CompileTimeConstantError(kind, const []));
+        } else {
+          lazyStatics.add(element);
+          return null;
+        }
       }
       pendingVariables.add(element);
 
       SendSet assignment = node.asSendSet();
       Constant value;
       if (assignment === null) {
         // No initial value.
         value = new NullConstant();
       } else {
         Node right = assignment.arguments.head;
-        value = compileNodeWithDefinitions(right, definitions);
+        value =
+            compileNodeWithDefinitions(right, definitions, isConst: isConst);
       }
-      initialVariableValues[element] = value;
+      if (value != null) {
+        initialVariableValues[element] = value;
+      } else {
+        assert(!isConst);
+        lazyStatics.add(element);
+      }
       pendingVariables.remove(element);
       return value;
     });
   }
 
-  Constant compileNodeWithDefinitions(Node node, TreeElements definitions) {
+  Constant compileNodeWithDefinitions(Node node,
+                                      TreeElements definitions,
+                                      [bool isConst]) {
     return measure(() {
       assert(node !== null);
       CompileTimeConstantEvaluator evaluator =
-          new CompileTimeConstantEvaluator(definitions, compiler);
+          new CompileTimeConstantEvaluator(definitions, compiler, isConst);
       return evaluator.evaluate(node);
     });
   }
 
   /** Attempts to compile a constant expression. Returns null if not possible */
   Constant tryCompileNodeWithDefinitions(Node node, TreeElements definitions) {
     return measure(() {
       assert(node !== null);
       try {
         TryCompileTimeConstantEvaluator evaluator =
@@ skipping 24 matching lines @@
    * other.
    */
   List<VariableElement> getStaticFinalFieldsForEmission() {
     return initialVariableValues.getKeys().filter((element) {
       return element.kind == ElementKind.FIELD
           && !element.isInstanceMember()
           && element.modifiers.isFinal();
     });
   }
 
+  List<VariableElement> getLazilyInitializedFieldsForEmission() {
+    return new List<VariableElement>.from(lazyStatics);
+  }
+
   List<Constant> getConstantsForEmission() {
     // We must emit dependencies before their uses.
     Set<Constant> seenConstants = new Set<Constant>();
     List<Constant> result = new List<Constant>();
 
     void addConstant(Constant constant) {
       if (!seenConstants.contains(constant)) {
         constant.getDependencies().forEach(addConstant);
         assert(!seenConstants.contains(constant));
         result.add(constant);
@@ skipping 83 matching lines @@
       }
     }
   }
 
   String getJsConstructor(ClassElement element) {
     return compiler.namer.isolatePropertiesAccess(element);
   }
 }
 
 class CompileTimeConstantEvaluator extends AbstractVisitor {
+  bool isEvaluatingConstant;
   final TreeElements elements;
   final Compiler compiler;
 
-  CompileTimeConstantEvaluator(this.elements, this.compiler);
+  CompileTimeConstantEvaluator(this.elements, this.compiler, [bool isConst])
+      : this.isEvaluatingConstant = isConst;
 
   Constant evaluate(Node node) {
     return node.accept(this);
   }
 
-  visitNode(Node node) {
-    error(node);
+  Constant evaluateConstant(Node node) {
+    bool oldIsEvaluatingConstant = isEvaluatingConstant;
+    isEvaluatingConstant = true;
+    Constant result = node.accept(this);
+    isEvaluatingConstant = oldIsEvaluatingConstant;
+    assert(result != null);
+    return result;
+  }
+
+  Constant visitNode(Node node) {
+    signalNotACompileTimeConstant(node);
+    return null;
   }
 
   Constant visitLiteralBool(LiteralBool node) {
     return new BoolConstant(node.value);
   }
 
   Constant visitLiteralDouble(LiteralDouble node) {
     return new DoubleConstant(node.value);
   }
 
   Constant visitLiteralInt(LiteralInt node) {
     return new IntConstant(node.value);
   }
 
   Constant visitLiteralList(LiteralList node) {
-    if (!node.isConst()) error(node);
+    if (!node.isConst())  {
+      signalNotACompileTimeConstant(node);
+      return null;
+    }
     List<Constant> arguments = <Constant>[];
     for (Link<Node> link = node.elements.nodes;
          !link.isEmpty();
          link = link.tail) {
-      arguments.add(evaluate(link.head));
+      arguments.add(evaluateConstant(link.head));
     }
     // TODO(floitsch): get type from somewhere.
     Type type = null;
     Constant constant = new ListConstant(type, arguments);
     compiler.constantHandler.registerCompileTimeConstant(constant);
     return constant;
   }
 
   Constant visitLiteralMap(LiteralMap node) {
-    if (!node.isConst()) error(node);
+    if (!node.isConst()) {
+      signalNotACompileTimeConstant(node);
+      error(node);
+    }
     List<StringConstant> keys = <StringConstant>[];
     Map<StringConstant, Constant> map = new Map<StringConstant, Constant>();
     for (Link<Node> link = node.entries.nodes;
          !link.isEmpty();
          link = link.tail) {
       LiteralMapEntry entry = link.head;
-      Constant key = evaluate(entry.key);
+      Constant key = evaluateConstant(entry.key);
       if (!key.isString() || entry.key.asStringNode() === null) {
         MessageKind kind = MessageKind.KEY_NOT_A_STRING_LITERAL;
         compiler.reportError(entry.key, new ResolutionError(kind, const []));
       }
       StringConstant keyConstant = key;
       if (!map.containsKey(key)) keys.add(key);
-      map[key] = evaluate(entry.value);
+      map[key] = evaluateConstant(entry.value);
     }
     List<Constant> values = <Constant>[];
     Constant protoValue = null;
     for (StringConstant key in keys) {
       if (key.value == const LiteralDartString(MapConstant.PROTO_PROPERTY)) {
         protoValue = map[key];
       } else {
         values.add(map[key]);
       }
     }
@@ skipping 19 matching lines @@
     return new NullConstant();
   }
 
   Constant visitLiteralString(LiteralString node) {
     return new StringConstant(node.dartString, node);
   }
 
   Constant visitStringJuxtaposition(StringJuxtaposition node) {
     StringConstant left = evaluate(node.first);
     StringConstant right = evaluate(node.second);
+    if (left == null || right == null) return null;
     return new StringConstant(new DartString.concat(left.value, right.value),
                               node);
   }
 
   Constant visitStringInterpolation(StringInterpolation node) {
     StringConstant initialString = evaluate(node.string);
+    if (initialString == null) return null;
     DartString accumulator = initialString.value;
     for (StringInterpolationPart part in node.parts) {
       Constant expression = evaluate(part.expression);
       DartString expressionString;
       if (expression.isNum() || expression.isBool()) {
         PrimitiveConstant primitive = expression;
         expressionString = new DartString.literal(primitive.value.toString());
       } else if (expression.isString()) {
         PrimitiveConstant primitive = expression;
         expressionString = primitive.value;
       } else {
-        error(part.expression);
+        signalNotACompileTimeConstant(part.expression);
+        return null;
       }
       accumulator = new DartString.concat(accumulator, expressionString);
       StringConstant partString = evaluate(part.string);
+      if (partString == null) return null;
       accumulator = new DartString.concat(accumulator, partString.value);
     };
     return new StringConstant(accumulator, node);
   }
 
   // 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);
+      Constant result;
+      if (element.modifiers !== null) {
+        if (element.modifiers.isConst()) {
+          result = compiler.compileConstant(element);
+        } else if (element.modifiers.isFinal()) {
+          // TODO(4516): remove support for final compile-time constants: if
+          // isCompilingConstant is true don't compile the variable.
+          result = compiler.compileVariable(element);
+        }
       }
-      return compiler.compileVariable(element);
+      if (result == null) signalNotACompileTimeConstant(send);
+      return result;
     } else if (send.isPrefix) {
       assert(send.isOperator);
       Constant receiverConstant = evaluate(send.receiver);
+      if (receiverConstant == null) return null;
       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);
+      if (folded === null) signalNotACompileTimeConstant(send);
       return folded;
     } else if (send.isOperator && !send.isPostfix) {
       assert(send.argumentCount() == 1);
       Constant left = evaluate(send.receiver);
       Constant right = evaluate(send.argumentsNode.nodes.head);
+      if (left == null || right == null) return null;
       Operator op = send.selector.asOperator();
       Constant folded = null;
       switch (op.source.stringValue) {
         case "+":
           folded = const AddOperation().fold(left, right);
           break;
         case "-":
           folded = const SubtractOperation().fold(left, right);
           break;
         case "*":
@@ skipping 66 matching lines @@
             BoolConstant areIdentical =
                 const IdentityOperation().fold(left, right);
             if (areIdentical === null) {
               folded = null;
             } else {
               folded = areIdentical.negate();
             }
           }
           break;
       }
-      if (folded === null) error(send);
+      if (folded === null) signalNotACompileTimeConstant(send);
       return folded;
     }
-    return super.visitSend(send);
+    signalNotACompileTimeConstant(send);
+    return null;
   }
 
-  visitSendSet(SendSet node) {
-    error(node);
+  Constant visitSendSet(SendSet node) {
+    signalNotACompileTimeConstant(node);
+    return null;
   }
 
   /** Returns the list of constants that are passed to the static function. */
   List<Constant> evaluateArgumentsToConstructor(Selector selector,
                                                 Link<Node> arguments,
                                                 FunctionElement target) {
     List<Constant> compiledArguments = <Constant>[];
 
-    Function compileArgument = evaluate;
-    Function compileConstant = compiler.compileVariable;
+    Function compileArgument = evaluateConstant;
+    Function compileConstant = compiler.compileConstant;
     bool succeeded = selector.addArgumentsToList(arguments,
                                                  compiledArguments,
                                                  target,
                                                  compileArgument,
                                                  compileConstant,
                                                  compiler);
     assert(succeeded);
     return compiledArguments;
   }
 
   Constant visitNewExpression(NewExpression node) {
-    if (!node.isConst()) error(node);
+    if (!node.isConst()) {
+      signalNotACompileTimeConstant(node);
+      return null;
+    }
 
     Send send = node.send;
     FunctionElement constructor = elements[send];
     ClassElement classElement = constructor.getEnclosingClass();
     if (classElement.isInterface()) {
       compiler.resolver.resolveMethodElement(constructor);
       constructor = constructor.defaultImplementation;
       classElement = constructor.getEnclosingClass();
     }
 
@@ skipping 16 matching lines @@
   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 []));
   }
+
+  void signalNotACompileTimeConstant(Node node) {

[kasperl, 2012/08/17 09:30:04]

I would remove the A.

[floitsch, 2012/09/04 17:32:21]

Done.

+    if (isEvaluatingConstant) {
+      error(node);
+    }
+    // Else we don't need to do anything. The final handler is only
+    // optimistically trying to compile constants. So it is normal that we
+    // sometimes see non-compile time constants.

[kasperl, 2012/08/17 09:30:04]

So in this case, you'll end up returning null anyway, right? You could make that
link more obvious by returning the result of calling
signalNotCompileTimeConstant where you use it and make this return a Constant
(which will always be null I guess).

[floitsch, 2012/09/04 17:32:21]

Done.

+  }
 }
 
 class TryCompileTimeConstantEvaluator extends CompileTimeConstantEvaluator {
   TryCompileTimeConstantEvaluator(TreeElements elements, Compiler compiler):
-      super(elements, compiler);
+      super(elements, compiler, isConst: true);
 
   error(Node node) {
     // Just fail without reporting it anywhere.
     throw new CompileTimeConstantError(
         MessageKind.NOT_A_COMPILE_TIME_CONSTANT, 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);
+              compiler,
+              isConst: true);
 
   Constant visitSend(Send send) {
     Element element = elements[send];
     if (Elements.isLocal(element)) {
       Constant constant = definitions[element];
       if (constant === null) {
         compiler.internalError("Local variable without value", node: send);
       }
       return constant;
     }
@@ skipping 105 matching lines @@
 
   List<Constant> buildJsNewArguments(ClassElement classElement) {
     List<Constant> jsNewArguments = <Constant>[];
     classElement.forEachInstanceField(
         includeBackendMembers: true,
         includeSuperMembers: true,
         f: (ClassElement enclosing, Element field) {
       Constant fieldValue = fieldValues[field];
       if (fieldValue === null) {
         // Use the default value.
-        fieldValue = compiler.compileVariable(field);
+        fieldValue = compiler.compileConstant(field);
       }
       jsNewArguments.add(fieldValue);
     });
     return jsNewArguments;
   }
 }