Change the type inference for fields 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('codegen enqueuer', compiler,
                              compiler.backend.createItemCompilationContext),
       resolution = new Enqueuer('resolution enqueuer', compiler,
                                 compiler.backend.createItemCompilationContext),
       super(compiler) {
     codegen.task = this;
     resolution.task = this;
   }
 }
 
-class RecompilationQueue {
-  final Function itemCompilationContextCreator;
-  final Queue<WorkItem> queue;
-  final Set<Element> queueElements;
-  int processed = 0;
-
-  RecompilationQueue(ItemCompilationContext itemCompilationContextCreator())
-    : this.itemCompilationContextCreator = itemCompilationContextCreator,
-      queue = new Queue<WorkItem>(),
-      queueElements = new Set<Element>();
-
-  void add(Element element, TreeElements elements) {
-    if (queueElements.contains(element)) return;
-    queueElements.add(element);
-    queue.add(new WorkItem(element, elements, itemCompilationContextCreator()));
-  }
-
-  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 String name;
   final Compiler compiler; // TODO(ahe): Remove this dependency.
   final Function itemCompilationContextCreator;
   final Map<String, Link<Element>> instanceMembersByName;
   final Set<ClassElement> seenClasses;
   final Universe universe;
   final Queue<WorkItem> queue;
 
   /**
    * Map from declaration elements to the [TreeElements] object holding the
    * resolution mapping for the element implementation.
    *
    * Invariant: Key elements are declaration elements.
    */
   final Map<Element, TreeElements> resolvedElements;
-  final RecompilationQueue recompilationCandidates;
 
   bool queueIsClosed = false;
   EnqueueTask task;
 
   Enqueuer(this.name, this.compiler,
            ItemCompilationContext itemCompilationContextCreator())
     : this.itemCompilationContextCreator = itemCompilationContextCreator,
       instanceMembersByName = new Map<String, Link<Element>>(),
       seenClasses = new Set<ClassElement>(),
       universe = new Universe(),
       queue = new Queue<WorkItem>(),
-      resolvedElements = new Map<Element, TreeElements>(),
-      recompilationCandidates =
-          new RecompilationQueue(itemCompilationContextCreator);
+      resolvedElements = new Map<Element, TreeElements>();
 
   bool get isResolutionQueue => compiler.enqueuer.resolution === this;
 
   TreeElements getCachedElements(Element element) {
     // TODO(ngeoffray): Get rid of this check.
     if (element.enclosingElement.isClosure()) {
       closureMapping.ClosureClassElement cls = element.enclosingElement;
       element = cls.methodElement;
     }
     Element owner = element.getOutermostEnclosingMemberOrTopLevel();
@@ skipping 11 matching lines @@
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [element] must be a declaration element.
    */
   void addToWorkList(Element element, [TreeElements elements]) {
     assert(invariant(element, element.isDeclaration));
     if (element.isForeign()) 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.getEnclosingClass());
     }
     if (elements === null) {
       elements = getCachedElements(element);
@@ skipping 23 matching lines @@
    *
    * Invariant: [element] must be an declaration element.
    */
   void eagerRecompile(Element element) {
     assert(invariant(element, element.isDeclaration));
     universe.generatedCode.remove(element);
     universe.generatedBailoutCode.remove(element);
     addToWorkList(element);
   }
 
-  void registerRecompilationCandidate(Element element,
-                                      [TreeElements elements]) {
-    if (queueIsClosed) {
-      compiler.internalErrorOnElement(element, "$name 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 147 matching lines @@
   }
 
   void handleUnseenSelector(SourceString methodName, Selector selector) {
     processInstanceMembers(methodName, (Element member) {
       if (selector.applies(member, compiler)) {
         addToWorkList(member);
         return true;
       }
       return false;
     });
+    // TODO(sgjesse): Add subscription to the enqueuer to deliver this
+    // information to the JavaScript backend instead of this hardcoded hack.
+    if (compiler.backend is js_backend.JavaScriptBackend) {

[ngeoffray, 2012/09/24 08:15:49]

So this has two effects: cancel previous optimizations and avoid doing new
optimizations based on the field.

It looks like you should check for setter kind here on the selector, otherwise
you would invalidate even if it's a method that is being called.

Also, I really don't like having this here. You're loosing the type information
on the selector, which might invalidate or not the optimizations.

[Søren Gjesse, 2012/09/24 15:06:50]

Moved to codegen.

+      compiler.backend.addedDynamicSetter(selector);
+    }
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [element] must be a declaration element.
    */
   void registerStaticUse(Element element) {
     if (element == null) return;
     assert(invariant(element, element.isDeclaration));
@@ skipping 49 matching lines @@
   }
 
   void forEach(f(WorkItem work)) {
     while (!queue.isEmpty()) {
       f(queue.removeLast()); // TODO(kasperl): Why isn't this removeFirst?
     }
   }
 
   String toString() => 'Enqueuer($name)';
 }