Remove Compiler and JavaScriptBackend from program_builder and collector.

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 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'
     show
         ClassElement,
         Element,
         Elements,
         FieldElement,
         FunctionElement,
         FunctionSignature,
         GetterElement,
         LibraryElement,
         MemberElement,
         MethodElement,
         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,
         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;
@@ skipping 20 matching lines @@
         TypeTestProperties;
 import '../model.dart';
 
 part 'collector.dart';
 part 'field_visitor.dart';
 part 'registry.dart';
 
 /// Builds a self-contained representation of the program that can then be
 /// emitted more easily by the individual emitters.
 class ProgramBuilder {
-  final Compiler _compiler;
+  final CompilerOptions _options;
+  final CommonElements _commonElements;
+  final Types _types;
+  final DeferredLoadTask _deferredLoadTask;
+  final ClosureTask _closureToClassMapper;
+  final CodegenWorldBuilder _worldBuilder;
+  final NativeCodegenEnqueuer _nativeCodegenEnqueuer;
+  final BackendUsage _backendUsage;
+  final JavaScriptConstantCompiler _constantHandler;
+  final NativeData _nativeData;
+  final RuntimeTypesNeed _rtiNeed;
+  final MirrorsData _mirrorsData;
+  final InterceptorData _interceptorData;
+  final SuperMemberData _superMemberData;
+  final RuntimeTypesChecks _rtiChecks;
+  final RuntimeTypesEncoder _rtiEncoder;
+  final RuntimeTypesSubstitutions _rtiSubstitutions;
+  final JsInteropAnalysis _jsInteropAnalysis;
+  final OneShotInterceptorData _oneShotInterceptorData;
+  final CustomElementsCodegenAnalysis _customElementsCodegenAnalysis;
+  final Map<MemberElement, js.Expression> _generatedCode;
   final Namer _namer;
   final CodeEmitterTask _task;
   final ClosedWorld _closedWorld;
 
   /// Contains the collected information the program builder used to build
   /// the model.
   // The collector will be filled on the first call to `buildProgram`.
   // It is stored and publicly exposed for backwards compatibility. New code
   // (and in particular new emitters) should not use it.
   final Collector collector;
 
   final Registry _registry;
 
+  final FunctionEntity _mainFunction;
+  final bool _isMockCompilation;
+
   /// True if the program should store function types in the metadata.
   bool _storeFunctionTypesInMetadata = false;
 
-  ProgramBuilder(Compiler compiler, Namer _namer, this._task, Emitter emitter,
-      ClosedWorld closedWorld, Set<ClassElement> rtiNeededClasses)
-      : this._compiler = compiler,
-        this._namer = _namer,
-        this._closedWorld = closedWorld,
+  ProgramBuilder(
+      this._options,
+      this._commonElements,
+      this._types,
+      this._deferredLoadTask,
+      this._closureToClassMapper,
+      this._worldBuilder,
+      this._nativeCodegenEnqueuer,
+      this._backendUsage,
+      this._constantHandler,
+      this._nativeData,
+      this._rtiNeed,
+      this._mirrorsData,
+      this._interceptorData,
+      this._superMemberData,
+      this._rtiChecks,
+      this._rtiEncoder,
+      this._rtiSubstitutions,
+      this._jsInteropAnalysis,
+      this._oneShotInterceptorData,
+      this._customElementsCodegenAnalysis,
+      this._generatedCode,
+      this._namer,
+      this._task,
+      this._closedWorld,
+      Set<ClassElement> rtiNeededClasses,
+      this._mainFunction,
+      {bool isMockCompilation})
+      : this._isMockCompilation = isMockCompilation,
         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;
-  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;
+            _options,
+            _commonElements,
+            _deferredLoadTask,
+            _worldBuilder,
+            _namer,
+            _task.emitter,
+            _constantHandler,
+            _nativeData,
+            _interceptorData,
+            _oneShotInterceptorData,
+            _mirrorsData,
+            _closedWorld,
+            rtiNeededClasses,
+            _generatedCode),
+        this._registry = new Registry(_deferredLoadTask);
 
   /// 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
   /// generate the deferredLoadingMap (to know which hunks to load).
   final Map<OutputUnit, Fragment> _outputs = <OutputUnit, Fragment>{};
 
   /// Mapping from [ConstantValue] to constructed [Constant]. We need this to
@@ skipping 133 matching lines @@
         _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");
+    if (_isMockCompilation) return js.js.comment("Mock compilation");
 
     MainCallStubGenerator generator = new MainCallStubGenerator(
         _commonElements, _task.emitter, _backendUsage);
