add a JsonInfoCodec class

lib/src/measurements.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.
 
 /// Measurements collected about individual functions.  Currently we compute
 /// data about "sends", to classify whether we know the target or not.
 library dart2js_info.src.measurements;
 
 /// Top-level set of metrics
-const List<Metric> _topLevelMetrics = const [
-  Metric.functions,
-  Metric.send,
-];
+const List<Metric> _topLevelMetrics = const [Metric.functions, Metric.send];
 
 /// Apply `f` on each metric in DFS order on the metric tree. [Metric.functions]
 /// and [Metric.send] are the top level metrics. See those declarations for
 /// details on the subtrees.
 visitAllMetrics(f) {
   var parentsStack = [];
   helper(Metric m) {
     f(m, parentsStack);
     if (m is GroupedMetric) {
       parentsStack.add(m);
       m.submetrics.forEach(helper);
       parentsStack.removeLast();
     }
   }
   _topLevelMetrics.forEach(helper);
 }
 
 /// A metric we intend to measure.
 class Metric {
   /// Name for the metric.
   final String name;
 
   const Metric(this.name);
 
+  factory Metric.fromName(String name) => _nameToMetricMap[name];
+
   String toString() => name;
 
   /// Total functions in a library/package/program. Parent of
   /// [reachableFunction].
-  static const Metric functions = const GroupedMetric('functions', const [
-      reachableFunctions,
-  ]);
+  static const Metric functions =
+      const GroupedMetric('functions', const [reachableFunctions]);
 
   /// Subset of the functions that are reachable.
   static const Metric reachableFunctions = const Metric('reachable functions');
 
   /// Parent of all send metrics. We classify sends as follows:
   ///
   ///     sends
   ///       |- monomorphic
   ///       |  |- static (top-levels, statics)
   ///       |  |- super
   ///       |  |- local (access to a local var, call local function)
   ///       |  |- constructor (like factory ctros)
   ///       |  |- type variable (reading a type variable)
   ///       |  |- nsm (known no such method exception)
   ///       |  |- single-nsm-call (known no such method call, single target)
   ///       |  |- instance (non-interceptor, only one possible target)
   ///       |  '- interceptor (interceptor, known)
   ///       |
   ///       '- polymorphic
   ///          |- multi-nsm (known to be nSM, but not sure if error, or call, or
   ///                        which call)
   ///          |- virtual (traditional virtual call, polymorphic equivalent of
   ///          |           `instance`, no-interceptor)
   ///          |- multi-interceptor (1 of n possible interceptors)
   ///          '- dynamic (any combination of the above)
   ///
-  static const Metric send = const GroupedMetric('send', const [
-      monomorphicSend,
-      polymorphicSend,
-  ]);
+  static const Metric send =
+      const GroupedMetric('send', const [monomorphicSend, polymorphicSend]);
 
   /// Parent of monomorphic sends, see [send] for details.
-  static const Metric monomorphicSend = const GroupedMetric('monomorphic',
-      const [
-        staticSend,
-        superSend,
-        localSend,
-        constructorSend,
-        typeVariableSend,
-        nsmErrorSend,
-        singleNsmCallSend,
-        instanceSend,
-        interceptorSend,
-      ]);
+  static const Metric monomorphicSend =
+      const GroupedMetric('monomorphic', const [
+    staticSend,
+    superSend,
+    localSend,
+    constructorSend,
+    typeVariableSend,
+    nsmErrorSend,
+    singleNsmCallSend,
+    instanceSend,
+    interceptorSend
+  ]);
 
   /// Metric for static calls, see [send] for details.
   static const Metric staticSend = const Metric('static');
 
   /// Metric for super calls, see [send] for details.
   static const Metric superSend = const Metric('super');
 
   /// Metric for local variable sends, see [send] for details.
   static const Metric localSend = const Metric('local');
 
@@ skipping 14 matching lines @@
   /// Metric for calls to a precisely known instance method, see [send] for
   /// details.
   static const Metric instanceSend = const Metric('instance');
 
   /// Metric for calls to a precisely known interceptor method, see [send] for
   /// details.
   static const Metric interceptorSend = const Metric('interceptor');
 
   /// Parent of polymorphic sends, see [send] for details.
   static const Metric polymorphicSend = const GroupedMetric('polymorphic',
-      const [
-        multiNsmCallSend,
-        virtualSend,
-        multiInterceptorSend,
-        dynamicSend,
-      ]);
+      const [multiNsmCallSend, virtualSend, multiInterceptorSend, dynamicSend]);
 
   /// Metric for calls to noSuchMethod methods with more than one possible
   /// target, see [send] for details.
   static const Metric multiNsmCallSend = const Metric('nSM call multi');
 
   /// Metric for calls that are dispatched virtually ar runtime, see [send] for
   /// details.
   static const Metric virtualSend = const Metric('virtual');
 
   /// Metyric for calls to more than one possible interceptor, see [send] for
   /// details.
   static const Metric multiInterceptorSend = const Metric('interceptor multi');
 
   /// Metyric for dynamic calls for which we know nothing about the target
   /// method. See [send] for details.
   static const Metric dynamicSend = const Metric('dynamic');
 
