Avoid eager enqueueing from resolution

pkg/compiler/lib/src/inferrer/type_graph_inferrer.dart

 // Copyright (c) 2013, 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.
 
 library type_graph_inferrer;
 
 import 'dart:collection' show
     IterableBase,
     Queue;
 
@@ skipping 653 matching lines @@
     workQueue.addAll(info.typeInfoMap.values);
     workQueue.add(info);
   }
 
   void runOverAllElements() {
     if (compiler.disableTypeInference) return;
     if (compiler.verbose) {
       compiler.progress.reset();
     }
     sortResolvedElements().forEach((Element element) {
+      assert(compiler.enqueuer.resolution.hasBeenProcessed(element));
       if (compiler.shouldPrintProgress) {
         reporter.log('Added $addedInGraph elements in inferencing graph.');
         compiler.progress.reset();
       }
       // This also forces the creation of the [ElementTypeInformation] to ensure
       // it is in the graph.
       types.withMember(element, () => analyze(element, null));
     });
     reporter.log('Added $addedInGraph elements in inferencing graph.');
 
@@ skipping 529 matching lines @@
     allocatedCalls.add(info);
     return info;
   }
 
   // Sorts the resolved elements by size. We do this for this inferrer
   // to get the same results for [ListTracer] compared to the
   // [SimpleTypesInferrer].
   Iterable<Element> sortResolvedElements() {
     int max = 0;
     Map<int, Setlet<Element>> methodSizes = new Map<int, Setlet<Element>>();
-    compiler.enqueuer.resolution.resolvedElements.forEach((AstElement element) {
+    compiler.enqueuer.resolution.processedElements.forEach((AstElement element) {
         // TODO(ngeoffray): Not sure why the resolver would put a null
         // mapping.
-        if (!compiler.enqueuer.resolution.hasBeenResolved(element)) return;
+        if (!compiler.enqueuer.resolution.hasBeenProcessed(element)) return;
         TreeElementMapping mapping = element.resolvedAst.elements;
         element = element.implementation;
         if (element.impliesType) return;
         assert(invariant(element,
             element.isField ||
             element.isFunction ||
             element.isGenerativeConstructor ||
             element.isGetter ||
             element.isSetter,
             message: 'Unexpected element kind: ${element.kind}'));
@@ skipping 152 matching lines @@
   bool isCalledOnce(Element element) {
     if (compiler.disableTypeInference) return false;
     MemberTypeInformation info = inferrer.types.getInferredTypeOf(element);
     return info.isCalledOnce();
   }
 
   void clear() {
     inferrer.clear();
   }
 }