Allow method-calls to getters (assuming they contain closures).

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 352 matching lines @@
           if (member.kind == ElementKind.FUNCTION) {
             if (compiler.universe.invokedGetters.contains(member.name)) {
               emitDynamicFunctionGetter(buffer, currentClass, member);
             }
           }
         }
       }
     }
   }
 
+  void emitCallStubForGetter(StringBuffer buffer,
+                             ClassElement enclosingClass,
+                             Element member,
+                             Set<Selector> selectors) {
+    String prototype =
+        "${namer.isolatePropertyAccess(enclosingClass)}.prototype";
+    String getter;
+    if (member.kind == ElementKind.GETTER) {
+      getter = "this.${namer.getterName(member.name)}()";
+    } else {
+      getter = "this.${namer.instanceFieldName(member.name)}";
+    }
+    for (Selector selector in selectors) {
+      String invocationName =
+          namer.instanceMethodInvocationName(member.name, selector);
+      SourceString callName = Namer.CLOSURE_INVOCATION_NAME;
+      String closureCallName =
+          namer.instanceMethodInvocationName(callName, selector);
+      List<String> arguments = <String>[];
+      for (int i = 0; i < selector.argumentCount; i++) {
+        arguments.add("arg$i");
+      }
+      String joined = Strings.join(arguments, ", ");
+      buffer.add("$prototype.$invocationName = function($joined) {\n");
+      buffer.add("  return $getter.$closureCallName($joined);\n");
+      buffer.add("};\n");
+    }
+  }
+
+  void emitCallStubForGetters(StringBuffer buffer) {
+    for (ClassElement classElement in compiler.universe.instantiatedClasses) {
+      for (ClassElement currentClass = classElement;
+           currentClass !== null;
+           currentClass = currentClass.superclass) {
+        // TODO(floitsch): we don't need to deal with members that have been
+        // overwritten by subclasses.
+        for (Element member in currentClass.members) {
+          if (!member.isInstanceMember()) continue;
+          if (member.kind == ElementKind.GETTER ||
+              member.kind == ElementKind.FIELD) {
+            Set<Selector> selectors =
+                compiler.universe.invokedNames[member.name];
+            if (selectors == null || selectors.isEmpty()) continue;
+            emitCallStubForGetter(buffer, currentClass, member, selectors);
+          }
+        }
+      }
+    }    
+  }
+
   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 73 matching lines @@
     measure(() {
       StringBuffer buffer = new StringBuffer();
       buffer.add('function ${namer.ISOLATE}() {');
       emitStaticNonFinalFieldInitializations(buffer);
       buffer.add('}\n\n');
       emitClasses(buffer);
       emitNoSuchMethodCalls(buffer);
       emitStaticFunctions(buffer);
       emitStaticFunctionGetters(buffer);
       emitDynamicFunctionGetters(buffer);
+      emitCallStubForGetters(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;
   }
 }