Use more entities in program_builder, collector and registry

pkg/compiler/lib/src/js_emitter/full_emitter/emitter.dart

 // Copyright (c) 2014, 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_emitter.full_emitter;
 
 import 'dart:collection' show HashMap;
 import 'dart:convert';
 
 import 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
@@ skipping 10 matching lines @@
 import '../../elements/elements.dart'
     show
         ClassElement,
         Element,
         Elements,
         FieldElement,
         FunctionElement,
         FunctionSignature,
         LibraryElement,
         MethodElement,
-        TypedefElement,
-        VariableElement;
+        TypedefElement;
 import '../../elements/entities.dart';
 import '../../hash/sha1.dart' show Hasher;
 import '../../io/code_output.dart';
 import '../../io/location_provider.dart' show LocationCollector;
 import '../../io/source_map_builder.dart' show SourceMapBuilder;
 import '../../js/js.dart' as jsAst;
 import '../../js/js.dart' show js;
 import '../../js_backend/js_backend.dart'
     show
         ConstantEmitter,
         JavaScriptBackend,
         JavaScriptConstantCompiler,
         Namer,
         SetterName,
         TypeVariableCodegenAnalysis;
 import '../../universe/call_structure.dart' show CallStructure;
 import '../../universe/selector.dart' show Selector;
 import '../../universe/world_builder.dart' show CodegenWorldBuilder;
 import '../../util/uri_extras.dart' show relativize;
 import '../../world.dart' show ClosedWorld;
 import '../constant_ordering.dart' show deepCompareConstants;
 import '../headers.dart';
 import '../js_emitter.dart' hide Emitter, EmitterFactory;
 import '../js_emitter.dart' as js_emitter show Emitter, EmitterFactory;
 import '../model.dart';
 import '../program_builder/program_builder.dart';