-  String toJson() => name;
   static Map<String, Metric> _nameToMetricMap = () {
     var res = {};
     visitAllMetrics((m, _) => res[m.name] = m);
     return res;
   }();
-
-  static Metric fromJson(String name) => _nameToMetricMap[name];
 }
 
 /// A metric that is subdivided in smaller metrics.
 class GroupedMetric extends Metric {
   final List<Metric> submetrics;
 
   const GroupedMetric(String name, this.submetrics) : super(name);
 }
 
 /// A measurement entry (practically a source-span location where the
 /// measurement was seen).
 class Entry {
   final int begin;
   final int end;
   Entry(this.begin, this.end);
 }
 
 /// A collection of data points for each metric. Used to summarize a single
 /// function, a library, a package, or an entire program.
 class Measurements {
   final Uri uri;
   final Map<Metric, List<Entry>> entries;
   final Map<Metric, int> counters;
 
   Measurements([this.uri])
       : entries = <Metric, List<Entry>>{},
         counters = <Metric, int>{};
 
   const Measurements.unreachableFunction()
-      : counters = const { Metric.functions: 1}, entries = const {}, uri = null;
+      : counters = const {Metric.functions: 1},
+        entries = const {},
+        uri = null;
 
   Measurements.reachableFunction([this.uri])
-      : counters = { Metric.functions: 1, Metric.reachableFunctions: 1},
+      : counters = {Metric.functions: 1, Metric.reachableFunctions: 1},
         entries = {};
 
   /// Record [metric] was seen. The optional [begin] and [end] offsets are
   /// included for metrics that correspond to a source range. Intended to be
   /// used by `StatsBuilder`.
   record(Metric metric, [int begin, int end]) {
     if (begin != null && end != null) {
       assert(uri != null);
       entries.putIfAbsent(metric, () => []).add(new Entry(begin, end));
     }
@@ skipping 24 matching lines @@
   /// submetric.
   bool checkInvariant(GroupedMetric key) {
     int total = counters[key] ?? 0;
     int submetricTotal = 0;
     for (var metric in key.submetrics) {
       var n = counters[metric];
       if (n != null) submetricTotal += n;
     }
     return total == submetricTotal;
   }
-
-  Map toJson() {
-    var jsonEntries = <String, List<Map>>{};
-    entries.forEach((metric, values) {
-      jsonEntries[metric.toJson()] =
-          values.expand((e) => [e.begin, e.end]).toList();
-    });
-    var json = {'entries': jsonEntries};
-    // TODO(sigmund): encode uri as an offset of the URIs available in the parts
-    // of the library info.
-    if (uri != null) json['sourceFile'] = '$uri';
-    if (counters[Metric.functions] != null) {
-      json[Metric.functions.toJson()] = counters[Metric.functions];
-    }
-    if (counters[Metric.reachableFunctions] != null) {
-      json[Metric.reachableFunctions.toJson()] =
-          counters[Metric.reachableFunctions];
-    }
-    return json;
-  }
 }