Put IR builder visitors in a different library than IrBuilder.

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';
 import '../elements/elements.dart';
-import '../io/source_file.dart';
 import '../io/source_information.dart';
 import '../tree/tree.dart' as ast;
-import '../scanner/scannerlib.dart' show Token, isUserDefinableOperator;
-import '../universe/universe.dart' show SelectorKind;
+import '../closure.dart' hide ClosureScope;
 import 'cps_ir_nodes.dart' as ir;
-import '../elements/modelx.dart' show SynthesizedConstructorElementX,
-    ConstructorBodyElementX, FunctionSignatureX;
-import '../closure.dart' hide ClosureScope;
-import '../closure.dart' as closurelib;
-import '../js_backend/js_backend.dart' show JavaScriptBackend;
-import '../util/util.dart' show Link;
-
-part 'cps_ir_builder_visitor.dart';
+import 'cps_ir_builder_task.dart' show DartCapturedVariables;
 
 /// A mapping from variable elements to their compile-time values.
 ///
 /// Map elements denoted by parameters and local variables to the
 /// [ir.Primitive] that is their value.  Parameters and locals are
 /// assigned indexes which can be used to refer to them.
 class Environment {
   /// A map from locals to their environment index.
   final Map<Local, int> variable2index;
 
@@ skipping 1441 matching lines @@
   // TODO(johnniwinther): Type [nodes] as `Iterable` when `NodeList` uses
   // `List` instead of `Link`.
   void buildSequence(var nodes, BuildFunction build) {
     for (var node in nodes) {
       if (!isOpen) return;
       build(node);
     }
   }
 
 
+  /// Creates a labeled statement
+  void buildLabeledStatement({SubbuildFunction buildBody,
+                              JumpTarget target}) {
+    JumpCollector jumps = new JumpCollector(target);
+    state.breakCollectors.add(jumps);
+    IrBuilder innerBuilder = makeDelimitedBuilder();
+    buildBody(innerBuilder);
+    state.breakCollectors.removeLast();
+    bool hasBreaks = !jumps.isEmpty;
+    ir.Continuation joinContinuation;
+    if (hasBreaks) {
+      if (innerBuilder.isOpen) {
+        jumps.addJump(innerBuilder);
+      }
+
+      // All jumps to the break continuation must be in the scope of the
+      // continuation's binding.  The continuation is bound just outside the
+      // body to satisfy this property without extra analysis.
+      // As a consequence, the break continuation needs parameters for all
+      // local variables in scope at the exit from the body.
+      List<ir.Parameter> parameters =
+          new List<ir.Parameter>.generate(environment.length, (i) {
+        return new ir.Parameter(environment.index2variable[i]);
+      });
+      joinContinuation = new ir.Continuation(parameters);
+      invokeFullJoin(joinContinuation, jumps, recursive: false);
+      add(new ir.LetCont(joinContinuation, innerBuilder._root));
+      for (int i = 0; i < environment.length; ++i) {
+        environment.index2value[i] = parameters[i];
+      }
+    } else {
+      if (innerBuilder._root != null) {
+        add(innerBuilder._root);
+        _current = innerBuilder._current;
+        environment = innerBuilder.environment;
+      }
+    }
+    return null;
+  }
+
+
   // Build(BreakStatement L, C) = C[InvokeContinuation(...)]
   //
   // The continuation and arguments are filled in later after translating
   // the body containing the break.
   bool buildBreak(JumpTarget target) {
     return buildJumpInternal(target, state.breakCollectors);
   }
 
   // Build(ContinueStatement L, C) = C[InvokeContinuation(...)]
   //
@@ skipping 255 matching lines @@
     return join;
   }
 }
 
 /// Shared state between DartIrBuilders within the same method.
 class DartIrBuilderSharedState {
   /// Maps local variables to their corresponding [MutableVariable] object.
   final Map<Local, ir.MutableVariable> local2mutable =
       <Local, ir.MutableVariable>{};
 
+  // Move this to the IrBuilderVisitor.
   final DartCapturedVariables capturedVariables;
 
   /// Creates a [MutableVariable] for the given local.
   void makeMutableVariable(Local local) {
     ir.MutableVariable variable =
         new ir.MutableVariable(local.executableContext, local);
     local2mutable[local] = variable;
   }
 
   /// [MutableVariable]s that should temporarily be treated as registers.
@@ skipping 250 matching lines @@
     if (env.thisLocal != null && env.freeVariables.containsKey(env.thisLocal)) {
       jsState.receiver = environment.lookup(env.thisLocal);
     }
 
     // If the function has a self-reference, use the value of `this`.
     if (env.selfReference != null) {
       environment.extend(env.selfReference, thisPrim);
     }
   }
 
+  /// Creates a box for [scope.box] and binds the captured variables to
+  /// that box.
+  ///
+  /// The captured variables can subsequently be manipulated with
+  /// [declareLocalVariable], [buildLocalGet], and [buildLocalSet].
+  void enterScope(ClosureScope scope) => _enterScope(scope);
+
   void _enterScope(ClosureScope scope) {
     if (scope == null) return;
     ir.CreateBox boxPrim = new ir.CreateBox();
     add(new ir.LetPrim(boxPrim));
     environment.extend(scope.box, boxPrim);
     boxPrim.useElementAsHint(scope.box);
     scope.capturedVariables.forEach((Local local, ClosureLocation location) {
       assert(!jsState.boxedVariables.containsKey(local));
       if (location.isBox) {
         jsState.boxedVariables[local] = location;
@@ skipping 241 matching lines @@
 // TODO(johnniwinther): Support passing of [DartType] for the exception.
 class CatchClauseInfo {
   final LocalVariableElement exceptionVariable;
   final LocalVariableElement stackTraceVariable;
   final SubbuildFunction buildCatchBlock;
 
   CatchClauseInfo({this.exceptionVariable,
                    this.stackTraceVariable,
                    this.buildCatchBlock});
 }