dart2js: emit metadata in new emitter.

pkg/compiler/lib/src/js_emitter/model.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.new_js_emitter.model;
 
 import '../js/js.dart' as js show Expression;
 import '../constants/values.dart' show ConstantValue;
 
 import '../deferred_load.dart' show OutputUnit;
 
+import 'js_emitter.dart' show MetadataCollector;
+
 import '../common.dart';
 
 class Program {
   final List<Fragment> fragments;
   final bool outputContainsConstantList;
   final bool outputContainsNativeClasses;
   /// A map from load id to the list of fragments that need to be loaded.
   final Map<String, List<Fragment>> loadMap;
 
   // If this field is not `null` then its value must be emitted in the embedded
   // global `TYPE_TO_INTERCEPTOR_MAP`. The map references constants and classes.
   final js.Expression typeToInterceptorMap;
 
+  // TODO(floitsch): we should store the metadata directly instead of storing
+  // the collector. However, the old emitter still updates the data.
+  final MetadataCollector _metadataCollector;
+
   Program(this.fragments,
           this.loadMap,
           this.typeToInterceptorMap,
+          this._metadataCollector,
           {this.outputContainsNativeClasses,
            this.outputContainsConstantList}) {
     assert(outputContainsNativeClasses != null);
     assert(outputContainsConstantList != null);
   }
 
+  /// A list of pretty-printed JavaScript expressions.
+  ///
+  /// This list must be emitted in the `METADATA` embedded global.
+  /// References to classes or constants are wrapped into functions (that are

[floitsch, 2015/01/29 17:06:31]

I'm not yet 100% sure of these claims. If necessary I will update the comment
once I run into data that behaves differently.

[floitsch, 2015/01/29 17:12:18]

Already updated...

+  /// only executed at runtime). It is safe to emit the data before classes
+  /// and constants are completely set up. In fact, the data must be emitted
+  /// before any class (including constant) is constructed.
+  ///
+  /// Note: the metadata is derived from the task's `metadataCollector`. The
+  /// list must not be emitted before all operations on it are done. For
+  /// example, the old emitter generates metadata when emitting reflection
+  /// data.
+  List<String> get metadata => _metadataCollector.globalMetadata;
+
   bool get isSplit => fragments.length > 1;
   Iterable<Fragment> get deferredFragments => fragments.skip(1);
 }
 
 /**
  * This class represents a JavaScript object that contains static state, like
  * classes or functions.
  */
 class Holder {
   final String name;
@@ skipping 334 matching lines @@
               canBeApplied : canBeApplied,
               canBeReflected : canBeReflected,
               needsStubs : needsStubs);
 }
 
 class StaticStubMethod extends StubMethod {
   Holder holder;
   StaticStubMethod(String name, this.holder, js.Expression code)
       : super(name, code);
 }