dart2js cps: Merge JsIrBuilder and IrBuilder.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.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_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 62 matching lines @@
           bailoutMessage = builder.bailoutMessage;
         } else if (builderCallback != null) {
           builderCallback(element, irNode);
         }
         return irNode;
       });
     });
   }
 }
 
-
-/// A tree visitor that builds [ir.Node]s.
+/// Translates the frontend AST of a method to its CPS IR.
 ///
-/// The visit methods add statements using the [irBuilder] and return the last
-/// added statement for trees that represent expressions.
+/// The visitor has an [IrBuilder] which contains an IR fragment to build upon
+/// and the current reaching definition of local variables.
 ///
+/// Visiting a statement or expression extends the IR builder's fragment.
+/// For expressions, the primitive holding the resulting value is returned.
+/// For statements, `null` is returned.
 // TODO(johnniwinther): Implement [SemanticDeclVisitor].
 abstract class IrBuilderVisitor extends ast.Visitor<ir.Primitive>
     with IrBuilderMixin<ast.Node>,
          SemanticSendResolvedMixin<ir.Primitive, dynamic>,
          SendResolverMixin,
          BaseImplementationOfStaticsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfLocalsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfDynamicsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfConstantsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfNewMixin<ir.Primitive, dynamic>,
@@ skipping 2028 matching lines @@
 
   DartType unaliasType(DartType type) => type.unalias(_compiler);
 
   TypeMask getTypeMaskForForeign(NativeBehavior behavior) {
     return TypeMaskFactory.fromNativeBehavior(behavior, _compiler);
   }
 }
 
 /// IR builder specific to the JavaScript backend, coupled to the [JsIrBuilder].
 class JsIrBuilderVisitor extends IrBuilderVisitor {
-  /// Promote the type of [irBuilder] to [JsIrBuilder].
-  JsIrBuilder get irBuilder => super.irBuilder;
-
   JavaScriptBackend get backend => compiler.backend;
 
   /// Result of closure conversion for the current body of code.
   ///
   /// Will be initialized upon entering the body of a function.
   /// It is computed by the [ClosureTranslator].
   ClosureClassMap closureClassMap;
 
   JsIrBuilderVisitor(TreeElements elements,
                      Compiler compiler,
@@ skipping 159 matching lines @@
 
   /// Builds the IR for a constant taken from a different [context].
   ///
   /// Such constants need to be compiled with a different [sourceFile] and
   /// [elements] mapping.
   ir.Primitive inlineConstant(AstElement context, ast.Expression exp) {
     JsIrBuilderVisitor visitor = makeVisitorForContext(context);
     return visitor.withBuilder(irBuilder, () => visitor.translateConstant(exp));
   }
 
-  JsIrBuilder getBuilderFor(Element element) {
-    return new JsIrBuilder(
+  IrBuilder getBuilderFor(Element element) {
+    return new IrBuilder(
         new GlobalProgramInformation(compiler),
         compiler.backend.constants,
         element);
   }
 
   /// Builds the IR for a given constructor.
   ///
   /// 1. Computes the type held in all own or "inherited" type variables.
   /// 2. Evaluates all own or inherited field initializers.
   /// 3. Creates the object and assigns its fields and runtime type.
   /// 4. Calls constructor body and super constructor bodies.
   /// 5. Returns the created object.
   ir.FunctionDefinition buildConstructor(ConstructorElement constructor) {
     // TODO(asgerf): Optimization: If constructor is redirecting, then just
     //               evaluate arguments and call the target constructor.
     constructor = constructor.implementation;
     ClassElement classElement = constructor.enclosingClass.implementation;
 
-    JsIrBuilder builder = getBuilderFor(constructor);
+    IrBuilder builder = getBuilderFor(constructor);
 
     final bool requiresTypeInformation =
         builder.program.requiresRuntimeTypesFor(classElement);
 
     return withBuilder(builder, () {
       // Setup parameters and create a box if anything is captured.
       List<Local> parameters = <Local>[];
       constructor.functionSignature.orderedForEachParameter(
           (ParameterElement p) => parameters.add(p));
 
@@ skipping 30 matching lines @@
       // This could be interleaved with field initialization, but we choose do
       // get it out of the way here to avoid complications with mixins.
       loadTypeVariablesForSuperClasses(classElement);
 
       /// Maps each field from this class or a superclass to its initial value.
       Map<FieldElement, ir.Primitive> fieldValues =
           <FieldElement, ir.Primitive>{};
 
       // -- Evaluate field initializers ---
       // Evaluate field initializers in constructor and super constructors.
-      irBuilder.enterInitializers();
       List<ConstructorElement> constructorList = <ConstructorElement>[];
       evaluateConstructorFieldInitializers(
           constructor, constructorList, fieldValues);
-      irBuilder.leaveInitializers();
 
       // All parameters in all constructors are now bound in the environment.
       // BoxLocals for captured parameters are also in the environment.
       // The initial value of all fields are now bound in [fieldValues].
 
       // --- Create the object ---
       // Get the initial field values in the canonical order.
       List<ir.Primitive> instanceArguments = <ir.Primitive>[];
       classElement.forEachInstanceField((ClassElement c, FieldElement field) {
         ir.Primitive value = fieldValues[field];
@@ skipping 321 matching lines @@
 
     // We compute variables boxed in mutable variables on entry to each try
     // block, not including variables captured by a closure (which are boxed
     // in the heap).  This duplicates some of the work of closure conversion
     // without directly using the results.  This duplication is wasteful and
     // error-prone.
     // TODO(kmillikin): We should combine closure conversion and try/catch
     // variable analysis in some way.
     DartCapturedVariables variables = _analyzeCapturedVariables(node);
     tryStatements = variables.tryStatements;
-    JsIrBuilder builder = getBuilderFor(body);
+    IrBuilder builder = getBuilderFor(body);
 
     return withBuilder(builder, () {
       irBuilder.buildConstructorBodyHeader(getConstructorBodyParameters(body),
                                            getClosureScopeForNode(node));
       visit(node.body);
       return irBuilder.makeFunctionDefinition();
     });
   }
 
   ir.FunctionDefinition buildFunction(FunctionElement element) {
@@ skipping 442 matching lines @@
   }
 
   processSetStatic(ir.SetStatic node) {
     node.body = replacementFor(node.body);
   }
 
   processContinuation(ir.Continuation node) {
     node.body = replacementFor(node.body);
   }
 }