dartfmt pkg/compiler

pkg/compiler/lib/src/helpers/stats.dart

 // Copyright (c) 2014, 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.
 
-import 'dart:async' show
-    EventSink;
+import 'dart:async' show EventSink;
 import 'dart:collection';
 import 'dart:convert';
 
 import '../../compiler.dart';
 import '../common.dart';
-import '../compiler.dart' show
-    Compiler;
+import '../compiler.dart' show Compiler;
 import '../util/util.dart';
 
-
 // Helper methods for statistics.
 
 /// Current stats collector. Use [enableStatsOutput] to enable recording of
 /// stats.
 Stats get stats {
   enableDebugMode();
   if (_stats == null) {
     _stats = const Stats();
   }
   return _stats;
 }
 
 Stats _stats;
 
 /// Enable recording of stats. Use [Stats.dumpStats] to output the record stats.
 ///
 /// Pass the [outputProvider] of [Compiler] to generate stats into a separate
 /// file using [name] and [extension] for the filename. If omitted, stats are
 /// printed on standard out.
 ///
 /// If [xml] is `true`, stats output is formatted as XML with a default
 /// extension of 'xml', otherwise the output is indented text with a default
 /// extension of 'log'.
-void enableStatsOutput({CompilerOutputProvider outputProvider,
-                        bool xml: true,
-                        String name: 'stats',
-                        String extension,
-                        int examples: 10}) {
+void enableStatsOutput(
+    {CompilerOutputProvider outputProvider,
+    bool xml: true,
+    String name: 'stats',
+    String extension,
+    int examples: 10}) {
   if (_stats != null) {
     throw new StateError('Stats have already been initialized.');
   }
   enableDebugMode();
 
   StatsOutput output;
   if (outputProvider != null) {
     if (extension == null) {
       extension = xml ? 'xml' : 'log';
     }
@@ skipping 135 matching lines @@
   /// [a] and [b]:
   ///
   ///   'idA && idB' lists the elements both in [a] and [b],
   ///   '!idA && idB' lists the elements not in [a] but in [b], and
   ///   'idA && !idB' lists the elements in [a] but not in [b].
   ///
   /// If [dataA] and/or [dataB] are provided, additional information on the
   /// elements are looked up in [dataA] or [dataB] using [dataA] as the primary
   /// source.
   void dumpCorrelation(idA, Iterable a, idB, Iterable b,
-                       {Map dataA, Map dataB}) {}
+      {Map dataA, Map dataB}) {}
 }
 
 /// Interface for printing output data.
 ///
 /// This class serves as the disabled output.
 class StatsOutput {
   const StatsOutput();
 
   /// Print [text] as on a separate line.
   void println(String text) {}
@@ skipping 32 matching lines @@
     start(id);
     createGroupContent();
     end(id);
   }
 
   /// End a group [id].
   void end(String id) {}
 
   /// Start a stat entry for [id] with additional [data].
   void open(String id,
-            [Map<String, dynamic> data = const <String, dynamic>{}]) {}
+      [Map<String, dynamic> data = const <String, dynamic>{}]) {}
 
   /// Create a stat entry for [id] with additional [data] and content created by
   /// [createChildContent].
   void child(String id,
-             [Map<String, dynamic> data = const <String, dynamic>{},
-              void createChildContent()]) {
+      [Map<String, dynamic> data = const <String, dynamic>{},
+      void createChildContent()]) {
     open(id, data);
     if (createChildContent != null) createChildContent();
     close(id);
   }
 
   /// End a stat entry for [id].
   void close(String id) {}
 
   /// Starts a group of additional information.
   void beginExtra() {}
 
   /// Starts a group of additional information.
   void endExtra() {}
 }
 
 /// Abstract base class for [ConsolePrinter] and [XMLPrinter].
 abstract class BasePrinter extends StatsPrinter with Indentation {
   final int examples;
   final StatsOutput output;
 
-  BasePrinter({this.output: const DebugOutput(),
-               this.examples: 10}) {
+  BasePrinter({this.output: const DebugOutput(), this.examples: 10}) {
     indentationUnit = " ";
   }
 }
 
 /// [StatsPrinter] that displays stats in console lines.
 class ConsolePrinter extends BasePrinter {
   int extraLevel = 0;
 
-  ConsolePrinter({StatsOutput output: const DebugOutput(),
-                  int examples: 10})
+  ConsolePrinter({StatsOutput output: const DebugOutput(), int examples: 10})
       : super(output: output, examples: examples);
 
   void open(String id,
-            [Map<String, dynamic> data = const <String, dynamic>{}]) {
+      [Map<String, dynamic> data = const <String, dynamic>{}]) {
     if (extraLevel > 0) return;
 
     StringBuffer sb = new StringBuffer();
     sb.write(indentation);
     String space = '';
     if (data['title'] != null) {
       sb.write('${data['title']}:');
       space = ' ';
       data.remove('title');
     } else if (data['name'] != null) {
@@ skipping 28 matching lines @@
   void endExtra() {
     extraLevel--;
   }
 }
 
 /// [StatsPrinter] that displays stats in XML format.
 class XMLPrinter extends BasePrinter {
   static const HtmlEscape escape = const HtmlEscape();
   bool opened = false;
 
-  XMLPrinter({output: const DebugOutput(),
-              int examples: 10})
+  XMLPrinter({output: const DebugOutput(), int examples: 10})
       : super(output: output, examples: examples);
 
   void start(String id) {
     if (!opened) {
       output.println('<?xml version="1.0" encoding="UTF-8"?>');
       opened = true;
     }
     open(id);
   }
 
   void end(String id) {
     close(id);
   }
 
   void open(String id,
-            [Map<String, dynamic> data = const <String, dynamic>{}]) {
+      [Map<String, dynamic> data = const <String, dynamic>{}]) {
     StringBuffer sb = new StringBuffer();
     sb.write(indentation);
     sb.write('<$id');
     data.forEach((key, value) {
       if (value != null) {
         sb.write(' $key="${escape.convert('$value')}"');
       }
     });
     sb.write('>');
     output.println(sb.toString());
@@ skipping 21 matching lines @@
   List<StackTraceLine> commonPrefix;
   List<_StackTraceNode> subtraces;
 
   _StackTraceNode(this.commonPrefix, this.count, this.subtraces);
 
   _StackTraceNode.root() : this([], 0, []);
 
   _StackTraceNode.leaf(StackTraceLines stackTrace)
       : this(stackTrace.lines, 1, const []);
 
-  _StackTraceNode.node(List<StackTraceLine> commonPrefix,
-                       _StackTraceNode first,
-                       _StackTraceNode second)
+  _StackTraceNode.node(List<StackTraceLine> commonPrefix, _StackTraceNode first,
+      _StackTraceNode second)
       : this(commonPrefix, first.count + second.count, [first, second]);
 
   void add(StackTraceLines stackTrace) {
     count++;
     if (!stackTrace.lines.isEmpty) {
       addSubtrace(stackTrace);
     }
   }
 
   void addSubtrace(StackTraceLines stackTrace) {
@@ skipping 80 matching lines @@
   final id;
   int totalCount = 0;
   final int sampleFrequency;
 
   _StackTraceTree(this.id, this.sampleFrequency) : super.root();
 
   void dumpTraces(StatsPrinter printer) {
     printer.open('trace', {
       'id': id,
       'totalCount': totalCount,
-      'sampleFrequency': sampleFrequency});
+      'sampleFrequency': sampleFrequency
+    });
     dumpSubtraces(printer);
     printer.close('trace');
   }
 
   void sample() {
     if (totalCount++ % sampleFrequency == 0) {
       add(stackTrace(offset: 3));
     }
   }
 }
@@ skipping 52 matching lines @@
   }
 
   void recordElement(key, element, {data}) {
     setsMap.putIfAbsent(key, () => new Map())[element] = data;
   }
 
   void recordTrace(key, {int sampleFrequency}) {
     if (sampleFrequency == null) {
       sampleFrequency = stackTraceSampleFrequency;
     }
-    traceMap.putIfAbsent(key,
-        () => new _StackTraceTree(key, sampleFrequency)).sample();
-
+    traceMap
+        .putIfAbsent(key, () => new _StackTraceTree(key, sampleFrequency))
+        .sample();
   }
 
   Iterable getList(String key) {
     Map map = setsMap[key];
     if (map == null) return const [];
     return map.keys;
   }
 
   void dumpStats({void beforeClose()}) {
     printer.start('stats');
     dumpFrequencies();
     dumpSets();
     dumpCounters();
     dumpTraces();
     if (beforeClose != null) {
       beforeClose();
     }
     printer.end('stats');
   }
 
   void dumpSets() {
     printer.group('sets', () {
       setsMap.forEach((k, set) {
         dumpIterable('examples', '$k', set.keys,
             limit: printer.examples, dataMap: set);
       });
     });
-
   }
 
   void dumpFrequencies() {
     printer.group('frequencies', () {
       frequencyMaps.forEach((key, Map<dynamic, List> map) {
         printer.child('frequency', {'title': '$key'}, () {
           dumpFrequency(map);
         });
       });
     });
@@ skipping 40 matching lines @@
     printer.open('counter', {'title': '$id', 'count': count});
     result.forEach((int count, Set examples) {
       if (counter == printer.examples) {
         printer.beginExtra();
         hasMore = true;
       }
       if (examples.length == 1 &&
           (examplesLimit == 0 || !hasData(examples.first))) {
         printer.child('examples', {'count': count, 'example': examples.first});
       } else {
-        printer.child('examples',
-            {'count': count, 'examples': examples.length},
+        printer.child('examples', {'count': count, 'examples': examples.length},
             () {
           examples.forEach((example) {
-            dumpIterable(
-                'examples', '$example', map[example],
-                limit: examplesLimit,
-                includeCount: false);
+            dumpIterable('examples', '$example', map[example],
+                limit: examplesLimit, includeCount: false);
           });
         });
       }
       counter++;
     });
     if (hasMore) {
       printer.endExtra();
     }
     printer.close('counter');
   }
 
   void dumpTraces() {
     printer.group('traces', () {
       traceMap.keys.forEach(dumpTrace);
     });
   }
 
   void dumpTrace(key) {
     _StackTraceTree tree = traceMap[key];
     tree.dumpTraces(printer);
   }
 
   void dumpCorrelation(keyA, Iterable a, keyB, Iterable b,
-                       {Map dataA, Map dataB}) {
+      {Map dataA, Map dataB}) {
     printer.child('correlations', {'title': '$keyA vs $keyB'}, () {
       List aAndB = a.where((e) => e != null && b.contains(e)).toList();
       List aAndNotB = a.where((e) => e != null && !b.contains(e)).toList();
       List notAandB = b.where((e) => e != null && !a.contains(e)).toList();
-      dumpIterable('correlation', '$keyA && $keyB', aAndB, dataMap: dataA,
-          limit: printer.examples);
-      dumpIterable('correlation', '$keyA && !$keyB', aAndNotB, dataMap: dataA,
-          limit: printer.examples);
-      dumpIterable('correlation', '!$keyA && $keyB', notAandB, dataMap: dataB,
-          limit: printer.examples);
+      dumpIterable('correlation', '$keyA && $keyB', aAndB,
+          dataMap: dataA, limit: printer.examples);
+      dumpIterable('correlation', '$keyA && !$keyB', aAndNotB,
+          dataMap: dataA, limit: printer.examples);
+      dumpIterable('correlation', '!$keyA && $keyB', notAandB,
+          dataMap: dataB, limit: printer.examples);
     });
   }
 
   void dumpIterable(String tag, String title, Iterable iterable,
-                    {int limit, Map dataMap, bool includeCount: true}) {
+      {int limit, Map dataMap, bool includeCount: true}) {
     if (limit == 0) return;
 
     Map childData = {};
     Iterable nonNullIterable = iterable.where((e) => e != null);
     if (nonNullIterable.isEmpty && !includeCount) {
       childData['name'] = title;
     } else {
       childData['title'] = title;
     }
     if (includeCount) {
@@ skipping 24 matching lines @@
 
 /// Returns a map that is an inversion of [map], where the keys are the values
 /// of [map] and the values are the set of keys in [map] that share values.
 ///
 /// If [equals] and [hashCode] are provided, these are used to determine
 /// equality among the values of [map].
 ///
 /// If [isValidKey] is provided, this is used to determine with a value of [map]
 /// is a potential key of the inversion map.
 Map<dynamic, Set> inverseMap(Map map,
-                             {bool equals(key1, key2),
-                              int hashCode(key),
-                              bool isValidKey(potentialKey)}) {
+    {bool equals(key1, key2),
+    int hashCode(key),
+    bool isValidKey(potentialKey)}) {
   Map<dynamic, Set> result = new LinkedHashMap<dynamic, Set>(
       equals: equals, hashCode: hashCode, isValidKey: isValidKey);
   map.forEach((k, v) {
     if (isValidKey == null || isValidKey(v)) {
       result.putIfAbsent(v, () => new Set()).add(k);
     }
   });
   return result;
 }
 
 /// Return a new map heuristically sorted by the keys of [map]. If the first
 /// key of [map] is [Comparable], the keys are sorted using [sortMap] under
 /// the assumption that all keys are [Comparable].
 /// Otherwise, the keys are sorted as string using their `toString`
 /// representation.
 Map trySortMap(Map map) {
   Iterable iterable = map.keys.where((k) => k != null);
   if (iterable.isEmpty) return map;
   var key = iterable.first;
   if (key is Comparable) {
     return sortMap(map);
   }
   return sortMap(map, (a, b) => '$a'.compareTo('$b'));
 }
 
 /// Returns a new map in which the keys of [map] are sorted using [compare].
 /// If [compare] is null, the keys must be [Comparable].
-Map sortMap(Map map, [int compare(a,b)]) {
+Map sortMap(Map map, [int compare(a, b)]) {
   List keys = map.keys.toList();
   keys.sort(compare);
   Map sortedMap = new Map();
   keys.forEach((k) => sortedMap[k] = map[k]);
   return sortedMap;
 }
-