Change Enqueuer to use Entity instead of Element.

pkg/compiler/lib/src/js_backend/mirrors_analysis.dart

 // Copyright (c) 2016, 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.mirrors_handler;
 
 import '../common.dart';
 import '../common/resolution.dart';
 import '../diagnostics/diagnostic_listener.dart';
 import '../elements/elements.dart';
+import '../elements/entities.dart';
 import '../universe/selector.dart';
 import '../universe/use.dart';
 import '../universe/world_impact.dart';
 import 'backend.dart';
 
 class MirrorsAnalysis {
   final MirrorsHandler resolutionHandler;
   final MirrorsHandler codegenHandler;
 
   MirrorsAnalysis(JavaScriptBackend backend, Resolution resolution)
       : resolutionHandler = new MirrorsHandler(backend, resolution),
         codegenHandler = new MirrorsHandler(backend, resolution);
 
   /// Compute the impact for elements that are matched by the mirrors used
   /// annotation or, in lack thereof, all elements.
   WorldImpact computeImpactForReflectiveElements(
-      Iterable<ClassElement> recents,
-      Iterable<ClassElement> processedClasses,
+      Iterable<ClassEntity> recents,
+      Iterable<ClassEntity> processedClasses,
       Iterable<LibraryElement> loadedLibraries,
       {bool forResolution}) {
     MirrorsHandler handler = forResolution ? resolutionHandler : codegenHandler;
     handler.enqueueReflectiveElements(
         recents, processedClasses, loadedLibraries);
     return handler.flush();
   }
 
   /// Compute the impact for the static fields that have been marked as used by
   /// reflective usage through `MirrorsUsed`.
@@ skipping 89 matching lines @@
         }
       }
     }
   }
 
   /// Enqeue the member [element] if it is required for reflection.
   ///
   /// [enclosingWasIncluded] provides a hint whether the enclosing element was
   /// needed for reflection.
   void _enqueueReflectiveElementsInClass(
-      ClassElement cls, Iterable<ClassElement> recents,
+      ClassElement cls, Iterable<ClassEntity> recents,
       {bool enclosingWasIncluded}) {
     if (cls.library.isInternalLibrary || cls.isInjected) return;
     bool includeClass = _shouldIncludeElementDueToMirrors(cls,
         includedEnclosing: enclosingWasIncluded);
     if (includeClass) {
       _logEnqueueReflectiveAction(cls, "register");
       ClassElement declaration = cls.declaration;
       declaration.ensureResolved(_resolution);
       impactBuilder.registerTypeUse(
           new TypeUse.mirrorInstantiation(declaration.rawType));
@@ skipping 28 matching lines @@
         cls.ensureResolved(_resolution);
         impactBuilder
             .registerTypeUse(new TypeUse.mirrorInstantiation(cls.rawType));
       }
     }
   }
 
   /// Enqeue all local members of the library [lib] if they are required for
   /// reflection.
   void _enqueueReflectiveElementsInLibrary(
-      LibraryElement lib, Iterable<ClassElement> recents) {
+      LibraryElement lib, Iterable<ClassEntity> recents) {
     bool includeLibrary =
         _shouldIncludeElementDueToMirrors(lib, includedEnclosing: false);
     lib.forEachLocalMember((Element member) {
       if (member.isInjected) return;
       if (member.isClass) {
         ClassElement cls = member;
         cls.ensureResolved(_resolution);
         do {
           _enqueueReflectiveElementsInClass(cls, recents,
               enclosingWasIncluded: includeLibrary);
           cls = cls.superclass;
         } while (cls != null && cls.isUnnamedMixinApplication);
       } else {
         _enqueueReflectiveMember(member, includeLibrary);
       }
     });
   }
 
   /// Enqueue all elements that are matched by the mirrors used
   /// annotation or, in lack thereof, all elements.
   // TODO(johnniwinther): Compute [WorldImpact] instead of enqueuing directly.
   void enqueueReflectiveElements(
-      Iterable<ClassElement> recents,
-      Iterable<ClassElement> processedClasses,
+      Iterable<ClassEntity> recents,
+      Iterable<ClassEntity> processedClasses,
       Iterable<LibraryElement> loadedLibraries) {
     if (!hasEnqueuedReflectiveElements) {
       _logEnqueueReflectiveAction("!START enqueueAll");
       // First round of enqueuing, visit everything that is visible to
       // also pick up static top levels, etc.
       // Also, during the first round, consider all classes that have been seen
       // as recently seen, as we do not know how many rounds of resolution might
       // have run before tree shaking is disabled and thus everything is
       // enqueued.
       recents = processedClasses.toSet();
@@ skipping 21 matching lines @@
   /// usage through `MirrorsUsed`.
   // TODO(johnniwinther): Compute [WorldImpact] instead of enqueuing directly.
   void enqueueReflectiveStaticFields(Iterable<Element> elements) {
     if (hasEnqueuedReflectiveStaticFields) return;
     hasEnqueuedReflectiveStaticFields = true;
     for (Element element in elements) {
       _enqueueReflectiveMember(element, true);
     }
   }
 }