Revert "Avoid eager enqueueing from resolution"

pkg/compiler/lib/src/compiler.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.
 
 library dart2js.compiler_base;
 
 import 'dart:async' show
     EventSink,
     Future;
 
 import '../compiler_new.dart' as api;
 import 'cache_strategy.dart' show
     CacheStrategy;
 import 'closure.dart' as closureMapping show
     ClosureTask;
 import 'common/backend_api.dart' show
     Backend;
 import 'common/codegen.dart' show
     CodegenRegistry,
     CodegenWorkItem;
 import 'common/names.dart' show
     Identifiers,
     Uris;
 import 'common/registry.dart' show
     Registry;
 import 'common/resolution.dart' show
     Parsing,
     Resolution,
-    ResolutionWorkItem,
-    ResolutionWorldImpact;
+    ResolutionWorkItem;
 import 'common/tasks.dart' show
     CompilerTask,
     GenericTask;
 import 'common/work.dart' show
     WorkItem;
 import 'compile_time_constants.dart';
 import 'constants/values.dart';
 import 'core_types.dart' show
     CoreTypes;
 import 'dart_backend/dart_backend.dart' as dart_backend;
@@ skipping 722 matching lines @@
             .then((LibraryElement libraryElement) {
           documentClass = libraryElement.find('Comment');
         });
       }
     }).then((_) => backend.onLibrariesLoaded(loadedLibraries));
   }
 
   bool isProxyConstant(ConstantValue value) {
     FieldElement field = coreLibrary.find('proxy');
     if (field == null) return false;
-    if (!resolution.hasBeenResolved(field)) return false;
+    if (!enqueuer.resolution.hasBeenResolved(field)) return false;
     if (proxyConstant == null) {
       proxyConstant =
           constants.getConstantValue(
               resolver.constantCompiler.compileConstant(field));
     }
     return proxyConstant == value;
   }
 
   Element findRequiredElement(LibraryElement library, String name) {
     var element = library.find(name);
@@ skipping 370 matching lines @@
    * processing the queues). Also compute the number of methods that
    * were resolved, but not compiled (aka excess resolution).
    */
   checkQueues() {
     for (Enqueuer world in [enqueuer.resolution, enqueuer.codegen]) {
       world.forEach((WorkItem work) {
         reporter.internalError(work.element, "Work list is not empty.");
       });
     }
     if (!REPORT_EXCESS_RESOLUTION) return;
-    var resolved = new Set.from(enqueuer.resolution.processedElements);
+    var resolved = new Set.from(enqueuer.resolution.resolvedElements);
     for (Element e in enqueuer.codegen.generatedCode.keys) {
       resolved.remove(e);
     }
     for (Element e in new Set.from(resolved)) {
       if (e.isClass ||
           e.isField ||
           e.isTypeVariable ||
           e.isTypedef ||
           identical(e.kind, ElementKind.ABSTRACT_FIELD)) {
         resolved.remove(e);
       }
       if (identical(e.kind, ElementKind.GENERATIVE_CONSTRUCTOR)) {
         resolved.remove(e);
       }
       if (backend.isBackendLibrary(e.library)) {
         resolved.remove(e);
       }
     }
     reporter.log('Excess resolution work: ${resolved.length}.');
     for (Element e in resolved) {
       reporter.reportWarningMessage(e,
           MessageKind.GENERIC,
           {'text': 'Warning: $e resolved but not compiled.'});
     }
   }
 
