dart2js cps: Debugging utility and fix idempotency in shrinking reducer.

pkg/compiler/lib/src/cps_ir/cps_ir_nodes_sexpr.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.
 
 library dart2js.ir_nodes_sexpr;
 
 import '../constants/values.dart';
 import '../util/util.dart';
 import 'cps_ir_nodes.dart';
 import '../universe/call_structure.dart' show
@@ skipping 11 matching lines @@
   String newValueName(Primitive node) => namer.nameValue(node);
   String newContinuationName(Continuation node) => namer.nameContinuation(node);
   Decorator decorator;
 
   SExpressionStringifier([this.decorator]) {
     if (this.decorator == null) {
       this.decorator = (node, String s) => s;
     }
   }
 
+  /// Create a stringifier with an extra layer of decoration.
+  SExpressionStringifier withDecorator(Decorator subDecorator) {
+    return new SExpressionStringifier((node, String s) {
+      return subDecorator(node, decorator(node, s));
+    });
+  }
+
+  /// Create a stringifier that displays type information.
+  SExpressionStringifier withTypes() => withDecorator(typeDecorator);
+
+  /// Creates a stringifier that adds annotations from a map;
+  /// see [Node.debugString].
+  SExpressionStringifier withAnnotations(Map annotations) {
+    return withDecorator(decoratorFromMap(annotations));
+  }
+
+  static Decorator decoratorFromMap(Map annotations) {
+    Map<Node, String> nodeMap = {};
+    for (var key in annotations.keys) {
+      if (key is Node) {
+        nodeMap[key] = '${annotations[key]}';
+      } else {
+        String text = key;
+        Node node = annotations[key];
+        if (nodeMap.containsKey(node)) {
+          // In case two annotations belong to the same node,
+          // put both annotations on that node.
+          nodeMap[node] += ' $text';
+        } else {
+          nodeMap[node] = text;
+        }
+      }
+    }
+    return (node, string) {
+      String text = nodeMap[node];
+      if (text != null) return '***$string*** $text';
+      return string;
+    };
+  }
+
+  static String typeDecorator(node, String string) {
+    return node is Variable ? '$string:${node.type}' : string;
+  }
+
   String access(Reference<Definition> r) {
     if (r == null) return '**** NULL ****';
     return decorator(r, namer.getName(r.definition));
   }
 
   String optionalAccess(Reference<Definition> reference) {
     return reference == null ? '()' : '(${access(reference)})';
   }
 
   String visitParameter(Parameter node) {
@@ skipping 29 matching lines @@
 
   String visitLetPrim(LetPrim node) {
     String name = newValueName(node.primitive);
     String value = visit(node.primitive);
     String bindings = '($name $value)';
     String skip = ' ' * '(LetPrim ('.length;
     while (node.body is LetPrim) {
       node = node.body;
       name = newValueName(node.primitive);
       value = visit(node.primitive);
-      bindings += '\n${indentation}$skip($name $value)';
+      String binding = decorator(node, '($name $value)');
+      bindings += '\n${indentation}$skip$binding';
     }
     String body = indentBlock(() => visit(node.body));
     return '$indentation(LetPrim ($bindings)\n$body)';
   }
 
   bool isBranchTarget(Continuation cont) {
     return cont.hasExactlyOneUse && cont.firstRef.parent is Branch;
   }
 
   String visitLetCont(LetCont node) {
@@ skipping 423 matching lines @@
   void setReturnContinuation(Continuation node) {
     assert(!_names.containsKey(node) || _names[node] == 'return');
     _names[node] = 'return';
   }
 
   String getName(Node node) {
     if (!_names.containsKey(node)) return 'MISSING_NAME';
     return _names[node];
   }
 }