Overhaul tree IR visitor and rename IR classes.

pkg/compiler/lib/src/cps_ir/cps_ir_builder.dart

 // Copyright (c) 2013, 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_builder;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_types.dart';
 import '../dart2jslib.dart';
@@ skipping 618 matching lines @@
    * such as `foo(){ }`.
    */
   void _ensureReturn() {
     if (!isOpen) return;
     ir.Constant constant = buildNullLiteral();
     add(new ir.InvokeContinuation(state.returnContinuation, [constant]));
     _current = null;
   }
 
   ir.SuperInitializer makeSuperInitializer(ConstructorElement target,
-                                           List<ir.RunnableBody> arguments,
+                                           List<ir.Body> arguments,
                                            Selector selector) {
     return new ir.SuperInitializer(target, arguments, selector);
   }
 
   ir.FieldInitializer makeFieldInitializer(FieldElement element,
-                                           ir.RunnableBody body) {
+                                           ir.Body body) {
     return new ir.FieldInitializer(element, body);
   }
 
   /// Create a [ir.FieldDefinition] for the current [Element] using [_root] as
   /// the body using [initializer] as the initial value.
   ir.FieldDefinition makeFieldDefinition(ir.Primitive initializer) {
     if (initializer == null) {
       return new ir.FieldDefinition.withoutInitializer(state.currentElement);
     } else {
-      ir.RunnableBody body = makeRunnableBody(initializer);
+      ir.Body body = makeBody(initializer);
       return new ir.FieldDefinition(state.currentElement, body);
     }
   }
 
-  ir.RunnableBody makeRunnableBody([ir.Primitive value]) {
+  ir.Body makeBody([ir.Primitive value]) {
     if (value == null) {
       _ensureReturn();
     } else {
       buildReturn(value);
     }
-    return new ir.RunnableBody(_root, state.returnContinuation);
+    return new ir.Body(_root, state.returnContinuation);
   }
 
   /// Create a [ir.FunctionDefinition] for [element] using [_root] as the body.
   ///
   /// Parameters must be created before the construction of the body using
   /// [createFunctionParameter].
   ir.FunctionDefinition makeFunctionDefinition(
       List<ConstantExpression> defaults) {
     FunctionElement element = state.currentElement;
     if (element.isAbstract || element.isExternal) {
       assert(invariant(element, _root == null,
           message: "Non-empty body for abstract method $element: $_root"));
       assert(invariant(element, state.localConstants.isEmpty,
           message: "Local constants for abstract method $element: "
                    "${state.localConstants}"));
       return new ir.FunctionDefinition.abstract(
-          element, state.thisParameter, state.functionParameters, defaults);
+          element, state.functionParameters, defaults);
     } else {
-      ir.RunnableBody body = makeRunnableBody();
+      ir.Body body = makeBody();
       return new ir.FunctionDefinition(
           element, state.thisParameter, state.functionParameters, body,
           state.localConstants, defaults);
     }
   }
 
   /// Create a constructor definition without a body, for representing
   /// external constructors declarations.
   ir.ConstructorDefinition makeAbstractConstructorDefinition(
       List<ConstantExpression> defaults) {
     FunctionElement element = state.currentElement;
     assert(invariant(element, _root == null,
         message: "Non-empty body for external constructor $element: $_root"));
     assert(invariant(element, state.localConstants.isEmpty,
         message: "Local constants for external constructor $element: "
                  "${state.localConstants}"));
     return new ir.ConstructorDefinition.abstract(
         element, state.functionParameters, defaults);
   }
 
   ir.ConstructorDefinition makeConstructorDefinition(
       List<ConstantExpression> defaults, List<ir.Initializer> initializers) {
     FunctionElement element = state.currentElement;
-    ir.RunnableBody body = makeRunnableBody();
+    ir.Body body = makeBody();
     return new ir.ConstructorDefinition(
         element, state.thisParameter, state.functionParameters, body, initializers,
         state.localConstants, defaults);
   }
 
   /// Create a super invocation where the method name and the argument structure
   /// are defined by [selector] and the argument values are defined by
   /// [arguments].
   ir.Primitive buildSuperInvocation(Element target,
                                     Selector selector,
@@ skipping 1865 matching lines @@
 }
 
 /// Synthetic parameter to a JavaScript factory method that takes the type
 /// argument given for the type variable [variable].
 class TypeInformationParameter implements Local {
   final TypeVariableElement variable;
   final ExecutableElement executableContext;
   TypeInformationParameter(this.variable, this.executableContext);
   String get name => variable.name;
 }