Remove Compiler access from ResolutionEnqueuer

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 58 matching lines @@
 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/world_impact.dart' show ImpactStrategy, WorldImpact, WorldImpactBuilderImpl;
+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);
 
 typedef CompilerDiagnosticReporter MakeReporterFunction(
     Compiler compiler, CompilerOptions options);
 
 abstract class Compiler implements LibraryLoaderListener {
   Measurer get measurer;
 
   final IdGenerator idGenerator = new IdGenerator();
-  WorldImpl _world;
+  WorldImpl get _world => resolverWorld.openWorld;
   Types types;
   _CompilerCoreTypes _coreTypes;
   CompilerDiagnosticReporter _reporter;
   _CompilerResolution _resolution;
   ParsingContext _parsingContext;
 
   final CacheStrategy cacheStrategy;
 
   ImpactStrategy impactStrategy = const ImpactStrategy();
 
@@ skipping 29 matching lines @@
 
   Tracer tracer;
 
   LibraryElement mainApp;
   FunctionElement mainFunction;
 
   DiagnosticReporter get reporter => _reporter;
   CommonElements get commonElements => _coreTypes;
   CoreClasses get coreClasses => _coreTypes;
   CoreTypes get coreTypes => _coreTypes;
-  CommonMasks get commonMasks => globalInference.masks;
   Resolution get resolution => _resolution;
   ParsingContext get parsingContext => _parsingContext;
 
   // TODO(zarah): Remove this map and incorporate compile-time errors
   // in the model.
   /// Tracks elements with compile-time errors.
   final Map<Element, List<DiagnosticMessage>> elementsWithCompileTimeErrors =
       new Map<Element, List<DiagnosticMessage>>();
 
   final Environment environment;
@@ skipping 24 matching lines @@
   ConstantEnvironment constants;
 
   EnqueueTask enqueuer;
   DeferredLoadTask deferredLoadTask;
   MirrorUsageAnalyzerTask mirrorUsageAnalyzerTask;
   DumpInfoTask dumpInfoTask;
 
   /// A customizable filter that is applied to enqueued work items.
   QueueFilter enqueuerFilter = new QueueFilter();
 
-  bool enabledRuntimeType = false;
-  bool enabledFunctionApply = false;
-  bool enabledInvokeOn = false;
-  bool hasIsolateSupport = false;
+  bool get hasFunctionApplySupport => resolverWorld.hasFunctionApplySupport;
+  bool get hasIsolateSupport => resolverWorld.hasIsolateSupport;
 
   bool get hasCrashed => _reporter.hasCrashed;
 
   Stopwatch progress;
 
   bool get shouldPrintProgress {
     return options.verbose && progress.elapsedMilliseconds > 500;
   }
 
   static const int PHASE_SCANNING = 0;
   static const int PHASE_RESOLVING = 1;
   static const int PHASE_DONE_RESOLVING = 2;
   static const int PHASE_COMPILING = 3;
   int phase;
 
   bool compilationFailed = false;
 
   Compiler(
       {CompilerOptions options,
       api.CompilerOutput outputProvider,
       this.environment: const _EmptyEnvironment(),
       MakeBackendFuncion makeBackend,
       MakeReporterFunction makeReporter})
       : this.options = options,
         this.cacheStrategy = new CacheStrategy(options.hasIncrementalSupport),
         this.userOutputProvider = outputProvider == null
             ? const NullCompilerOutput()
             : outputProvider {
-    _world = new WorldImpl(this);
     if (makeReporter != null) {
       _reporter = makeReporter(this, options);
     } else {
       _reporter = new CompilerDiagnosticReporter(this, options);
     }
     _resolution = new _CompilerResolution(this);
     // TODO(johnniwinther): Initialize core types in [initializeCoreClasses] and
     // make its field final.
     _coreTypes = new _CompilerCoreTypes(_resolution, reporter);
     types = new Types(_resolution);
@@ skipping 11 matching lines @@
       backend = makeBackend(this);
     } else {
       js_backend.JavaScriptBackend jsBackend = new js_backend.JavaScriptBackend(
           this,
           generateSourceMap: options.generateSourceMap,
           useStartupEmitter: options.useStartupEmitter,
           useNewSourceInfo: options.useNewSourceInfo,
           useKernel: options.useKernel);
       backend = jsBackend;
     }
+    enqueuer = backend.makeEnqueuer();
 
     if (options.dumpInfo && options.useStartupEmitter) {
       throw new ArgumentError(
           '--dump-info is not supported with the fast startup emitter');
     }
 
     tasks = [
       dietParser =
           new DietParserTask(options, idGenerator, backend, reporter, measurer),
       scanner = createScannerTask(),
@@ skipping 11 matching lines @@
           measurer),
       parser = new ParserTask(this, options),
       patchParser = new PatchParserTask(this, options),
       resolver = createResolverTask(),
       closureToClassMapper = new closureMapping.ClosureTask(this),
       checker = new TypeCheckerTask(this),
       globalInference = new GlobalTypeInferenceTask(this),
       constants = backend.constantCompilerTask,
       deferredLoadTask = new DeferredLoadTask(this),
       mirrorUsageAnalyzerTask = new MirrorUsageAnalyzerTask(this),
-      enqueuer = backend.makeEnqueuer(),
+      // [enqueuer] is created earlier because it contains the resolution world
+      // objects needed by other tasks.
+      enqueuer,
       dumpInfoTask = new DumpInfoTask(this),
       selfTask = new GenericTask('self', measurer),
     ];
     if (options.resolveOnly) {
       serialization.supportSerialization = true;
     }
 
     _parsingContext =
         new ParsingContext(reporter, options, parser, patchParser, backend);
 
