Overhaul tree IR visitor and rename IR classes.

pkg/compiler/lib/src/tree_ir/tree_ir_builder.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 tree_ir_builder;
 
 import '../dart2jslib.dart' as dart2js;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../cps_ir/cps_ir_nodes.dart' as cps_ir;
@@ skipping 102 matching lines @@
   /// referred to by [reference].
   /// This increments the reference count for the given variable, so the
   /// returned expression must be used in the tree.
   Expression getVariableUse(cps_ir.Reference<cps_ir.Primitive> reference) {
     if (thisParameter != null && reference.definition == thisParameter) {
       return new This();
     }
     return new VariableUse(getVariable(reference.definition));
   }
 
-  ExecutableDefinition build(cps_ir.ExecutableDefinition node) {
+  RootNode build(cps_ir.RootNode node) {
     // TODO(asgerf): Don't have build AND buildXXX as public API.
     if (node is cps_ir.FieldDefinition) {
       return buildField(node);
     } else if (node is cps_ir.ConstructorDefinition) {
       return buildConstructor(node);
     } else {
       assert(dart2js.invariant(
           CURRENT_ELEMENT_SPANNABLE,
           node is cps_ir.FunctionDefinition,
           message: 'expected FunctionDefinition or FieldDefinition, '
             ' found $node'));
       return buildFunction(node);
     }
   }
 
   FieldDefinition buildField(cps_ir.FieldDefinition node) {
     Statement body;
-    if (node.hasInitializer) {
+    if (!node.isEmpty) {
       currentElement = node.element;
       returnContinuation = node.body.returnContinuation;
 
       phiTempVar = new Variable(node.element, null);
 
       body = visit(node.body);
     }
     return new FieldDefinition(node.element, body);
   }
 
   Variable addFunctionParameter(cps_ir.Definition variable) {
     if (variable is cps_ir.Parameter) {
       return getVariable(variable);
     } else {
       return addMutableVariable(variable as cps_ir.MutableVariable);
     }
   }
 
   FunctionDefinition buildFunction(cps_ir.FunctionDefinition node) {
     currentElement = node.element;
     if (parent != null) {
       // Local function's 'this' refers to enclosing method's 'this'
       thisParameter = parent.thisParameter;
     } else {
       thisParameter = node.thisParameter;
     }
     List<Variable> parameters =
         node.parameters.map(addFunctionParameter).toList();
     Statement body;
-    if (!node.isAbstract) {
+    if (!node.isEmpty) {
       returnContinuation = node.body.returnContinuation;
       phiTempVar = new Variable(node.element, null);
       body = visit(node.body);
     }
 
     return new FunctionDefinition(node.element, parameters,
         body, node.localConstants, node.defaultParameterValues);
   }
 
   ConstructorDefinition buildConstructor(cps_ir.ConstructorDefinition node) {
     currentElement = node.element;
     thisParameter = node.thisParameter;
     List<Variable> parameters =
         node.parameters.map(addFunctionParameter).toList();
     List<Initializer> initializers;
     Statement body;
-    if (!node.isAbstract) {
+    if (!node.isEmpty) {
       initializers = node.initializers.map(visit).toList();
       returnContinuation = node.body.returnContinuation;
 
       phiTempVar = new Variable(node.element, null);
       body = visit(node.body);
     }
 
     return new ConstructorDefinition(node.element, parameters,
         body, initializers, node.localConstants, node.defaultParameterValues);
   }
@@ skipping 144 matching lines @@
     return unexpectedNode(node);
   }
 
   Initializer visitFieldInitializer(cps_ir.FieldInitializer node) {
     returnContinuation = node.body.returnContinuation;
     return new FieldInitializer(node.element, visit(node.body.body));
   }
 
   Initializer visitSuperInitializer(cps_ir.SuperInitializer node) {
     List<Statement> arguments =
-        node.arguments.map((cps_ir.RunnableBody argument) {
+        node.arguments.map((cps_ir.Body argument) {
       returnContinuation = argument.returnContinuation;
       return visit(argument.body);
     }).toList();
     return new SuperInitializer(node.target, node.selector, arguments);
   }
 
   Statement visitLetPrim(cps_ir.LetPrim node) {
     Variable variable = getVariable(node.primitive);
 
     // Don't translate unused primitives.
     if (variable == null) return visit(node.body);
 
     Node definition = visit(node.primitive);
 
     // visitPrimitive returns a Statement without successor if it cannot occur
     // in expression context (currently only the case for FunctionDeclarations).
     if (definition is Statement) {
       definition.next = visit(node.body);
       return definition;
     } else {
       return new Assign(variable, definition, visit(node.body));
     }
   }
 
-  Statement visitRunnableBody(cps_ir.RunnableBody node) {
+  Statement visitBody(cps_ir.Body node) {
     return visit(node.body);
   }
 
   Statement visitLetCont(cps_ir.LetCont node) {
     // Introduce labels for continuations that need them.
     int safeForInliningLengthOnEntry = safeForInlining.length;
     for (cps_ir.Continuation continuation in node.continuations) {
       if (continuation.hasMultipleUses) {
         labels[continuation] = new Label();
       } else {
@@ skipping 251 matching lines @@
   }
 
   @override
   Node visitTypeExpression(cps_ir.TypeExpression node) {
     return new TypeExpression(
         node.dartType,
         node.arguments.map(getVariableUse).toList());
   }
 }