Further encapsulate Enqueuer

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;
@@ skipping 38 matching lines @@
         LibraryLoaderTask,
         LoadedLibraries,
         LibraryLoaderListener,
         ScriptLoader;
 import 'mirrors_used.dart' show MirrorUsageAnalyzerTask;
 import 'null_compiler_output.dart' show NullCompilerOutput, NullSink;
 import 'options.dart' show CompilerOptions, DiagnosticOptions;
 import 'parser/diet_parser_task.dart' show DietParserTask;
 import 'parser/parser_task.dart' show ParserTask;
 import 'patch_parser.dart' show PatchParserTask;
-import 'resolution/registry.dart' show ResolutionRegistry;
 import 'resolution/resolution.dart' show ResolverTask;
-import 'resolution/tree_elements.dart' show TreeElementMapping;
 import 'resolved_uri_translator.dart';
 import 'scanner/scanner_task.dart' show ScannerTask;
 import 'script.dart' show Script;
 import 'serialization/task.dart' show SerializationTask;
 import 'ssa/nodes.dart' show HInstruction;
 import 'tokens/token.dart' show StringToken, Token, TokenPair;
 import 'tokens/token_map.dart' show TokenMap;
 import 'tracer.dart' show Tracer;
 import 'tree/tree.dart' show Node, TypeAnnotation;
 import 'typechecker.dart' show TypeCheckerTask;
 import 'types/types.dart' show GlobalTypeInferenceTask;
-import 'types/masks.dart' show CommonMasks;
 import 'universe/selector.dart' show Selector;
 import 'universe/world_builder.dart'
     show ResolutionWorldBuilder, CodegenWorldBuilder;
-import 'universe/use.dart' show StaticUse;
+import 'universe/use.dart' show StaticUse, TypeUse;
 import 'universe/world_impact.dart'
     show
         ImpactStrategy,
         WorldImpact,
         WorldImpactBuilder,
         WorldImpactBuilderImpl;
 import 'util/util.dart' show Link, Setlet;
 import 'world.dart' show ClosedWorld, ClosedWorldRefiner, OpenWorld, WorldImpl;
 
 typedef Backend MakeBackendFuncion(Compiler compiler);
