dart2js: add visitors and parsing support to infos

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 15 matching lines @@
   /// A globally unique id combining [kind] and [id] together.
   String get serializedId;
 
   /// Bytes used in the generated code for the corresponding element.
   int size;
 
   /// 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 String kind;

[Harry Terkelsen, 2015/08/11 01:15:18]

consider making kind an enum?

[Siggi Cherem (dart-lang), 2015/08/11 16:09:27]

It's interesting because I only had in mind to use kind for serialization. I
didn't initially intend for the kind to be used to compare for the kind of info,
but now that you mention this, I can see how that's a natural thing to do (end
even I used it in dump_info.dart!).

I think we should use the type itself for that purpose (`e is ClassInfo` instead
of `e.kind == InfoKinds.classInfo`). I',m wondering whether we should make this
field private as well?

I added the enum here for now, but enums are so restricted in Dart, that the
code is more complex as a result. I'm not sure if it's worth it. WDYT?

[Harry Terkelsen, 2015/08/11 20:11:55]

I've run into the same problem when trying to enum-ify Dart code. If it makes
things more complex then I think it's better to just leave it.

   final int id;
+
+  /// Bytes used in the generated code for the corresponding element.
   int size;
 
   String get serializedId => '$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 = serializedId.substring(0, serializedId.indexOf('/')),
+       id = int.parse(serializedId.substring(serializedId.indexOf('/') + 1));
+
   Map toJson() {
     var res = {'id': serializedId, 'kind': 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;
     return res;
   }
 
   String toString() => '$serializedId $name [$size]';
 }
@@ skipping 44 matching lines @@
 
   /// 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;
 
   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;
   }
 
