Remove Compiler and JavaScriptBackend from main_call_stub_generator and runtime_type_generator

pkg/compiler/lib/src/js_emitter/program_builder/program_builder.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.program_builder;
 
-import '../../closure.dart' show ClosureFieldElement;
+import '../../closure.dart' show ClosureTask, ClosureFieldElement;
 import '../../common.dart';
 import '../../common/names.dart' show Names, Selectors;
 import '../../compiler.dart' show Compiler;
 import '../../constants/values.dart'
     show ConstantValue, InterceptorConstantValue;
 import '../../common_elements.dart' show CommonElements;
 import '../../elements/resolution_types.dart'
     show ResolutionDartType, ResolutionFunctionType, ResolutionTypedefType;
 import '../../deferred_load.dart' show DeferredLoadTask, OutputUnit;
 import '../../elements/elements.dart'
@@ skipping 11 matching lines @@
         ParameterElement,
         TypedefElement,
         VariableElement;
 import '../../elements/entities.dart';
 import '../../elements/resolution_types.dart' show Types;
 import '../../elements/types.dart' show DartType;
 import '../../js/js.dart' as js;
 import '../../js_backend/backend.dart'
     show
         JavaScriptBackend,
+        RuntimeTypesChecks,
+        RuntimeTypesNeed,
         RuntimeTypesEncoder,
-        RuntimeTypesNeed,
+        RuntimeTypesSubstitutions,
         SuperMemberData;
 import '../../js_backend/backend_usage.dart';
 import '../../js_backend/constant_handler_javascript.dart'
     show JavaScriptConstantCompiler;
 import '../../js_backend/custom_elements_analysis.dart';
 import '../../js_backend/namer.dart' show Namer, StringBackedName;
 import '../../js_backend/native_data.dart';
 import '../../js_backend/interceptor_data.dart';
 import '../../js_backend/mirrors_data.dart';
+import '../../js_backend/js_interop_analysis.dart';
 import '../../native/enqueue.dart' show NativeCodegenEnqueuer;
 import '../../options.dart';
 import '../../universe/selector.dart' show Selector;
 import '../../universe/world_builder.dart'
     show CodegenWorldBuilder, SelectorConstraints;
 import '../../world.dart' show ClosedWorld;
 import '../js_emitter.dart'
     show
         ClassStubGenerator,
         CodeEmitterTask,
@@ skipping 38 matching lines @@
         this.collector = new Collector(
             compiler, _namer, closedWorld, rtiNeededClasses, emitter),
         this._registry = new Registry(compiler);
 
   JavaScriptBackend get _backend => _compiler.backend;
   CodegenWorldBuilder get _worldBuilder => _compiler.codegenWorldBuilder;
   DeferredLoadTask get _deferredLoadTask => _compiler.deferredLoadTask;
   Types get _types => _compiler.types;
   CommonElements get _commonElements => _compiler.commonElements;
   CompilerOptions get _options => _compiler.options;
+  ClosureTask get _closureToClassMapper => _compiler.closureToClassMapper;
   NativeCodegenEnqueuer get _nativeCodegenEnqueuer =>
       _backend.nativeCodegenEnqueuer;
   BackendUsage get _backendUsage => _backend.backendUsage;
-  CodeEmitterTask get _emitter => _backend.emitter;
   JavaScriptConstantCompiler get _constantHandler => _backend.constants;
   NativeData get _nativeData => _backend.nativeData;
   RuntimeTypesNeed get _rtiNeed => _backend.rtiNeed;
   MirrorsData get _mirrorsData => _backend.mirrorsData;
   InterceptorData get _interceptorData => _backend.interceptorData;
   SuperMemberData get _superMemberData => _backend.superMemberData;
+  RuntimeTypesChecks get _rtiChecks => _backend.rtiChecks;
   RuntimeTypesEncoder get _rtiEncoder => _backend.rtiEncoder;
+  RuntimeTypesSubstitutions get _rtiSubstitutions => _backend.rtiSubstitutions;
+  JsInteropAnalysis get _jsInteropAnalysis => _backend.jsInteropAnalysis;
   OneShotInterceptorData get _oneShotInterceptorData =>
       _backend.oneShotInterceptorData;
   CustomElementsCodegenAnalysis get _customElementsCodegenAnalysis =>
       _backend.customElementsCodegenAnalysis;
 
   /// Mapping from [ClassElement] to constructed [Class]. We need this to
   /// update the superclass in the [Class].
   final Map<ClassElement, Class> _classes = <ClassElement, Class>{};
 
   /// Mapping from [OutputUnit] to constructed [Fragment]. We need this to
