Re-apply "Implement operator== and hashCode for bound closures."

sdk/lib/_internal/compiler/implementation/enqueue.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.
 
 part of dart2js;
 
 class EnqueueTask extends CompilerTask {
   final ResolutionEnqueuer resolution;
   final CodegenEnqueuer codegen;
 
@@ skipping 69 matching lines @@
         compiler.backend.nativeResolutionEnqueuer(resolution);
   }
 }
 
 abstract class Enqueuer {
   final String name;
   final Compiler compiler; // TODO(ahe): Remove this dependency.
   final Function itemCompilationContextCreator;
   final Map<String, Link<Element>> instanceMembersByName
       = new Map<String, Link<Element>>();
+  final Map<String, Link<Element>> instanceFunctionsByName
+      = new Map<String, Link<Element>>();
   final Set<ClassElement> seenClasses = new Set<ClassElement>();
   final Universe universe = new Universe();
 
   bool queueIsClosed = false;
   EnqueueTask task;
   native.NativeEnqueuer nativeEnqueuer;  // Set by EnqueueTask
 
   Enqueuer(this.name, this.compiler,
            ItemCompilationContext itemCompilationContextCreator())
     : this.itemCompilationContextCreator = itemCompilationContextCreator;
@@ skipping 102 matching lines @@
       // enclosing class, since the metadata has not been parsed yet.
       if (!member.enclosingElement.isNative()) return;
     }
 
     String memberName = member.name.slowToString();
 
     if (member.kind == ElementKind.FUNCTION) {
       if (member.name == Compiler.NO_SUCH_METHOD) {
         enableNoSuchMethod(member);
       }
-      if (universe.hasInvocation(member, compiler)) {
-        return addToWorkList(member);
-      }
       // If there is a property access with the same name as a method we
       // need to emit the method.
       if (universe.hasInvokedGetter(member, compiler)) {
-        // We will emit a closure, so make sure the closure class is
+        // We will emit a closure, so make sure the bound closure class is
         // generated.
-        compiler.closureClass.ensureResolved(compiler);
-        registerInstantiatedClass(compiler.closureClass,
+        registerInstantiatedClass(compiler.boundClosureClass,
                                   // Precise dependency is not important here.
                                   compiler.globalDependencies);
         return addToWorkList(member);
       }
+      // Store the member in [instanceFunctionsByName] to catch
+      // getters on the function.
+      Link<Element> members = instanceFunctionsByName.putIfAbsent(
+          memberName, () => const Link<Element>());
+      instanceFunctionsByName[memberName] = members.prepend(member);
+      if (universe.hasInvocation(member, compiler)) {
+        return addToWorkList(member);
+      }
     } else if (member.kind == ElementKind.GETTER) {
       if (universe.hasInvokedGetter(member, compiler)) {
         return addToWorkList(member);
       }
       // We don't know what selectors the returned closure accepts. If
       // the set contains any selector we have to assume that it matches.
       if (universe.hasInvocation(member, compiler)) {
         return addToWorkList(member);
       }
     } else if (member.kind == ElementKind.SETTER) {
@@ skipping 143 matching lines @@
           registerInvokedGetter(element.name, selector);
         }
       }
     }
   }
 
   /// Called when [:new Symbol(...):] is seen.
   void registerNewSymbol(TreeElements elements) {
   }
 
-  processInstanceMembers(SourceString n, bool f(Element e)) {
+  processLink(Map<String, Link<Element>> map,
+              SourceString n,
+              bool f(Element e)) {
     String memberName = n.slowToString();
-    Link<Element> members = instanceMembersByName[memberName];
+    Link<Element> members = map[memberName];
     if (members != null) {
       LinkBuilder<Element> remaining = new LinkBuilder<Element>();
       for (; !members.isEmpty; members = members.tail) {
         if (!f(members.head)) remaining.addLast(members.head);
       }
-      instanceMembersByName[memberName] = remaining.toLink();
+      map[memberName] = remaining.toLink();
     }
   }
 
+  processInstanceMembers(SourceString n, bool f(Element e)) {
+    processLink(instanceMembersByName, n, f);
+  }
+
+  processInstanceFunctions(SourceString n, bool f(Element e)) {
+    processLink(instanceFunctionsByName, n, f);
+  }
+
   void handleUnseenSelector(SourceString methodName, Selector selector) {
     processInstanceMembers(methodName, (Element member) {
       if (selector.appliesUnnamed(member, compiler)) {
         if (member.isField() && member.enclosingElement.isNative()) {
           if (selector.isGetter() || selector.isCall()) {
             nativeEnqueuer.registerFieldLoad(member);
             // We have to also handle storing to the field because we only get
             // one look at each member and there might be a store we have not
             // seen yet.
             // TODO(sra): Process fields for storing separately.
             nativeEnqueuer.registerFieldStore(member);
           } else {
             nativeEnqueuer.registerFieldStore(member);
             // We have to also handle loading from the field because we only get
             // one look at each member and there might be a load we have not
             // seen yet.
             // TODO(sra): Process fields for storing separately.
             nativeEnqueuer.registerFieldLoad(member);
           }
         } else {
           addToWorkList(member);
         }
         return true;
       }
       return false;
     });
+    if (selector.isGetter()) {
+      processInstanceFunctions(methodName, (Element member) {
+        if (selector.appliesUnnamed(member, compiler)) {
+          // We will emit a closure, so make sure the bound closure class is
+          // generated.
+          registerInstantiatedClass(compiler.boundClosureClass,
+                                    // Precise dependency is not important here.
+                                    compiler.globalDependencies);
+          return true;
+        }
+        return false;
+      });
+    }
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [element] must be a declaration element.
    */
   void registerStaticUse(Element element) {
     if (element == null) return;
     assert(invariant(element, element.isDeclaration));
     addToWorkList(element);
   }
 
   void registerGetOfStaticFunction(FunctionElement element) {
     registerStaticUse(element);
+    registerInstantiatedClass(compiler.closureClass,
+                              compiler.globalDependencies);
     universe.staticFunctionsNeedingGetter.add(element);
   }
 
   void registerDynamicInvocation(SourceString methodName, Selector selector) {
     assert(selector != null);
     registerInvocation(methodName, selector);
   }
 
   void registerDynamicInvocationOf(Element element, Selector selector) {
     assert(selector.isCall()
@@ skipping 269 matching lines @@
     while(!queue.isEmpty) {
       // TODO(johnniwinther): Find an optimal process order for codegen.
       f(queue.removeLast());
     }
   }
 
   void _logSpecificSummary(log(message)) {
     log('Compiled ${generatedCode.length} methods.');
   }
 }