-  // TODO(sigmund): implement fromJson
   Map toJson() => {
         'elements': {
           'library': _listAsJsonMap(libraries),
           'class': _listAsJsonMap(classes),
           'function': _listAsJsonMap(functions),
           'typedef': _listAsJsonMap(typedefs),
           'field': _listAsJsonMap(fields),
         },
         'holding': _extractHoldingInfo(),
         '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);
 }
 
 class ProgramInfo {
   int size;
   String dart2jsVersion;
   DateTime compilationMoment;
   Duration compilationDuration;
   // TODO(sigmund): use Duration.
   int toJsonDuration;
   int dumpInfoDuration;
@@ skipping 13 matching lines @@
   Map toJson() => {
         'size': size,
         'dart2jsVersion': dart2jsVersion,
         'compilationMoment': '$compilationMoment',
         'compilationDuration': '${compilationDuration}',
         'toJsonDuration': toJsonDuration,
         'dumpInfoDuration': '$dumpInfoDuration',
         'noSuchMethodEnabled': noSuchMethodEnabled,
         'minified': minified,
       };
+
+  void accept(InfoVisitor visitor) => visitor.visitProgram(this);
+}
+
+class _ParseHelper {

[Johnni Winther, 2015/08/11 08:45:37]

Do we have a test of the serialization/deserialization so we don't unintendedly
miss fields?

[Siggi Cherem (dart-lang), 2015/08/11 16:09:27]

Not yet, but we will. Added a TODO

+  Map<String, Info> registry = {};
+
+  AllInfo parseAll(Map json) {
+    var result = new AllInfo();
+    var elements = json['elements'];
+    result.libraries.addAll(elements['library'].values.map(parseLibrary));
+    result.classes.addAll(elements['class'].values.map(parseClass));
+    result.functions.addAll(elements['function'].values.map(parseFunction));
+    result.fields.addAll(elements['field'].values.map(parseField));
+    result.typedefs.addAll(elements['typedef'].values.map(parseTypedef));
+
+    var idMap = {};
+    for (var f in result.functions) {
+      idMap[f.serializedId] = f;
+    }
+    for (var f in result.fields) {
+      idMap[f.serializedId] = f;
+    }
+
+    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']));
+      }
+    });
+
+    result.program = parseProgram(json['program']);
+    // todo: version, etc
+    return result;
+  }
+
+  LibraryInfo parseLibrary(Map json) {
+    var result = parseId(json['id'])
+        ..name = json['name']
+        ..uri = Uri.parse(json['canonicalUri'])
+        ..outputUnit = parseId(json['outputUnit'])
+        ..size = json['size'];
+    assert(result.kind == 'library');
+    for (var child in json['children'].map(parseId)) {
+      if (child is FunctionInfo) {
+        result.topLevelFunctions.add(child);
+      } else if (child is FieldInfo) {
+        result.topLevelVariables.add(child);
+      } else if (child is ClassInfo) {
+        result.classes.add(child);
+      } else {
+        assert(child is TypedefInfo);
+        result.typedefs.add(child);
+      }
+    }
+    return result;
+  }
+
+  ClassInfo parseClass(Map json) {
+    var result = parseId(json['id'])
+        ..name = json['name']
+        ..outputUnit = parseId(json['outputUnit'])
+        ..size = json['size']
+        ..isAbstract = json['modifiers']['abstract'] == true;
+    assert(result.kind == 'class');
+    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) {
+    return parseId(json['id'])
+      ..name = json['name']
+      ..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) => parseId(json['id'])
+      ..name = json['name']
+      ..type = json['type']
+      ..size = 0;
+
+  ProgramInfo parseProgram(Map json) =>
+      new ProgramInfo()..size = json['size'];
+
+  FunctionInfo parseFunction(Map json) {
+    return parseId(json['id'])
+      ..name = json['name']
+      ..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();
+  }
+
+  ParameterInfo parseParameter(Map json) =>
+      new ParameterInfo(json['name'], json['type'], json['declaredType']);
+
+  FunctionModifiers parseModifiers(Map<String, bool> json) {
+    return new FunctionModifiers(
+        isStatic: json['static'] == true,
+        isConst: json['const'] == true,
+        isFactory: json['factory'] == true,
+        isExternal: json['external'] == true);
+  }
+
+  Info parseId(String serializedId) => registry.putIfAbsent(serializedId, () {
+    if (serializedId == null) {
+      return null;
+    } else if (serializedId.startsWith('function/')) {
+      return new FunctionInfo._(serializedId);
+    } else if (serializedId.startsWith('library/')) {
+      return new LibraryInfo._(serializedId);
+    } else if (serializedId.startsWith('class/')) {
+      return new ClassInfo._(serializedId);
+    } else if (serializedId.startsWith('field/')) {
+      return new FieldInfo._(serializedId);
+    } else if (serializedId.startsWith('typedef/')) {
+      return new TypedefInfo._(serializedId);
+    } else if (serializedId.startsWith('outputUnit/')) {
+      return new OutputUnitInfo._(serializedId);
+    }
+    assert(false);
+  });
 }
 
 class LibraryInfo extends BasicInfo {
   Uri uri;
   final List<FunctionInfo> topLevelFunctions = <FunctionInfo>[];

[Harry Terkelsen, 2015/08/11 01:15:18]

document all of the fields for the Info classes

[Siggi Cherem (dart-lang), 2015/08/11 16:09:27]

Done.

   final List<FieldInfo> topLevelVariables = <FieldInfo>[];
   final List<ClassInfo> classes = <ClassInfo>[];
   final List<TypedefInfo> typedefs = <TypedefInfo>[];
 
   static int _id = 0;
 
   bool get isEmpty =>
       topLevelFunctions.isEmpty && topLevelVariables.isEmpty && classes.isEmpty;
 
   LibraryInfo(String name, this.uri, OutputUnitInfo outputUnit, int size)
       : super('library', _id++, name, outputUnit, size);
 
+  LibraryInfo._(String serializedId) : super._fromId(serializedId);
+
   Map toJson() => super.toJson()
     ..addAll({
       'children': []
         ..addAll(topLevelFunctions.map((f) => f.serializedId))
         ..addAll(topLevelVariables.map((v) => v.serializedId))
         ..addAll(classes.map((c) => c.serializedId))
         ..addAll(typedefs.map((t) => t.serializedId)),
       'canonicalUri': '$uri',
     });
+
+  void accept(InfoVisitor visitor) => visitor.visitLibrary(this);
 }
 
 class OutputUnitInfo extends BasicInfo {
   static int _ids = 0;
   OutputUnitInfo(String name, int size)
       : super('outputUnit', _ids++, name, null, size);
+
+  OutputUnitInfo._(String serializedId) : super._fromId(serializedId);
+
+  void accept(InfoVisitor visitor) => visitor.visitOutput(this);
 }
 
 class ClassInfo extends BasicInfo {
   bool isAbstract;
 
   // TODO(sigmund): split static vs instance vs closures
   final List<FunctionInfo> functions = <FunctionInfo>[];
   final List<FieldInfo> fields = <FieldInfo>[];
   static int _ids = 0;
 
   ClassInfo(
       {String name, this.isAbstract, OutputUnitInfo outputUnit, int size: 0})
       : super('class', _ids++, name, outputUnit, size);
 
+  ClassInfo._(String serializedId) : super._fromId(serializedId);
+
   Map toJson() => super.toJson()
     ..addAll({
       // TODO(sigmund): change format, include only when abstract is true.
       'modifiers': {'abstract': isAbstract},
       'children': []
         ..addAll(fields.map((f) => f.serializedId))
         ..addAll(functions.map((m) => m.serializedId))
     });
+
+  void accept(InfoVisitor visitor) => visitor.visitClass(this);
 }
 
 class FieldInfo extends BasicInfo with CodeInfo {
   String type;
   String inferredType;
   List<FunctionInfo> closures;
   String code;
 
   static int _ids = 0;
   FieldInfo(
       {String name,
       int size: 0,
       this.type,
       this.inferredType,
       this.closures,
       this.code,
       OutputUnitInfo outputUnit})
       : super('field', _ids++, name, outputUnit, size);
 
+  FieldInfo._(String serializedId) : super._fromId(serializedId);
+
   Map toJson() => super.toJson()
     ..addAll({
       'children': closures.map((i) => i.serializedId).toList(),
       'inferredType': inferredType,
       'code': code,
       'type': type,
     });
+
+  void accept(InfoVisitor visitor) => visitor.visitField(this);
 }
 
 class TypedefInfo extends BasicInfo {
   String type;
 
   static int _ids = 0;
   TypedefInfo(String name, this.type, OutputUnitInfo outputUnit)
       : super('typedef', _ids++, name, outputUnit, 0);
 
+  TypedefInfo._(String serializedId) : super._fromId(serializedId);
+
   Map toJson() => super.toJson()..['type'] = '$type';
+
+  void accept(InfoVisitor visitor) => visitor.visitTypedef(this);
 }
 
 class FunctionInfo extends BasicInfo with CodeInfo {
   static const int TOP_LEVEL_FUNCTION_KIND = 0;
   static const int CLOSURE_FUNCTION_KIND = 1;
   static const int METHOD_FUNCTION_KIND = 2;
   static const int CONSTRUCTOR_FUNCTION_KIND = 3;
   static int _ids = 0;
 
   /// Kind of function (top-level function, closure, method, or constructor).
-  final int functionKind;
+  int functionKind;
 
   /// Modifiers applied to this function.
-  final FunctionModifiers modifiers;
+  FunctionModifiers modifiers;
 
   /// Nested closures that appear within the body of this function.
   List<FunctionInfo> closures;
 
   /// The type of this function.
   String type;
 
   /// The declared return type.
   String returnType;
 
@@ skipping 22 matching lines @@
       this.closures,
       this.type,
       this.returnType,
       this.inferredReturnType,
       this.parameters,
       this.sideEffects,
       this.inlinedCount,
       this.code})
       : super('function', _ids++, name, outputUnit, size);
 
