dart2js: Move metadata from old_emitter to shared directory.

pkg/compiler/lib/src/js_emitter/old_emitter/emitter.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.
 
 part of dart2js.js_emitter;
 
 
 class OldEmitter implements Emitter {
   final Compiler compiler;
   final CodeEmitterTask task;
 
   final ContainerBuilder containerBuilder = new ContainerBuilder();
   final ClassEmitter classEmitter = new ClassEmitter();
   final NsmEmitter nsmEmitter = new NsmEmitter();
   final InterceptorEmitter interceptorEmitter = new InterceptorEmitter();
-  final MetadataEmitter metadataEmitter = new MetadataEmitter();
 
   // TODO(johnniwinther): Wrap these fields in a caching strategy.
   final Set<ConstantValue> cachedEmittedConstants;
   final CodeBuffer cachedEmittedConstantsBuffer = new CodeBuffer();
   final Map<Element, ClassBuilder> cachedClassBuilders;
   final Set<Element> cachedElements;
 
   bool needsClassSupport = false;
   bool needsMixinSupport = false;
   bool needsLazyInitializer = false;
@@ skipping 68 matching lines @@
         this.namer = namer,
         cachedEmittedConstants = compiler.cacheStrategy.newSet(),
         cachedClassBuilders = compiler.cacheStrategy.newMap(),
         cachedElements = compiler.cacheStrategy.newSet() {
     constantEmitter =
         new ConstantEmitter(compiler, namer, makeConstantListTemplate);
     containerBuilder.emitter = this;
     classEmitter.emitter = this;
     nsmEmitter.emitter = this;
     interceptorEmitter.emitter = this;
-    metadataEmitter.emitter = this;
   }
 
   List<jsAst.Node> cspPrecompiledFunctionFor(OutputUnit outputUnit) {
     return _cspPrecompiledFunctions.putIfAbsent(
         outputUnit,
         () => new List<jsAst.Node>());
   }
 
   List<jsAst.Expression> cspPrecompiledConstructorNamesFor(
       OutputUnit outputUnit) {
@@ skipping 673 matching lines @@
     // closure that constructs the initial value.
     return js('#(#,#,#,#,#)',
         [js(lazyInitializerName),
             js(isolateProperties),
             js.string(element.name),
             js.string(namer.getNameX(element)),
             js.string(namer.getLazyInitializerName(element)),
             code]);
   }
 
+  void emitMetadata(List<String> globalMetadata, CodeOutput output) {
+    String metadataAccess =
+        generateEmbeddedGlobalAccessString(embeddedNames.METADATA);
+    output.add('$metadataAccess$_=$_[');
+    for (String metadata in globalMetadata) {
+      if (metadata is String) {
+        if (metadata != 'null') {
+          output.add(metadata);
+        }
+      } else {
+        throw 'Unexpected value in metadata: ${Error.safeToString(metadata)}';
+      }
+      output.add(',$n');
+    }
+    output.add('];$n');
+  }
+
   bool isConstantInlinedOrAlreadyEmitted(ConstantValue constant) {
     if (constant.isFunction) return true;    // Already emitted.
     if (constant.isPrimitive) return true;   // Inlined.
     if (constant.isDummy) return true;       // Inlined.
     // The name is null when the constant is already a JS constant.
     // TODO(floitsch): every constant should be registered, so that we can
     // share the ones that take up too much space (like some strings).
     if (namer.constantName(constant) == null) return true;
     return false;
   }
@@ skipping 353 matching lines @@
       // with language/prefix6_negative_test.dart where we have an instance
       // method without its corresponding class.
       return;
     }
 
     String libraryName =
         (!compiler.enableMinification || backend.mustRetainLibraryNames) ?
         library.getLibraryName() :
         "";
 
-    jsAst.Fun metadata = metadataEmitter.buildMetadataFunction(library);
+    jsAst.Fun metadata = task.metadataEmitter.buildMetadataFunction(library);
 
     jsAst.ObjectInitializer initializers = descriptor.toObjectInitializer();
 
     compiler.dumpInfoTask.registerElementAst(library, metadata);
     compiler.dumpInfoTask.registerElementAst(library, initializers);
     output
         ..add('["$libraryName",$_')
         ..add('"${uri}",$_');
     if (metadata != null) {
       output.addBuffer(jsAst.prettyPrint(metadata,
@@ skipping 48 matching lines @@
   void emitTypedefs() {
     OutputUnit mainOutputUnit = compiler.deferredLoadTask.mainOutputUnit;
 
     // Emit all required typedef declarations into the main output unit.
     // TODO(karlklose): unify required classes and typedefs to declarations
     // and have builders for each kind.
     for (TypedefElement typedef in typedefsNeededForReflection) {
       LibraryElement library = typedef.library;
       // TODO(karlklose): add a TypedefBuilder and move this code there.
       DartType type = typedef.alias;
-      int typeIndex = metadataEmitter.reifyType(type);
+      int typeIndex = task.metadataEmitter.reifyType(type);
       ClassBuilder builder = new ClassBuilder(typedef, namer);
       builder.addProperty(embeddedNames.TYPEDEF_TYPE_PROPERTY_NAME,
                           js.number(typeIndex));
       builder.addProperty(embeddedNames.TYPEDEF_PREDICATE_PROPERTY_NAME,
                           js.boolean(true));
 
       // We can be pretty sure that the objectClass is initialized, since
       // typedefs are only emitted with reflection, which requires lots of
       // classes.
       assert(compiler.objectClass != null);
@@ skipping 240 matching lines @@
     }
 
     // Static field initializations require the classes and compile-time
     // constants to be set up.
     emitStaticNonFinalFieldInitializations(mainOutput, mainOutputUnit);
     interceptorEmitter.emitTypeToInterceptorMap(program, mainOutput);
     emitLazilyInitializedStaticFields(mainOutput);
 
     mainOutput.add('\n');
 
-    metadataEmitter.emitMetadata(mainOutput);
+    emitMetadata(task.metadataEmitter.globalMetadata, mainOutput);
 
     isolateProperties = isolatePropertiesName;
     // The following code should not use the short-hand for the
     // initialStatics.
     mainOutput.add('${namer.currentIsolate}$_=${_}null$N');
 
     emitFinishIsolateConstructorInvocation(mainOutput);
     mainOutput.add(
         '${namer.currentIsolate}$_=${_}new ${namer.isolateName}()$N');
 
@@ skipping 525 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }