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{

[kasperl, 2012/08/27 13:17:26]

Space between Constant and {.

[ngeoffray, 2012/08/27 14:09:09]

Done.

+  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 _writeCanonicalizedJsCode(CodeBuffer buffer, ConstantHandler handler) {

[kasperl, 2012/08/27 13:17:26]

Don't you need to also provide an implementation of _writeJsCode? It's abstract
in Constant.

[ngeoffray, 2012/08/27 14:09:09]

Yes, but it will never be called because there's nothing to write for functions
(this method is used for the definition of a CTC, and a function is already
defined). I made it throw an internalError.

+    buffer.add(handler.compiler.namer.isolatePropertiesAccess(element));
+  }
+
+  int hashCode() => element.hashCode();
+}
+
 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 791 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);

[kasperl, 2012/08/27 13:17:26]

Could this registration happen later in the codegen? It feels a bit nasty to
have the registration in here -- I'd rather have it in codegen where we do tons
of registration already.

[ngeoffray, 2012/08/27 14:09:09]

It has to be done here, the codegen only handles uses of the method in a method
body. For fields, the CTC handler is the codegen.

+      return new FunctionConstant(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 "-":
@@ skipping 313 matching lines @@
       Constant fieldValue = fieldValues[field];
       if (fieldValue === null) {
         // Use the default value.
         fieldValue = compiler.compileVariable(field);
       }
       jsNewArguments.add(fieldValue);
     });
     return jsNewArguments;
   }
 }