Support getting of static functions.

frog/leg/emitter.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.
 
 /**
  * Generates the code for all used classes in the program. Static fields (even
  * in classes) are ignored, since they can be treated as non-class elements.
  *
  * The code for the containing (used) methods must exist in the [:universe:].
  */
@@ skipping 248 matching lines @@
 
   void emitStaticFunctions(StringBuffer buffer) {
     emitStaticFunctionsWithNamer(buffer,
                                  compiler.universe.generatedCode,
                                  namer.isolatePropertyAccess);
     emitStaticFunctionsWithNamer(buffer,
                                  compiler.universe.generatedBailoutCode,
                                  namer.isolateBailoutPropertyAccess);
   }
 
+  void emitStaticFunctionGetters(StringBuffer buffer) {
+    Set<FunctionElement> functionsNeedingGetter =
+        compiler.universe.staticFunctionsNeedingGetter;
+    for (FunctionElement element in functionsNeedingGetter) {
+      // The static function does not have the correct name. Since
+      // [addParameterStubs] use the name to create its stubs we simply
+      // create a fake element with the correct name.
+      // Note: the callElement will not have the correct modifiers (in case
+      // of static functions) and will not have any enclosingElement.
+      FunctionElement callElement =
+          new FunctionElement.from(Namer.CLOSURE_INVOCATION_NAME,
+                                   element,
+                                   null);
+      String staticName = namer.isolatePropertyAccess(element);
+      int parameterCount = element.parameterCount(compiler);
+      String invocationName =
+          namer.instanceMethodName(callElement.name, parameterCount);
+      buffer.add("$staticName.$invocationName = $staticName;\n");
+      addParameterStubs(callElement, staticName, buffer);
+    }
+  }
+
   void emitStaticNonFinalFieldInitializations(StringBuffer buffer) {
     // Adds initializations inside the Isolate constructor.
     // Example:
     //    function Isolate() {
     //       this.staticNonFinal = Isolate.prototype.someVal;
     //       ...
     //    }
     CompileTimeConstantHandler constants = compiler.compileTimeConstantHandler;
     List<VariableElement> staticNonFinalFields =
         constants.getStaticNonFinalFieldsForEmission();
@@ skipping 71 matching lines @@
 
   String assembleProgram() {
     measure(() {
       StringBuffer buffer = new StringBuffer();
       buffer.add('function ${namer.ISOLATE}() {');
       emitStaticNonFinalFieldInitializations(buffer);
       buffer.add('}\n\n');
       emitClasses(buffer);
       emitNoSuchMethodCalls(buffer);
       emitStaticFunctions(buffer);
+      emitStaticFunctionGetters(buffer);
       emitStaticFinalFieldInitializations(buffer);
       buffer.add('var ${namer.CURRENT_ISOLATE} = new ${namer.ISOLATE}();\n');
       Element main = compiler.mainApp.find(Compiler.MAIN);
       buffer.add('${namer.isolateAccess(main)}();\n');
       compiler.assembledCode = buffer.toString();
     });
     return compiler.assembledCode;
   }
 }