Use entities in runtime_types

pkg/compiler/lib/src/js_backend/backend.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 js_backend.backend;
 
 import '../common.dart';
 import '../common/backend_api.dart'
     show ForeignResolver, NativeRegistry, ImpactTransformer;
 import '../common/codegen.dart' show CodegenImpact, CodegenWorkItem;
 import '../common/names.dart' show Uris;
 import '../common/resolution.dart' show Resolution, Target;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
-import '../common_elements.dart' show CommonElements, ElementEnvironment;
+import '../common_elements.dart' show CommonElements;
 import '../deferred_load.dart' show DeferredLoadTask;
 import '../dump_info.dart' show DumpInfoTask;
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/names.dart';
 import '../elements/resolution_types.dart';
-import '../elements/types.dart';
 import '../enqueue.dart'
     show
         DirectEnqueuerStrategy,
         Enqueuer,
         EnqueueTask,
         ResolutionEnqueuer,
         TreeShakingEnqueuerStrategy;
 import '../frontend_strategy.dart';
 import '../io/multi_information.dart' show MultiSourceInformationStrategy;
 import '../io/position_information.dart' show PositionSourceInformationStrategy;
 import '../io/source_information.dart' show SourceInformationStrategy;
 import '../io/start_end_information.dart'
     show StartEndSourceInformationStrategy;
 import '../js/js.dart' as jsAst;
 import '../js/js.dart' show js;
 import '../js/js_source_mapping.dart' show JavaScriptSourceInformationStrategy;
 import '../js/rewrite_async.dart';
-import '../js_emitter/js_emitter.dart' show CodeEmitterTask, Emitter;
+import '../js_emitter/js_emitter.dart' show CodeEmitterTask;
 import '../kernel/task.dart';
 import '../library_loader.dart' show LoadedLibraries;
 import '../native/native.dart' as native;
 import '../native/resolver.dart';
 import '../ssa/ssa.dart' show SsaFunctionCompiler;
 import '../tracer.dart';
 import '../tree/tree.dart';
 import '../types/types.dart';
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart' show Selector;
@@ skipping 17 matching lines @@
 import 'js_interop_analysis.dart' show JsInteropAnalysis;
 import 'lookup_map_analysis.dart'
     show LookupMapResolutionAnalysis, LookupMapAnalysis;
 import 'mirrors_analysis.dart';
 import 'mirrors_data.dart';
 import 'namer.dart';
 import 'native_data.dart';
 import 'no_such_method_registry.dart';
 import 'patch_resolver.dart';
 import 'resolution_listener.dart';
+import 'runtime_types.dart';
 import 'type_variable_handler.dart';
 
-part 'runtime_types.dart';
-
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 abstract class FunctionCompiler {
   /// Generates JavaScript code for `work.element`.
   jsAst.Fun compile(CodegenWorkItem work, ClosedWorld closedWorld);
 
   Iterable get tasks;
 }
 
 /*
@@ skipping 274 matching lines @@
   List<CompilerTask> get tasks {
     List<CompilerTask> result = functionCompiler.tasks;
     result.add(emitter);
     result.add(patchResolverTask);
     result.add(kernelTask);
     return result;
   }
 
   final RuntimeTypesNeedBuilder _rtiNeedBuilder;
   RuntimeTypesNeed _rtiNeed;
-  final _RuntimeTypes _rti;
+  final RuntimeTypesImpl _rti;
 
   RuntimeTypesEncoder _rtiEncoder;
 
   /// True if the html library has been loaded.
   bool htmlLibraryIsLoaded = false;
 
   /// Resolution analysis for tracking reflective access to type variables.
   TypeVariableResolutionAnalysis _typeVariableResolutionAnalysis;
 
   /// Codegen handler for reflective access to type variables.
@@ skipping 91 matching lines @@
       return const StartEndSourceInformationStrategy();
     }
   }
 
   JavaScriptBackend(this.compiler,
       {bool generateSourceMap: true,
       bool useStartupEmitter: false,
       bool useMultiSourceInfo: false,
       bool useNewSourceInfo: false,
       bool useKernel: false})
-      : _rti = new _RuntimeTypes(compiler),
+      : _rti = new RuntimeTypesImpl(
+            compiler.elementEnvironment, compiler.frontEndStrategy.dartTypes),
         optimizerHints = new OptimizerHintsForTests(
             compiler.elementEnvironment, compiler.commonElements),
         this.sourceInformationStrategy = createSourceInformationStrategy(
             generateSourceMap: generateSourceMap,
             useMultiSourceInfo: useMultiSourceInfo,
             useNewSourceInfo: useNewSourceInfo),
         constantCompilerTask = new JavaScriptConstantTask(compiler),
         _nativeDataResolver = new NativeDataResolverImpl(compiler),
         _rtiNeedBuilder =
             compiler.frontEndStrategy.createRuntimeTypesNeedBuilder() {
@@ skipping 614 matching lines @@
   }
 
   /// Called when the compiler starts running the codegen enqueuer. The
   /// [WorldImpact] of enabled backend features is returned.
   WorldImpact onCodegenStart(
       ClosedWorld closedWorld, CodegenWorldBuilder codegenWorldBuilder) {
     _oneShotInterceptorData =
         new OneShotInterceptorData(closedWorld.interceptorData, commonElements);
     _namer = determineNamer(closedWorld, codegenWorldBuilder);
     tracer = new Tracer(closedWorld, namer, compiler);
-    _rtiEncoder =
-        _namer.rtiEncoder = new _RuntimeTypesEncoder(namer, commonElements);
+    _rtiEncoder = _namer.rtiEncoder = new RuntimeTypesEncoderImpl(
+        namer, compiler.elementEnvironment, commonElements);
     emitter.createEmitter(namer, closedWorld, codegenWorldBuilder);
     _codegenImpactTransformer = new CodegenImpactTransformer(
         compiler.options,
         compiler.elementEnvironment,
         commonElements,
         impacts,
         checkedModeHelpers,
         closedWorld.nativeData,
         backendUsage,
         rtiNeed,
@@ skipping 311 matching lines @@
 
   bool canUseAliasedSuperMember(MemberEntity member, Selector selector) {
     return !selector.isGetter;
   }
 
   /// Returns `true` if [member] is called from a subclass via `super`.
   bool isAliasedSuperMember(MemberEntity member) {
     return _aliasedSuperMembers.contains(member);
   }
 }