enable --dump-info with the --fast-startup emitter

pkg/compiler/lib/src/js_emitter/startup_emitter/fragment_emitter.dart

 // Copyright (c) 2015, 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.startup_emitter.model_emitter;
 
 /// The name of the property that stores the tear-off getter on a static
 /// function.
 ///
 /// This property is only used when isolates are used.
@@ skipping 153 matching lines @@
   // hidden class. The actual values of the fields don't matter, since we
   // only check if they exist.
   list.immutable\$list = Array;
   list.fixed\$length = Array;
   return list;
 }
 
 function convertToFastObject(properties) {
   // Create an instance that uses 'properties' as prototype. This should
   // make 'properties' a fast object.
-  function t() {};
+  function t() {}
   t.prototype = properties;
   new t();
   return properties;
 }
 
 // This variable is used by the tearOffCode to guarantee unique functions per
 // tear-offs.
 var functionCounter = 0;
 #tearOffCode;
 
@@ skipping 371 matching lines @@
     Map<Holder, Map<js.Name, js.Expression>> holderCode =
         <Holder, Map<js.Name, js.Expression>>{};
 
     for (Holder holder in holders) {
       holderCode[holder] = <js.Name, js.Expression>{};
     }
 
     for (Library library in fragment.libraries) {
       for (StaticMethod method in library.statics) {
         assert(!method.holder.isStaticStateHolder);
-        holderCode[method.holder].addAll(emitStaticMethod(method));
+        var staticMethod = emitStaticMethod(method);
+        if (compiler.options.dumpInfo) {
+          for (var code in staticMethod.values) {
+            compiler.dumpInfoTask.registerElementAst(method.element, code);
+            compiler.dumpInfoTask.registerElementAst(library.element, code);
+          }
+        }
+        holderCode[method.holder].addAll(staticMethod);
       }
       for (Class cls in library.classes) {
         assert(!cls.holder.isStaticStateHolder);
-        holderCode[cls.holder][cls.name] = emitConstructor(cls);
+        var constructor = emitConstructor(cls);
+        compiler.dumpInfoTask.registerElementAst(cls.element, constructor);
+        compiler.dumpInfoTask.registerElementAst(library.element, constructor);
+        holderCode[cls.holder][cls.name] = constructor;
       }
     }
 
     js.VariableInitialization emitHolderInitialization(Holder holder) {
       List<js.Property> properties = <js.Property>[];
       holderCode[holder].forEach((js.Name key, js.Expression value) {
         properties.add(new js.Property(js.quoteName(key), value));
       });
 
       return new js.VariableInitialization(
@@ skipping 80 matching lines @@
     return js.js('function #(#) { # }', [name, fieldNames, assignments]);
   }
 
   /// Emits the prototype-section of the fragment.
   ///
   /// This section updates the prototype-property of all constructors in the
   /// global holders.
   js.Statement emitPrototypes(Fragment fragment) {
     List<js.Statement> assignments = fragment.libraries
         .expand((Library library) => library.classes)
-        .map((Class cls) => js.js.statement(
-            '#.prototype = #;', [classReference(cls), emitPrototype(cls)]))
-        .toList(growable: false);
+        .map((Class cls) {
+      var proto = js.js.statement(
+          '#.prototype = #;', [classReference(cls), emitPrototype(cls)]);
+      compiler.dumpInfoTask.registerElementAst(cls.element, proto);
+      compiler.dumpInfoTask.registerElementAst(cls.element.library, proto);
+      return proto;
+    }).toList(growable: false);
 
     return new js.Block(assignments);
   }
 
   /// Emits the prototype of the given class [cls].
   ///
   /// The prototype is generated as object literal. Inheritance is ignored.
   ///
   /// The prototype also includes the `is-property` that every class must have.
   // TODO(floitsch): we could avoid that property if we knew that it wasn't
@@ skipping 21 matching lines @@
     if (cls.superclass == null) {
       properties
           .add(new js.Property(js.string("constructor"), classReference(cls)));
       properties
           .add(new js.Property(namer.operatorIs(cls.element), js.number(1)));
     }
 
     allMethods.forEach((Method method) {
       emitInstanceMethod(method)
           .forEach((js.Expression name, js.Expression code) {
-        properties.add(new js.Property(name, code));
+        var prop = new js.Property(name, code);
+        compiler.dumpInfoTask.registerElementAst(method.element, prop);
+        properties.add(prop);
       });
     });
 
     return new js.ObjectInitializer(properties);
   }
 
   /// Generates a getter for the given [field].
   Method generateGetter(Field field) {
     assert(field.needsGetter);
 
@@ skipping 278 matching lines @@
   }
 
   /// Emits the constants section.
   js.Statement emitConstants(Fragment fragment) {
     List<js.Statement> assignments = <js.Statement>[];
     for (Constant constant in fragment.constants) {
       // TODO(floitsch): instead of just updating the constant holder, we should
       // find the constants that don't have any dependency on other constants
       // and create an object-literal with them (and assign it to the
       // constant-holder variable).
-      assignments.add(js.js.statement('#.# = #', [
+      var assignment = js.js.statement('#.# = #', [
         constant.holder.name,
         constant.name,
         constantEmitter.generate(constant.value)
-      ]));
+      ]);
+      compiler.dumpInfoTask.registerConstantAst(constant.value, assignment);
+      assignments.add(assignment);
     }
     return new js.Block(assignments);
   }
 
   /// Emits the static non-final fields section.
   ///
   /// This section initializes all static non-final fields that don't require
   /// an initializer.
   js.Block emitStaticNonFinalFields(Fragment fragment) {
     List<StaticField> fields = fragment.staticNonFinalFields;
@@ skipping 336 matching lines @@
     }
     statements.add(js.js.statement("setOrUpdateInterceptorsByTag(#);",
         js.objectLiteral(interceptorsByTag)));
     statements.add(
         js.js.statement("setOrUpdateLeafTags(#);", js.objectLiteral(leafTags)));
     statements.addAll(subclassAssignments);
 
     return new js.Block(statements);
   }
 }