Move CodegenEnqueuer.generatedCode to JavaScriptBackend.

pkg/compiler/lib/src/js_backend/enqueuer.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.js.enqueue;
 
 import 'dart:collection' show Queue;
 
 import '../cache_strategy.dart' show CacheStrategy;
 import '../common/backend_api.dart' show Backend;
 import '../common/codegen.dart' show CodegenWorkItem;
 import '../common/tasks.dart' show CompilerTask;
 import '../common/work.dart' show WorkItem;
 import '../common.dart';
 import '../compiler.dart' show Compiler;
 import '../dart_types.dart' show DartType, InterfaceType;
-import '../elements/elements.dart'
-    show ClassElement, Element, Entity, MemberElement, TypedElement;
+import '../elements/elements.dart' show Element, Entity, TypedElement;
 import '../elements/entities.dart';
 import '../enqueue.dart';
-import '../js/js.dart' as js;
 import '../native/native.dart' as native;
 import '../options.dart';
 import '../types/types.dart' show TypeMaskStrategy;
 import '../universe/world_builder.dart';
 import '../universe/use.dart'
     show DynamicUse, StaticUse, StaticUseKind, TypeUse, TypeUseKind;
 import '../universe/world_impact.dart'
     show ImpactUseCase, WorldImpact, WorldImpactVisitor;
 import '../util/enumset.dart';
 import '../util/util.dart' show Setlet;
 
 /// [Enqueuer] which is specific to code generation.
 class CodegenEnqueuer extends EnqueuerImpl {
   final String name;
   final EnqueuerStrategy strategy;
 
-  Set<ClassElement> _recentClasses = new Setlet<ClassElement>();
+  Set<ClassEntity> _recentClasses = new Setlet<ClassEntity>();
   final CodegenWorldBuilderImpl _universe;
 
   bool queueIsClosed = false;
   final CompilerTask task;
   final native.NativeEnqueuer nativeEnqueuer;
   final Backend _backend;
   final CompilerOptions _options;
 
   WorldImpactVisitor _impactVisitor;
 
   final Queue<WorkItem> _queue = new Queue<WorkItem>();
-  final Map<Element, js.Expression> generatedCode = <Element, js.Expression>{};
 
-  final Set<Element> newlyEnqueuedElements;
+  /// All declaration elements that have been processed by codegen.
+  final Set<Entity> _processedEntities = new Set<Entity>();
+
+  final Set<Entity> newlyEnqueuedElements;
 
   final Set<DynamicUse> newlySeenSelectors;
 
   static const ImpactUseCase IMPACT_USE =
       const ImpactUseCase('CodegenEnqueuer');
 
   CodegenEnqueuer(this.task, CacheStrategy cacheStrategy, Backend backend,
       this._options, this.strategy)
       : _universe =
             new CodegenWorldBuilderImpl(backend, const TypeMaskStrategy()),
@@ skipping 14 matching lines @@
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [element] must be a declaration element.
    */
   void _addToWorkList(Element element) {
     assert(invariant(element, element.isDeclaration));
     // Don't generate code for foreign elements.
     if (_backend.isForeign(element)) return;
+    if (element.isAbstract) return;
 
     // Codegen inlines field initializers. It only needs to generate
     // code for checked setters.
     if (element.isField && element.isInstanceMember) {
       if (!_options.enableTypeAssertions ||
           element.enclosingElement.isClosure) {
         return;
       }
     }
 
-    if (_options.hasIncrementalSupport && !isProcessed(element)) {
+    if (_options.hasIncrementalSupport &&
+        !_processedEntities.contains(element)) {
       newlyEnqueuedElements.add(element);
     }
 
     if (queueIsClosed) {
       throw new SpannableAssertionFailure(
           element, "Codegen work list is closed. Trying to add $element");
     }
     _queue.add(new CodegenWorkItem(_backend, element));
     applyImpact(_backend.registerUsedElement(element, forResolution: false));
   }
 
-  void applyImpact(WorldImpact worldImpact, {Element impactSource}) {
+  void applyImpact(WorldImpact worldImpact, {var impactSource}) {

[Siggi Cherem (dart-lang), 2016/12/20 19:26:34]

var => Entity?

[Johnni Winther, 2016/12/21 09:43:40]

No. The plan it to allow for any key; elements, but also for instance markers
for features like noSuchMethod, mirrors, etc.

     if (worldImpact.isEmpty) return;
     impactStrategy.visitImpact(
         impactSource, worldImpact, _impactVisitor, impactUse);
   }
 
   void _registerInstantiatedType(InterfaceType type,
       {bool mirrorUsage: false, bool nativeUsage: false}) {
     task.measure(() {
       _universe.registerTypeInstantiation(type, _applyClassUse,
           byMirrors: mirrorUsage);
       if (nativeUsage) {
         nativeEnqueuer.onInstantiatedType(type);
       }
       _backend.registerInstantiatedType(type);
     });
   }
 
   bool checkNoEnqueuedInvokedInstanceMethods() {
     return strategy.checkEnqueuerConsistency(this);
   }
 
-  void checkClass(ClassElement cls) {
-    _universe.processClassMembers(cls, (MemberElement member, useSet) {
+  void checkClass(ClassEntity cls) {
+    _universe.processClassMembers(cls, (MemberEntity member, useSet) {
       if (useSet.isNotEmpty) {
         _backend.compiler.reporter.internalError(member,
             'Unenqueued use of $member: ${useSet.iterable(MemberUse.values)}');
       }
     });
   }
 
   /// Callback for applying the use of a [cls].
   void _applyClassUse(ClassEntity cls, EnumSet<ClassUse> useSet) {
     if (useSet.contains(ClassUse.INSTANTIATED)) {
@@ skipping 27 matching lines @@
     task.measure(() {
       if (_universe.registerDynamicUse(dynamicUse, _applyMemberUse)) {
         if (_options.hasIncrementalSupport) {
           newlySeenSelectors.add(dynamicUse);
         }
       }
     });
   }
 
   void processStaticUse(StaticUse staticUse) {
-    Element element = staticUse.element;
-    assert(invariant(element, element.isDeclaration,
-        message: "Element ${element} is not the declaration."));
     _universe.registerStaticUse(staticUse, _applyMemberUse);
     switch (staticUse.kind) {
       case StaticUseKind.CONSTRUCTOR_INVOKE:
       case StaticUseKind.CONST_CONSTRUCTOR_INVOKE:
       case StaticUseKind.REDIRECTION:
         processTypeUse(new TypeUse.instantiation(staticUse.type));
         break;
       default:
         break;
     }
@@ skipping 41 matching lines @@
           forResolution: false));
     }
     applyImpact(_backend.registerBoundClosure());
   }
 
   void forEach(void f(WorkItem work)) {
     do {
       while (_queue.isNotEmpty) {
         // TODO(johnniwinther): Find an optimal process order.
         WorkItem work = _queue.removeLast();
-        if (!isProcessed(work.element)) {
+        if (!_processedEntities.contains(work.element)) {
           strategy.processWorkItem(f, work);
           // TODO(johnniwinther): Register the processed element here. This
           // is currently a side-effect of calling `work.run`.
+          _processedEntities.add(work.element);
         }
       }
       List recents = _recentClasses.toList(growable: false);
       _recentClasses.clear();
       if (!_onQueueEmpty(recents)) _recentClasses.addAll(recents);
     } while (_queue.isNotEmpty || _recentClasses.isNotEmpty);
   }
 
   /// [_onQueueEmpty] is called whenever the queue is drained. [recentClasses]
   /// contains the set of all classes seen for the first time since
   /// [_onQueueEmpty] was called last. A return value of [true] indicates that
   /// the [recentClasses] have been processed and may be cleared. If [false] is
   /// returned, [_onQueueEmpty] will be called once the queue is empty again (or
   /// still empty) and [recentClasses] will be a superset of the current value.
-  bool _onQueueEmpty(Iterable<ClassElement> recentClasses) {
+  bool _onQueueEmpty(Iterable<ClassEntity> recentClasses) {
     return _backend.onQueueEmpty(this, recentClasses);
   }
 
   void logSummary(log(message)) {
-    log('Compiled ${generatedCode.length} methods.');
+    log('Compiled ${_processedEntities.length} methods.');
     nativeEnqueuer.logSummary(log);
   }
 
   String toString() => 'Enqueuer($name)';
 
   ImpactUseCase get impactUse => IMPACT_USE;
 
-  bool isProcessed(Element member) =>
-      member.isAbstract || generatedCode.containsKey(member);
-
-  void forgetEntity(Element element, Compiler compiler) {
-    _universe.forgetElement(element, compiler);
-    generatedCode.remove(element);
-    if (element is MemberElement) {
-      for (Element closure in element.nestedClosures) {
-        generatedCode.remove(closure);
-      }
-    }
+  void forgetEntity(Entity entity, Compiler compiler) {
+    _universe.forgetElement(entity, compiler);
+    _processedEntities.remove(entity);
   }
 
   @override
-  Iterable<Entity> get processedEntities => generatedCode.keys;
+  Iterable<Entity> get processedEntities => _processedEntities;
 
   @override
   Iterable<ClassEntity> get processedClasses => _universe.processedClasses;
 }