Fix bug where the closure-invocation method was not mangled correctly.

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.
 
 /**
+ * A function element that represents a closure call. The signature is copied
+ * from the given element.
+ */
+class ClosureInvocationElement extends FunctionElement {
+  ClosureInvocationElement(SourceString name,
+                           FunctionElement other)
+      : super.from(name, other, null);
+
+  isInstanceMember() => true;
+}
+
+/**
  * 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:].
  */
 class CodeEmitterTask extends CompilerTask {
   static final String INHERIT_FUNCTION = '''
 function(child, parent) {
   if (child.prototype.__proto__) {
     child.prototype.__proto__ = parent.prototype;
@@ skipping 472 matching lines @@
                                  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.
+      // Note: the callElement will not have any enclosingElement.
       FunctionElement callElement =
-          new FunctionElement.from(Namer.CLOSURE_INVOCATION_NAME,
-                                   element,
-                                   null);
+          new ClosureInvocationElement(Namer.CLOSURE_INVOCATION_NAME, element);
       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, (name) => '$staticName.$name', buffer);
     }
   }
 
   void emitDynamicFunctionGetter(StringBuffer buffer,
@@ skipping 33 matching lines @@
     ClassElement objectClass =
         compiler.coreLibrary.find(const SourceString('Object'));
     String superName = namer.isolatePropertyAccess(objectClass);
     buffer.add('${inheritsName}($isolateAccess, $superName);\n');
 
     String prototype = "$isolateAccess.prototype";
 
     // Now add the methods on the closure class. The instance method 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.
+    // Note: the callElement will not have any enclosingElement.
     FunctionElement callElement =
-        new FunctionElement.from(Namer.CLOSURE_INVOCATION_NAME, member, null);
+        new ClosureInvocationElement(Namer.CLOSURE_INVOCATION_NAME, member);
 
     int parameterCount = member.parameterCount(compiler);
     String invocationName =
         namer.instanceMethodName(callElement.name, parameterCount);
     String targetName = namer.instanceMethodName(member.name, parameterCount);
     List<String> arguments = new List<String>(parameterCount);
     for (int i = 0; i < parameterCount; i++) {
       arguments[i] = "arg$i";
     }
     String joinedArgs = Strings.join(arguments, ", ");
@@ skipping 196 matching lines @@
       emitCompileTimeConstants(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;
   }
 }