Static and top-level methods can be compile time constants.

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;
   bool isFalse() => false;
   bool isInt() => false;
   bool isDouble() => false;
   bool isNum() => false;
   bool isString() => false;
   bool isList() => false;
   bool isMap() => false;
   bool isConstructedObject() => false;
+  bool isFunction() => false;
   /** Returns true if the constant is null, a bool, a number or a string. */
   bool isPrimitive() => false;
   /** Returns true if the constant is a list, a map or a constructed object. */
   bool isObject() => false;
 
   bool isNaN() => false;
 
   abstract void _writeJsCode(CodeBuffer buffer, ConstantHandler handler);
   /**
     * Unless the constant can be emitted multiple times (as for numbers and
     * strings) adds its canonical name to the buffer.
     */
   abstract void _writeCanonicalizedJsCode(CodeBuffer buffer,
                                           ConstantHandler handler);
   abstract List<Constant> getDependencies();
 }
 
+class FunctionConstant extends Constant {
+  Element element;
+
+  FunctionConstant(this.element);
+
+  bool isFunction() => true;
+
+  bool operator ==(var other) {
+    if (other is !FunctionConstant) return false;
+    return other.element === element;
+  }
+
+  String toString() => element.toString();
+  List<Constant> getDependencies() => const <Constant>[];
+  DartString toDartString() {
+    return new DartString.literal(element.name.slowToString());
+  }
+
+  void _writeJsCode(CodeBuffer buffer, ConstantHandler handler) {
+    compiler.internalError(
+        "A constant function does not need specific JS code");
+  }
+
+  void _writeCanonicalizedJsCode(CodeBuffer buffer, ConstantHandler handler) {
+    buffer.add(handler.compiler.namer.isolatePropertiesAccess(element));
+  }
+
+  int hashCode() => element.hashCode();

[ahe, 2012/08/28 13:35:54]

You should make sure that FunctionConstant has a different hashCode from
element. It's good practice, a not-come-back-and-bite-you thing.

+}
+
 class PrimitiveConstant extends Constant {
   abstract get value;
   const PrimitiveConstant();
   bool isPrimitive() => true;
 
   bool operator ==(var other) {
     if (other is !PrimitiveConstant) return false;
     PrimitiveConstant otherPrimitive = other;
     // We use == instead of === so that DartStrings compare correctly.
     return value == otherPrimitive.value;
@@ skipping 446 matching lines @@
   final Set<VariableElement> pendingVariables;
 
   ConstantHandler(Compiler compiler)
       : initialVariableValues = new Map<VariableElement, Dynamic>(),
         compiledConstants = new Map<Constant, String>(),
         pendingVariables = new Set<VariableElement>(),
         super(compiler);
   String get name => 'ConstantHandler';
 
   void registerCompileTimeConstant(Constant constant) {
-    Function ifAbsentThunk = (() => compiler.namer.getFreshGlobalName("CTC"));
+    Function ifAbsentThunk = (() {
+      return constant.isFunction()
+          ? null : compiler.namer.getFreshGlobalName("CTC");
+    });
     compiledConstants.putIfAbsent(constant, ifAbsentThunk);
   }
 
   /**
    * 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.
    */
@@ skipping 324 matching lines @@
   // TODO(floitsch): provide better error-messages.
   Constant visitSend(Send send) {
     Element element = elements[send];
     if (Elements.isStaticOrTopLevelField(element)) {
       if (element.modifiers === null ||
           // TODO(johnniwinther): This should eventually be [isConst].  
           !element.modifiers.isFinalOrConst()) {
         error(send);
       }
       return compiler.compileVariable(element);
+    } else if (Elements.isStaticOrTopLevelFunction(element)
+               && send.isPropertyAccess) {
+      compiler.codegenWorld.staticFunctionsNeedingGetter.add(element);
+      Constant constant = new FunctionConstant(element);
+      compiler.constantHandler.registerCompileTimeConstant(constant);
+      return constant;
     } 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 "-":
@@ skipping 313 matching lines @@
       Constant fieldValue = fieldValues[field];
       if (fieldValue === null) {
         // Use the default value.
         fieldValue = compiler.compileVariable(field);
       }
       jsNewArguments.add(fieldValue);
     });
     return jsNewArguments;
   }
 }