+import '../sorter.dart';
 
 import 'class_builder.dart';
 import 'class_emitter.dart';
 import 'container_builder.dart';
 import 'interceptor_emitter.dart';
 import 'nsm_emitter.dart';
 
 export 'class_builder.dart';
 export 'class_emitter.dart';
 export 'container_builder.dart';
 export 'interceptor_emitter.dart';
 export 'nsm_emitter.dart';
 
 part 'code_emitter_helper.dart';
 part 'declarations.dart';
 part 'deferred_output_unit_hash.dart';
 part 'setup_program_builder.dart';
 
 class EmitterFactory implements js_emitter.EmitterFactory {
   final bool generateSourceMap;
 
   EmitterFactory({this.generateSourceMap});
 
   @override
   bool get supportsReflection => true;
 
   @override
   Emitter createEmitter(
       CodeEmitterTask task, Namer namer, ClosedWorld closedWorld) {
-    return new Emitter(
-        task.compiler, namer, closedWorld, generateSourceMap, task);
+    return new Emitter(task.compiler, namer, closedWorld, generateSourceMap,
+        task, task.sorter);
   }
 }
 
 class Emitter implements js_emitter.Emitter {
   final Compiler compiler;
   final CodeEmitterTask task;
 
   // The following fields will be set to copies of the program-builder's
   // collector.
-  Map<OutputUnit, List<VariableElement>> outputStaticNonFinalFieldLists;
-  Map<OutputUnit, Set<LibraryElement>> outputLibraryLists;
+  Map<OutputUnit, List<FieldEntity>> outputStaticNonFinalFieldLists;
+  Map<OutputUnit, Set<LibraryEntity>> outputLibraryLists;
   List<TypedefElement> typedefsNeededForReflection;
 
   final ContainerBuilder containerBuilder = new ContainerBuilder();
   final ClassEmitter classEmitter;
   final NsmEmitter nsmEmitter;
   final InterceptorEmitter interceptorEmitter;
+  final Sorter _sorter;
 
   // TODO(johnniwinther): Wrap these fields in a caching strategy.
   final List<jsAst.Statement> cachedEmittedConstantsAst = <jsAst.Statement>[];
 
   bool needsClassSupport = false;
   bool needsMixinSupport = false;
   bool needsLazyInitializer = false;
 
   /// True if [ContainerBuilder.addMemberMethodFromInfo] used "structured info",
   /// that is, some function was needed for reflection, had stubs, or had a
@@ skipping 47 matching lines @@
    * See [getElementDescriptor].
    */
   // TODO(ahe): Generate statics with their class, and store only libraries in
   // this map.
   final Map<Fragment, Map<Element, ClassBuilder>> elementDescriptors =
       new Map<Fragment, Map<Element, ClassBuilder>>();
 
   final bool generateSourceMap;
 
   Emitter(Compiler compiler, Namer namer, ClosedWorld closedWorld,
-      this.generateSourceMap, this.task)
+      this.generateSourceMap, this.task, this._sorter)
       : this.compiler = compiler,
         this.namer = namer,
         classEmitter = new ClassEmitter(closedWorld),
         interceptorEmitter = new InterceptorEmitter(closedWorld),
         nsmEmitter = new NsmEmitter(closedWorld) {
     constantEmitter = new ConstantEmitter(
         compiler, namer, this.constantReference, constantListGenerator);
     containerBuilder.emitter = this;
     classEmitter.emitter = this;
     nsmEmitter.emitter = this;
@@ skipping 405 matching lines @@
       containerBuilder.addMemberMethod(method, builder);
       getStaticMethodDescriptor(element, fragment)
           .properties
           .addAll(builder.properties);
     }
   }
 
   jsAst.Statement buildStaticNonFinalFieldInitializations(
       OutputUnit outputUnit) {
     jsAst.Statement buildInitialization(
-        Element element, jsAst.Expression initialValue) {
+        FieldElement element, jsAst.Expression initialValue) {
       return js.statement('${namer.staticStateHolder}.# = #',
           [namer.globalPropertyName(element), initialValue]);
     }
 
     bool inMainUnit = (outputUnit == compiler.deferredLoadTask.mainOutputUnit);
     JavaScriptConstantCompiler handler = backend.constants;
     List<jsAst.Statement> parts = <jsAst.Statement>[];
 
-    Iterable<Element> fields = outputStaticNonFinalFieldLists[outputUnit];
+    Iterable<FieldEntity> fields = outputStaticNonFinalFieldLists[outputUnit];
     // If the outputUnit does not contain any static non-final fields, then
     // [fields] is `null`.
     if (fields != null) {
       for (FieldElement element in fields) {
         reporter.withCurrentElement(element, () {
           ConstantValue constant = handler.getConstantValue(element.constant);
           parts.add(buildInitialization(element, constantReference(constant)));
         });
       }
     }
 
     if (inMainUnit && outputStaticNonFinalFieldLists.length > 1) {
       // In the main output-unit we output a stub initializer for deferred
       // variables, so that `isolateProperties` stays a fast object.
-      outputStaticNonFinalFieldLists.forEach(
-          (OutputUnit fieldsOutputUnit, Iterable<VariableElement> fields) {
+      outputStaticNonFinalFieldLists
+          .forEach((OutputUnit fieldsOutputUnit, Iterable<FieldEntity> fields) {
         if (fieldsOutputUnit == outputUnit) return; // Skip the main unit.
-        for (Element element in fields) {
+        for (FieldEntity element in fields) {
           reporter.withCurrentElement(element, () {
             parts.add(buildInitialization(element, jsAst.number(0)));
           });
         }
       });
     }
 
     return new jsAst.Block(parts);
   }
 
@@ skipping 702 matching lines @@
     if (isProgramSplit) {
       statements.add(buildDeferredHeader());
     }
 
     // Collect the AST for the decriptors
     Map<Element, ClassBuilder> descriptors = elementDescriptors[mainFragment];
     if (descriptors == null) descriptors = const {};
 
     checkEverythingEmitted(descriptors.keys);
 
-    Iterable<LibraryElement> libraries = outputLibraryLists[mainOutputUnit];
+    Iterable<LibraryEntity> libraries = outputLibraryLists[mainOutputUnit];
     if (libraries == null) libraries = <LibraryElement>[];
 
     List<jsAst.Expression> parts = <jsAst.Expression>[];
-    for (LibraryElement library in Elements.sortedByPosition(libraries)) {
+    for (LibraryEntity library in _sorter.sortLibraries(libraries)) {
       parts.add(generateLibraryDescriptor(library, mainFragment));
       descriptors.remove(library);
     }
 
     if (descriptors.isNotEmpty) {
       List<Element> remainingLibraries =
           descriptors.keys.where((Element e) => e is LibraryElement).toList();
 
       // The remaining descriptors are only accessible through reflection.
       // The program builder does not collect libraries that only
@@ skipping 196 matching lines @@
       Program program) {
     Map<OutputUnit, jsAst.Expression> outputs =
         new Map<OutputUnit, jsAst.Expression>();
 
     for (Fragment fragment in program.deferredFragments) {
       OutputUnit outputUnit = fragment.outputUnit;
 
       Map<Element, ClassBuilder> descriptors = elementDescriptors[fragment];
 
       if (descriptors != null && descriptors.isNotEmpty) {
-        Iterable<LibraryElement> libraries = outputLibraryLists[outputUnit];
+        Iterable<LibraryEntity> libraries = outputLibraryLists[outputUnit];
         if (libraries == null) libraries = [];
 
         // TODO(johnniwinther): Avoid creating [CodeBuffer]s.
         List<jsAst.Expression> parts = <jsAst.Expression>[];
-        for (LibraryElement library in Elements.sortedByPosition(libraries)) {
+        for (LibraryEntity library in _sorter.sortLibraries(libraries)) {
           parts.add(generateLibraryDescriptor(library, fragment));
           descriptors.remove(library);
         }
 
         outputs[outputUnit] = new jsAst.ArrayInitializer(parts);
       }
     }
 
     return outputs;
   }
@@ skipping 340 matching lines @@
     // data.
     mapping["_comment"] = "This mapping shows which compiled `.js` files are "
         "needed for a given deferred library import.";
     mapping.addAll(compiler.deferredLoadTask.computeDeferredMap());
     compiler.outputProvider(
         compiler.options.deferredMapUri.path, '', OutputType.info)
       ..add(const JsonEncoder.withIndent("  ").convert(mapping))
       ..close();
   }
 }