+  FunctionInfo._(String serializedId) : super._fromId(serializedId);
+
   Map toJson() => super.toJson()
     ..addAll({
       'children': closures.map((i) => i.serializedId).toList(),
       'modifiers': modifiers.toJson(),
       'returnType': returnType,
       'inferredReturnType': inferredReturnType,
       'parameters': parameters.map((p) => p.toJson()).toList(),
       'sideEffects': sideEffects,
       'inlinedCount': inlinedCount,
       'code': code,
       'type': type,
       // Note: version 3.2 of dump-info serializes `uses` in a section called
       // `holding` at the top-level.
     });
+
+  void accept(InfoVisitor visitor) => visitor.visitFunction(this);
 }
 
 /// Information about how a dependency is used.
 class DependencyInfo {
   /// The dependency, either a FunctionInfo or FieldInfo.
   final Info target;
 
   /// Either a selector mask indicating how this is used, or 'inlined'.
   // TODO(sigmund): split mask into an enum or something more precise to really
   // describe the dependencies in detail.
@@ skipping 37 matching lines @@
   //     if (isExternal) res['external'] = true;
   //     return res;
   //   }
   Map toJson() => {
         'static': isStatic,
         'const': isConst,
         'factory': isFactory,
         'external': isExternal,
       };
 }
+
+/// A simple visitor for information produced by the dart2js compiler.
+class InfoVisitor {
+  visitAll(AllInfo info) {}
+  visitProgram(ProgramInfo info) {}
+  visitLibrary(LibraryInfo info) {}
+  visitClass(ClassInfo info) {}
+  visitField(FieldInfo info) {}
+  visitFunction(FunctionInfo info) {}
+  visitTypedef(TypedefInfo info) {}
+  visitOutput(OutputUnitInfo info) {}
+}
+
+/// A visitor that recursively walks each portion of the program. Because the
+/// info representation is redundant, this visitor only walks the structure of
+/// the program and skips some redundant links. For example, even though
+/// visitAll contains references to functions, this visitor only recurses to
+/// visit libraries, then from each library we visit functions and classes, and
+/// so on.
+class RecursiveInfoVisitor extends InfoVisitor {
+  visitAll(AllInfo info) {
+    // Note: we don't visit functions, fields, classes, and typedefs because
+    // they are reachable from the library info.
+    info.libraries.forEach(visitLibrary);
+  }
+
+  visitLibrary(LibraryInfo info) {
+    info.topLevelFunctions.forEach(visitFunction);
+    info.topLevelVariables.forEach(visitField);
+    info.classes.forEach(visitClass);
+    info.typedefs.forEach(visitTypedef);
+  }
+
+  visitClass(ClassInfo info) {
+    info.functions.forEach(visitFunction);
+    info.fields.forEach(visitField);
+  }
+
+  visitField(FieldInfo info) {
+    info.closures.forEach(visitFunction);
+  }
+
+  visitFunction(FunctionInfo info) {
+    info.closures.forEach(visitFunction);
+  }
+
+  visitTypedef(TypedefInfo info) {}

[Harry Terkelsen, 2015/08/11 01:15:18]

remove or make InfoVisitor abstract

[Siggi Cherem (dart-lang), 2015/08/11 16:09:27]

Done.

+  visitOutput(OutputUnitInfo info) {}

[Harry Terkelsen, 2015/08/11 01:15:18]

ditto

[Siggi Cherem (dart-lang), 2015/08/11 16:09:27]

Done.

+}