-    return generator.generateInvokeMain(_compiler.mainFunction);
+    return generator.generateInvokeMain(_mainFunction);
   }
 
   DeferredFragment _buildDeferredFragment(LibrariesMap librariesMap) {
     DeferredFragment result = new DeferredFragment(
         librariesMap.outputUnit,
-        _backend.deferredPartFileName(librariesMap.name, addExtension: false),
+        _deferredLoadTask.deferredPartFileName(librariesMap.name,
+            addExtension: false),
         librariesMap.name,
         _buildLibraries(librariesMap),
         _buildStaticNonFinalFields(librariesMap),
         _buildStaticLazilyInitializedFields(librariesMap),
         _buildConstants(librariesMap));
     _outputs[librariesMap.outputUnit] = result;
     return result;
   }
 
   List<Constant> _buildConstants(LibrariesMap librariesMap) {
@@ skipping 41 matching lines @@
             _deferredLoadTask.outputUnitForElement(element) ==
             librariesMap.outputUnit);
     return Elements
         .sortedByPosition(lazyFields)
         .map(_buildLazyField)
         .where((field) => field != null) // Happens when the field was unused.
         .toList(growable: false);
   }
 
   StaticField _buildLazyField(FieldElement element) {
-    js.Expression code = _backend.generatedCode[element];
+    js.Expression code = _generatedCode[element];
     // The code is null if we ended up not needing the lazily
     // initialized field after all because of constant folding
     // before code generation.
     if (code == null) return null;
 
     js.Name name = _namer.globalPropertyName(element);
     bool isFinal = element.isFinal;
     bool isLazy = true;
     // TODO(floitsch): we shouldn't update the registry in the middle of
     // building a static field. (Note that the static-state holder was
@@ skipping 283 matching lines @@
       typeTests.properties.forEach((js.Name name, js.Node code) {
         _classes[_commonElements.jsInterceptorClass]
             .isChecks
             .add(_buildStubMethod(name, code));
       });
     } else {
       for (Field field in instanceFields) {
         if (field.needsCheckedSetter) {
           assert(!field.needsUncheckedSetter);
           FieldElement element = field.element;
-          js.Expression code = _backend.generatedCode[element];
+          js.Expression code = _generatedCode[element];
           assert(code != null);
           js.Name name = _namer.deriveSetterName(field.accessorName);
           checkedSetters.add(_buildStubMethod(name, code, element: element));
         }
       }
 
       typeTests.properties.forEach((js.Name name, js.Node code) {
         isChecks.add(_buildStubMethod(name, code));
       });
     }
@@ skipping 77 matching lines @@
             _constantHandler.getConstantValue(parameter.constant);
         optionalParameterDefaultValues.add(def);
       });
     }
     return optionalParameterDefaultValues;
   }
 
   DartMethod _buildMethod(MethodElement element) {
     assert(element.isDeclaration);
     js.Name name = _namer.methodPropertyName(element);
-    js.Expression code = _backend.generatedCode[element];
+    js.Expression code = _generatedCode[element];
 
     // TODO(kasperl): Figure out under which conditions code is null.
     if (code == null) return null;
 
     bool canTearOff = false;
     js.Name tearOffName;
     bool isClosureCallMethod = false;
     bool isNotApplyTarget = !element.isFunction || element.isAccessor;
 
     bool canBeReflected = _methodCanBeReflected(element);
@@ skipping 225 matching lines @@
     List<js.Name> names = _oneShotInterceptorData.oneShotInterceptorNames;
     return names.map((js.Name name) {
       js.Expression code = stubGenerator.generateOneShotInterceptor(name);
       return new StaticStubMethod(name, holder, code);
     });
   }
 
   StaticDartMethod _buildStaticMethod(MethodElement element) {
     js.Name name = _namer.methodPropertyName(element);
     String holder = _namer.globalObjectFor(element);
-    js.Expression code = _backend.generatedCode[element];
+    js.Expression code = _generatedCode[element];
 
     bool isApplyTarget = !element.isConstructor && !element.isAccessor;
     bool canBeApplied = _methodCanBeApplied(element);
     bool canBeReflected = _methodCanBeReflected(element);
 
     bool needsTearOff = isApplyTarget &&
         (canBeReflected ||
             _worldBuilder.staticFunctionsNeedingGetter.contains(element));
 
     js.Name tearOffName =
@@ skipping 48 matching lines @@
       Constant constant = new Constant(name, holder, constantValue);
       _constants[constantValue] = constant;
     }
   }
 
   Holder _registerStaticStateHolder() {
     return _registry.registerHolder(_namer.staticStateHolder,
         isStaticStateHolder: true);
   }
 }