Some cleanup of recompilation

lib/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.
 
 class EnqueueTask extends CompilerTask {
   final Enqueuer codegen;
   final Enqueuer resolution;
 
   String get name() => 'Enqueue';
 
   EnqueueTask(Compiler compiler)
     : codegen = new Enqueuer(compiler),
       resolution = new Enqueuer(compiler),
       super(compiler) {
     codegen.task = this;
     resolution.task = this;
   }
 }
 
 class RecompilationQueue {
   final Queue<WorkItem> queue;
   final Set<Element> queueElements;
+  int processed = 0;
 
   RecompilationQueue()
     : queue = new Queue<WorkItem>(),
       queueElements = new Set<Element>();
 
   void add(Element element, TreeElements elements) {
     if (queueElements.contains(element)) return;
     // TODO(sgjesse): Make this handle constructor bodies as well.
     if (element.kind !== ElementKind.GENERATIVE_CONSTRUCTOR_BODY) {
       queueElements.add(element);
       queue.add(new WorkItem(element, elements));
     }
   }
 
   int get length() => queue.length;
 
   bool isEmpty() => queue.isEmpty();
 
   WorkItem next() {
     WorkItem item = queue.removeLast();
     queueElements.remove(item.element);
+    processed++;
     return item;
   }
 }
 
 class Enqueuer {
   final Compiler compiler; // TODO(ahe): Remove this dependency.
   final Map<String, Link<Element>> instanceMembersByName;
   final Set<ClassElement> seenClasses;
   final Universe universe;
   final Queue<WorkItem> queue;
@@ skipping 13 matching lines @@
 
   bool get isResolutionQueue() => compiler.enqueuer.resolution === this;
 
   TreeElements getCachedElements(Element element) {
     Element owner = element.getOutermostEnclosingMemberOrTopLevel();
     return compiler.enqueuer.resolution.resolvedElements[owner];
   }
 
   void addToWorkList(Element element, [TreeElements elements]) {
     if (element.isForeign()) return;
-    if (compiler.pass == 2) return;
+    if (compiler.phase == Compiler.PHASE_RECOMPILING) return;
     if (queueIsClosed) {
       if (isResolutionQueue && getCachedElements(element) !== null) return;
       compiler.internalErrorOnElement(element, "Work list is closed.");
     }
     if (!isResolutionQueue &&
         element.kind === ElementKind.GENERATIVE_CONSTRUCTOR) {
       registerInstantiatedClass(element.enclosingElement);
     }
     if (elements === null) {
       elements = getCachedElements(element);
     }
     queue.add(new WorkItem(element, elements));
   }
 
   bool canBeRecompiled(Element element) {
     // Only member functions can be recompiled. An exception to this is members
     // of closures. They are processed as part of the enclosing function and not
     // present as a separate element (the call to the closure will be a member
     // function).
     var closure = const SourceString("Closure");
-    return element.isMember() && element.getEnclosingClass().name != closure;
+    return element.isMember() &&
+           element.getEnclosingClass() != compiler.closureClass;

[Søren Gjesse, 2012/06/18 07:00:29]

Turned out that comparing with compiler.closureClass did not work.

[ahe, 2012/06/18 07:38:50]

It MUST work. If it doesn't, then something is wrong. For example, perhaps you
have to look at:

element.getEnclosingClass().superclass

[Søren Gjesse, 2012/06/18 07:44:10]

Then something is wrong. Comparing with compiler.closureClass does not detect
the classes created for local functions and closures. The reason for skipping
them here is that the call function on then cannot be recompiled as they do not
exist as separate top level elements. Maybe they are constructed the wrong way.

[ahe, 2012/06/18 07:55:00]

I don't know. All I know is testing for names does not work. Do you need help
debugging this?

   }
 
   void registerRecompilationCandidate(Element element,
                                       [TreeElements elements]) {
     if (!canBeRecompiled(element)) return;
     if (queueIsClosed) {
       compiler.internalErrorOnElement(element, "Work list is closed.");
     }
     recompilationCandidates.add(element, elements);
   }
@@ skipping 206 matching lines @@
   void registerIsCheck(Element element) {
     universe.isChecks.add(element);
   }
 
   void forEach(f(WorkItem work)) {
     while (!queue.isEmpty()) {
       f(queue.removeLast());
     }
   }
 }