Support local variables in dart2dart.

sdk/lib/_internal/compiler/implementation/ir/ir_tracer.dart

 library dart2js.ir_tracer;
 
 import 'dart:async' show EventSink;
 
 import 'ir_nodes.dart' as ir hide Function;
 import '../tracer.dart';
 
 /**
  * If true, show LetCont expressions in output.
  */
@@ skipping 13 matching lines @@
       visitFunctionDefinition(graph);
     });
   }
 
   // Temporary field used during tree walk
   Names names;
 
   visitFunctionDefinition(ir.FunctionDefinition f) {
     names = new Names();
     BlockCollector builder = new BlockCollector(names);
-    f.accept(builder);
+    builder.visit(f);
 
     printNode(builder.entry);
     for (Block block in builder.cont2block.values) {
       printNode(block);
     }
     names = null;
   }
 
   printNode(Block block) {
     tag("block", () {
       printProperty("name", block.name);
       printProperty("from_bci", -1);
       printProperty("to_bci", -1);
       printProperty("predecessors", block.pred.map((n) => n.name));
       printProperty("successors", block.succ.map((n) => n.name));
       printEmptyProperty("xhandlers");
       printEmptyProperty("flags");
       tag("states", () {
         tag("locals", () {
           printProperty("size", 0);
           printProperty("method", "None");
           // We could print parameters here,
           // but does the hydra tool actually use this info??
         });
       });
       tag("HIR", () {
-        block.body.accept(this);
+        visit(block.body);
       });
     });
   }
 
   void printStmt(String resultVar, String contents) {
     int bci = 0;
     int uses = 0;
     addIndent();
     add("$bci $uses $resultVar $contents <|@\n");
   }
 
   visitLetPrim(ir.LetPrim node) {
     String id = names.name(node.primitive);
     printStmt(id, "LetPrim $id = ${formatPrimitive(node.primitive)}");
-    node.body.accept(this);
+    visit(node.body);
   }
 
   visitLetCont(ir.LetCont node) {
     if (IR_TRACE_LET_CONT) {
       String dummy = names.name(node);
       String id = names.name(node.continuation);
       printStmt(dummy, "LetCont $id = <$id>");
     }
-    node.body.accept(this);
+    visit(node.body);
   }
 
   visitInvokeStatic(ir.InvokeStatic node) {
     String dummy = names.name(node);
     String callName = node.selector.name;
     String args = node.arguments.map(formatReference).join(', ');
     String kont = formatReference(node.continuation);
     printStmt(dummy, "InvokeStatic $callName ($args) $kont");
   }
 
   visitInvokeContinuation(ir.InvokeContinuation node) {
     String dummy = names.name(node);
     String kont = formatReference(node.continuation);
-    String arg = formatReference(node.argument);
-    printStmt(dummy, "InvokeContinuation $kont ($arg)");
+    String args = node.arguments.map(formatReference).join(', ');
+    printStmt(dummy, "InvokeContinuation $kont ($args)");
+  }
+
+  visitBranch(ir.Branch node) {
+    String dummy = names.name(node);
+    String condition = visit(node.condition);
+    String trueCont = formatReference(node.trueContinuation);
+    String falseCont = formatReference(node.falseContinuation);
+    printStmt(dummy, "Branch $condition ($trueCont, $falseCont)");
   }
 
   String formatReference(ir.Reference ref) {
     ir.Definition target = ref.definition;
     if (target is ir.Continuation && target.body == null) {
       return "return"; // Do not generate a name for the return continuation
     } else {
       return names.name(ref.definition);
     }
   }
 
-  String formatPrimitive(ir.Primitive p) {
-    return p.accept(this);
-  }
+  String formatPrimitive(ir.Primitive p) => visit(p);
 
   visitConstant(ir.Constant node) {
     return "Constant ${node.value}";
   }
 
   visitParameter(ir.Parameter node) {
     return "Parameter ${names.name(node)}";
   }
 
   visitContinuation(ir.Continuation node) {
     return "Continuation ${names.name(node)}";
   }
 
+  visitIsTrue(ir.IsTrue node) {
+    return "IsTrue(${names.name(node)})";
+  }
+
+  visitCondition(ir.Condition c) {}
   visitExpression(ir.Expression e) {}
   visitPrimitive(ir.Primitive p) {}
   visitDefinition(ir.Definition d) {}
   visitNode(ir.Node n) {}
 }
 
 /**
  * Invents (and remembers) names for Continuations, Parameters, etc.
  * The names must match the conventions used by IR Hydra, e.g.
  * Continuations and Functions must have names of form B### since they
@@ skipping 56 matching lines @@
     Block block = cont2block[c];
     if (block == null) {
       block = new Block(names.name(c), c.parameters, c.body);
       cont2block[c] = block;
     }
     return block;
   }
 
   visitFunctionDefinition(ir.FunctionDefinition f) {
     entry = current_block = new Block(names.name(f), [], f.body);
-    f.body.accept(this);
+    visit(f.body);
   }
 
   visitLetPrim(ir.LetPrim exp) {
-    exp.body.accept(this);
+    visit(exp.body);
   }
 
   visitLetCont(ir.LetCont exp) {
-    exp.continuation.accept(this);
-    exp.body.accept(this);
+    visit(exp.continuation);
+    visit(exp.body);
   }
 
   visitInvokeStatic(ir.InvokeStatic exp) {
     ir.Definition target = exp.continuation.definition;
     if (target is ir.Continuation && target.body != null) {
       current_block.addEdgeTo(getBlock(target));
     }
   }
 
   visitInvokeContinuation(ir.InvokeContinuation exp) {
     ir.Definition target = exp.continuation.definition;
     if (target is ir.Continuation && target.body != null) {
       current_block.addEdgeTo(getBlock(target));
     }
   }
 
-  visitConstant(ir.Constant constant) {}
-
-  visitParameter(ir.Parameter p) {}
+  visitBranch(ir.Branch exp) {
+    ir.Continuation trueTarget = exp.trueContinuation.definition;
+    if (trueTarget.body != null) {
+      current_block.addEdgeTo(getBlock(trueTarget));
+    }
+    ir.Continuation falseTarget = exp.falseContinuation.definition;
+    if (falseTarget.body != null) {
+      current_block.addEdgeTo(getBlock(falseTarget));
+    }
+  }
 
   visitContinuation(ir.Continuation c) {
     var old_node = current_block;
     current_block = getBlock(c);
-    c.body.accept(this);
+    visit(c.body);
     current_block = old_node;
   }
 }