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 '../tree/tree.dart' as ast;
-import '../scanner/scannerlib.dart' show Token, isUserDefinableOperator;
-import '../universe/universe.dart' show SelectorKind;
 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;
-
-part 'cps_ir_builder_visitor.dart';
 
 /// 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 1203 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 504 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);
     }
   }
 
+  // TODO(johnniwinther,asgerf): Should this be public? Currently needed by
+  // [JsIrBuilderVisitor.loadArguments].

[asgerf, 2015/02/11 10:51:14]

I'd say ditch the TODO and just document what the method does. Here is a doc
comment you can use:

/// 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].

[Johnni Winther, 2015/03/05 11:05:53]

Done.

+  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 227 matching lines @@
   ClosureEnvironment(this.selfReference, this.thisLocal, this.freeVariables);
 }
 
 /// Information about which variables are captured by a nested function.
 ///
 /// This is used by the [DartIrBuilder] instead of [ClosureScope] and
 /// [ClosureEnvironment].
 abstract class DartCapturedVariableInfo {
   Iterable<Local> get capturedVariables;
 }