First version of typr propagation in the new IR.

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 '../util/util.dart';
 import 'cps_ir_nodes.dart';
 
 /// A [Decorator] is a function used by [SExpressionStringifier] to augment the
 /// output produced for a node.  It can be provided to the constructor.
 typedef String Decorator(Node node, String s);
 
 /// Generate a Lisp-like S-expression representation of an IR node as a string.
 class SExpressionStringifier extends Visitor<String> with Indentation {
   final _Namer namer = new _Namer();
 
   String newValueName(Node node) => namer.defineValueName(node);
   String newContinuationName(Node node) => namer.defineContinuationName(node);
-  final Decorator decorator;
+  Decorator decorator;
 
-  SExpressionStringifier([this.decorator]);
+  SExpressionStringifier([this.decorator]) {
+    if (this.decorator == null) {
+      this.decorator = (Node node, String s) => s;
+    }
+  }
 
-  String access(Reference<Definition> r) => namer.getName(r.definition);
+  String access(Reference<Definition> r) {
+    return decorator(r.definition, namer.getName(r.definition));
+  }
 
   String visitParameter(Parameter node) {
     return namer.useElementName(node);
   }
 
   String visitClosureVariable(ClosureVariable node) {
     return namer.getName(node);
   }
 
   /// Main entry point for creating a [String] from a [Node].  All recursive
@@ skipping 33 matching lines @@
     String body = visit(node.body);
     return '$indentation(LetPrim $name $value)\n$body';
   }
 
   String visitLetCont(LetCont node) {
     String cont = newContinuationName(node.continuation);
     // TODO(karlklose): this should be changed to `.map(visit).join(' ')`  and
     // should recurse to [visit].  Currently we can't do that, because the
     // unstringifier_test produces [LetConts] with dummy arguments on them.
     String parameters = node.continuation.parameters
-        .map((p) => ' ${newValueName(p)}')
+        .map((p) => ' ${decorator(p, newValueName(p))}')
         .join('');
     String contBody = indentBlock(() => visit(node.continuation.body));
     String body = visit(node.body);
     String op = node.continuation.isRecursive ? 'LetCont*' : 'LetCont';
     return '$indentation($op ($cont$parameters)\n'
            '$contBody)\n'
            '$body';
   }
 
   String formatArguments(Invoke node) {
@@ skipping 164 matching lines @@
   String useReturnName(Continuation node) {
     assert(!_names.containsKey(node) || _names[node] == 'return');
     return _names[node] = 'return';
   }
 
   String getName(Node node) {
     assert(_names.containsKey(node));
     return _names[node];
   }
 }