dart2js: dump info about dependencies added by the enqueuer

pkg/compiler/lib/src/info/info.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.
 
 /// Data collected by the dump-info task.
 library compiler.src.lib.info;
 
 // Note: this file intentionally doesn't import anything from the compiler. That
 // should make it easier for tools to depend on this library. The idea is that
 // by using this library, tools can consume the information in the same way it
@@ skipping 101 matching lines @@
   /// Information about output units (should be just one entry if not using
   /// deferred loading).
   List<OutputUnitInfo> outputUnits = <OutputUnitInfo>[];
 
   /// Details about all deferred imports and what files would be loaded when the
   /// import is resolved.
   // TODO(sigmund): use a different format for dump-info. This currently emits
   // the same map that is created for the `--deferred-map` flag.
   Map<String, Map<String, dynamic>> deferredFiles;
 
+  /// A new representation of dependencies form one info to another. An entry in
+  /// this map indicates that an Info depends on another (e.g. a function
+  /// invokes another). Please note that the data in this field might not be
+  /// accurate yet (this is work in progress).
+  Map<Info, List<Info>> dependencies = {};
+
   /// Major version indicating breaking changes in the format. A new version
   /// means that an old deserialization algorithm will not work with the new
   /// format.
   final int version = 3;
 
   /// Minor version indicating non-breaking changes in the format. A change in
   /// this version number means that the json parsing in this library from a
   /// previous will continue to work after the change. This is typically
   /// increased when adding new entries to the file format.
   // Note: the dump-info.viewer app was written using a json parser version 3.2.
-  final int minorVersion = 4;
+  final int minorVersion = 5;
 
   AllInfo();
 
   static AllInfo parseFromJson(Map map) => new _ParseHelper().parseAll(map);
 
   Map _listAsJsonMap(List<Info> list) {
     var map = <String, Map>{};
     for (var info in list) {
       map['${info.id}'] = info.toJson();
     }
     return map;
   }
 
   Map _extractHoldingInfo() {
     var map = <String, List>{};
     void helper(CodeInfo info) {
       if (info.uses.isEmpty) return;
       map[info.serializedId] = info.uses.map((u) => u.toJson()).toList();
     }
     functions.forEach(helper);
     fields.forEach(helper);
     return map;
   }
 
+  Map _extractDependencies() {
+    var map = <String, List>{};
+    dependencies.forEach((k, v) {
+      map[k.serializedId] = v.map((i) => i.serializedId).toList();
+    });
+    return map;
+  }
+
   Map toJson() => {
         'elements': {
           'library': _listAsJsonMap(libraries),
           'class': _listAsJsonMap(classes),
           'function': _listAsJsonMap(functions),
           'typedef': _listAsJsonMap(typedefs),
           'field': _listAsJsonMap(fields),
         },
         'holding': _extractHoldingInfo(),
+        'dependencies': _extractDependencies(),
         'outputUnits': outputUnits.map((u) => u.toJson()).toList(),
         'dump_version': version,
         'deferredFiles': deferredFiles,
         'dump_minor_version': '$minorVersion',
         // TODO(sigmund): change viewer to accept an int?
         'program': program.toJson(),
       };
 
   void accept(InfoVisitor visitor) => visitor.visitAll(this);
 }
@@ skipping 57 matching lines @@
     json['holding'].forEach((k, deps) {
       var src = idMap[k];
       assert (src != null);
       for (var dep in deps) {
         var target = idMap[dep['id']];
         assert (target != null);
         src.uses.add(new DependencyInfo(target, dep['mask']));
       }
     });
 
+    json['dependencies']?.forEach((k, deps) {
+      result.deps[idMap[k]] = deps.map((d) => idMap[d]).toList();
+    });
+
     result.program = parseProgram(json['program']);
     // todo: version, etc
     return result;
   }
 
   LibraryInfo parseLibrary(Map json) {
     LibraryInfo result = parseId(json['id']);
     result..name = json['name']
         ..uri = Uri.parse(json['canonicalUri'])
         ..outputUnit = parseId(json['outputUnit'])
@@ skipping 452 matching lines @@
   }
 
   visitField(FieldInfo info) {
     info.closures.forEach(visitFunction);
   }
 
   visitFunction(FunctionInfo info) {
     info.closures.forEach(visitFunction);
   }
 }