Change Enqueuer to use Entity instead of Element.

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 '../common/backend_api.dart' show Backend;
 import '../common/codegen.dart' show CodegenWorkItem;
 import '../common/names.dart' show Identifiers;
 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,
-        Elements,
         Entity,
         FunctionElement,
-        LibraryElement,
-        Member,
         MemberElement,
         MethodElement,
-        Name,
-        TypedElement,
-        TypedefElement;
+        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/selector.dart' show Selector;
 import '../universe/world_builder.dart';
 import '../universe/use.dart'
     show DynamicUse, StaticUse, StaticUseKind, TypeUse, TypeUseKind;
 import '../universe/world_impact.dart'
-    show ImpactUseCase, ImpactStrategy, WorldImpact, WorldImpactVisitor;
+    show ImpactUseCase, WorldImpact, WorldImpactVisitor;
 import '../util/util.dart' show Setlet;
 import '../world.dart';
 
 /// [Enqueuer] which is specific to code generation.
 class CodegenEnqueuer extends EnqueuerImpl {
   final String name;
   @deprecated
   final Compiler _compiler; // TODO(ahe): Remove this dependency.
   final EnqueuerStrategy strategy;
   final Map<String, Set<Element>> _instanceMembersByName =
@@ skipping 291 matching lines @@
         return false;
       });
     }
   }
 
   void processStaticUse(StaticUse staticUse) {
     Element element = staticUse.element;
     assert(invariant(element, element.isDeclaration,
         message: "Element ${element} is not the declaration."));
     _universe.registerStaticUse(staticUse);
-    applyImpact(_backend.registerStaticUse(element, forResolution: false));
+    applyImpact(_backend.registerUsedElement(element, forResolution: false));
     bool addElement = true;
     switch (staticUse.kind) {
       case StaticUseKind.STATIC_TEAR_OFF:
         applyImpact(_backend.registerGetOfStaticFunction());
         break;
       case StaticUseKind.FIELD_GET:
       case StaticUseKind.FIELD_SET:
       case StaticUseKind.CLOSURE:
         // TODO(johnniwinther): Avoid this. Currently [FIELD_GET] and
         // [FIELD_SET] contains [BoxFieldElement]s which we cannot enqueue.
@@ skipping 96 matching lines @@
     return _backend.onQueueEmpty(this, recentClasses);
   }
 
   void logSummary(log(message)) {
     log('Compiled ${generatedCode.length} methods.');
     nativeEnqueuer.logSummary(log);
   }
 
   String toString() => 'Enqueuer($name)';
 
-  void _forgetElement(Element element) {
-    _universe.forgetElement(element, _compiler);
-    _processedClasses.remove(element);
-    _instanceMembersByName[element.name]?.remove(element);
-    _instanceFunctionsByName[element.name]?.remove(element);
-  }
-
   ImpactUseCase get impactUse => IMPACT_USE;
 
   bool isProcessed(Element member) =>
       member.isAbstract || generatedCode.containsKey(member);
 
   void _registerNoSuchMethod(Element element) {
     if (!_enabledNoSuchMethod && _backend.enabledNoSuchMethod) {
       applyImpact(_backend.enableNoSuchMethod());
       _enabledNoSuchMethod = true;
     }
   }
 
-  void forgetElement(Element element, Compiler compiler) {
-    _forgetElement(element);
+  void forgetEntity(Element element, Compiler compiler) {
+    _universe.forgetElement(element, _compiler);
+    _processedClasses.remove(element);
+    _instanceMembersByName[element.name]?.remove(element);
+    _instanceFunctionsByName[element.name]?.remove(element);
     generatedCode.remove(element);
     if (element is MemberElement) {
       for (Element closure in element.nestedClosures) {
         generatedCode.remove(closure);
         removeFromSet(_instanceMembersByName, closure);
         removeFromSet(_instanceFunctionsByName, closure);
       }
     }
   }
 
   @override
   Iterable<Entity> get processedEntities => generatedCode.keys;
 
   @override
-  Iterable<ClassElement> get processedClasses => _processedClasses;
+  Iterable<ClassEntity> get processedClasses => _processedClasses;
 }
 
 void removeFromSet(Map<String, Set<Element>> map, Element element) {
   Set<Element> set = map[element.name];
   if (set == null) return;
   set.remove(element);
 }