Support static/global field initializations.

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.
 
 /**
  * The [CompileTimeConstantHandler] keeps track of compile-time constants, and
  * initializations of global and static fields.
  */
 class CompileTimeConstantHandler extends CompilerTask {
   // Contains the initial value of fields. Must contain all static and global
@@ skipping 17 matching lines @@
     VariableElement element = work.element;
     // Shortcut if it has already been compiled.
     if (initialFieldValues.containsKey(element)) return;
     compileFieldWithDefinitions(element, work.resolutionTree);
   }
 
   compileField(VariableElement element) {
     if (initialFieldValues.containsKey(element)) {
       return initialFieldValues[element];
     }
+    // TODO(floitsch): keep track of currently compiling elements so that we
+    // don't end up in an infinite loop: final x = y; final y = x;
     TreeElements definitions = compiler.analyzeElement(element);
     return compileFieldWithDefinitions(element, definitions);
   }
 
   compileFieldWithDefinitions(VariableElement element,
                               TreeElements definitions) {
     return measure(() {
       Node node = element.parseNode(compiler, compiler);
       assert(node !== null);
       SendSet assignment = node.asSendSet();
       var value;
       if (assignment === null) {
         // No initial value.
         value = null;
       } else {
-        compiler.unimplemented("CTC for static initialized fields.",
-                               node: node);
+        Node right = node.arguments.head;
+        CompileTimeConstantEvaluator evaluator =
+            new CompileTimeConstantEvaluator(this, definitions, compiler);
+        value = evaluator.evaluate(right);
       }
       initialFieldValues[element] = value;
       return value;
     });
   }
 
   /**
    * 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.
@@ skipping 10 matching lines @@
    * other.
    */
   List<VariableElement> getStaticFinalFieldsForEmission() {
     return initialFieldValues.getKeys().filter((element) {
       return !element.isInstanceMember() && element.modifiers.isFinal();
     });
   }
 
   void emitJsCodeForField(VariableElement element, StringBuffer buffer) {
     var value = initialFieldValues[element];
-    // TODO(floitsch): support more values.
-    assert(value === null);
-    buffer.add("(void 0)");
+    if (value === null) {
+      buffer.add("(void 0)");
+    } else if (value === true) {
+      buffer.add("true");
+    } else if (value === false) {
+      buffer.add("false");
+    } else if (value is num) {
+      buffer.add("$value");
+    } else {
+      // TODO(floitsch): support more values.
+      compiler.unimplemented("CompileTimeConstantHandler.emitJsCodeForField",
+                             node: element.parseNode(compiler, compiler));
+    }
   }
 }
+
+class CompileTimeConstantEvaluator extends AbstractVisitor {
+  final CompileTimeConstantHandler constantHandler;
+  final TreeElements definitions;
+  final Compiler compiler;
+
+  CompileTimeConstantEvaluator(this.constantHandler,
+                               this.definitions,
+                               this.compiler);
+
+  evaluate(Node node) {
+    return node.accept(this);
+  }
+
+  visitNode(Node node) {
+    compiler.unimplemented("CompileTimeConstantEvaluator", node: node);
+  }
+
+  visitLiteral(Literal literal) {
+    return literal.value;
+  }
+
+  visitSend(Send send) {

[ngeoffray, 2012/01/16 15:22:35]

Maybe add a helper in Elements:
Elements.isNonInstanceFinalField().

[floitsch, 2012/01/18 12:56:19]

Since I want to check for non-final accesses keeping as is.

+    Element element = definitions[send];
+    if (element !== null &&
+        element.kind == ElementKind.FIELD) {
+      if (element.isInstanceMember() ||
+          element.modifiers === null ||
+          !element.modifiers.isFinal()) {
+        error(element);

[ngeoffray, 2012/01/16 15:22:35]

I believe this can be tested in the resolver.

[floitsch, 2012/01/18 12:56:19]

this one yes, but the resolver would need a state. Since the CTC needs to check
anyways for the cases the resolver cannot handle it seems easier to keep all
checking in the CTC.
leaving as is.

+      }
+      return constantHandler.compileField(element);
+    }
+    return super.visitSend(send);
+  }
+
+  error(Element element) {
+    MessageKind kind = MessageKind.NOT_A_COMPILE_TIME_CONSTANT;
+    List arguments = [element.name];
+    Node node = element.parseNode(compiler, compiler);
+    compiler.reportError(node, new CompileTimeConstantError(kind, arguments));
+  }
+}