@@ skipping 536 matching lines @@
   /// This operation assumes an unclosed resolution queue and is only supported
   /// when the '--analyze-main' option is used.
   Future<LibraryElement> analyzeUri(Uri libraryUri,
       {bool skipLibraryWithPartOfTag: true}) {
     assert(options.analyzeMain);
     reporter.log('Analyzing $libraryUri (${options.buildId})');
     return libraryLoader
         .loadLibrary(libraryUri, skipFileWithPartOfTag: true)
         .then((LibraryElement library) {
       if (library == null) return null;
-      fullyEnqueueLibrary(library, enqueuer.resolution);
+      enqueuer.resolution.applyImpact(computeImpactForLibrary(library));
       emptyQueue(enqueuer.resolution);
       enqueuer.resolution.logSummary(reporter.log);
       return library;
     });
   }
 
   /// Performs the compilation when all libraries have been loaded.
   void compileLoadedLibraries() =>
       selfTask.measureSubtask("Compiler.compileLoadedLibraries", () {
         WorldImpact mainImpact = computeMain();
@@ skipping 10 matching lines @@
             supportDumpInfo: options.dumpInfo,
             supportSerialization: serialization.supportSerialization);
 
         phase = PHASE_RESOLVING;
         enqueuer.resolution.applyImpact(mainImpact);
         if (options.resolveOnly) {
           libraryLoader.libraries.where((LibraryElement library) {
             return !serialization.isDeserialized(library);
           }).forEach((LibraryElement library) {
             reporter.log('Enqueuing ${library.canonicalUri}');
-            fullyEnqueueLibrary(library, enqueuer.resolution);
+            enqueuer.resolution.applyImpact(computeImpactForLibrary(library));
           });
         } else if (analyzeAll) {
           libraryLoader.libraries.forEach((LibraryElement library) {
             reporter.log('Enqueuing ${library.canonicalUri}');
-            fullyEnqueueLibrary(library, enqueuer.resolution);
+            enqueuer.resolution.applyImpact(computeImpactForLibrary(library));
           });
         } else if (options.analyzeMain) {
           if (mainApp != null) {
-            fullyEnqueueLibrary(mainApp, enqueuer.resolution);
+            enqueuer.resolution.applyImpact(computeImpactForLibrary(mainApp));
           }
           if (librariesToAnalyzeWhenRun != null) {
             for (Uri libraryUri in librariesToAnalyzeWhenRun) {
-              fullyEnqueueLibrary(
-                  libraryLoader.lookupLibrary(libraryUri), enqueuer.resolution);
+              enqueuer.resolution.applyImpact(computeImpactForLibrary(
+                  libraryLoader.lookupLibrary(libraryUri)));
             }
           }
         }
         if (deferredLoadTask.isProgramSplit) {
           enqueuer.resolution
               .applyImpact(backend.computeDeferredLoadingImpact());
         }
         // Elements required by enqueueHelpers are global dependencies
         // that are not pulled in by a particular element.
         enqueuer.resolution.applyImpact(backend.computeHelpersImpact());
@@ skipping 42 matching lines @@
 
         reporter.log('Inferring types...');
         globalInference.runGlobalTypeInference(mainFunction);
 
         if (stopAfterTypeInference) return;
 
         backend.onTypeInferenceComplete();
 
         reporter.log('Compiling...');
         phase = PHASE_COMPILING;
+
         backend.onCodegenStart();
         if (hasIsolateSupport) {
           enqueuer.codegen
               .applyImpact(backend.enableIsolateSupport(forResolution: false));
         }
         if (compileAll) {
           libraryLoader.libraries.forEach((LibraryElement library) {
-            fullyEnqueueLibrary(library, enqueuer.codegen);
+            enqueuer.codegen.applyImpact(computeImpactForLibrary(library));
           });
         }
         processQueue(enqueuer.codegen, mainFunction);
         enqueuer.codegen.logSummary(reporter.log);
 
         int programSize = backend.assembleProgram();
 
         if (options.dumpInfo) {
           dumpInfoTask.reportSize(programSize);
           dumpInfoTask.dumpInfo();
@@ skipping 13 matching lines @@
     // require the information computed in [world.closeWorld].)
     backend.onResolutionComplete();
 
     deferredLoadTask.onResolutionComplete(mainFunction);
 
     // TODO(johnniwinther): Move this after rti computation but before
     // reflection members computation, and (re-)close the world afterwards.
     closureToClassMapper.createClosureClasses();
   }
 
-  void fullyEnqueueLibrary(LibraryElement library, Enqueuer world) {
-    void enqueueAll(Element element) {
-      fullyEnqueueTopLevelElement(element, world);
+  /// Compute the [WorldImpact] for accessing all elements in [library].
+  WorldImpact computeImpactForLibrary(LibraryElement library) {
+    WorldImpactBuilderImpl impactBuilder = new WorldImpactBuilderImpl();
+
+    void registerStaticUse(Element element) {
+      impactBuilder.registerStaticUse(new StaticUse.directUse(element));
     }
 
-    library.implementation.forEachLocalMember(enqueueAll);
+    void registerElement(Element element) {
+      if (element.isClass) {
+        ClassElement cls = element;
+        cls.ensureResolved(resolution);
+        cls.forEachLocalMember(registerStaticUse);
+        impactBuilder.registerTypeUse(new TypeUse.instantiation(cls.rawType));
+      } else {
+        registerStaticUse(element);
+      }
+    }
+
+    library.implementation.forEachLocalMember(registerElement);
+
     library.imports.forEach((ImportElement import) {
       if (import.isDeferred) {
         // `import.prefix` and `loadLibrary` may be `null` when the deferred
         // import has compile-time errors.
         GetterElement loadLibrary = import.prefix?.loadLibrary;
         if (loadLibrary != null) {
-          world.addToWorkList(loadLibrary);
+          registerStaticUse(loadLibrary);
         }
       }
       if (serialization.supportSerialization) {
         for (MetadataAnnotation metadata in import.metadata) {
           metadata.ensureResolved(resolution);
         }
       }
     });
     if (serialization.supportSerialization) {
       library.exports.forEach((ExportElement export) {
         for (MetadataAnnotation metadata in export.metadata) {
           metadata.ensureResolved(resolution);
         }
       });
       library.compilationUnits.forEach((CompilationUnitElement unit) {
         for (MetadataAnnotation metadata in unit.metadata) {
           metadata.ensureResolved(resolution);
         }
       });
     }
-  }
-
-  void fullyEnqueueTopLevelElement(Element element, Enqueuer world) {
-    if (element.isClass) {
-      ClassElement cls = element;
-      cls.ensureResolved(resolution);
-      cls.forEachLocalMember(enqueuer.resolution.addToWorkList);
-      world.registerInstantiatedType(cls.rawType);
-    } else {
-      world.addToWorkList(element);
-    }
+    return impactBuilder;
   }
 
   // Resolves metadata on library elements.  This is necessary in order to
   // resolve metadata classes referenced only from metadata on library tags.
   // TODO(ahe): Figure out how to do this lazily.
   void resolveLibraryMetadata() {
     for (LibraryElement library in libraryLoader.libraries) {
       if (library.metadata != null) {
         for (MetadataAnnotation metadata in library.metadata) {
           metadata.ensureResolved(resolution);
@@ skipping 1417 matching lines @@
   _ElementScanner(this.scanner);
   void scanLibrary(LibraryElement library) => scanner.scanLibrary(library);
   void scanUnit(CompilationUnitElement unit) => scanner.scan(unit);
 }
 
 class _EmptyEnvironment implements Environment {
   const _EmptyEnvironment();
 
   String valueOf(String key) => null;
 }