-  ResolutionWorldImpact analyzeElement(Element element) {
+  WorldImpact analyzeElement(Element element) {
     assert(invariant(element,
            element.impliesType ||
            element.isField ||
            element.isFunction ||
            element.isGenerativeConstructor ||
            element.isGetter ||
            element.isSetter,
            message: 'Unexpected element kind: ${element.kind}'));
     assert(invariant(element, element is AnalyzableElement,
         message: 'Element $element is not analyzable.'));
     assert(invariant(element, element.isDeclaration));
-    return resolution.analyzeElement(element);
+    ResolutionEnqueuer world = enqueuer.resolution;
+    if (world.hasBeenResolved(element)) {
+      return const WorldImpact();
+    }
+    assert(parser != null);
+    Node tree = parser.parse(element);
+    assert(invariant(element, !element.isSynthesized || tree == null));
+    WorldImpact worldImpact = resolver.resolve(element);
+    if (tree != null && !analyzeSignaturesOnly && !suppressWarnings) {
+      // Only analyze nodes with a corresponding [TreeElements].
+      checker.check(element);
+    }
+    world.registerResolvedElement(element);
+    return worldImpact;
   }
 
-  ResolutionWorldImpact analyze(ResolutionWorkItem work,
-                                ResolutionEnqueuer world) {
+  WorldImpact analyze(ResolutionWorkItem work, ResolutionEnqueuer world) {
     assert(invariant(work.element, identical(world, enqueuer.resolution)));
     assert(invariant(work.element, !work.isAnalyzed,
         message: 'Element ${work.element} has already been analyzed'));
     if (shouldPrintProgress) {
       // TODO(ahe): Add structured diagnostics to the compiler API and
       // use it to separate this from the --verbose option.
       if (phase == PHASE_RESOLVING) {
-        reporter.log(
-            'Resolved ${enqueuer.resolution.processedElements.length} '
+      reporter.log(
+            'Resolved ${enqueuer.resolution.resolvedElements.length} '
             'elements.');
         progress.reset();
       }
     }
     AstElement element = work.element;
-    if (world.hasBeenProcessed(element)) {
-      return const ResolutionWorldImpact();
+    if (world.hasBeenResolved(element)) {
+      return const WorldImpact();
     }
-    ResolutionWorldImpact worldImpact = analyzeElement(element);
+    WorldImpact worldImpact = analyzeElement(element);
     backend.onElementResolved(element, element.resolvedAst.elements);
-    world.registerProcessedElement(element);
     return worldImpact;
   }
 
   WorldImpact codegen(CodegenWorkItem work, CodegenEnqueuer world) {
     assert(invariant(work.element, identical(world, enqueuer.codegen)));
     if (shouldPrintProgress) {
       // TODO(ahe): Add structured diagnostics to the compiler API and
       // use it to separate this from the --verbose option.
       reporter.log(
           'Compiled ${enqueuer.codegen.generatedCode.length} methods.');
@@ skipping 75 matching lines @@
       prevToken = currentToken;
       currentToken = currentToken.next;
     }
     return firstToken;
   }
 
   void reportUnusedCode() {
     void checkLive(member) {
       if (member.isErroneous) return;
       if (member.isFunction) {
-        if (!enqueuer.resolution.hasBeenProcessed(member)) {
+        if (!enqueuer.resolution.hasBeenResolved(member)) {
           reporter.reportHintMessage(
               member, MessageKind.UNUSED_METHOD, {'name': member.name});
         }
       } else if (member.isClass) {
         if (!member.isResolved) {
           reporter.reportHintMessage(
               member, MessageKind.UNUSED_CLASS, {'name': member.name});
         } else {
           member.forEachLocalMember(checkLive);
         }
@@ skipping 139 matching lines @@
   ClassElement symbolClass;
   ClassElement stackTraceClass;
   ClassElement futureClass;
   ClassElement iterableClass;
   ClassElement streamClass;
   ClassElement resourceClass;
 
   _CompilerCoreTypes(this.resolution);
 
   @override
-  InterfaceType get objectType {
-    objectClass.ensureResolved(resolution);
-    return objectClass.rawType;
-  }
+  InterfaceType get objectType => objectClass.computeType(resolution);
 
   @override
-  InterfaceType get boolType {
-    boolClass.ensureResolved(resolution);
-    return boolClass.rawType;
-  }
+  InterfaceType get boolType => boolClass.computeType(resolution);
 
   @override
-  InterfaceType get doubleType {
-    doubleClass.ensureResolved(resolution);
-    return doubleClass.rawType;
-  }
+  InterfaceType get doubleType => doubleClass.computeType(resolution);
 
   @override
-  InterfaceType get functionType {
-    functionClass.ensureResolved(resolution);
-    return functionClass.rawType;
-  }
+  InterfaceType get functionType => functionClass.computeType(resolution);
 
   @override
-  InterfaceType get intType {
-    intClass.ensureResolved(resolution);
-    return intClass.rawType;
-  }
+  InterfaceType get intType => intClass.computeType(resolution);
 
   @override
-  InterfaceType get resourceType {
-    resourceClass.ensureResolved(resolution);
-    return resourceClass.rawType;
-  }
+  InterfaceType get resourceType => resourceClass.computeType(resolution);
 
   @override
   InterfaceType listType([DartType elementType]) {
-    listClass.ensureResolved(resolution);
-    InterfaceType type = listClass.rawType;
+    InterfaceType type = listClass.computeType(resolution);
     if (elementType == null) {
-      return type;
+      return listClass.rawType;
     }
     return type.createInstantiation([elementType]);
   }
 
   @override
   InterfaceType mapType([DartType keyType,
                          DartType valueType]) {
-    mapClass.ensureResolved(resolution);
-    InterfaceType type = mapClass.rawType;
+    InterfaceType type = mapClass.computeType(resolution);
     if (keyType == null && valueType == null) {
-      return type;
+      return mapClass.rawType;
     } else if (keyType == null) {
       keyType = const DynamicType();
     } else if (valueType == null) {
       valueType = const DynamicType();
     }
     return type.createInstantiation([keyType, valueType]);
   }
 
   @override
-  InterfaceType get nullType {
-    nullClass.ensureResolved(resolution);
-    return nullClass.rawType;
-  }
+  InterfaceType get nullType => nullClass.computeType(resolution);
 
   @override
-  InterfaceType get numType {
-    numClass.ensureResolved(resolution);
-    return numClass.rawType;
-  }
+  InterfaceType get numType => numClass.computeType(resolution);
 
   @override
-  InterfaceType get stringType {
-    stringClass.ensureResolved(resolution);
-    return stringClass.rawType;
-  }
+  InterfaceType get stringType => stringClass.computeType(resolution);
 
   @override
-  InterfaceType get symbolType {
-    symbolClass.ensureResolved(resolution);
-    return symbolClass.rawType;
-  }
+  InterfaceType get symbolType => symbolClass.computeType(resolution);
 
   @override
-  InterfaceType get typeType {
-    typeClass.ensureResolved(resolution);
-    return typeClass.rawType;
-  }
+  InterfaceType get typeType => typeClass.computeType(resolution);
 
   @override
   InterfaceType iterableType([DartType elementType]) {
-    iterableClass.ensureResolved(resolution);
-    InterfaceType type = iterableClass.rawType;
+    InterfaceType type = iterableClass.computeType(resolution);
     if (elementType == null) {
-      return type;
+      return iterableClass.rawType;
     }
     return type.createInstantiation([elementType]);
   }
 
   @override
   InterfaceType futureType([DartType elementType]) {
-    futureClass.ensureResolved(resolution);
-    InterfaceType type = futureClass.rawType;
+    InterfaceType type = futureClass.computeType(resolution);
     if (elementType == null) {
-      return type;
+      return futureClass.rawType;
     }
     return type.createInstantiation([elementType]);
   }
 
   @override
   InterfaceType streamType([DartType elementType]) {
-    streamClass.ensureResolved(resolution);
-    InterfaceType type = streamClass.rawType;
+    InterfaceType type = streamClass.computeType(resolution);
     if (elementType == null) {
-      return type;
+      return streamClass.rawType;
     }
     return type.createInstantiation([elementType]);
   }
 }
 
 class _CompilerDiagnosticReporter extends DiagnosticReporter {
   final Compiler compiler;
   final DiagnosticOptions options;
 
   Element _currentElement;
@@ skipping 332 matching lines @@
             const <DiagnosticMessage>[],
             api.Diagnostic.HINT);
       });
     }
   }
 }
 
 // TODO(johnniwinther): Move [ResolverTask] here.
 class _CompilerResolution implements Resolution {
   final Compiler compiler;
-  final Map<Element, ResolutionWorldImpact> _worldImpactCache =
-      <Element, ResolutionWorldImpact>{};
 
   _CompilerResolution(this.compiler);
 
   @override
   DiagnosticReporter get reporter => compiler.reporter;
 
   @override
   Parsing get parsing => compiler.parsing;
 
   @override
@@ skipping 21 matching lines @@
 
   @override
   FunctionSignature resolveSignature(FunctionElement function) {
     return compiler.resolver.resolveSignature(function);
   }
 
   @override
   DartType resolveTypeAnnotation(Element element, TypeAnnotation node) {
     return compiler.resolver.resolveTypeAnnotation(element, node);
   }
-
-  ResolutionWorldImpact analyzeElement(Element element) {
-    return _worldImpactCache.putIfAbsent(element, () {
-      assert(compiler.parser != null);
-      Node tree = compiler.parser.parse(element);
-      assert(invariant(element, !element.isSynthesized || tree == null));
-      ResolutionWorldImpact worldImpact = compiler.resolver.resolve(element);
-      if (tree != null &&
-          !compiler.analyzeSignaturesOnly &&
-          !compiler.suppressWarnings) {
-        // Only analyze nodes with a corresponding [TreeElements].
-        compiler.checker.check(element);
-      }
-      return worldImpact;
-    });
-  }
-
-  @override
-  bool hasBeenResolved(Element element) {
-    return _worldImpactCache.containsKey(element);
-  }
 }
 
 // TODO(johnniwinther): Move [ParserTask], [PatchParserTask], [DietParserTask]
 // and [ScannerTask] here.
 class _CompilerParsing implements Parsing {
   final Compiler compiler;
 
   _CompilerParsing(this.compiler);
 
   @override
   DiagnosticReporter get reporter => compiler.reporter;
 
   @override
   measure(f()) => compiler.parser.measure(f);
 
   @override
   void parsePatchClass(ClassElement cls) {
     compiler.patchParser.measure(() {
       if (cls.isPatch) {
         compiler.patchParser.parsePatchClassNode(cls);
       }
     });
   }
 }