Use more entities in program_builder, collector and registry

pkg/compiler/lib/src/js_emitter/program_builder/collector.dart

 // Copyright (c) 2015, 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.
 
 part of dart2js.js_emitter.program_builder;
 
 /**
  * Generates the code for all used classes in the program. Static fields (even
  * in classes) are ignored, since they can be treated as non-class elements.
  *
  * The code for the containing (used) methods must exist in the `universe`.
  */
 class Collector {
   final CompilerOptions _options;
   final CommonElements _commonElements;
   final DeferredLoadTask _deferredLoadTask;
   final CodegenWorldBuilder _worldBuilder;
   // TODO(floitsch): the code-emitter task should not need a namer.
   final Namer _namer;
   final Emitter _emitter;
   final JavaScriptConstantCompiler _constantHandler;
   final NativeData _nativeData;
   final InterceptorData _interceptorData;
   final OneShotInterceptorData _oneShotInterceptorData;
   final MirrorsData _mirrorsData;
   final ClosedWorld _closedWorld;
-  final Set<ClassElement> _rtiNeededClasses;
+  final Set<ClassEntity> _rtiNeededClasses;
   final Map<MemberElement, js.Expression> _generatedCode;
+  final Sorter _sorter;
 
-  final Set<ClassElement> neededClasses = new Set<ClassElement>();
+  final Set<ClassEntity> neededClasses = new Set<ClassEntity>();
   // This field is set in [computeNeededDeclarations].
-  Set<ClassElement> classesOnlyNeededForRti;
-  final Map<OutputUnit, List<ClassElement>> outputClassLists =
-      new Map<OutputUnit, List<ClassElement>>();
+  Set<ClassEntity> classesOnlyNeededForRti;
+  final Map<OutputUnit, List<ClassEntity>> outputClassLists =
+      new Map<OutputUnit, List<ClassEntity>>();
   final Map<OutputUnit, List<ConstantValue>> outputConstantLists =
       new Map<OutputUnit, List<ConstantValue>>();
-  final Map<OutputUnit, List<Element>> outputStaticLists =
-      new Map<OutputUnit, List<Element>>();
-  final Map<OutputUnit, List<VariableElement>> outputStaticNonFinalFieldLists =
-      new Map<OutputUnit, List<VariableElement>>();
-  final Map<OutputUnit, Set<LibraryElement>> outputLibraryLists =
-      new Map<OutputUnit, Set<LibraryElement>>();
+  final Map<OutputUnit, List<MemberEntity>> outputStaticLists =
+      new Map<OutputUnit, List<MemberEntity>>();
+  final Map<OutputUnit, List<FieldEntity>> outputStaticNonFinalFieldLists =
+      new Map<OutputUnit, List<FieldEntity>>();
+  final Map<OutputUnit, Set<LibraryEntity>> outputLibraryLists =
+      new Map<OutputUnit, Set<LibraryEntity>>();
 
   /// True, if the output contains a constant list.
   ///
   /// This flag is updated in [computeNeededConstants].
   bool outputContainsConstantList = false;
 
   final List<ClassElement> nativeClassesAndSubclasses = <ClassElement>[];
 
   List<TypedefElement> typedefsNeededForReflection;
 
   Collector(
       this._options,
       this._commonElements,
       this._deferredLoadTask,
       this._worldBuilder,
       this._namer,
       this._emitter,
       this._constantHandler,
       this._nativeData,
       this._interceptorData,
       this._oneShotInterceptorData,
       this._mirrorsData,
       this._closedWorld,
       this._rtiNeededClasses,
-      this._generatedCode);
+      this._generatedCode,
+      this._sorter);
 
   Set<ClassElement> computeInterceptorsReferencedFromConstants() {
     Set<ClassElement> classes = new Set<ClassElement>();
     JavaScriptConstantCompiler handler = _constantHandler;
     List<ConstantValue> constants = handler.getConstantsForEmission();
     for (ConstantValue constant in constants) {
       if (constant is InterceptorConstantValue) {
         InterceptorConstantValue interceptorConstant = constant;
         classes.add(interceptorConstant.cls);
       }
@@ skipping 186 matching lines @@
       neededClasses.add(_commonElements.stringClass);
     }
     if (neededClasses.contains(_commonElements.jsBoolClass)) {
       neededClasses.add(_commonElements.boolClass);
     }
     if (neededClasses.contains(_commonElements.jsArrayClass)) {
       neededClasses.add(_commonElements.listClass);
     }
 
     // 4. Finally, sort the classes.
-    List<ClassElement> sortedClasses = Elements.sortedByPosition(neededClasses);
+    List<ClassEntity> sortedClasses = _sorter.sortClasses(neededClasses);
 
-    for (ClassElement element in sortedClasses) {
-      if (_nativeData.isNativeOrExtendsNative(element) &&
-          !classesOnlyNeededForRti.contains(element)) {
+    for (ClassEntity cls in sortedClasses) {
+      if (_nativeData.isNativeOrExtendsNative(cls) &&
+          !classesOnlyNeededForRti.contains(cls)) {
         // For now, native classes and related classes cannot be deferred.
-        nativeClassesAndSubclasses.add(element);
-        assert(invariant(element, !_deferredLoadTask.isDeferred(element)));
+        nativeClassesAndSubclasses.add(cls);
+        assert(invariant(cls, !_deferredLoadTask.isDeferredClass(cls)));
         outputClassLists
             .putIfAbsent(_deferredLoadTask.mainOutputUnit,
                 () => new List<ClassElement>())
-            .add(element);
+            .add(cls);
       } else {
         outputClassLists
-            .putIfAbsent(_deferredLoadTask.outputUnitForElement(element),
+            .putIfAbsent(_deferredLoadTask.outputUnitForClass(cls),
                 () => new List<ClassElement>())
-            .add(element);
+            .add(cls);
       }
     }
   }
 
   void computeNeededStatics() {
-    bool isStaticFunction(MemberElement element) =>
+    bool isStaticFunction(MemberEntity element) =>
         !element.isInstanceMember && !element.isField;
 
-    Iterable<MemberElement> elements =
+    Iterable<MemberEntity> elements =
         _generatedCode.keys.where(isStaticFunction);
 
-    for (Element element in Elements.sortedByPosition(elements)) {
-      List<Element> list = outputStaticLists.putIfAbsent(
-          _deferredLoadTask.outputUnitForElement(element),
-          () => new List<Element>());
-      list.add(element);
+    for (MemberEntity member in _sorter.sortMembers(elements)) {
+      List<MemberEntity> list = outputStaticLists.putIfAbsent(
+          _deferredLoadTask.outputUnitForMember(member),
+          () => new List<MemberEntity>());
+      list.add(member);
     }
   }
 
   void computeNeededStaticNonFinalFields() {
-    addToOutputUnit(Element element) {
-      List<VariableElement> list = outputStaticNonFinalFieldLists.putIfAbsent(
-          _deferredLoadTask.outputUnitForElement(element),
-          () => new List<VariableElement>());
+    addToOutputUnit(FieldEntity element) {
+      List<FieldEntity> list = outputStaticNonFinalFieldLists.putIfAbsent(
+          // ignore: UNNECESSARY_CAST
+          _deferredLoadTask.outputUnitForMember(element as MemberEntity),
+          () => new List<FieldEntity>());
       list.add(element);
     }
 
-    Iterable<FieldElement> fields =
+    Iterable<FieldEntity> fields =
         // TODO(johnniwinther): This should be accessed from a codegen closed
         // world.
         _worldBuilder.allReferencedStaticFields.where((FieldElement field) {
       if (!field.isConst) {
         return field.isField &&
             !field.isInstanceMember &&
             !field.isFinal &&
             field.constant != null;
       } else {
         // We also need to emit static const fields if they are available for
         // reflection.
         return _mirrorsData.isMemberAccessibleByReflection(field);
       }
     });
 
-    Elements.sortedByPosition(fields).forEach(addToOutputUnit);
+    _sorter.sortMembers(fields).forEach(addToOutputUnit);
   }
 
   void computeNeededLibraries() {
-    void addSurroundingLibraryToSet(Element element) {
-      OutputUnit unit = _deferredLoadTask.outputUnitForElement(element);
-      LibraryElement library = element.library;
+    _generatedCode.keys.forEach((MemberEntity element) {
+      OutputUnit unit = _deferredLoadTask.outputUnitForMember(element);
+      LibraryEntity library = element.library;
       outputLibraryLists
-          .putIfAbsent(unit, () => new Set<LibraryElement>())
+          .putIfAbsent(unit, () => new Set<LibraryEntity>())
           .add(library);
-    }
-
-    _generatedCode.keys.forEach(addSurroundingLibraryToSet);
-    neededClasses.forEach(addSurroundingLibraryToSet);
+    });
+    neededClasses.forEach((ClassEntity element) {
+      OutputUnit unit = _deferredLoadTask.outputUnitForClass(element);
+      LibraryEntity library = element.library;
+      outputLibraryLists
+          .putIfAbsent(unit, () => new Set<LibraryEntity>())
+          .add(library);
+    });
   }
 
   void collect() {
     computeNeededDeclarations();
     computeNeededConstants();
     computeNeededStatics();
     computeNeededStaticNonFinalFields();
     computeNeededLibraries();
   }
 }