Implement JsKernelToElementMap through KernelToElementMapBase

pkg/compiler/lib/src/js_emitter/code_emitter_task.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_emitter.code_emitter_task;
 
 import 'package:js_runtime/shared/embedded_names.dart' show JsBuiltin;
 
 import '../common.dart';
 import '../common/tasks.dart' show CompilerTask;
@@ skipping 25 matching lines @@
  * The code for the containing (used) methods must exist in the `universe`.
  */
 class CodeEmitterTask extends CompilerTask {
   TypeTestRegistry typeTestRegistry;
   NativeEmitter _nativeEmitter;
   MetadataCollector metadataCollector;
   EmitterFactory _emitterFactory;
   Emitter _emitter;
   final Compiler compiler;
 
-  /// The [Sorter] use for ordering elements in the generated JavaScript.
-  final Sorter sorter;
-
   JavaScriptBackend get backend => compiler.backend;
 
   @deprecated
   // This field should be removed. It's currently only needed for dump-info and
   // tests.
   // The field is set after the program has been emitted.
   /// Contains a list of all classes that are emitted.
   Set<ClassEntity> neededClasses;
 
   CodeEmitterTask(
       Compiler compiler, bool generateSourceMap, bool useStartupEmitter)
       : compiler = compiler,
-        sorter = compiler.backendStrategy.sorter,
         super(compiler.measurer) {
     if (USE_LAZY_EMITTER) {
       _emitterFactory = new lazy_js_emitter.EmitterFactory();
     } else if (useStartupEmitter) {
       _emitterFactory = new startup_js_emitter.EmitterFactory(
           generateSourceMap: generateSourceMap);
     } else {
       _emitterFactory = new full_js_emitter.EmitterFactory(
           generateSourceMap: generateSourceMap);
     }
@@ skipping 89 matching lines @@
     // Compute the required type checks to know which classes need a
     // 'is$' method.
     typeTestRegistry.computeRequiredTypeChecks(backend.rtiChecksBuilder);
     // Compute the classes needed by RTI.
     typeTestRegistry.computeRtiNeededClasses(backend.rtiSubstitutions,
         backend.mirrorsData, backend.generatedCode.keys);
   }
 
   /// Creates the [Emitter] for this task.
   void createEmitter(Namer namer, ClosedWorld closedWorld,
-      CodegenWorldBuilder codegenWorldBuilder) {
+      CodegenWorldBuilder codegenWorldBuilder, Sorter sorter) {
     measure(() {
       _nativeEmitter = new NativeEmitter(this, closedWorld, codegenWorldBuilder,
           backend.nativeCodegenEnqueuer);
-      _emitter = _emitterFactory.createEmitter(this, namer, closedWorld);
+      _emitter =
+          _emitterFactory.createEmitter(this, namer, closedWorld, sorter);
       metadataCollector = new MetadataCollector(
           compiler.options,
           compiler.reporter,
           compiler.deferredLoadTask,
           _emitter,
           backend.constants,
           backend.typeVariableCodegenAnalysis,
           backend.mirrorsData,
           backend.rtiEncoder);
       typeTestRegistry = new TypeTestRegistry(
@@ skipping 24 matching lines @@
           typeTestRegistry.rtiChecks,
           backend.rtiEncoder,
           backend.rtiSubstitutions,
           backend.jsInteropAnalysis,
           backend.oneShotInterceptorData,
           backend.customElementsCodegenAnalysis,
           backend.generatedCode,
           namer,
           this,
           closedWorld,
+          compiler.backendStrategy.sorter,
           typeTestRegistry.rtiNeededClasses,
           closedWorld.elementEnvironment.mainFunction,
           isMockCompilation: compiler.isMockCompilation);
       int size = emitter.emitProgram(programBuilder);
       // TODO(floitsch): we shouldn't need the `neededClasses` anymore.
       neededClasses = programBuilder.collector.neededClasses;
       return size;
     });
   }
 }
 
 abstract class EmitterFactory {
   /// Returns true, if the emitter supports reflection.
   bool get supportsReflection;
 
   /// Create the [Emitter] for the emitter [task] that uses the given [namer].
-  Emitter createEmitter(
-      CodeEmitterTask task, Namer namer, ClosedWorld closedWorld);
+  Emitter createEmitter(CodeEmitterTask task, Namer namer,
+      ClosedWorld closedWorld, Sorter sorter);
 }
 
 abstract class Emitter {
   Program get programForTesting;
 
   /// Uses the [programBuilder] to generate a model of the program, emits
   /// the program, and returns the size of the generated output.
   int emitProgram(ProgramBuilder programBuilder);
 
   /// Returns the JS function that must be invoked to get the value of the
@@ skipping 87 matching lines @@
   @override
   jsAst.Expression interceptorClassAccess(ClassEntity element) {
     return globalPropertyAccessForClass(element);
   }
 
   @override
   jsAst.Expression typeAccess(Entity element) {
     return globalPropertyAccessForType(element);
   }
 }