Overhaul tree IR visitor and rename IR classes.

pkg/compiler/lib/src/cps_ir/cps_ir_tracer.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_tracer;
 
 import 'dart:async' show EventSink;
 
 import 'cps_ir_nodes.dart' as cps_ir hide Function;
 import '../tracer.dart';
 
 /**
  * If true, show LetCont expressions in output.
  */
 const bool IR_TRACE_LET_CONT = false;
 
 class IRTracer extends TracerUtil implements cps_ir.Visitor {
   EventSink<String> output;
 
   IRTracer(this.output);
 
   visit(cps_ir.Node node) => node.accept(this);
 
-  void traceGraph(String name, cps_ir.ExecutableDefinition graph) {
+  void traceGraph(String name, cps_ir.RootNode graph) {
     tag("cfg", () {
       printProperty("name", name);
+      if (graph.isEmpty) return;
       visit(graph);

[Kevin Millikin (Google), 2015/04/08 15:10:15]

Maybe this can be disentangled a bit after this change.  Right now:

IRTracer.traceGraph(name, graph) calls
IRTracer.visit(graph) when graph.body is non-null, which just calls
IRTracer.printDefinition(graph), which calls
BlockCollector.visit(graph), which just calls
BlockCollector.visit(graph.body)

meanwhile IRTracer.visitBody is unexpected.

It seems simpler to switch so:

IRTracer.traceGraph(name, graph) calls IRTracer.visit(graph.body) when
graph.body is non-null and just move the definition of printDefinition into
IRTracer.visitBody.

[asgerf, 2015/04/09 09:58:23]

I agree, this code has stagnated quite a bit.

I updated both IR tracers to properly handle the multiple bodies of constructors
and print an explicit 'Entry' statement in front of blocks that are entry
points. They also print the parameter list now, which is nice.

The many bodies of a constructor should be passed to the same block collector so
traversing the top-level nodes in the IRTracer did not work. So they are just
unexpected nodes.

     });
   }
 
   // Temporary field used during tree walk
   Names names;
 
-  printDefinition(cps_ir.ExecutableDefinition node) {
+  printDefinition(cps_ir.RootNode node) {
     names = new Names();
     BlockCollector builder = new BlockCollector(names);
     builder.visit(node);
 
     for (Block block in builder.entries) {
       printBlock(block);
     }
     for (Block block in builder.cont2block.values) {
       printBlock(block);
     }
     names = null;
   }
 
   visitFieldDefinition(cps_ir.FieldDefinition node) {
-    if (node.hasInitializer) {
-      printDefinition(node);
-    }
+    printDefinition(node);
   }
 
   visitFunctionDefinition(cps_ir.FunctionDefinition node) {
-    if (node.isAbstract) return;
     printDefinition(node);
   }
 
   visitConstructorDefinition(cps_ir.ConstructorDefinition node) {
-    if (node.isAbstract) return;
     printDefinition(node);
   }
 
   // Bodies and initializers are not visited.  They contain continuations which
   // are found by a BlockCollector, then those continuations are processed by
   // this visitor.
   unexpectedNode(cps_ir.Node node) {
     throw 'The IR tracer reached an unexpected IR instruction: $node';
   }
 
-  visitRunnableBody(cps_ir.RunnableBody node) {
+  visitBody(cps_ir.Body node) {
     unexpectedNode(node);
   }
   visitFieldInitializer(cps_ir.FieldInitializer node) {
     unexpectedNode(node);
   }
   visitSuperInitializer(cps_ir.SuperInitializer node) {
     unexpectedNode(node);
   }
 
   int countUses(cps_ir.Definition definition) {
@@ skipping 340 matching lines @@
     if (block == null) {
       block = new Block(names.name(c), c.parameters, c.body);
       cont2block[c] = block;
     }
     return block;
   }
 
   visit(cps_ir.Node node) => node.accept(this);
 
   visitFieldDefinition(cps_ir.FieldDefinition node) {
-    if (node.hasInitializer) {
-      visit(node.body);
-    }
+    visit(node.body);
   }
 
   visitFunctionDefinition(cps_ir.FunctionDefinition node) {
     visit(node.body);
   }
 
   visitConstructorDefinition(cps_ir.ConstructorDefinition node) {
     visit(node.body);
   }
 
-  visitRunnableBody(cps_ir.RunnableBody node) {
+  visitBody(cps_ir.Body node) {
     current_block = new Block(names.name(node), [], node.body);
     entries.add(current_block);
     visit(node.body);
   }
 
   visitFieldInitializer(cps_ir.FieldInitializer node) {
     visit(node.body);
   }
 
   visitSuperInitializer(cps_ir.SuperInitializer node) {
@@ skipping 140 matching lines @@
   @override
   visitReifyRuntimeType(cps_ir.ReifyRuntimeType node) {
     unexpectedNode(node);
   }
 
   @override
   visitTypeExpression(cps_ir.TypeExpression node) {
     unexpectedNode(node);
   }
 }