dart2js: add parent references to some info objects

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 11 matching lines @@
 
   /// An id to uniquely identify this info among infos of the same [kind].
   int get id;
 
   /// A globally unique id combining [kind] and [id] together.
   String get serializedId;
 
   /// Bytes used in the generated code for the corresponding element.
   int size;
 
+  /// Info of the enclosing element.
+  Info parent;
+
   /// Serializes the information into a JSON format.
   // TODO(sigmund): refactor and put toJson outside the class, so we can have 2
   // different serializer/deserializers at once.
   Map toJson();
 
   void accept(InfoVisitor visitor);
 }
 
 /// Common information used for most kind of elements.
 // TODO(sigmund): add more:
 //  - inputSize: bytes used in the Dart source program
 abstract class BasicInfo implements Info {
   final InfoKind kind;
   final int id;
   int size;
+  Info parent;
 
   String get serializedId => '${_kindToString(kind)}/$id';
 
   String name;
 
   /// If using deferred libraries, where the element associated with this info
   /// is generated.
   OutputUnitInfo outputUnit;
 
   BasicInfo(this.kind, this.id, this.name, this.outputUnit, this.size);
 
   BasicInfo._fromId(String serializedId)
      : kind = _kindFromSerializedId(serializedId),
        id = _idFromSerializedId(serializedId);
 
   Map toJson() {
     var res = {
       'id': serializedId,
       'kind': _kindToString(kind),
       'name': name,
       'size': size,
     };
     // TODO(sigmund): omit this also when outputUnit.id == 0
     // (most code is by default in the main output unit)
     if (outputUnit != null) res['outputUnit'] = outputUnit.serializedId;
+    if (parent != null) res['parent'] = parent.serializedId;
     return res;
   }
 
   String toString() => '$serializedId $name [$size]';
 }
 
 /// Info associated with elements containing executable code (like fields and
 /// methods)
 abstract class CodeInfo implements Info {
   /// How does this function or field depend on others.
@@ skipping 35 matching lines @@
   /// 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 = 3;
+  final int minorVersion = 4;
 
   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();
     }
@@ skipping 119 matching lines @@
         assert(child is TypedefInfo);
         result.typedefs.add(child);
       }
     }
     return result;
   }
 
   ClassInfo parseClass(Map json) {
     ClassInfo result = parseId(json['id']);
     result..name = json['name']
+        ..parent = parseId(json['parent'])
         ..outputUnit = parseId(json['outputUnit'])
         ..size = json['size']
         ..isAbstract = json['modifiers']['abstract'] == true;
     assert(result is ClassInfo);
     for (var child in json['children'].map(parseId)) {
       if (child is FunctionInfo) {
         result.functions.add(child);
       } else {
         assert(child is FieldInfo);
         result.fields.add(child);
       }
     }
     return result;
   }
 
   FieldInfo parseField(Map json) {
     FieldInfo result = parseId(json['id']);
     return result..name = json['name']
+      ..parent = parseId(json['parent'])
       ..outputUnit = parseId(json['outputUnit'])
       ..size = json['size']
       ..type = json['type']
       ..inferredType = json['inferredType']
       ..code = json['code']
       ..closures = json['children'].map(parseId).toList();
   }
 
   TypedefInfo parseTypedef(Map json) {
     TypedefInfo result = parseId(json['id']);
     return result..name = json['name']
+      ..parent = parseId(json['parent'])
       ..type = json['type']
       ..size = 0;
   }
 
   ProgramInfo parseProgram(Map json) =>
       new ProgramInfo()..size = json['size'];
 
   FunctionInfo parseFunction(Map json) {
     FunctionInfo result = parseId(json['id']);
     return result..name = json['name']
+      ..parent = parseId(json['parent'])
       ..outputUnit = parseId(json['outputUnit'])
       ..size = json['size']
       ..type = json['type']
       ..returnType = json['returnType']
       ..inferredReturnType = json['inferredReturnType']
       ..parameters = json['parameters'].map(parseParameter).toList()
       ..code = json['code']
       ..sideEffects = json['sideEffects']
       ..modifiers = parseModifiers(json['modifiers'])
       ..closures = json['children'].map(parseId).toList();
@@ skipping 380 matching lines @@
   }
 
   visitField(FieldInfo info) {
     info.closures.forEach(visitFunction);
   }
 
   visitFunction(FunctionInfo info) {
     info.closures.forEach(visitFunction);
   }
 }