Move global dependencies to BackendUsage

pkg/compiler/lib/src/enqueue.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.enqueue;
 
 import 'dart:collection' show Queue;
 
 import 'common/resolution.dart' show Resolution;
 import 'common/tasks.dart' show CompilerTask;
 import 'common/work.dart' show WorkItem;
 import 'common.dart';
-import 'compiler.dart' show Compiler, GlobalDependencyRegistry;
+import 'compiler.dart' show Compiler;
 import 'options.dart';
 import 'elements/elements.dart'
     show
         AnalyzableElement,
         ClassElement,
         ConstructorElement,
         Element,
         MemberElement;
 import 'elements/entities.dart';
 import 'elements/resolution_types.dart'
@@ skipping 18 matching lines @@
   EnqueueTask(Compiler compiler)
       : this.compiler = compiler,
         super(compiler.measurer) {
     _resolution = new ResolutionEnqueuer(
         this,
         compiler.options,
         compiler.reporter,
         compiler.options.analyzeOnly && compiler.options.analyzeMain
             ? const DirectEnqueuerStrategy()
             : const TreeShakingEnqueuerStrategy(),
-        compiler.globalDependencies,
         compiler.backend,
         compiler.backend.nativeResolutionEnqueuer(),
         new ResolutionWorldBuilderImpl(
             compiler.backend, compiler.resolution, const OpenWorldStrategy()),
         new ResolutionWorkItemBuilder(compiler.resolution));
     _codegen = compiler.backend.createCodegenEnqueuer(this, compiler);
   }
 
   ResolutionEnqueuer get resolution => _resolution;
   Enqueuer get codegen => _codegen;
@@ skipping 36 matching lines @@
   bool checkNoEnqueuedInvokedInstanceMethods();
   void logSummary(log(message));
 
   Iterable<Entity> get processedEntities;
 
   Iterable<ClassEntity> get processedClasses;
 }
 
 abstract class EnqueuerListener {
   /// Called to instruct to the backend that [type] has been instantiated.
-  void registerInstantiatedType(InterfaceType type);
+  void registerInstantiatedType(InterfaceType type, {bool isGlobal});
 
   /// Called to notify to the backend that a class is being instantiated. Any
   /// backend specific [WorldImpact] of this is returned.
   WorldImpact registerInstantiatedClass(ClassEntity cls, {bool forResolution});
 
   /// Called to notify to the backend that a class is implemented by an
   /// instantiated class. Any backend specific [WorldImpact] of this is
   /// returned.
   WorldImpact registerImplementedClass(ClassEntity cls, {bool forResolution});
 
@@ skipping 45 matching lines @@
 
 /// [Enqueuer] which is specific to resolution.
 class ResolutionEnqueuer extends EnqueuerImpl {
   static const ImpactUseCase IMPACT_USE =
       const ImpactUseCase('ResolutionEnqueuer');
 
   final CompilerTask task;
   final String name;
   final CompilerOptions _options;
   final EnqueuerListener _listener;
-  final GlobalDependencyRegistry _globalDependencies;
   final native.NativeEnqueuer nativeEnqueuer;
 
   final EnqueuerStrategy strategy;
   final Set<ClassEntity> _recentClasses = new Setlet<ClassEntity>();
   final ResolutionWorldBuilderImpl _universe;
   final WorkItemBuilder _workItemBuilder;
   final DiagnosticReporter _reporter;
 
   bool queueIsClosed = false;
 
   WorldImpactVisitor _impactVisitor;
 
   /// All declaration elements that have been processed by the resolver.
   final Set<Entity> _processedEntities = new Set<Entity>();
 
   final Queue<WorkItem> _queue = new Queue<WorkItem>();
 
   /// Queue of deferred resolution actions to execute when the resolution queue
   /// has been emptied.
   final Queue<_DeferredAction> _deferredQueue = new Queue<_DeferredAction>();
 
   ResolutionEnqueuer(
       this.task,
       this._options,
       this._reporter,
       this.strategy,
-      this._globalDependencies,
       this._listener,
       this.nativeEnqueuer,
       this._universe,
       this._workItemBuilder,
       [this.name = 'resolution enqueuer']) {
     _impactVisitor = new EnqueuerImplImpactVisitor(this);
   }
 
   ResolutionWorldBuilder get worldBuilder => _universe;
 
@@ skipping 11 matching lines @@
       {ConstructorElement constructor,
       bool mirrorUsage: false,
       bool nativeUsage: false,
       bool globalDependency: false,
       bool isRedirection: false}) {
     task.measure(() {
       _universe.registerTypeInstantiation(type, _applyClassUse,
           constructor: constructor,
           byMirrors: mirrorUsage,
           isRedirection: isRedirection);
-      if (globalDependency && !mirrorUsage) {
-        _globalDependencies.registerDependency(type.element);
-      }
       if (nativeUsage) {
         nativeEnqueuer.onInstantiatedType(type);
       }
-      _listener.registerInstantiatedType(type);
+      _listener.registerInstantiatedType(type,
+          isGlobal: globalDependency && !mirrorUsage);
     });
   }
 
   bool checkNoEnqueuedInvokedInstanceMethods() {
     return strategy.checkEnqueuerConsistency(this);
   }
 
   void checkClass(ClassEntity cls) {
     _universe.processClassMembers(cls,
         (MemberEntity member, EnumSet<MemberUse> useSet) {
@@ skipping 323 matching lines @@
   @override
   WorkItem createWorkItem(MemberElement element) {
     assert(invariant(element, element.isDeclaration));
     if (element.isMalformed) return null;
 
     assert(invariant(element, element is AnalyzableElement,
         message: 'Element $element is not analyzable.'));
     return _resolution.createWorkItem(element);
   }
 }