@@ skipping 346 matching lines @@
       selfTask.measureSubtask("Compiler.compileLoadedLibraries", () {
         computeMain();
 
         mirrorUsageAnalyzerTask.analyzeUsage(mainApp);
 
         // In order to see if a library is deferred, we must compute the
         // compile-time constants that are metadata.  This means adding
         // something to the resolution queue.  So we cannot wait with
         // this until after the resolution queue is processed.
         deferredLoadTask.beforeResolution(this);
-        impactStrategy = backend.createImpactStrategy(
+        ImpactStrategy impactStrategy = backend.createImpactStrategy(
             supportDeferredLoad: deferredLoadTask.isProgramSplit,
             supportDumpInfo: options.dumpInfo,
             supportSerialization: serialization.supportSerialization);
 
         phase = PHASE_RESOLVING;
         if (options.resolveOnly) {
           libraryLoader.libraries.where((LibraryElement library) {
             return !serialization.isDeserialized(library);
           }).forEach((LibraryElement library) {
             reporter.log('Enqueuing ${library.canonicalUri}');
@@ skipping 87 matching lines @@
 
         backend.sourceInformationStrategy.onComplete();
 
         checkQueues();
       });
 
   /// Perform the steps needed to fully end the resolution phase.
   void closeResolution() {
     phase = PHASE_DONE_RESOLVING;
 
-    openWorld.closeWorld();
+    openWorld.closeWorld(reporter);
     // Compute whole-program-knowledge that the backend needs. (This might
     // 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();
   }
@@ skipping 51 matching lines @@
     for (LibraryElement library in libraryLoader.libraries) {
       if (library.metadata != null) {
         for (MetadataAnnotation metadata in library.metadata) {
           metadata.ensureResolved(resolution);
         }
       }
     }
   }
 
   /**
-   * Empty the [world] queue.
+   * Empty the [enqueuer] queue.
    */
-  void emptyQueue(Enqueuer world) =>
-      selfTask.measureSubtask("Compiler.emptyQueue", () {
-        world.forEach((WorkItem work) {
-          reporter.withCurrentElement(
-              work.element,
-              () => selfTask.measureSubtask("world.applyImpact", () {
-                    world.applyImpact(
-                        selfTask.measureSubtask(
-                            "work.run", () => work.run(this, world)),
-                        impactSource: work.element);
-                  }));
-        });
+  void emptyQueue(Enqueuer enqueuer) {
+    selfTask.measureSubtask("Compiler.emptyQueue", () {
+      enqueuer.forEach((WorkItem work) {
+        reporter.withCurrentElement(
+            work.element,
+            () => selfTask.measureSubtask("world.applyImpact", () {
+                  enqueuer.applyImpact(
+                      impactStrategy,
+                      selfTask.measureSubtask(
+                          "work.run", () => work.run(this, enqueuer)),
+                      impactSource: work.element);
+                }));
       });
+    });
+  }
 
   void processQueue(Enqueuer enqueuer, Element main) {
     selfTask.measureSubtask("Compiler.processQueue", () {
       WorldImpactBuilderImpl nativeImpact = new WorldImpactBuilderImpl();
       enqueuer.nativeEnqueuer
           .processNativeClasses(nativeImpact, libraryLoader.libraries);
-      enqueuer.applyImpact(nativeImpact);
+      enqueuer.applyImpact(impactStrategy, nativeImpact);
       if (main != null && !main.isMalformed) {
         FunctionElement mainMethod = main;
         mainMethod.computeType(resolution);
         if (mainMethod.functionSignature.parameterCount != 0) {
           // The first argument could be a list of strings.
           backend.backendClasses.listImplementation.ensureResolved(resolution);
           enqueuer.registerInstantiatedType(
               backend.backendClasses.listImplementation.rawType);
           backend.backendClasses.stringImplementation
               .ensureResolved(resolution);
@@ skipping 1170 matching lines @@
 
   @override
   void ensureResolved(Element element) {
     if (compiler.serialization.isDeserialized(element)) {
       return;
     }
     computeWorldImpact(element);
   }
 
   @override
+  void ensureClassMembers(ClassElement element) {
+    if (!compiler.serialization.isDeserialized(element)) {
+      compiler.resolver.checkClass(element);
+    }
+  }
+
+  @override
   void registerCompileTimeError(Element element, DiagnosticMessage message) =>
       compiler.registerCompileTimeError(element, message);
 
   @override
   bool hasResolvedAst(ExecutableElement element) {
     assert(invariant(element, element.isDeclaration,
         message: "Element $element must be the declaration."));
     if (compiler.serialization.isDeserialized(element)) {
       return compiler.serialization.hasResolvedAst(element);
     }
@@ skipping 80 matching lines @@
         compiler.checker.check(element);
       }
       return transformResolutionImpact(element, resolutionImpact);
     });
   }
 
   @override
   WorldImpact transformResolutionImpact(
       Element element, ResolutionImpact resolutionImpact) {
     WorldImpact worldImpact = compiler.backend.impactTransformer
-        .transformResolutionImpact(compiler.enqueuer.resolution, resolutionImpact);
+        .transformResolutionImpact(
+            compiler.enqueuer.resolution, resolutionImpact);
     _worldImpactCache[element] = worldImpact;
     return worldImpact;
   }
 
   @override
   void uncacheWorldImpact(Element element) {
     assert(invariant(element, element.isDeclaration,
         message: "Element $element must be the declaration."));
     if (retainCachesForTesting) return;
     if (compiler.serialization.isDeserialized(element)) return;
@@ skipping 92 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;
 }