dart2js: Rename metadataEmitter to metadataCollector and make it independent of old emitter.

pkg/compiler/lib/src/js_emitter/metadata_emitter.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.
 
 part of dart2js.js_emitter;
 
-class MetadataEmitter extends CodeEmitterHelper {
+class MetadataCollector {
+  final Compiler _compiler;
+  final Emitter _emitter;
+
   /// A list of JS expressions that represent metadata, parameter names and
   /// type, and return types.
   final List<String> globalMetadata = [];
 
   /// A map used to canonicalize the entries of globalMetadata.
-  final Map<String, int> globalMetadataMap = <String, int>{};
+  final Map<String, int> _globalMetadataMap = <String, int>{};
 
-  bool mustEmitMetadataFor(Element element) {
-    return backend.mustRetainMetadata &&
-        backend.referencedFromMirrorSystem(element);
+  MetadataCollector(this._compiler, this._emitter);
+
+  JavaScriptBackend get _backend => _compiler.backend;
+  TypeVariableHandler get _typeVariableHandler => _backend.typeVariableHandler;
+
+  bool _mustEmitMetadataFor(Element element) {
+    return _backend.mustRetainMetadata &&
+        _backend.referencedFromMirrorSystem(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) {
-    if (!mustEmitMetadataFor(element)) return null;
-    return compiler.withCurrentElement(element, () {
+    if (!_mustEmitMetadataFor(element)) return null;
+    return _compiler.withCurrentElement(element, () {
       List<jsAst.Expression> metadata = <jsAst.Expression>[];
       Link link = element.metadata;
       // TODO(ahe): Why is metadata sometimes null?
       if (link != null) {
         for (; !link.isEmpty; link = link.tail) {
           MetadataAnnotation annotation = link.head;
           ConstantExpression constant =
-              backend.constants.getConstantForMetadata(annotation);
+              _backend.constants.getConstantForMetadata(annotation);
           if (constant == null) {
-            compiler.internalError(annotation, 'Annotation value is null.');
+            _compiler.internalError(annotation, 'Annotation value is null.');
           } else {
-            metadata.add(emitter.constantReference(constant.value));
+            metadata.add(_emitter.constantReference(constant.value));
           }
         }
       }
       if (metadata.isEmpty) return null;
       return js('function() { return # }',
           new jsAst.ArrayInitializer(metadata));
     });
   }
 
   List<int> reifyDefaultArguments(FunctionElement function) {
     FunctionSignature signature = function.functionSignature;
     if (signature.optionalParameterCount == 0) return const [];
     List<int> defaultValues = <int>[];
     for (ParameterElement element in signature.optionalParameters) {
       ConstantExpression constant =
-          backend.constants.getConstantForVariable(element);
+          _backend.constants.getConstantForVariable(element);
       String stringRepresentation = (constant == null)
           ? "null"
           : jsAst.prettyPrint(
-              emitter.constantReference(constant.value), compiler).getText();
+              _emitter.constantReference(constant.value), _compiler).getText();
       defaultValues.add(addGlobalMetadata(stringRepresentation));
     }
     return defaultValues;
   }
 
   int reifyMetadata(MetadataAnnotation annotation) {
     ConstantExpression constant =
-        backend.constants.getConstantForMetadata(annotation);
+        _backend.constants.getConstantForMetadata(annotation);
     if (constant == null) {
-      compiler.internalError(annotation, 'Annotation value is null.');
+      _compiler.internalError(annotation, 'Annotation value is null.');
       return -1;
     }
     return addGlobalMetadata(
         jsAst.prettyPrint(
-            emitter.constantReference(constant.value), compiler).getText());
+            _emitter.constantReference(constant.value), _compiler).getText());
   }
 
   int reifyType(DartType type) {
     jsAst.Expression representation =
-        backend.rti.getTypeRepresentation(
+        _backend.rti.getTypeRepresentation(
             type,
             (variable) {
               return js.number(
-                  emitter.typeVariableHandler.reifyTypeVariable(
+                  _typeVariableHandler.reifyTypeVariable(
                       variable.element));
             },
             (TypedefType typedef) {
-              return backend.isAccessibleByReflection(typedef.element);
+              return _backend.isAccessibleByReflection(typedef.element);
             });
 
     return addGlobalMetadata(
-        jsAst.prettyPrint(representation, compiler).getText());
+        jsAst.prettyPrint(representation, _compiler).getText());
   }
 
   int reifyName(String name) {
     return addGlobalMetadata('"$name"');
   }
 
   int addGlobalMetadata(String string) {
-    return globalMetadataMap.putIfAbsent(string, () {
+    return _globalMetadataMap.putIfAbsent(string, () {
       globalMetadata.add(string);
       return globalMetadata.length - 1;
     });
   }
 
   List<int> computeMetadata(FunctionElement element) {
-    return compiler.withCurrentElement(element, () {
-      if (!mustEmitMetadataFor(element)) return const <int>[];
+    return _compiler.withCurrentElement(element, () {
+      if (!_mustEmitMetadataFor(element)) return const <int>[];
       List<int> metadata = <int>[];
       Link link = element.metadata;
       // TODO(ahe): Why is metadata sometimes null?
       if (link != null) {
         for (; !link.isEmpty; link = link.tail) {
           metadata.add(reifyMetadata(link.head));
         }
       }
       return metadata;
     });
   }
 }