Prototype re-compiling methods in dart2js

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;
+
+  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);
+    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;
   final Map<Element, TreeElements> resolvedElements;
+  final RecompilationQueue recompilationCandidates;
+
   bool queueIsClosed = false;
   EnqueueTask task;
 
   Enqueuer(this.compiler)
     : instanceMembersByName = new Map<String, Link<Element>>(),
       seenClasses = new Set<ClassElement>(),
       universe = new Universe(),
       queue = new Queue<WorkItem>(),
-      resolvedElements = new Map<Element, TreeElements>();
+      resolvedElements = new Map<Element, TreeElements>(),
+      recompilationCandidates = new RecompilationQueue();
 
   bool get isFirstQueue() => 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 (queueIsClosed) {
       if (isFirstQueue && getCachedElements(element) !== null) return;
       compiler.internalErrorOnElement(element, "Work list is closed.");
     }
     if (!isFirstQueue && element.kind === ElementKind.GENERATIVE_CONSTRUCTOR) {
       registerInstantiatedClass(element.enclosingElement);
     }
     if (elements === null) {
       elements = getCachedElements(element);
     }
     queue.add(new WorkItem(element, elements));
   }
 
+  void addToRecompilationCandidates(Element element, [TreeElements elements]) {

[floitsch, 2012/06/13 12:51:10]

maybe
addRecompilationCandidate
registerRecompilationCandidate
addToRecompilationCandidatesQueue

[Søren Gjesse, 2012/06/14 06:37:10]

Changed to registerRecompilationCandidate.

+    if (element.isMember() &&
+        element.getEnclosingClass().name == const SourceString("Closure")) {

[floitsch, 2012/06/13 12:51:10]

explain why.

[Søren Gjesse, 2012/06/14 06:37:10]

Added a function canByRecompiled and placed the explanation there.

+      return;
+    }
+    if (queueIsClosed) {
+      compiler.internalErrorOnElement(element, "Work list is closed.");
+    }
+    recompilationCandidates.add(element, elements);
+  }
+
   void registerInstantiatedClass(ClassElement cls) {
     if (cls.isInterface()) {
       compiler.internalErrorOnElement(
           // Use the current element, as this is where cls is referenced from.
           compiler.currentElement,
           'Expected a class, but $cls is an interface.');
     }
     universe.instantiatedClasses.add(cls);
     onRegisterInstantiatedClass(cls);
   }
@@ skipping 195 matching lines @@
   void registerIsCheck(Element element) {
     universe.isChecks.add(element);
   }
 
   void forEach(f(WorkItem work)) {
     while (!queue.isEmpty()) {
       f(queue.removeLast());
     }
   }
 }