Support static/global field initializations.

frog/leg/compile_time_constants.dart

Index: frog/leg/compile_time_constants.dart
diff --git a/frog/leg/compile_time_constants.dart b/frog/leg/compile_time_constants.dart
index 09463d45264f880d814a60fb0fffa9c462730266..b58d8c47214f7988e885f359f6142fd45c4e2ea4 100644
--- a/frog/leg/compile_time_constants.dart
+++ b/frog/leg/compile_time_constants.dart
@@ -35,6 +35,8 @@ class CompileTimeConstantHandler extends CompilerTask {
     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);
   }
@@ -50,8 +52,10 @@ class CompileTimeConstantHandler extends CompilerTask {
         // 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;
@@ -82,8 +86,51 @@ class CompileTimeConstantHandler extends CompilerTask {
 
   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 compileTimeConstantHandler;
+  final TreeElements definitions;
+  final Compiler compiler;
+
+  CompileTimeConstantEvaluator(this.compileTimeConstantHandler,
+                               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) {
+    Element element = definitions[send];
+    if (element !== null &&
+        !element.isInstanceMember() &&
+        element.kind == ElementKind.FIELD) {
+      // TODO(floitsch): make sure the field is final.

[ngeoffray, 2012/01/16 14:03:35]

You have the modifiers, this should be easy to check.

[floitsch, 2012/01/16 15:07:18]

done.

+      return compileTimeConstantHandler.compileField(element);
+    }
+    return super.visitSend(send);
   }
 }