@@ skipping 109 matching lines @@
           .map((OutputUnit unit) => _outputs[unit])
           .toList(growable: false);
     });
     return loadMap;
   }
 
   js.Expression _buildTypeToInterceptorMap() {
     InterceptorStubGenerator stubGenerator = new InterceptorStubGenerator(
         _options,
         _commonElements,
-        _emitter,
+        _task,
         _nativeCodegenEnqueuer,
         _constantHandler,
         _namer,
         _nativeData,
         _interceptorData,
         _oneShotInterceptorData,
         _customElementsCodegenAnalysis,
         _worldBuilder,
         _closedWorld);
     return stubGenerator.generateTypeToInterceptorMap();
   }
 
   MainFragment _buildMainFragment(LibrariesMap librariesMap) {
     // Construct the main output from the libraries and the registered holders.
     MainFragment result = new MainFragment(
         librariesMap.outputUnit,
         "", // The empty string is the name for the main output file.
         _buildInvokeMain(),
         _buildLibraries(librariesMap),
         _buildStaticNonFinalFields(librariesMap),
         _buildStaticLazilyInitializedFields(librariesMap),
         _buildConstants(librariesMap));
     _outputs[librariesMap.outputUnit] = result;
     return result;
   }
 
   js.Statement _buildInvokeMain() {
     if (_compiler.isMockCompilation) return js.js.comment("Mock compilation");
 
-    MainCallStubGenerator generator =
-        new MainCallStubGenerator(_backend, _emitter);
+    MainCallStubGenerator generator = new MainCallStubGenerator(
+        _commonElements, _task.emitter, _backendUsage);
     return generator.generateInvokeMain(_compiler.mainFunction);
   }
 
   DeferredFragment _buildDeferredFragment(LibrariesMap librariesMap) {
     DeferredFragment result = new DeferredFragment(
         librariesMap.outputUnit,
         _backend.deferredPartFileName(librariesMap.name, addExtension: false),
         librariesMap.name,
         _buildLibraries(librariesMap),
         _buildStaticNonFinalFields(librariesMap),
@@ skipping 255 matching lines @@
       // if it does not we can suppress it completely.
       onlyForRti = true;
     }
 
     List<Method> methods = [];
     List<StubMethod> callStubs = <StubMethod>[];
 
     ClassStubGenerator classStubGenerator = new ClassStubGenerator(
         _namer, _backend, _worldBuilder, _closedWorld,
         enableMinification: _options.enableMinification);
-    RuntimeTypeGenerator runtimeTypeGenerator =
-        new RuntimeTypeGenerator(_compiler, _task, _namer);
+    RuntimeTypeGenerator runtimeTypeGenerator = new RuntimeTypeGenerator(
+        _commonElements,
+        _closureToClassMapper,
+        _task,
+        _namer,
+        _nativeData,
+        _rtiChecks,
+        _rtiEncoder,
+        _rtiNeed,
+        _rtiSubstitutions,
+        _jsInteropAnalysis);
 
     void visitMember(ClassElement enclosing, MemberElement member) {
       assert(invariant(element, member.isDeclaration));
       assert(invariant(element, element == enclosing));
 
       if (Elements.isNonAbstractInstanceMember(member)) {
         // TODO(herhut): Remove once _buildMethod can no longer return null.
         Method method = _buildMethod(member);
         if (method != null) methods.add(method);
       }
@@ skipping 246 matching lines @@
         canBeReflected: canBeReflected,
         requiredParameterCount: requiredParameterCount,
         optionalParameterDefaultValues: optionalParameterDefaultValues,
         functionType: functionType);
   }
 
   js.Expression _generateFunctionType(
       ResolutionDartType type, OutputUnit outputUnit) {
     if (type.containsTypeVariables) {
       js.Expression thisAccess = js.js(r'this.$receiver');
-      return _rtiEncoder.getSignatureEncoding(
-          _emitter.emitter, type, thisAccess);
+      return _rtiEncoder.getSignatureEncoding(_task.emitter, type, thisAccess);
     } else {
-      return _emitter.metadataCollector
-          .reifyTypeForOutputUnit(type, outputUnit);
+      return _task.metadataCollector.reifyTypeForOutputUnit(type, outputUnit);
     }
   }
 
   List<ParameterStubMethod> _generateParameterStubs(
       MethodElement element, bool canTearOff) {
     if (!_methodNeedsStubs(element)) return const <ParameterStubMethod>[];
 
     ParameterStubGenerator generator =
         new ParameterStubGenerator(_compiler, _namer, _backend, _closedWorld);
     return generator.generateParameterStubs(element, canTearOff: canTearOff);
@@ skipping 20 matching lines @@
         Class cls = _classes[element];
         if (cls != null) cls.isEager = true;
       }
     }
   }
 
   Iterable<StaticStubMethod> _generateGetInterceptorMethods() {
     InterceptorStubGenerator stubGenerator = new InterceptorStubGenerator(
         _options,
         _commonElements,
-        _emitter,
+        _task,
         _nativeCodegenEnqueuer,
         _constantHandler,
         _namer,
         _nativeData,
         _interceptorData,
         _oneShotInterceptorData,
         _customElementsCodegenAnalysis,
         _worldBuilder,
         _closedWorld);
 
@@ skipping 58 matching lines @@
           needsCheckedSetter));
     });
 
     return fields;
   }
 
   Iterable<StaticStubMethod> _generateOneShotInterceptors() {
     InterceptorStubGenerator stubGenerator = new InterceptorStubGenerator(
         _options,
         _commonElements,
-        _emitter,
+        _task,
         _nativeCodegenEnqueuer,
         _constantHandler,
         _namer,
         _nativeData,
         _interceptorData,
         _oneShotInterceptorData,
         _customElementsCodegenAnalysis,
         _worldBuilder,
         _closedWorld);
 
@@ skipping 75 matching lines @@
       Constant constant = new Constant(name, holder, constantValue);
       _constants[constantValue] = constant;
     }
   }
 
   Holder _registerStaticStateHolder() {
     return _registry.registerHolder(_namer.staticStateHolder,
         isStaticStateHolder: true);
   }
 }