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;
+    ResolutionWorkItem,
+    ResolutionWorldImpact;
 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 866 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 (!enqueuer.resolution.hasBeenResolved(field)) return false;
+    if (!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 389 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) {
         internalError(work.element, "Work list is not empty.");
       });
     }
     if (!REPORT_EXCESS_RESOLUTION) return;
-    var resolved = new Set.from(enqueuer.resolution.resolvedElements);
+    var resolved = new Set.from(enqueuer.resolution.processedElements);
     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);
       }
     }
     log('Excess resolution work: ${resolved.length}.');
     for (Element e in resolved) {
       reportWarningMessage(e,
           MessageKind.GENERIC,
           {'text': 'Warning: $e resolved but not compiled.'});
     }
   }
 
-  WorldImpact analyzeElement(Element element) {
+  ResolutionWorldImpact 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));
-    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;
+    return resolution.analyzeElement(element);
   }
 
-  WorldImpact analyze(ResolutionWorkItem work, ResolutionEnqueuer world) {
+  ResolutionWorldImpact 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) {
-        log('Resolved ${enqueuer.resolution.resolvedElements.length} '
+        log('Resolved ${enqueuer.resolution.processedElements.length} '
             'elements.');
         progress.reset();
       }
     }
     AstElement element = work.element;
-    if (world.hasBeenResolved(element)) {
-      return const WorldImpact();
+    if (world.hasBeenProcessed(element)) {
+      return const ResolutionWorldImpact();
     }
-    WorldImpact worldImpact = analyzeElement(element);
+    ResolutionWorldImpact 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.
       log('Compiled ${enqueuer.codegen.generatedCode.length} methods.');
       progress.reset();
@@ skipping 209 matching lines @@
       prevToken = currentToken;
       currentToken = currentToken.next;
     }
     return firstToken;
   }
 
   void reportUnusedCode() {
     void checkLive(member) {
       if (member.isErroneous) return;
       if (member.isFunction) {
-        if (!enqueuer.resolution.hasBeenResolved(member)) {
+        if (!enqueuer.resolution.hasBeenProcessed(member)) {
           reportHintMessage(
               member, MessageKind.UNUSED_METHOD, {'name': member.name});
         }
       } else if (member.isClass) {
         if (!member.isResolved) {
           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.computeType(resolution);
+  InterfaceType get objectType {
+    objectClass.ensureResolved(resolution);
+    return objectClass.rawType;
+  }
 
   @override
-  InterfaceType get boolType => boolClass.computeType(resolution);
+  InterfaceType get boolType {
+    boolClass.ensureResolved(resolution);
+    return boolClass.rawType;
+  }
 
   @override
-  InterfaceType get doubleType => doubleClass.computeType(resolution);
+  InterfaceType get doubleType {
+    doubleClass.ensureResolved(resolution);
+    return doubleClass.rawType;
+  }
 
   @override
-  InterfaceType get functionType => functionClass.computeType(resolution);
+  InterfaceType get functionType {
+    functionClass.ensureResolved(resolution);
+    return functionClass.rawType;
+  }
 
   @override
-  InterfaceType get intType => intClass.computeType(resolution);
+  InterfaceType get intType {
+    intClass.ensureResolved(resolution);
+    return intClass.rawType;
+  }
 
   @override
-  InterfaceType get resourceType => resourceClass.computeType(resolution);
+  InterfaceType get resourceType {
+    resourceClass.ensureResolved(resolution);
+    return resourceClass.rawType;
+  }
 
   @override
   InterfaceType listType([DartType elementType]) {
-    InterfaceType type = listClass.computeType(resolution);
+    listClass.ensureResolved(resolution);
+    InterfaceType type = listClass.rawType;
     if (elementType == null) {
-      return listClass.rawType;
+      return type;
     }
     return type.createInstantiation([elementType]);
   }
 
   @override
   InterfaceType mapType([DartType keyType,
                          DartType valueType]) {
-    InterfaceType type = mapClass.computeType(resolution);
+    mapClass.ensureResolved(resolution);
+    InterfaceType type = mapClass.rawType;
     if (keyType == null && valueType == null) {
-      return mapClass.rawType;
+      return type;
     } else if (keyType == null) {
       keyType = const DynamicType();
     } else if (valueType == null) {
       valueType = const DynamicType();
     }
     return type.createInstantiation([keyType, valueType]);
   }
 
   @override
-  InterfaceType get nullType => nullClass.computeType(resolution);
+  InterfaceType get nullType {
+    nullClass.ensureResolved(resolution);
+    return nullClass.rawType;
+  }
 
   @override
-  InterfaceType get numType => numClass.computeType(resolution);
+  InterfaceType get numType {
+    numClass.ensureResolved(resolution);
+    return numClass.rawType;
+  }
 
   @override
-  InterfaceType get stringType => stringClass.computeType(resolution);
+  InterfaceType get stringType {
+    stringClass.ensureResolved(resolution);
+    return stringClass.rawType;
+  }
 
   @override
-  InterfaceType get symbolType => symbolClass.computeType(resolution);
+  InterfaceType get symbolType {
+    symbolClass.ensureResolved(resolution);
+    return symbolClass.rawType;
+  }
 
   @override
-  InterfaceType get typeType => typeClass.computeType(resolution);
+  InterfaceType get typeType {
+    typeClass.ensureResolved(resolution);
+    return typeClass.rawType;
+  }
 
   @override
   InterfaceType iterableType([DartType elementType]) {
-    InterfaceType type = iterableClass.computeType(resolution);
+    iterableClass.ensureResolved(resolution);
+    InterfaceType type = iterableClass.rawType;
     if (elementType == null) {
-      return iterableClass.rawType;
+      return type;
     }
     return type.createInstantiation([elementType]);
   }
 
   @override
   InterfaceType futureType([DartType elementType]) {
-    InterfaceType type = futureClass.computeType(resolution);
+    futureClass.ensureResolved(resolution);
+    InterfaceType type = futureClass.rawType;
     if (elementType == null) {
-      return futureClass.rawType;
+      return type;
     }
     return type.createInstantiation([elementType]);
   }
 
   @override
   InterfaceType streamType([DartType elementType]) {
-    InterfaceType type = streamClass.computeType(resolution);
+    streamClass.ensureResolved(resolution);
+    InterfaceType type = streamClass.rawType;
     if (elementType == null) {
-      return streamClass.rawType;
+      return type;
     }
     return type.createInstantiation([elementType]);
   }
 }
 
 // TODO(johnniwinther): Move [ResolverTask] here.
 class _CompilerResolution implements Resolution {
   final Compiler compiler;
+  final Map<Element, ResolutionWorldImpact> _worldImpactCache =
+      <Element, ResolutionWorldImpact>{};
 
   _CompilerResolution(this.compiler);
 
   @override
   DiagnosticListener get listener => compiler;
 
   @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
   DiagnosticListener get listener => compiler;
 
   @override
   measure(f()) => compiler.parser.measure(f);
 
   @override
   void parsePatchClass(ClassElement cls) {
     compiler.patchParser.measure(() {
       if (cls.isPatch) {
         compiler.patchParser.parsePatchClassNode(cls);
       }
     });
   }
 }