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

frog/leg/compiler.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 WorkItem {
   final Element element;
   TreeElements resolutionTree;
   Function run;
   Map<int, BailoutInfo> bailouts = null;
   bool allowSpeculativeOptimization = true;
@@ skipping 168 matching lines @@
     library.define(new ForeignElement(
         const SourceString('JS'), library), this);
     library.define(new ForeignElement(
         const SourceString('UNINTERCEPTED'), library), this);
     library.define(new ForeignElement(
         const SourceString('JS_HAS_EQUALS'), library), this);
   }
 
   void enqueueInvokedInstanceMethods() {
     // TODO(floitsch): find a more efficient way of doing this.
+
     // Run through the classes and see if we need to compile methods.
     for (ClassElement classElement in universe.instantiatedClasses) {
       for (ClassElement currentClass = classElement;
            currentClass !== null;
            currentClass = currentClass.superclass) {
         // TODO(floitsch): we don't need to add members that have been
         // overwritten by subclasses.
         for (Element member in currentClass.members) {
           if (universe.generatedCode[member] !== null) continue;
           if (!member.isInstanceMember()) continue;
           if (member.kind == ElementKind.FUNCTION) {
             Set<Selector> selectors = universe.invokedNames[member.name];
             if (selectors != null) {
               for (Selector selector in selectors) {
                 if (selector.applies(this, member)) {
                   addToWorklist(member);
                   break;
                 }
               }
             }
             // If there is a property access with the same name as a method we
             // need to emit the method.
             if (universe.invokedGetters.contains(member.name)) {
               addToWorklist(member);
             }
           } else if (member.kind == ElementKind.GETTER) {
             if (universe.invokedGetters.contains(member.name)) {
               addToWorklist(member);
             }
+            // A method invocation like in o.foo(x, y) might actually be an
+            // invocation of the getter foo followed by an invocation of the
+            // returned closure.
+            Set<Selector> invokedSelectors = universe.invokedNames[member.name];
+            // We don't know what selectors the returned closure accepts. If
+            // the set contains any selector we have to assume that it matches.
+            if (invokedSelectors !== null && !invokedSelectors.isEmpty()) {
+              addToWorklist(member);
+            }
           } else if (member.kind === ElementKind.SETTER) {
              if (universe.invokedSetters.contains(member.name)) {
               addToWorklist(member);
             }
           }
+
+          // Make sure that the closure understands a call with the given
+          // selector. For a method-invocation of the form o.foo(a: 499), we
+          // need to make sure that closures can handle the optional argument if
+          // there exists a field or getter 'foo'.
+          if (member.kind === ElementKind.GETTER ||
+              member.kind === ElementKind.FIELD) {
+            Set<Selector> invokedSelectors = universe.invokedNames[member.name];
+            if (invokedSelectors != null) {
+              for (Selector selector in invokedSelectors) {
+                registerDynamicInvocation(Namer.CLOSURE_INVOCATION_NAME,
+                                          selector);
+              }
+            }
+          }
         }
       }
     }
   }
 
   void runCompiler(Script script) {
     scanBuiltinLibraries();
     mainApp = new LibraryElement(script);
     Element element;
     withCurrentElement(mainApp, () {
@@ skipping 141 matching lines @@
 
 class CompilerCancelledException implements Exception {
   final String reason;
   CompilerCancelledException(this.reason);
 
   String toString() {
     String banner = 'compiler cancelled';
     return (reason !== null) ? '$banner: $reason' : '$banner';
   }
 }