dartfmt pkg/compiler

pkg/compiler/lib/src/inferrer/type_graph_dump.dart

 // Copyright (c) 2016, 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 dart2js.inferrer.type_graph_dump;
 
 import 'dart:async';
 import 'type_graph_nodes.dart';
 import 'type_graph_inferrer.dart';
 import '../elements/elements.dart';
 import '../types/types.dart';
@@ skipping 11 matching lines @@
 ///     dot -Tpng -O typegraph/main.dot
 ///     open typegraph/main.dot.png
 ///
 ///     dot -Tpng -O typegraph/dart._internal.Sort._dualPivotQuicksort.dot
 ///     open typegraph/dart._internal.Sort._dualPivotQuicksort.dot.png
 ///
 class TypeGraphDump {
   static const String outputDir = 'typegraph';
 
   final TypeGraphInferrerEngine inferrer;
-  final Map<TypeInformation, Set<TypeInformation>> assignmentsBeforeAnalysis
-      = <TypeInformation, Set<TypeInformation>>{};
-  final Map<TypeInformation, Set<TypeInformation>> assignmentsBeforeTracing
-      = <TypeInformation, Set<TypeInformation>>{};
+  final Map<TypeInformation, Set<TypeInformation>> assignmentsBeforeAnalysis =
+      <TypeInformation, Set<TypeInformation>>{};
+  final Map<TypeInformation, Set<TypeInformation>> assignmentsBeforeTracing =
+      <TypeInformation, Set<TypeInformation>>{};
   final Set<String> usedFilenames = new Set<String>();
 
   TypeGraphDump(this.inferrer);
 
   /// Take a copy of the assignment set for each node, since that may change
   /// during the analysis.
   void beforeAnalysis() {
     for (TypeInformation node in inferrer.types.allTypes) {
       Set<TypeInformation> copy = node.assignments.toSet();
       if (!copy.isEmpty) {
@@ skipping 12 matching lines @@
     }
   }
 
   /// Dumps the entire graph.
   void afterAnalysis() {
     // Group all the type nodes by their context member.
     Map<Element, List<TypeInformation>> nodes =
         <Element, List<TypeInformation>>{};
     for (TypeInformation node in inferrer.types.allTypes) {
       if (node.contextMember != null) {
-        nodes.putIfAbsent(node.contextMember, () => <TypeInformation>[])
-             .add(node);
+        nodes
+            .putIfAbsent(node.contextMember, () => <TypeInformation>[])
+            .add(node);
       }
     }
     // Print every group separately.
     for (Element element in nodes.keys) {
       EventSink<String> output;
       try {
         String name = filenameFromElement(element);
         output = inferrer.compiler.outputProvider('$outputDir/$name', 'dot');
         _GraphGenerator visitor = new _GraphGenerator(this, element, output);
         for (TypeInformation node in nodes[element]) {
@@ skipping 13 matching lines @@
   /// graph for [element].
   ///
   /// Will never return the a given filename more than once, even if called with
   /// the same element.
   String filenameFromElement(Element element) {
     // The toString method of elements include characters that are unsuitable
     // for URIs and file systems.
     List<String> parts = <String>[];
     parts.add(element.library?.libraryName);
     parts.add(element.enclosingClass?.name);
-    Element namedElement = element is LocalElement
-        ? element.executableContext
-        : element;
+    Element namedElement =
+        element is LocalElement ? element.executableContext : element;
     if (namedElement.isGetter) {
       parts.add('get-${namedElement.name}');
     } else if (namedElement.isSetter) {
       parts.add('set-${namedElement.name}');
     } else if (namedElement.isConstructor) {
       if (namedElement.name.isEmpty) {
         parts.add('-constructor');
       } else {
         parts.add(namedElement.name);
       }
     } else if (namedElement.isOperator) {
-      parts.add(Elements.operatorNameToIdentifier(namedElement.name)
+      parts.add(Elements
+          .operatorNameToIdentifier(namedElement.name)
           .replaceAll(r'$', '-'));
     } else {
       parts.add(namedElement.name);
     }
     if (namedElement != element) {
       if (element.name.isEmpty) {
         parts.add('anon${element.sourcePosition.begin}');
       } else {
         parts.add(element.name);
       }
@@ skipping 70 matching lines @@
 
   /// Escapes characters in [text] so it can be used as part of a label.
   String escapeLabel(String text) {
     return text.replaceAllMapped(escapeRegexp, (m) => '\\${m.group(0)}');
   }
 
   /// Creates an edge from [src] to [dst].
   ///
   /// If [dst] is a record type node, [port] may refer to one of the fields
   /// defined in that record (e.g. `obj`, `arg0`, `arg1`, etc)
-  void addEdge(TypeInformation src,
-               TypeInformation dst,
-               {String port,
-                String color: 'black'}) {
+  void addEdge(TypeInformation src, TypeInformation dst,
+      {String port, String color: 'black'}) {
     if (isExternal(src) && isExternal(dst)) {
       return; // Do not add edges between external nodes.
     }
     String dstText = getNode(dst);
     if (port != null) {
       dstText += ':$port';
     }
     if (src is ConcreteTypeInformation) {
       // Concrete types can have a huge number of uses which will flood the
       // graph with very long hard-to-follow edges. Copy the concrete nodes
@@ skipping 41 matching lines @@
     if (node.contextMember != null && node.contextMember != element) {
       return '$text\n(from ${node.contextMember})';
     }
     return text;
   }
 
   /// Creates a node for [node] displaying the given [text] in its box.
   ///
   /// [inputs] specify named inputs to the node. If omitted, edges will be
   /// based on [node.assignments].
-  void addNode(TypeInformation node,
-               String text,
-               {String color: defaultNodeColor,
-                Map<String, TypeInformation> inputs}) {
+  void addNode(TypeInformation node, String text,
+      {String color: defaultNodeColor, Map<String, TypeInformation> inputs}) {
     seen.add(node);
     String style = getStyleForNode(node, color);
     text = appendDetails(node, text);
     text = escapeLabel(text);
     String id = getNode(node);
     String returnType = escapeLabel(formatType(node.type));
     if (inputs != null) {
       Iterable<String> keys = inputs.keys.where((key) => inputs[key] != null);
       String header = keys.map((key) => '<a$key> $key').join('|');
       String label = '{{$header}|$text|<returnType> $returnType}';
       append('$id [shape=record,label="$label",$style]');
       for (String key in keys) {
         addEdge(inputs[key], node, port: 'a$key');
       }
     } else {
       String label = '{$text|<returnType> $returnType}';
       append('$id [shape=record,label="$label",$style]');
       // Add assignment edges. Color the edges based on whether they were
       // added, removed, temporary, or unchanged.
       var originalSet = global.assignmentsBeforeAnalysis[node] ?? const [];
       var tracerSet = global.assignmentsBeforeTracing[node] ?? const [];
       var currentSet = node.assignments.toSet();
       for (TypeInformation assignment in currentSet) {
-        String color = originalSet.contains(assignment)
-            ? unchangedEdge
-            : addedEdge;
+        String color =
+            originalSet.contains(assignment) ? unchangedEdge : addedEdge;
         addEdge(assignment, node, color: color);
       }
       for (TypeInformation assignment in originalSet) {
         if (!currentSet.contains(assignment)) {
           addEdge(assignment, node, color: removedEdge);
         }
       }
       for (TypeInformation assignment in tracerSet) {
         if (!currentSet.contains(assignment) &&
             !originalSet.contains(assignment)) {
@@ skipping 31 matching lines @@
 
   void visitMapTypeInformation(MapTypeInformation info) {
     addNode(info, 'Map');
   }
 
   void visitConcreteTypeInformation(ConcreteTypeInformation info) {
     addNode(info, 'Concrete');
   }
 
   void visitStringLiteralTypeInformation(StringLiteralTypeInformation info) {
-    String text = shorten(info.value.slowToString()).replaceAll('\n','\\n');
+    String text = shorten(info.value.slowToString()).replaceAll('\n', '\\n');
     addNode(info, 'StringLiteral\n"$text"');
   }
 
   void visitBoolLiteralTypeInformation(BoolLiteralTypeInformation info) {
     addNode(info, 'BoolLiteral\n${info.value}');
   }
 
   void handleCall(CallSiteTypeInformation info, String text, Map inputs) {
     String sourceCode = shorten('${info.call}');
     text = '$text\n$sourceCode';
     if (info.arguments != null) {
       for (int i = 0; i < info.arguments.positional.length; ++i) {
         inputs['arg$i'] = info.arguments.positional[i];
       }
       for (String argName in info.arguments.named.keys) {
         inputs[argName] = info.arguments.named[argName];
       }
     }
     addNode(info, text, color: callColor, inputs: inputs);
   }
 
-  void visitClosureCallSiteTypeInformation(ClosureCallSiteTypeInformation info) {
+  void visitClosureCallSiteTypeInformation(
+      ClosureCallSiteTypeInformation info) {
     handleCall(info, 'ClosureCallSite', {});
   }
 
   void visitStaticCallSiteTypeInformation(StaticCallSiteTypeInformation info) {
     handleCall(info, 'StaticCallSite', {});
   }
 
-  void visitDynamicCallSiteTypeInformation(DynamicCallSiteTypeInformation info) {
-    handleCall(info, 'DynamicCallSite', {
-      'obj': info.receiver
-    });
+  void visitDynamicCallSiteTypeInformation(
+      DynamicCallSiteTypeInformation info) {
+    handleCall(info, 'DynamicCallSite', {'obj': info.receiver});
   }
 
   void visitMemberTypeInformation(MemberTypeInformation info) {
     addNode(info, 'Member\n${info.element}');
   }
 
   void visitParameterTypeInformation(ParameterTypeInformation info) {
     addNode(info, 'Parameter ${info.element?.name ?? ''}');
   }
 
@@ skipping 38 matching lines @@
     String value = formatType(type.valueType);
     return '$container<$key,$value>';
   }
   if (type is ValueTypeMask) {
     String baseType = formatType(type.forwardTo);
     String value = type.value.toStructuredString();
     return '$baseType=$value';
   }
   return '$type'; // Fall back on toString if not supported here.
 }