Change Enqueuer to use Entity instead of Element.

pkg/compiler/lib/src/universe/world_builder.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 universe;
 
 import 'dart:collection';
 
 import '../cache_strategy.dart';
 import '../common.dart';
@@ skipping 703 matching lines @@
       case StaticUseKind.CLOSURE:
         allClosures.add(element);
         break;
       case StaticUseKind.DIRECT_INVOKE:
         invariant(
             element, 'Direct static use is not supported for resolution.');
         break;
     }
   }
 
-  void forgetElement(Element element, Compiler compiler) {
-    allClosures.remove(element);
-    slowDirectlyNestedClosures(element).forEach(compiler.forgetElement);
-    closurizedMembers.remove(element);
-    fieldSetters.remove(element);
-    _instantiationInfo.remove(element);
+  void forgetEntity(Entity entity, Compiler compiler) {
+    allClosures.remove(entity);
+    slowDirectlyNestedClosures(entity).forEach(compiler.forgetElement);
+    closurizedMembers.remove(entity);
+    fieldSetters.remove(entity);
+    _instantiationInfo.remove(entity);
 
-    void removeUsage(Set<_MemberUsage> set, Element element) {
+    void removeUsage(Set<_MemberUsage> set, Entity entity) {
       if (set == null) return;
       set.removeAll(
-          set.where((_MemberUsage usage) => usage.entity == element).toList());
+          set.where((_MemberUsage usage) => usage.entity == entity).toList());
     }
 
-    _processedClasses.remove(element);
-    removeUsage(_instanceMembersByName[element.name], element);
-    removeUsage(_instanceFunctionsByName[element.name], element);
+    _processedClasses.remove(entity);
+    removeUsage(_instanceMembersByName[entity.name], entity);
+    removeUsage(_instanceFunctionsByName[entity.name], entity);
   }
 
   // TODO(ahe): Replace this method with something that is O(1), for example,
   // by using a map.
   List<LocalFunctionElement> slowDirectlyNestedClosures(Element element) {
     // Return new list to guard against concurrent modifications.
     return new List<LocalFunctionElement>.from(
         allClosures.where((LocalFunctionElement closure) {
       return closure.executableContext == element;
     }));
@@ skipping 51 matching lines @@
     for (_MemberUsage usage in members) {
       if (!updateUsage(usage)) remaining.add(usage);
     }
     map[memberName].addAll(remaining);
   }
 
   void _processInstanceMembers(String name, bool updateUsage(_MemberUsage e)) {
     _processSet(_instanceMembersByName, name, updateUsage);
   }
 
-  void _processInstanceFunctions(String name, bool updateUsage(_MemberUsage e)) {
+  void _processInstanceFunctions(
+      String name, bool updateUsage(_MemberUsage e)) {
     _processSet(_instanceFunctionsByName, name, updateUsage);
   }
 
   void _processInstantiatedClassMember(
       ClassElement cls, MemberElement member, MemberUsed memberUsed) {
     assert(invariant(member, member.isDeclaration));
     if (!member.isInstanceMember) return;
     String memberName = member.name;
     member.computeType(_resolution);
     EnumSet<MemberUse> useSet = new EnumSet<MemberUse>();
@@ skipping 619 matching lines @@
 class ClassUses {
   static const EnumSet<ClassUse> NONE = const EnumSet<ClassUse>.fixed(0);
   static const EnumSet<ClassUse> INSTANTIATED_ONLY =
       const EnumSet<ClassUse>.fixed(1);
   static const EnumSet<ClassUse> IMPLEMENTED_ONLY =
       const EnumSet<ClassUse>.fixed(2);
   static const EnumSet<ClassUse> ALL = const EnumSet<ClassUse>.fixed(3);
 }
 
 typedef void ClassUsed(ClassEntity cls, EnumSet<ClassUse> useSet);