Remove Enqueuer.nativeEnqueuer

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;
 import 'options.dart';
 import 'elements/elements.dart'
     show AnalyzableElement, ClassElement, MemberElement;
 import 'elements/entities.dart';
 import 'elements/resolution_types.dart' show ResolutionTypedefType;
 import 'elements/types.dart';
-import 'native/native.dart' as native;
 import 'universe/world_builder.dart';
 import 'universe/use.dart'
     show DynamicUse, StaticUse, StaticUseKind, TypeUse, TypeUseKind;
 import 'universe/world_impact.dart'
     show ImpactStrategy, ImpactUseCase, WorldImpact, WorldImpactVisitor;
 import 'util/enumset.dart';
 import 'util/util.dart' show Setlet;
 
 class EnqueueTask extends CompilerTask {
   ResolutionEnqueuer _resolution;
   Enqueuer _codegen;
   final Compiler compiler;
 
   String get name => 'Enqueue';
 
   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.backend.resolutionEnqueuerListener,
-        compiler.backend.nativeResolutionEnqueuer(),
         new ElementResolutionWorldBuilder(
             compiler.backend, compiler.resolution, const OpenWorldStrategy()),
         new ResolutionWorkItemBuilder(compiler.resolution));
     _codegen = compiler.backend.createCodegenEnqueuer(this, compiler);
   }
 
   ResolutionEnqueuer get resolution => _resolution;
   Enqueuer get codegen => _codegen;
 }
 
 abstract class Enqueuer {
   WorldBuilder get worldBuilder;
-  native.NativeEnqueuer get nativeEnqueuer;
   ImpactStrategy get impactStrategy;
 
   void open(ImpactStrategy impactStrategy, FunctionEntity mainMethod,
       Iterable<LibraryEntity> libraries);
   void close();
 
   /// Returns [:true:] if this enqueuer is the resolution enqueuer.
   bool get isResolutionQueue;
 
   bool queueIsClosed;
 
   bool get queueIsEmpty;
 
   ImpactUseCase get impactUse;
 
   void forEach(void f(WorkItem work));
 
   /// Apply the [worldImpact] to this enqueuer. If the [impactSource] is
   /// provided the impact strategy will remove it from the element impact cache,
   /// if it is no longer needed.
   void applyImpact(WorldImpact worldImpact, {var impactSource});
   bool checkNoEnqueuedInvokedInstanceMethods();
 
   /// Check the enqueuer queue is empty or fail otherwise.
   void checkQueueIsEmpty();
-  void logSummary(log(message));
+  void logSummary(void log(String 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, {bool isGlobal});
+  void registerInstantiatedType(InterfaceType type,
+      {bool isGlobal: false, bool nativeUsage: false});
 
   /// Called to notify to the backend that a class is being instantiated. Any
   /// backend specific [WorldImpact] of this is returned.
   WorldImpact registerInstantiatedClass(ClassEntity cls);
 
   /// 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);
 
@@ skipping 22 matching lines @@
   /// A return value of `true` indicates that [recentClasses] has been
   /// processed and its elements do not need to be seen in the next round. When
   /// `false` is returned, [onQueueEmpty] will be called again once the
   /// resolution queue has drained and [recentClasses] will be a superset of the
   /// current value.
   ///
   /// There is no guarantee that a class is only present once in
   /// [recentClasses], but every class seen by the [enqueuer] will be present in
   /// [recentClasses] at least once.
   bool onQueueEmpty(Enqueuer enqueuer, Iterable<ClassEntity> recentClasses);
+
+  /// Called when to the queue is emptied.

[Siggi Cherem (dart-lang), 2017/03/14 03:10:50]

mmm... "when to the"?

[Johnni Winther, 2017/03/15 09:02:58]

Good English not?

+  void logSummary(void log(String message));
 }
 
 abstract class EnqueuerImpl extends Enqueuer {
   CompilerTask get task;
   EnqueuerStrategy get strategy;
   void checkClass(ClassEntity cls);
   void processStaticUse(StaticUse staticUse);
   void processTypeUse(TypeUse typeUse);
   void processDynamicUse(DynamicUse dynamicUse);
   EnqueuerListener get listener;
@@ skipping 18 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 native.NativeEnqueuer nativeEnqueuer;
 
   final EnqueuerStrategy strategy;
   final Set<ClassEntity> _recentClasses = new Setlet<ClassEntity>();
   final ResolutionEnqueuerWorldBuilder _worldBuilder;
   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.listener,
-      this.nativeEnqueuer,
-      this._worldBuilder,
-      this._workItemBuilder,
+  ResolutionEnqueuer(this.task, this._options, this._reporter, this.strategy,
+      this.listener, this._worldBuilder, this._workItemBuilder,
       [this.name = 'resolution enqueuer']) {
     _impactVisitor = new EnqueuerImplImpactVisitor(this);
   }
 
   ResolutionWorldBuilder get worldBuilder => _worldBuilder;
 
   bool get queueIsEmpty => _queue.isEmpty;
 
   @override
   void checkQueueIsEmpty() {
@@ skipping 15 matching lines @@
       {ConstructorEntity constructor,
       bool mirrorUsage: false,
       bool nativeUsage: false,
       bool globalDependency: false,
       bool isRedirection: false}) {
     task.measure(() {
       _worldBuilder.registerTypeInstantiation(type, _applyClassUse,
           constructor: constructor,
           byMirrors: mirrorUsage,
           isRedirection: isRedirection);
-      if (nativeUsage) {
-        nativeEnqueuer.onInstantiatedType(type);
-      }
       listener.registerInstantiatedType(type,
-          isGlobal: globalDependency && !mirrorUsage);
+          isGlobal: globalDependency && !mirrorUsage, nativeUsage: nativeUsage);
     });
   }
 
   bool checkNoEnqueuedInvokedInstanceMethods() {
     return strategy.checkEnqueuerConsistency(this);
   }
 
   void checkClass(ClassEntity cls) {
     _worldBuilder.processClassMembers(cls,
         (MemberEntity member, EnumSet<MemberUse> useSet) {
@@ skipping 113 matching lines @@
         }
       }
       List recents = _recentClasses.toList(growable: false);
       _recentClasses.clear();
       if (!_onQueueEmpty(recents)) {
         _recentClasses.addAll(recents);
       }
     } while (_queue.isNotEmpty || _recentClasses.isNotEmpty);
   }
 
-  void logSummary(log(message)) {
+  void logSummary(void log(String message)) {
     log('Resolved ${_processedEntities.length} elements.');
-    nativeEnqueuer.logSummary(log);
+    listener.logSummary(log);
   }
 
   String toString() => 'Enqueuer($name)';
 
   Iterable<Entity> get processedEntities => _processedEntities;
 
   ImpactUseCase get impactUse => IMPACT_USE;
 
   bool get isResolutionQueue => true;
 
@@ skipping 178 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);
   }
 }