dump-info additionally dumps a json info file

sdk/lib/_internal/compiler/implementation/dump_info.dart

 // Copyright (c) 2013, 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 dump_info;
 
-import 'dart:convert' show HtmlEscape;
+import 'dart:convert' show
+    HtmlEscape,
+    JsonEncoder,
+    StringConversionSink,
+    ChunkedConversionSink;
 
 import 'elements/elements.dart';
 import 'elements/visitor.dart';
 import 'dart2jslib.dart' show
     Compiler,
     CompilerTask,
     CodeBuffer;
 import 'dart_types.dart' show DartType;
 import 'types/types.dart' show TypeMask;
 import 'util/util.dart' show modifiersToString;
@@ skipping 54 matching lines @@
 var esc = const HtmlEscape().convert;
 
 String sizeDescription(int size, ProgramInfo programInfo) {
   if (size == null) {
     return '';
   }
   return span(span(size.toString(), cls: 'value') +
       ' bytes (${size * 100 ~/ programInfo.size}%)', cls: 'size');
 }
 
+String sizePercent(int size, ProgramInfo programInfo) {
+  if (size == null) {
+    return "0.000%";
+  } else {
+    return (100 * size / programInfo.size).toStringAsFixed(3) + "%";
+  }
+}
+
 /// An [InfoNode] holds information about a part the program.
 abstract class InfoNode {
   String get name;
 
   int get size;
 
   void emitHtml(ProgramInfo programInfo, StringSink buffer,
       [String indentation = '']);
+
+  Map<String, dynamic> toJson(ProgramInfo programInfo);
 }
 
 /// An [ElementNode] holds information about an [Element]
 class ElementInfoNode implements InfoNode {
   /// The name of the represented [Element].
   final String name;
 
   /// The kind of the [Element] represented.  This is presented to the
   /// user, so it might be more specific than [element.kind].
   final String kind;
@@ skipping 23 matching lines @@
 
   ElementInfoNode({this.name: "",
       this.kind: "",
       this.type,
       this.modifiers: "",
       this.size,
       this.contents,
       this.extra: "",
       this.outputUnitId});
 
+  Map<String, dynamic> toJson(ProgramInfo programInfo) {
+    Map<String, dynamic> json = <String, dynamic>{
+      'kind': this.kind,
+      'modifiers': this.modifiers,
+      'name': this.name,
+      'type': this.type,
+      'size': this.size,
+      'sizePercent': sizePercent(this.size, programInfo),
+      'extra': this.extra
+    };
+
+    if (this.contents != null) {
+      json['children'] =
+        this.contents.map((c) => c.toJson(programInfo)).toList();
+    }
+
+    return json;
+  }
+
   void emitHtml(ProgramInfo programInfo, StringSink buffer,
       [String indentation = '']) {
     String kindString = span(esc(kind), cls: 'kind');
     String modifiersString = span(esc(modifiers), cls: "modifiers");
 
     String nameString = span(esc(name), cls: 'name');
     String typeString = type == null
         ? ''
         : span('/* ' + esc(type) + ' */', cls: 'type');
     String extraString = span(esc(extra), cls: 'type');
@@ skipping 47 matching lines @@
 
   void emitHtml(ProgramInfo programInfo, StringBuffer buffer,
       [String indentation = '']) {
     buffer.write(indentation);
     buffer.write(div(description + ' ' +
                      sizeDescription(generatedCode.length, programInfo),
                      cls: 'kind') +
         code(esc(generatedCode)));
     buffer.write('\n');
   }
+
+  Map<String, dynamic> toJson(ProgramInfo programInfo) {
+    return <String, dynamic>{
+      'kind': 'code',
+      'description': description,
+      'code': generatedCode,
+      'size': generatedCode.length,
+      'sizePercent': sizePercent(generatedCode.length, programInfo)
+    };
+  }
 }
 
 /// Instances represent information inferred about the program such as
 /// inferred type information or inferred side effects.
 class InferredInfoNode implements InfoNode {
   /// Text describing the represented information.
   final String description;
 
   /// The name of the entity this information is inferred about (for example the
   /// name of a parameter).
   final String name;
 
   /// The inferred type/side effect.
   final String type;
 
   get size => 0;
 
   InferredInfoNode({this.name: "", this.description, this.type});
 
+  Map<String, dynamic> toJson(ProgramInfo programInfo) {
+    return <String, dynamic>{
+      'kind': 'inferred',
+      'name': name,
+      'type': type,
+      'desc': description
+    };
+  }
+
   void emitHtml(ProgramInfo programInfo, StringBuffer buffer,
       [String indentation = '']) {
     buffer.write(indentation);
     buffer.write(
         div('${span("Inferred " + description, cls: "kind")} '
             '${span(esc(name), cls: "name")} '
             '${span(esc(type), cls: "type")} ',
             cls: "attr"));
     buffer.write('\n');
   }
@@ skipping 17 matching lines @@
   final String dart2jsVersion;
 
   final Map<OutputUnit, int> outputUnitNumbering;
 
   ProgramInfo({this.libraries,
                this.size,
                this.compilationMoment,
                this.compilationDuration,
                this.dart2jsVersion,
                this.outputUnitNumbering: null});
+
+  Map<String, dynamic> toJson() {
+    return <String, dynamic>{
+      'program_size': size,
+      'compile_time': compilationMoment.toString(),
+      'compile_duration': compilationDuration.toString(),
+      'dart2js_version': dart2jsVersion
+    };
+  }
 }
 
 class InfoDumpVisitor extends ElementVisitor<InfoNode> {
   final Compiler compiler;
 
   /// Contains the elements visited on the path from the library to here.
   final List<Element> stack = new List<Element>();
 
   final Map<OutputUnit, int> outputUnitNumbering = new Map<OutputUnit, int>();
 
@@ skipping 259 matching lines @@
   CodeBuffer codeOf(Element element) {
     jsAst.Expression code = _generatedCode[element];
     return code != null
         ? jsAst.prettyPrint(code, compiler)
         : compiler.backend.codeOf(element);
   }
 
   void dumpInfo() {
     measure(() {
       ProgramInfo info = infoDumpVisitor.collectDumpInfo();
-      StringBuffer buffer = new StringBuffer();
-      dumpInfoHtml(info, buffer);
+
+      StringBuffer htmlBuffer = new StringBuffer();
+      dumpInfoHtml(info, htmlBuffer);
       compiler.outputProvider('', 'info.html')
-        ..add(buffer.toString())
+        ..add(htmlBuffer.toString())
+        ..close();
+
+      StringBuffer jsonBuffer = new StringBuffer();
+      dumpInfoJson(info, jsonBuffer);
+      compiler.outputProvider('', 'info.json')
+        ..add(jsonBuffer.toString())
         ..close();
     });
   }
 
+  void dumpInfoJson(ProgramInfo info, StringSink buffer) {
+    Map<String, dynamic> entire = <String, dynamic>{
+      'program': info.toJson(),
+      'libs': info.libraries.map((lib) => lib.toJson(info)).toList()
+    };
+
+    JsonEncoder encoder = const JsonEncoder();
+    ChunkedConversionSink<Object> sink =
+      encoder.startChunkedConversion(
+          new StringConversionSink.fromStringSink(buffer));
+    sink.add(entire);
+  }
+
   void dumpInfoHtml(ProgramInfo info, StringSink buffer) {
     int totalSize = info.size;
 
     buffer.writeln("""
 <html>
   <head>
     <title>Dart2JS compilation information</title>
        <style>
         code {margin-left: 20px; display: block; white-space: pre; }
         div.container, div.contained, div.element, div.attr {
@@ skipping 125 matching lines @@
       }
       document.querySelector('.sort_by_size').addEventListener('click',
           function() {
             sortBySize();
           }, false);
     </script>
   </body>
 </html>""");
   }
 }