Remove Compiler/JavaScriptBackend from metadata_collector

pkg/compiler/lib/src/js_emitter/metadata_collector.dart

 // Copyright (c) 2013, 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.metadata_collector;
 
 import 'package:js_ast/src/precedence.dart' as js_precedence;
 
 import '../common.dart';
-import '../compiler.dart' show Compiler;
 import '../constants/values.dart';
 import '../elements/resolution_types.dart'
     show ResolutionDartType, ResolutionTypedefType;
-import '../deferred_load.dart' show OutputUnit;
+import '../deferred_load.dart' show DeferredLoadTask, OutputUnit;
 import '../elements/elements.dart'
     show
         ClassElement,
         ConstructorElement,
         Element,
         FieldElement,
         FunctionElement,
         FunctionSignature,
         LibraryElement,
         MemberElement,
         MethodElement,
         MetadataAnnotation,
         ParameterElement;
 import '../js/js.dart' as jsAst;
 import '../js/js.dart' show js;
-import '../js_backend/js_backend.dart'
-    show JavaScriptBackend, TypeVariableCodegenAnalysis;
+import '../js_backend/backend.dart' show RuntimeTypesEncoder;
+import '../js_backend/constant_handler_javascript.dart';
+import '../js_backend/mirrors_data.dart';
+import '../js_backend/type_variable_handler.dart'
+    show TypeVariableCodegenAnalysis;
+import '../options.dart';
 
 import 'code_emitter_task.dart' show Emitter;
 
 /// Represents an entry's position in one of the global metadata arrays.
 ///
 /// [_rc] is used to count the number of references of the token in the
 /// ast for a program.
 /// [value] is the actual position, once they have been finalized.
 abstract class _MetadataEntry extends jsAst.DeferredNumber
     implements Comparable, jsAst.ReferenceCountedAstNode {
@@ skipping 86 matching lines @@
 
   jsAst.Expression get value {
     assert(_value != null);
     return _value;
   }
 
   int get precedenceLevel => js_precedence.PRIMARY;
 }
 
 class MetadataCollector implements jsAst.TokenFinalizer {
-  final Compiler _compiler;
+  final CompilerOptions _options;
+  final DiagnosticReporter reporter;
+  final DeferredLoadTask _deferredLoadTask;
   final Emitter _emitter;
+  final JavaScriptConstantCompiler _constants;
+  final TypeVariableCodegenAnalysis _typeVariableCodegenAnalysis;
+  final MirrorsData _mirrorsData;
+  final RuntimeTypesEncoder _rtiEncoder;
 
   /// A token for a list of expressions that represent metadata, parameter names
   /// and type variable types.
   final _MetadataList _globalMetadata = new _MetadataList();
   jsAst.Expression get globalMetadata => _globalMetadata;
 
   /// A map used to canonicalize the entries of globalMetadata.
   Map<String, _BoundMetadataEntry> _globalMetadataMap;
 
   /// A map with a token for a lists of JS expressions, one token for each
   /// output unit. Once finalized, the entries represent types including
   /// function types and typedefs.
   Map<OutputUnit, _MetadataList> _typesTokens =
       new Map<OutputUnit, _MetadataList>();
 
   jsAst.Expression getTypesForOutputUnit(OutputUnit outputUnit) {
     return _typesTokens.putIfAbsent(outputUnit, () => new _MetadataList());
   }
 
   /// A map used to canonicalize the entries of types.
   Map<OutputUnit, Map<ResolutionDartType, _BoundMetadataEntry>> _typesMap =
       <OutputUnit, Map<ResolutionDartType, _BoundMetadataEntry>>{};
 
-  MetadataCollector(this._compiler, this._emitter) {
+  MetadataCollector(
+      this._options,
+      this.reporter,
+      this._deferredLoadTask,
+      this._emitter,
+      this._constants,
+      this._typeVariableCodegenAnalysis,
+      this._mirrorsData,
+      this._rtiEncoder) {
     _globalMetadataMap = new Map<String, _BoundMetadataEntry>();
   }
 
-  JavaScriptBackend get _backend => _compiler.backend;
-  TypeVariableCodegenAnalysis get _typeVariableCodegenAnalysis =>
-      _backend.typeVariableCodegenAnalysis;
-  DiagnosticReporter get reporter => _compiler.reporter;
-
   jsAst.Fun buildLibraryMetadataFunction(LibraryElement element) {
-    if (!_backend.mirrorsData.mustRetainMetadata ||
-        !_backend.mirrorsData.isLibraryReferencedFromMirrorSystem(element)) {
+    if (!_mirrorsData.mustRetainMetadata ||
+        !_mirrorsData.isLibraryReferencedFromMirrorSystem(element)) {
       return null;
     }
     return _buildMetadataFunction(element);
   }
 
   jsAst.Fun buildClassMetadataFunction(ClassElement element) {
-    if (!_backend.mirrorsData.mustRetainMetadata ||
-        !_backend.mirrorsData.isClassReferencedFromMirrorSystem(element)) {
+    if (!_mirrorsData.mustRetainMetadata ||
+        !_mirrorsData.isClassReferencedFromMirrorSystem(element)) {
       return null;
     }
     return _buildMetadataFunction(element);
   }
 
   bool _mustEmitMetadataForMember(MemberElement element) {
-    return _backend.mirrorsData.mustRetainMetadata &&
-        _backend.mirrorsData.isMemberReferencedFromMirrorSystem(element);
+    return _mirrorsData.mustRetainMetadata &&
+        _mirrorsData.isMemberReferencedFromMirrorSystem(element);
   }
 
   jsAst.Fun buildFieldMetadataFunction(FieldElement element) {
     if (!_mustEmitMetadataForMember(element)) return null;
     return _buildMetadataFunction(element);
   }
 
   /// The metadata function returns the metadata associated with
   /// [element] in generated code.  The metadata needs to be wrapped
   /// in a function as it refers to constants that may not have been
   /// constructed yet.  For example, a class is allowed to be
   /// annotated with itself.  The metadata function is used by
   /// mirrors_patch to implement DeclarationMirror.metadata.
   jsAst.Fun _buildMetadataFunction(Element element) {
     return reporter.withCurrentElement(element, () {
       List<jsAst.Expression> metadata = <jsAst.Expression>[];
       for (MetadataAnnotation annotation in element.metadata) {
         ConstantValue constant =
-            _backend.constants.getConstantValueForMetadata(annotation);
+            _constants.getConstantValueForMetadata(annotation);
         if (constant == null) {
           reporter.internalError(annotation, 'Annotation value is null.');
         } else {
           metadata.add(_emitter.constantReference(constant));
         }
       }
       if (metadata.isEmpty) return null;
       return js(
           'function() { return # }', new jsAst.ArrayInitializer(metadata));
     });
@@ skipping 28 matching lines @@
         }
       }
     }
 
     List<jsAst.DeferredNumber> defaultValues = <jsAst.DeferredNumber>[];
     for (ParameterElement element in signature.optionalParameters) {
       ParameterElement parameter =
           (targetParameterMap == null) ? element : targetParameterMap[element];
       ConstantValue constant = (parameter == null)
           ? null
-          : _backend.constants.getConstantValue(parameter.constant);
+          : _constants.getConstantValue(parameter.constant);
       jsAst.Expression expression = (constant == null)
           ? new jsAst.LiteralNull()
           : _emitter.constantReference(constant);
       defaultValues.add(_addGlobalMetadata(expression));
     }
     return defaultValues;
   }
 
   Map<ParameterElement, ParameterElement>
       mapRedirectingFactoryConstructorOptionalParameters(
@@ skipping 23 matching lines @@
           map[element] = target
               .orderedOptionalParameters[i - target.requiredParameterCount];
         }
         ++i;
       }
     }
     return map;
   }
 
   jsAst.Expression reifyMetadata(MetadataAnnotation annotation) {
-    ConstantValue constant =
-        _backend.constants.getConstantValueForMetadata(annotation);
+    ConstantValue constant = _constants.getConstantValueForMetadata(annotation);
     if (constant == null) {
       reporter.internalError(annotation, 'Annotation value is null.');
       return null;
     }
     return _addGlobalMetadata(_emitter.constantReference(constant));
   }
 
   jsAst.Expression reifyType(ResolutionDartType type,
       {ignoreTypeVariables: false}) {
-    return reifyTypeForOutputUnit(
-        type, _compiler.deferredLoadTask.mainOutputUnit,
+    return reifyTypeForOutputUnit(type, _deferredLoadTask.mainOutputUnit,
         ignoreTypeVariables: ignoreTypeVariables);
   }
 
   jsAst.Expression reifyTypeForOutputUnit(
       ResolutionDartType type, OutputUnit outputUnit,
       {ignoreTypeVariables: false}) {
     return addTypeInOutputUnit(type, outputUnit,
         ignoreTypeVariables: ignoreTypeVariables);
   }
 
   jsAst.Expression reifyName(String name) {
     return _addGlobalMetadata(js.string(name));
   }
 
   jsAst.Expression reifyExpression(jsAst.Expression expression) {
     return _addGlobalMetadata(expression);
   }
 
   Placeholder getMetadataPlaceholder([debug]) {
     return new _ForwardingMetadataEntry(debug);
   }
 
   _MetadataEntry _addGlobalMetadata(jsAst.Node node) {
     String nameToKey(jsAst.Name name) => "${name.key}";
     String printed =
-        jsAst.prettyPrint(node, _compiler, renamerForNames: nameToKey);
+        jsAst.prettyPrint(node, _options, renamerForNames: nameToKey);
     return _globalMetadataMap.putIfAbsent(printed, () {
       return new _BoundMetadataEntry(node);
     });
   }
 
   jsAst.Expression _computeTypeRepresentation(ResolutionDartType type,
       {ignoreTypeVariables: false}) {
     jsAst.Expression representation =
-        _backend.rtiEncoder.getTypeRepresentation(type, (variable) {
+        _rtiEncoder.getTypeRepresentation(_emitter, type, (variable) {
       if (ignoreTypeVariables) return new jsAst.LiteralNull();
       return _typeVariableCodegenAnalysis.reifyTypeVariable(variable.element);
     }, (ResolutionTypedefType typedef) {
-      return _backend.mirrorsData
-          .isTypedefAccessibleByReflection(typedef.element);
+      return _mirrorsData.isTypedefAccessibleByReflection(typedef.element);
     });
 
     if (representation is jsAst.LiteralString) {
       // We don't want the representation to be a string, since we use
       // strings as indicator for non-initialized types in the lazy emitter.
       reporter.internalError(
           NO_LOCATION_SPANNABLE, 'reified types should not be strings.');
     }
 
     return representation;
@@ skipping 89 matching lines @@
     if (token is _ForwardingMetadataEntry && !token.isBound) {
       _foundUnboundToken = true;
     }
   }
 
   bool findUnboundPlaceholders(jsAst.Node node) {
     node.accept(this);
     return _foundUnboundToken;
   }
 }