Split IrBuilder and IrBuilderVisitor.

sdk/lib/_internal/compiler/implementation/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_backend/dart_backend.dart' show DartBackend;
 import '../dart_types.dart';
@@ skipping 197 matching lines @@
   final List<ir.InvokeContinuation> _invocations = <ir.InvokeContinuation>[];
   final List<Environment> _environments = <Environment>[];
 
   JumpCollector(this.target);
 
   bool get isEmpty => _invocations.isEmpty;
   int get length => _invocations.length;
   List<ir.InvokeContinuation> get invocations => _invocations;
   List<Environment> get environments => _environments;
 
-  void addJump(IrBuilderVisitor builder) {
+  void addJump(IrBuilder builder) {
     ir.InvokeContinuation invoke = new ir.InvokeContinuation.uninitialized();
     builder.add(invoke);
     _invocations.add(invoke);
     _environments.add(builder.environment);
     builder._current = null;
     // TODO(kmillikin): Can we set builder.environment to null to make it
     // less likely to mutate it?
   }
 }
 
+/// Mixin that provided encapsulated access to nested builders.
+class IrBuilderMixin {
+  IrBuilder _irBuilder;
+
+  /// Execute [f] with [builder] as the current builder.
+  withBuilder(IrBuilder builder, f()) {
+    assert(builder != null);
+    IrBuilder prev = _irBuilder;
+    _irBuilder = builder;
+    var result = f();
+    _irBuilder = prev;
+    return result;
+  }
+
+  /// The current builder.
+  IrBuilder get irBuilder {
+    assert(_irBuilder != null);
+    return _irBuilder;
+  }
+}
+
+
+/// Shared state between nested builders.
+class IrBuilderSharedState {
+  final ConstantSystem constantSystem;
+
+  /// A stack of collectors for breaks.
+  final List<JumpCollector> breakCollectors = <JumpCollector>[];
+
+  /// A stack of collectors for continues.
+  final List<JumpCollector> continueCollectors = <JumpCollector>[];
+
+  final List<ConstDeclaration> localConstants = <ConstDeclaration>[];
+
+  final Iterable<Entity> closureLocals;
+
+  final FunctionElement currentFunction;
+
+  final ir.Continuation returnContinuation = new ir.Continuation.retrn();
+
+  IrBuilderSharedState(this.constantSystem,
+                       this.currentFunction,
+                       this.closureLocals);
+}
+
 /// A factory for building the cps IR.
 class IrBuilder {
   // TODO(johnniwinther): Make these field final and remove the default values
   // when [IrBuilder] is a property of [IrBuilderVisitor] instead of a mixin.
-  ConstantSystem constantSystem = DART_CONSTANT_SYSTEM;
 
-  ir.Continuation returnContinuation = new ir.Continuation.retrn();
+  final List<ir.Parameter> _parameters = <ir.Parameter>[];
 
-  List<ir.Parameter> _parameters = <ir.Parameter>[];
+  final IrBuilderSharedState state;
 
   /// A map from variable indexes to their values.
-  Environment environment = new Environment.empty();
-
-  List<ConstDeclaration> _localConstants = <ConstDeclaration>[];
+  Environment environment;
 
   // The IR builder maintains a context, which is an expression with a hole in
   // it.  The hole represents the focus where new expressions can be added.
   // The context is implemented by 'root' which is the root of the expression
   // and 'current' which is the expression that immediately contains the hole.
   // Not all expressions have a hole (e.g., invocations, which always occur in
   // tail position, do not have a hole).  Expressions with a hole have a plug
   // method.
   //
   // Conceptually, visiting a statement takes a context as input and returns
   // either a new context or else an expression without a hole if all
   // control-flow paths through the statement have exited.  An expression
   // without a hole is represented by a (root, current) pair where root is the
   // expression and current is null.
   //
   // Conceptually again, visiting an expression takes a context as input and
   // returns either a pair of a new context and a definition denoting
   // the expression's value, or else an expression without a hole if all
   // control-flow paths through the expression have exited.
   //
   // We do not pass contexts as arguments or return them.  Rather we use the
   // current context (root, current) as the visitor state and mutate current.
   // Visiting a statement returns null; visiting an expression returns the
   // primitive denoting its value.
 
   ir.Expression _root = null;
   ir.Expression _current = null;
 
+  IrBuilder(ConstantSystem constantSystem,
+            FunctionElement currentFunction,
+            Iterable<Entity> closureLocals)
+      : this.state = new IrBuilderSharedState(
+            constantSystem, currentFunction, closureLocals),
+        this.environment = new Environment.empty();
+
+  /// Construct a delimited visitor for visiting a subtree.
+  ///
+  /// The delimited visitor has its own compile-time environment mapping
+  /// local variables to their values, which is initially a copy of the parent
+  /// environment.  It has its own context for building an IR expression, so
+  /// the built expression is not plugged into the parent's context.
+  IrBuilder.delimited(IrBuilder parent)
+      : this.state = parent.state,
+        this.environment = new Environment.from(parent.environment);
+
+  /// Construct a visitor for a recursive continuation.
+  ///
+  /// The recursive continuation builder has fresh parameters (i.e. SSA phis)
+  /// for all the local variables in the parent, because the invocation sites
+  /// of the continuation are not all known when the builder is created.  The
+  /// recursive invocations will be passed values for all the local variables,
+  /// which may be eliminated later if they are redundant---if they take on
+  /// the same value at all invocation sites.
+  IrBuilder.recursive(IrBuilder parent)
+      : this.state = parent.state,
+        this.environment = new Environment.empty() {
+    parent.environment.index2variable.forEach(createParameter);
+  }
+
+
   bool get isOpen => _root == null || _current != null;
 
   /// Create a parameter for [parameterElement] and add it to the current
   /// environment. If [isClosureVariable] marks whether [parameterElement] is
   /// accessed from an inner function.
   void createParameter(LocalElement parameterElement,
                        {bool isClosureVariable: false}) {
     ir.Parameter parameter = new ir.Parameter(parameterElement);
     _parameters.add(parameter);
     if (isClosureVariable) {
       add(new ir.SetClosureVariable(parameterElement, parameter));
     } else {
       environment.extend(parameterElement, parameter);
     }
   }
 
   void declareLocalConstant(LocalVariableElement variableElement,
                             ConstantExpression value) {
-    _localConstants.add(new ConstDeclaration(variableElement, value));
+    state.localConstants.add(new ConstDeclaration(variableElement, value));
   }
 
   void declareLocalVariable(LocalVariableElement variableElement,
                             {ir.Primitive initialValue,
                              bool isClosureVariable: false}) {
     assert(isOpen);
     if (initialValue == null) {
       // TODO(kmillikin): Consider pooling constants.
       // The initial value is null.
-      initialValue = makePrimConst(constantSystem.createNull());
+      initialValue = makePrimConst(state.constantSystem.createNull());
       add(new ir.LetPrim(initialValue));
     }
     if (isClosureVariable) {
       add(new ir.SetClosureVariable(variableElement,
                                     initialValue,
                                     isDeclaration: true));
     } else {
       // In case a primitive was introduced for the initializer expression,
       // use this variable element to help derive a good name for it.
       initialValue.useElementAsHint(variableElement);
@@ skipping 35 matching lines @@
   // are created from analyzer2dart.
   ir.Node buildPrimConst(PrimitiveConstantValue constant) {
     assert(isOpen);
     ir.Node prim = makePrimConst(constant);
     add(new ir.LetPrim(prim));
     return prim;
   }
 
   /// Create an integer literal.
   ir.Constant buildIntegerLiteral(int value) {
-    return buildPrimConst(constantSystem.createInt(value));
+    return buildPrimConst(state.constantSystem.createInt(value));
   }
 
   /// Create an double literal.
   ir.Constant buildDoubleLiteral(double value) {
-    return buildPrimConst(constantSystem.createDouble(value));
+    return buildPrimConst(state.constantSystem.createDouble(value));
   }
 
   /// Create an bool literal.
   ir.Constant buildBooleanLiteral(bool value) {
-    return buildPrimConst(constantSystem.createBool(value));
+    return buildPrimConst(state.constantSystem.createBool(value));
   }
 
   /// Create an null literal.
   ir.Constant buildNullLiteral() {
-    return buildPrimConst(constantSystem.createNull());
+    return buildPrimConst(state.constantSystem.createNull());
   }
 
   /// Create a string literal.
   ir.Constant buildStringLiteral(String value) {
     return buildPrimConst(
-        constantSystem.createString(new ast.DartString.literal(value)));
+        state.constantSystem.createString(new ast.DartString.literal(value)));
   }
 
   /// Create a get access of [local].
   ir.Primitive buildGetLocal(Element local) {
     assert(isOpen);
     return environment.lookup(local);
   }
 
   /// Create a get access of the static [element].
   ir.Primitive buildGetStatic(Element element, Selector selector) {
     assert(isOpen);
     assert(selector.isGetter);
     return continueWithExpression(
         (k) => new ir.InvokeStatic(element, selector, k, []));
   }
 
   /**
    * Add an explicit `return null` for functions that don't have a return
    * statement on each branch. This includes functions with an empty body,
    * such as `foo(){ }`.
    */
   void ensureReturn() {
     if (!isOpen) return;
-    ir.Constant constant = makePrimConst(constantSystem.createNull());
+    ir.Constant constant = makePrimConst(state.constantSystem.createNull());
     add(new ir.LetPrim(constant));
-    add(new ir.InvokeContinuation(returnContinuation, [constant]));
+    add(new ir.InvokeContinuation(state.returnContinuation, [constant]));
     _current = null;
   }
 
   /// Create a [ir.FunctionDefinition] for [element] using [_root] as the body.
   ///
   /// Parameters must be created before the construction of the body using
   /// [createParameter].
   ir.FunctionDefinition buildFunctionDefinition(
       FunctionElement element,
       List<ConstantExpression> defaults) {
     if (!element.isAbstract) {
       ensureReturn();
       return new ir.FunctionDefinition(
-          element, returnContinuation, _parameters, _root,
-          _localConstants, defaults);
+          element, state.returnContinuation, _parameters, _root,
+          state.localConstants, defaults);
     } else {
       assert(invariant(element, _root == null,
           message: "Non-empty body for abstract method $element: $_root"));
-      assert(invariant(element, _localConstants.isEmpty,
+      assert(invariant(element, state.localConstants.isEmpty,
           message: "Local constants for abstract method $element: "
-                   "$_localConstants"));
+                   "${state.localConstants}"));
       return new ir.FunctionDefinition.abstract(
                 element, _parameters, defaults);
     }
   }
 
   /// Create a static invocation of [element] with arguments structure defined
   /// by [selector] and argument values defined by [arguments].
   ir.Primitive buildStaticInvocation(Element element,
                                      Selector selector,
                                      List<ir.Definition> arguments) {
     return continueWithExpression(
         (k) => new ir.InvokeStatic(element, selector, k, arguments));
   }
 
   /// Create a return statement `return value;` or `return;` if [value] is
   /// null.
   void buildReturn([ir.Primitive value]) {
     // Build(Return(e), C) = C'[InvokeContinuation(return, x)]
     //   where (C', x) = Build(e, C)
     //
     // Return without a subexpression is translated as if it were return null.
     assert(isOpen);
     if (value == null) {
-      value = makePrimConst(constantSystem.createNull());
+      value = makePrimConst(state.constantSystem.createNull());
       add(new ir.LetPrim(value));
     }
-    add(new ir.InvokeContinuation(returnContinuation, [value]));
+    add(new ir.InvokeContinuation(state.returnContinuation, [value]));
     _current = null;
   }
 
+  // Build(BreakStatement L, C) = C[InvokeContinuation(...)]

[Johnni Winther, 2014/10/17 10:13:46]

A lot more functionality should be moved to the IrBuilder likes these, but I
leave that for later CLs.

+  //
+  // 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(...)]
+  //
+  // The continuation and arguments are filled in later after translating
+  // the body containing the continue.
+  bool buildContinue(JumpTarget target) {
+    return buildJumpInternal(target, state.continueCollectors);
+  }
+
+  bool buildJumpInternal(JumpTarget target,
+                         Iterable<JumpCollector> collectors) {
+    assert(isOpen);
+    for (JumpCollector collector in collectors) {
+      if (target == collector.target) {
+        collector.addJump(this);
+        return true;
+      }
+    }
+    return false;
+  }
 }
 
 /**
  * A tree visitor that builds [IrNodes]. The visit methods add statements using
  * to the [builder] and return the last added statement for trees that represent
  * an expression.
  */
-class IrBuilderVisitor extends ResolvedVisitor<ir.Primitive> with IrBuilder {
+class IrBuilderVisitor extends ResolvedVisitor<ir.Primitive>
+    with IrBuilderMixin {
   final Compiler compiler;
   final SourceFile sourceFile;
 
   // In SSA terms, join-point continuation parameters are the phis and the
   // continuation invocation arguments are the corresponding phi inputs.  To
   // support name introduction and renaming for source level variables, we use
   // nested (delimited) visitors for constructing subparts of the IR that will
   // need renaming.  Each source variable is assigned an index.
   //
   // Each nested visitor maintains a list of free variable uses in the body.
   // These are implemented as a list of parameters, each with their own use
   // list of references.  When the delimited subexpression is plugged into the
   // surrounding context, the free occurrences can be captured or become free
   // occurrences in the next outer delimited subexpression.
   //
   // Each nested visitor maintains a list that maps indexes of variables
   // assigned in the delimited subexpression to their reaching definition ---
   // that is, the definition in effect at the hole in 'current'.  These are
   // used to determine if a join-point continuation needs to be passed
   // arguments, and what the arguments are.
 
-  /// A stack of collectors for breaks.
-  final List<JumpCollector> breakCollectors;
-  /// A stack of collectors for continues.
-  final List<JumpCollector> continueCollectors;
-
-  FunctionElement currentFunction;
-  final DetectClosureVariables closureLocals;
-
   /// Construct a top-level visitor.
   IrBuilderVisitor(TreeElements elements, this.compiler, this.sourceFile)
-      : breakCollectors = <JumpCollector>[],
-        continueCollectors = <JumpCollector>[],
-        closureLocals = new DetectClosureVariables(elements),
-        super(elements) {
-    constantSystem = compiler.backend.constantSystem;
-  }
-
-  /// Construct a delimited visitor for visiting a subtree.
-  ///
-  /// The delimited visitor has its own compile-time environment mapping
-  /// local variables to their values, which is initially a copy of the parent
-  /// environment.  It has its own context for building an IR expression, so
-  /// the built expression is not plugged into the parent's context.
-  IrBuilderVisitor.delimited(IrBuilderVisitor parent)
-      : compiler = parent.compiler,
-        sourceFile = parent.sourceFile,
-        breakCollectors = parent.breakCollectors,
-        continueCollectors = parent.continueCollectors,
-        currentFunction = parent.currentFunction,
-        closureLocals = parent.closureLocals,
-        super(parent.elements) {
-    constantSystem = parent.constantSystem;
-    returnContinuation = parent.returnContinuation;
-    _localConstants = parent._localConstants;
-    environment = new Environment.from(parent.environment);
-  }
-
-  /// Construct a visitor for a recursive continuation.
-  ///
-  /// The recursive continuation builder has fresh parameters (i.e. SSA phis)
-  /// for all the local variables in the parent, because the invocation sites
-  /// of the continuation are not all known when the builder is created.  The
-  /// recursive invocations will be passed values for all the local variables,
-  /// which may be eliminated later if they are redundant---if they take on
-  /// the same value at all invocation sites.
-  IrBuilderVisitor.recursive(IrBuilderVisitor parent)
-      : compiler = parent.compiler,
-        sourceFile = parent.sourceFile,
-        breakCollectors = parent.breakCollectors,
-        continueCollectors = parent.continueCollectors,
-        currentFunction = parent.currentFunction,
-        closureLocals = parent.closureLocals,
-        super(parent.elements) {
-    constantSystem = parent.constantSystem;
-    returnContinuation = parent.returnContinuation;
-    _localConstants = parent._localConstants;
-    parent.environment.index2variable.forEach(createParameter);
-  }
+      : super(elements);
 
   /**
    * Builds the [ir.FunctionDefinition] for a function element. In case the
    * function uses features that cannot be expressed in the IR, this function
    * returns `null`.
    */
   ir.FunctionDefinition buildFunction(FunctionElement functionElement) {
     return nullIfGiveup(() => buildFunctionInternal(functionElement));
   }
 
   ir.FunctionDefinition buildFunctionInternal(FunctionElement element) {
     assert(invariant(element, element.isImplementation));
-    currentFunction = element;
     ast.FunctionExpression function = element.node;
     assert(function != null);
     assert(!function.modifiers.isExternal);
     assert(elements[function] != null);
 
+    DetectClosureVariables closureLocals = new DetectClosureVariables(elements);
     closureLocals.visit(function);
 
-    _root = _current = null;
+    return withBuilder(
+        new IrBuilder(compiler.backend.constantSystem,
+                      element, closureLocals.usedFromClosure),
+        () {
+      FunctionSignature signature = element.functionSignature;
+      signature.orderedForEachParameter((ParameterElement parameterElement) {
+        irBuilder.createParameter(
+            parameterElement,
+            isClosureVariable: isClosureVariable(parameterElement));
+      });
 
-    FunctionSignature signature = element.functionSignature;
-    signature.orderedForEachParameter((ParameterElement parameterElement) {
-      createParameter(parameterElement,
-                      isClosureVariable: isClosureVariable(parameterElement));
+      List<ConstantExpression> defaults = new List<ConstantExpression>();
+      signature.orderedOptionalParameters.forEach((ParameterElement element) {
+        defaults.add(getConstantForVariable(element));
+      });
+
+      visit(function.body);
+      return irBuilder.buildFunctionDefinition(element, defaults);
     });
-
-    List<ConstantExpression> defaults = new List<ConstantExpression>();
-    signature.orderedOptionalParameters.forEach((ParameterElement element) {
-      defaults.add(getConstantForVariable(element));
-    });
-
-    visit(function.body);
-    return buildFunctionDefinition(element, defaults);
   }
 
   ir.Primitive visit(ast.Node node) => node.accept(this);
 
   // ==== Statements ====
   // Build(Block(stamements), C) = C'
   //   where C' = statements.fold(Build, C)
   ir.Primitive visitBlock(ast.Block node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     for (ast.Node n in node.statements.nodes) {
       visit(n);
-      if (!isOpen) return null;
+      if (!irBuilder.isOpen) return null;
     }
     return null;
   }
 
-  // Build(BreakStatement L, C) = C[InvokeContinuation(...)]
-  //
-  // The continuation and arguments are filled in later after translating
-  // the body containing the break.
   ir.Primitive visitBreakStatement(ast.BreakStatement node) {
-    assert(isOpen);
-    JumpTarget target = elements.getTargetOf(node);
-    for (JumpCollector collector in breakCollectors) {
-      if (target == collector.target) {
-        collector.addJump(this);
-        return null;
-      }
+    if (!irBuilder.buildBreak(elements.getTargetOf(node))) {
+      compiler.internalError(node, "'break' target not found");
     }
-    compiler.internalError(node, "'break' target not found");
     return null;
   }
 
-  // Build(ContinueStatement L, C) = C[InvokeContinuation(...)]
-  //
-  // The continuation and arguments are filled in later after translating
-  // the body containing the continue.
   ir.Primitive visitContinueStatement(ast.ContinueStatement node) {
-    assert(isOpen);
-    JumpTarget target = elements.getTargetOf(node);
-    for (JumpCollector collector in continueCollectors) {
-      if (target == collector.target) {
-        collector.addJump(this);
-        return null;
-      }
+    if (!irBuilder.buildContinue(elements.getTargetOf(node))) {
+      compiler.internalError(node, "'continue' target not found");
     }
-    compiler.internalError(node, "'continue' target not found");
     return null;
   }
 
   // Build(EmptyStatement, C) = C
   ir.Primitive visitEmptyStatement(ast.EmptyStatement node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     return null;
   }
 
   // Build(ExpressionStatement(e), C) = C'
   //   where (C', _) = Build(e, C)
   ir.Primitive visitExpressionStatement(ast.ExpressionStatement node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     visit(node.expression);
     return null;
   }
 
 
   /// Create a non-recursive join-point continuation.
   ///
   /// Given the environment length at the join point and a list of
   /// jumps that should reach the join point, create a join-point
   /// continuation.  The join-point continuation has a parameter for each
@@ skipping 81 matching lines @@
 
     // Mutate this.environment to be the environment at the join point.  Do
     // this after adding the continuation invocations, because this.environment
     // might be collected by the jump collector and so the old environment
     // values are needed for the continuation invocation.
     //
     // Iterate to environment.length because environmentLength includes values
     // outside the environment which are 'phantom' variables used for the
     // values of expressions like &&, ||, and ?:.
     index = 0;
-    for (int i = 0; i < environment.length; ++i) {
+    for (int i = 0; i < irBuilder.environment.length; ++i) {
       if (common[i] == null) {
-        environment.index2value[i] = parameters[index++];
+        irBuilder.environment.index2value[i] = parameters[index++];
       }
     }
 
     return join;
   }
 
   /// Invoke a join-point continuation that contains arguments for all local
   /// variables.
   ///
   /// Given the continuation and a list of uninitialized invocations, fill
   /// in each invocation with the continuation and appropriate arguments.
   void invokeFullJoin(ir.Continuation join,
                       JumpCollector jumps,
                       {recursive: false}) {
     join.isRecursive = recursive;
     for (int i = 0; i < jumps.length; ++i) {
       Environment currentEnvironment = jumps.environments[i];
       ir.InvokeContinuation invoke = jumps.invocations[i];
       invoke.continuation = new ir.Reference(join);
       invoke.arguments = new List<ir.Reference>.generate(
           join.parameters.length,
           (i) => new ir.Reference(currentEnvironment[i]));
       invoke.isRecursive = recursive;
     }
   }
 
   ir.Primitive visitFor(ast.For node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     // TODO(kmillikin,sigurdm): Handle closure variables declared in a for-loop.
     if (node.initializer is ast.VariableDefinitions) {
       ast.VariableDefinitions definitions = node.initializer;
       for (ast.Node definition in definitions.definitions.nodes) {
         Element element = elements[definition];
         if (isClosureVariable(element)) {
           return giveup(definition, 'Closure variable in for loop initializer');
         }
       }
     }
@@ skipping 15 matching lines @@
     // loop(v, ...)
     //
     // If there are no breaks in the body, the break continuation is inlined
     // in the exit continuation (i.e., the translation of the successor
     // statement occurs in the exit continuation).  If there is only one
     // invocation of the continue continuation (i.e., no continues in the
     // body), the continue continuation is inlined in the body.
 
     if (node.initializer != null) visit(node.initializer);
 
-    IrBuilderVisitor condBuilder = new IrBuilderVisitor.recursive(this);
+    IrBuilder condBuilder = new IrBuilder.recursive(irBuilder);
     ir.Primitive condition;
     if (node.condition == null) {
       // If the condition is empty then the body is entered unconditionally.
-      condition = makePrimConst(constantSystem.createBool(true));
+      condition = irBuilder.makePrimConst(
+          irBuilder.state.constantSystem.createBool(true));
       condBuilder.add(new ir.LetPrim(condition));
     } else {
-      condition = condBuilder.visit(node.condition);
+      condition = withBuilder(condBuilder, () => visit(node.condition));
     }
 
     JumpTarget target = elements.getTargetDefinition(node);
     JumpCollector breakCollector = new JumpCollector(target);
     JumpCollector continueCollector = new JumpCollector(target);
-    breakCollectors.add(breakCollector);
-    continueCollectors.add(continueCollector);
+    irBuilder.state.breakCollectors.add(breakCollector);
+    irBuilder.state.continueCollectors.add(continueCollector);
 
-    IrBuilderVisitor bodyBuilder = new IrBuilderVisitor.delimited(condBuilder);
-    bodyBuilder.visit(node.body);
-    assert(breakCollectors.last == breakCollector);
-    assert(continueCollectors.last == continueCollector);
-    breakCollectors.removeLast();
-    continueCollectors.removeLast();
+    IrBuilder bodyBuilder = new IrBuilder.delimited(condBuilder);
+    withBuilder(bodyBuilder, () => visit(node.body));
+    assert(irBuilder.state.breakCollectors.last == breakCollector);
+    assert(irBuilder.state.continueCollectors.last == continueCollector);
+    irBuilder.state.breakCollectors.removeLast();
+    irBuilder.state.continueCollectors.removeLast();
 
     // The binding of the continue continuation should occur as late as
     // possible, that is, at the nearest common ancestor of all the continue
     // sites in the body.  However, that is difficult to compute here, so it
     // is instead placed just outside the body of the body continuation.
     bool hasContinues = !continueCollector.isEmpty;
-    IrBuilderVisitor updateBuilder = hasContinues
-        ? new IrBuilderVisitor.recursive(condBuilder)
+    IrBuilder updateBuilder = hasContinues
+        ? new IrBuilder.recursive(condBuilder)
         : bodyBuilder;
     for (ast.Node n in node.update) {
       if (!updateBuilder.isOpen) break;
-      updateBuilder.visit(n);
+      withBuilder(updateBuilder, () => visit(n));
     }
 
     // Create body entry and loop exit continuations and a branch to them.
     ir.Continuation bodyContinuation = new ir.Continuation([]);
     ir.Continuation exitContinuation = new ir.Continuation([]);
     ir.LetCont branch =
         new ir.LetCont(exitContinuation,
             new ir.LetCont(bodyContinuation,
                 new ir.Branch(new ir.IsTrue(condition),
                               bodyContinuation,
@@ skipping 29 matching lines @@
     // only after it is guaranteed that they are not empty.
     if (hasContinues) {
       continueContinuation.body = updateBuilder._root;
       bodyContinuation.body =
           new ir.LetCont(continueContinuation, bodyBuilder._root);
     } else {
       bodyContinuation.body = bodyBuilder._root;
     }
 
     loopContinuation.body = condBuilder._root;
-    add(new ir.LetCont(loopContinuation,
+    irBuilder.add(new ir.LetCont(loopContinuation,
             new ir.InvokeContinuation(loopContinuation,
-                                      environment.index2value)));
+                irBuilder.environment.index2value)));
     if (hasBreaks) {
-      _current = branch;
-      environment = condBuilder.environment;
-      breakCollector.addJump(this);
-      letJoin.continuation = createJoin(environment.length, breakCollector);
-      _current = letJoin;
+      irBuilder._current = branch;
+      irBuilder.environment = condBuilder.environment;
+      breakCollector.addJump(irBuilder);
+      letJoin.continuation =
+          createJoin(irBuilder.environment.length, breakCollector);
+      irBuilder._current = letJoin;
     } else {
-      _current = condBuilder._current;
-      environment = condBuilder.environment;
+      irBuilder._current = condBuilder._current;
+      irBuilder.environment = condBuilder.environment;
     }
     return null;
   }
 
   ir.Primitive visitIf(ast.If node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     ir.Primitive condition = visit(node.condition);
 
     // The then and else parts are delimited.
-    IrBuilderVisitor thenBuilder = new IrBuilderVisitor.delimited(this);
-    IrBuilderVisitor elseBuilder = new IrBuilderVisitor.delimited(this);
-    thenBuilder.visit(node.thenPart);
-    if (node.hasElsePart) elseBuilder.visit(node.elsePart);
+    IrBuilder thenBuilder = new IrBuilder.delimited(irBuilder);
+    IrBuilder elseBuilder = new IrBuilder.delimited(irBuilder);
+    withBuilder(thenBuilder, () => visit(node.thenPart));
+    if (node.hasElsePart) {
+      withBuilder(elseBuilder, () => visit(node.elsePart));
+    }
 
     // Build the term
     // (Result =) let cont then() = [[thenPart]] in
     //            let cont else() = [[elsePart]] in
     //              if condition (then, else)
     ir.Continuation thenContinuation = new ir.Continuation([]);
     ir.Continuation elseContinuation = new ir.Continuation([]);
     ir.Expression letElse =
         new ir.LetCont(elseContinuation,
           new ir.Branch(new ir.IsTrue(condition),
                         thenContinuation,
                         elseContinuation));
     ir.Expression letThen = new ir.LetCont(thenContinuation, letElse);
     ir.Expression result = letThen;
 
     ir.Continuation joinContinuation;  // Null if there is no join.
     if (thenBuilder.isOpen && elseBuilder.isOpen) {
       // There is a join-point continuation.  Build the term
       // 'let cont join(x, ...) = [] in Result' and plug invocations of the
       // join-point continuation into the then and else continuations.
       JumpCollector jumps = new JumpCollector(null);
       jumps.addJump(thenBuilder);
       jumps.addJump(elseBuilder);
-      joinContinuation = createJoin(environment.length, jumps);
+      joinContinuation = createJoin(irBuilder.environment.length, jumps);
       result = new ir.LetCont(joinContinuation, result);
     }
 
     // The then or else term root could be null, but not both.  If there is
     // a join then an InvokeContinuation was just added to both of them.  If
     // there is no join, then at least one of them is closed and thus has a
     // non-null root by the definition of the predicate isClosed.  In the
     // case that one of them is null, it must be the only one that is open
     // and thus contains the new hole in the context.  This case is handled
     // after the branch is plugged into the current hole.
     thenContinuation.body = thenBuilder._root;
     elseContinuation.body = elseBuilder._root;
 
-    add(result);
+    irBuilder.add(result);
     if (joinContinuation == null) {
       // At least one subexpression is closed.
       if (thenBuilder.isOpen) {
-        _current = (thenBuilder._root == null) ? letThen : thenBuilder._current;
-        environment = thenBuilder.environment;
+        irBuilder._current =
+            (thenBuilder._root == null) ? letThen : thenBuilder._current;
+        irBuilder.environment = thenBuilder.environment;
       } else if (elseBuilder.isOpen) {
-        _current = (elseBuilder._root == null) ? letElse : elseBuilder._current;
-        environment = elseBuilder.environment;
+        irBuilder._current =
+            (elseBuilder._root == null) ? letElse : elseBuilder._current;
+        irBuilder.environment = elseBuilder.environment;
       } else {
-        _current = null;
+        irBuilder._current = null;
       }
     }
     return null;
   }
 
   ir.Primitive visitLabeledStatement(ast.LabeledStatement node) {
     ast.Statement body = node.statement;
     return body is ast.Loop
         ? visit(body)
         : giveup(node, 'labeled statement');
   }
 
   ir.Primitive visitWhile(ast.While node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     // While loops use four named continuations: the entry to the body, the
     // loop exit, the loop back edge (continue), and the loop exit (break).
     // The CPS translation of [[while (condition) body; successor]] is:
     //
     // let cont continue(x, ...) =
     //     let prim cond = [[condition]] in
     //     let cont break() = [[successor]] in
     //     let cont exit() = break(v, ...) in
     //     let cont body() = [[body]]; continue(v, ...) in
     //     branch cond (body, exit) in
     // continue(v, ...)
     //
     // If there are no breaks in the body, the break continuation is inlined
     // in the exit continuation (i.e., the translation of the successor
     // statement occurs in the exit continuation).
 
     // The condition and body are delimited.
-    IrBuilderVisitor condBuilder = new IrBuilderVisitor.recursive(this);
-    ir.Primitive condition = condBuilder.visit(node.condition);
+    IrBuilder condBuilder = new IrBuilder.recursive(irBuilder);
+    ir.Primitive condition =
+        withBuilder(condBuilder, () => visit(node.condition));
 
     JumpTarget target = elements.getTargetDefinition(node);
     JumpCollector breakCollector = new JumpCollector(target);
     JumpCollector continueCollector = new JumpCollector(target);
-    breakCollectors.add(breakCollector);
-    continueCollectors.add(continueCollector);
+    irBuilder.state.breakCollectors.add(breakCollector);
+    irBuilder.state.continueCollectors.add(continueCollector);
 
-    IrBuilderVisitor bodyBuilder = new IrBuilderVisitor.delimited(condBuilder);
-    bodyBuilder.visit(node.body);
-    assert(breakCollectors.last == breakCollector);
-    assert(continueCollectors.last == continueCollector);
-    breakCollectors.removeLast();
-    continueCollectors.removeLast();
+    IrBuilder bodyBuilder = new IrBuilder.delimited(condBuilder);
+    withBuilder(bodyBuilder, () => visit(node.body));
+    assert(irBuilder.state.breakCollectors.last == breakCollector);
+    assert(irBuilder.state.continueCollectors.last == continueCollector);
+    irBuilder.state.breakCollectors.removeLast();
+    irBuilder.state.continueCollectors.removeLast();
 
     // Create body entry and loop exit continuations and a branch to them.
     ir.Continuation bodyContinuation = new ir.Continuation([]);
     ir.Continuation exitContinuation = new ir.Continuation([]);
     ir.LetCont branch =
         new ir.LetCont(exitContinuation,
             new ir.LetCont(bodyContinuation,
                 new ir.Branch(new ir.IsTrue(condition),
                               bodyContinuation,
                               exitContinuation)));
     // If there are breaks in the body, then there must be a join-point
     // continuation for the normal exit and the breaks.
     bool hasBreaks = !breakCollector.isEmpty;
     ir.LetCont letJoin;
     if (hasBreaks) {
       letJoin = new ir.LetCont(null, branch);
       condBuilder.add(letJoin);
       condBuilder._current = branch;
     } else {
       condBuilder.add(branch);
     }
     ir.Continuation loopContinuation =
         new ir.Continuation(condBuilder._parameters);
     if (bodyBuilder.isOpen) continueCollector.addJump(bodyBuilder);
     invokeFullJoin(loopContinuation, continueCollector, recursive: true);
     bodyContinuation.body = bodyBuilder._root;
 
     loopContinuation.body = condBuilder._root;
-    add(new ir.LetCont(loopContinuation,
+    irBuilder.add(new ir.LetCont(loopContinuation,
             new ir.InvokeContinuation(loopContinuation,
-                                      environment.index2value)));
+                                      irBuilder.environment.index2value)));
     if (hasBreaks) {
-      _current = branch;
-      environment = condBuilder.environment;
-      breakCollector.addJump(this);
-      letJoin.continuation = createJoin(environment.length, breakCollector);
-      _current = letJoin;
+      irBuilder._current = branch;
+      irBuilder.environment = condBuilder.environment;
+      breakCollector.addJump(irBuilder);
+      letJoin.continuation =
+          createJoin(irBuilder.environment.length, breakCollector);
+      irBuilder._current = letJoin;
     } else {
-      _current = condBuilder._current;
-      environment = condBuilder.environment;
+      irBuilder._current = condBuilder._current;
+      irBuilder.environment = condBuilder.environment;
     }
     return null;
   }
 
   ir.Primitive visitForIn(ast.ForIn node) {
     // The for-in loop
     //
     // for (a in e) s;
     //
     // Is compiled analogously to:
     //
     // a = e.iterator;
     // while (a.moveNext()) {
     //   var n0 = a.current;
     //   s;
     // }
 
     // The condition and body are delimited.
-    IrBuilderVisitor condBuilder = new IrBuilderVisitor.recursive(this);
+    IrBuilder condBuilder = new IrBuilder.recursive(irBuilder);
 
     ir.Primitive expressionReceiver = visit(node.expression);
     List<ir.Primitive> emptyArguments = new List<ir.Primitive>();
 
     ir.Parameter iterator = new ir.Parameter(null);
     ir.Continuation iteratorInvoked = new ir.Continuation([iterator]);
-    add(new ir.LetCont(iteratorInvoked,
+    irBuilder.add(new ir.LetCont(iteratorInvoked,
         new ir.InvokeMethod(expressionReceiver,
             new Selector.getter("iterator", null), iteratorInvoked,
             emptyArguments)));
 
     ir.Parameter condition = new ir.Parameter(null);
     ir.Continuation moveNextInvoked = new ir.Continuation([condition]);
     condBuilder.add(new ir.LetCont(moveNextInvoked,
         new ir.InvokeMethod(iterator,
             new Selector.call("moveNext", null, 0),
             moveNextInvoked, emptyArguments)));
 
     JumpTarget target = elements.getTargetDefinition(node);
     JumpCollector breakCollector = new JumpCollector(target);
     JumpCollector continueCollector = new JumpCollector(target);
-    breakCollectors.add(breakCollector);
-    continueCollectors.add(continueCollector);
+    irBuilder.state.breakCollectors.add(breakCollector);
+    irBuilder.state.continueCollectors.add(continueCollector);
 
-    IrBuilderVisitor bodyBuilder = new IrBuilderVisitor.delimited(condBuilder);
+    IrBuilder bodyBuilder = new IrBuilder.delimited(condBuilder);
     ast.Node identifier = node.declaredIdentifier;
     Element variableElement = elements.getForInVariable(node);
     Selector selector = elements.getSelector(identifier);
 
     // node.declaredIdentifier can be either an ast.VariableDefinitions
     // (defining a new local variable) or a send designating some existing
     // variable.
     ast.Node declaredIdentifier = node.declaredIdentifier;
 
     if (declaredIdentifier is ast.VariableDefinitions) {
-      bodyBuilder.visit(declaredIdentifier);
+      withBuilder(bodyBuilder, () => visit(declaredIdentifier));
     }
 
     ir.Parameter currentValue = new ir.Parameter(null);
     ir.Continuation currentInvoked = new ir.Continuation([currentValue]);
     bodyBuilder.add(new ir.LetCont(currentInvoked,
         new ir.InvokeMethod(iterator, new Selector.getter("current", null),
             currentInvoked, emptyArguments)));
     if (Elements.isLocal(variableElement)) {
-      bodyBuilder.setLocal(variableElement, currentValue);
+      withBuilder(bodyBuilder, () => setLocal(variableElement, currentValue));
     } else if (Elements.isStaticOrTopLevel(variableElement)) {
-      bodyBuilder.setStatic(variableElement, selector, currentValue);
+      withBuilder(bodyBuilder,
+          () => setStatic(variableElement, selector, currentValue));
     } else {
-      ir.Primitive receiver = bodyBuilder.lookupThis();
-      bodyBuilder.setDynamic(null, receiver, selector, currentValue);
+      ir.Primitive receiver =
+          withBuilder(bodyBuilder, () => lookupThis());
+      withBuilder(bodyBuilder,
+          () => setDynamic(null, receiver, selector, currentValue));
     }
 
-    bodyBuilder.visit(node.body);
-    assert(breakCollectors.last == breakCollector);
-    assert(continueCollectors.last == continueCollector);
-    breakCollectors.removeLast();
-    continueCollectors.removeLast();
+    withBuilder(bodyBuilder, () => visit(node.body));
+    assert(irBuilder.state.breakCollectors.last == breakCollector);
+    assert(irBuilder.state.continueCollectors.last == continueCollector);
+    irBuilder.state.breakCollectors.removeLast();
+    irBuilder.state.continueCollectors.removeLast();
 
     // Create body entry and loop exit continuations and a branch to them.
     ir.Continuation bodyContinuation = new ir.Continuation([]);
     ir.Continuation exitContinuation = new ir.Continuation([]);
     ir.LetCont branch =
         new ir.LetCont(exitContinuation,
             new ir.LetCont(bodyContinuation,
                 new ir.Branch(new ir.IsTrue(condition),
                               bodyContinuation,
                               exitContinuation)));
     // If there are breaks in the body, then there must be a join-point
     // continuation for the normal exit and the breaks.
     bool hasBreaks = !breakCollector.isEmpty;
     ir.LetCont letJoin;
     if (hasBreaks) {
       letJoin = new ir.LetCont(null, branch);
       condBuilder.add(letJoin);
       condBuilder._current = branch;
     } else {
       condBuilder.add(branch);
     }
     ir.Continuation loopContinuation =
         new ir.Continuation(condBuilder._parameters);
     if (bodyBuilder.isOpen) continueCollector.addJump(bodyBuilder);
     invokeFullJoin(loopContinuation, continueCollector, recursive: true);
     bodyContinuation.body = bodyBuilder._root;
 
     loopContinuation.body = condBuilder._root;
-    add(new ir.LetCont(loopContinuation,
+    irBuilder.add(new ir.LetCont(loopContinuation,
             new ir.InvokeContinuation(loopContinuation,
-                                      environment.index2value)));
+                                      irBuilder.environment.index2value)));
     if (hasBreaks) {
-      _current = branch;
-      environment = condBuilder.environment;
-      breakCollector.addJump(this);
-      letJoin.continuation = createJoin(environment.length, breakCollector);
-      _current = letJoin;
+      irBuilder._current = branch;
+      irBuilder.environment = condBuilder.environment;
+      breakCollector.addJump(irBuilder);
+      letJoin.continuation =
+          createJoin(irBuilder.environment.length, breakCollector);
+      irBuilder._current = letJoin;
     } else {
-      _current = condBuilder._current;
-      environment = condBuilder.environment;
+      irBuilder._current = condBuilder._current;
+      irBuilder.environment = condBuilder.environment;
     }
     return null;
   }
 
   ir.Primitive visitVariableDefinitions(ast.VariableDefinitions node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     if (node.modifiers.isConst) {
       for (ast.SendSet definition in node.definitions.nodes) {
         assert(!definition.arguments.isEmpty);
         assert(definition.arguments.tail.isEmpty);
         VariableElement element = elements[definition];
         ConstantExpression value = getConstantForVariable(element);
-        declareLocalConstant(element, value);
+        irBuilder.declareLocalConstant(element, value);
       }
     } else {
       for (ast.Node definition in node.definitions.nodes) {
         Element element = elements[definition];
         ir.Primitive initialValue;
         // Definitions are either SendSets if there is an initializer, or
         // Identifiers if there is no initializer.
         if (definition is ast.SendSet) {
           assert(!definition.arguments.isEmpty);
           assert(definition.arguments.tail.isEmpty);
           initialValue = visit(definition.arguments.head);
         } else {
           assert(definition is ast.Identifier);
         }
-        declareLocalVariable(element,
-                             initialValue: initialValue,
-                             isClosureVariable: isClosureVariable(element));
+        irBuilder.declareLocalVariable(element,
+            initialValue: initialValue,
+            isClosureVariable: isClosureVariable(element));
       }
     }
     return null;
   }
 
   // Build(Return(e), C) = C'[InvokeContinuation(return, x)]
   //   where (C', x) = Build(e, C)
   //
   // Return without a subexpression is translated as if it were return null.
   ir.Primitive visitReturn(ast.Return node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     assert(invariant(node, node.beginToken.value != 'native'));
     if (node.expression == null) {
-      buildReturn();
+      irBuilder.buildReturn();
     } else {
-      buildReturn(visit(node.expression));
+      irBuilder.buildReturn(visit(node.expression));
     }
     return null;
   }
 
   // ==== Expressions ====
   ir.Primitive visitConditional(ast.Conditional node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     ir.Primitive condition = visit(node.condition);
 
     // The then and else expressions are delimited.
-    IrBuilderVisitor thenBuilder = new IrBuilderVisitor.delimited(this);
-    IrBuilderVisitor elseBuilder = new IrBuilderVisitor.delimited(this);
-    ir.Primitive thenValue = thenBuilder.visit(node.thenExpression);
-    ir.Primitive elseValue = elseBuilder.visit(node.elseExpression);
+    IrBuilder thenBuilder = new IrBuilder.delimited(irBuilder);
+    IrBuilder elseBuilder = new IrBuilder.delimited(irBuilder);
+    ir.Primitive thenValue =
+        withBuilder(thenBuilder, () => visit(node.thenExpression));
+    ir.Primitive elseValue =
+        withBuilder(elseBuilder, () => visit(node.elseExpression));
 
     // Treat the values of the subexpressions as named values in the
     // environment, so they will be treated as arguments to the join-point
     // continuation.
-    assert(environment.length == thenBuilder.environment.length);
-    assert(environment.length == elseBuilder.environment.length);
+    assert(irBuilder.environment.length == thenBuilder.environment.length);
+    assert(irBuilder.environment.length == elseBuilder.environment.length);
     thenBuilder.environment.extend(null, thenValue);
     elseBuilder.environment.extend(null, elseValue);
     JumpCollector jumps = new JumpCollector(null);
     jumps.addJump(thenBuilder);
     jumps.addJump(elseBuilder);
     ir.Continuation joinContinuation =
-        createJoin(environment.length + 1, jumps);
+        createJoin(irBuilder.environment.length + 1, jumps);
 
     // Build the term
     //   let cont join(x, ..., result) = [] in
     //   let cont then() = [[thenPart]]; join(v, ...) in
     //   let cont else() = [[elsePart]]; join(v, ...) in
     //     if condition (then, else)
     ir.Continuation thenContinuation = new ir.Continuation([]);
     ir.Continuation elseContinuation = new ir.Continuation([]);
     thenContinuation.body = thenBuilder._root;
     elseContinuation.body = elseBuilder._root;
-    add(new ir.LetCont(joinContinuation,
+    irBuilder.add(new ir.LetCont(joinContinuation,
             new ir.LetCont(thenContinuation,
                 new ir.LetCont(elseContinuation,
                     new ir.Branch(new ir.IsTrue(condition),
                                   thenContinuation,
                                   elseContinuation)))));
     return (thenValue == elseValue)
         ? thenValue
         : joinContinuation.parameters.last;
   }
 
   // For all simple literals:
   // Build(Literal(c), C) = C[let val x = Constant(c) in [], x]
   ir.Primitive visitLiteralBool(ast.LiteralBool node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     return translateConstant(node);
   }
 
   ir.Primitive visitLiteralDouble(ast.LiteralDouble node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     return translateConstant(node);
   }
 
   ir.Primitive visitLiteralInt(ast.LiteralInt node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     return translateConstant(node);
   }
 
   ir.Primitive visitLiteralNull(ast.LiteralNull node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     return translateConstant(node);
   }
 
   ir.Primitive visitLiteralString(ast.LiteralString node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     return translateConstant(node);
   }
 
   ConstantExpression getConstantForNode(ast.Node node) {
     ConstantExpression constant =
         compiler.backend.constantCompilerTask.compileNode(node, elements);
     assert(invariant(node, constant != null,
         message: 'No constant computed for $node'));
     return constant;
   }
 
   ConstantExpression getConstantForVariable(VariableElement element) {
     ConstantExpression constant =
         compiler.backend.constants.getConstantForVariable(element);
     assert(invariant(element, constant != null,
             message: 'No constant computed for $element'));
     return constant;
   }
 
   ir.Primitive visitLiteralList(ast.LiteralList node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     if (node.isConst) {
       return translateConstant(node);
     }
     List<ir.Primitive> values = node.elements.nodes.mapToList(visit);
     GenericType type = elements.getType(node);
     ir.Primitive result = new ir.LiteralList(type, values);
-    add(new ir.LetPrim(result));
+    irBuilder.add(new ir.LetPrim(result));
     return result;
   }
 
   ir.Primitive visitLiteralMap(ast.LiteralMap node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     if (node.isConst) {
       return translateConstant(node);
     }
     List<ir.Primitive> keys = new List<ir.Primitive>();
     List<ir.Primitive> values = new List<ir.Primitive>();
     node.entries.nodes.forEach((ast.LiteralMapEntry node) {
       keys.add(visit(node.key));
       values.add(visit(node.value));
     });
     GenericType type = elements.getType(node);
     ir.Primitive result = new ir.LiteralMap(type, keys, values);
-    add(new ir.LetPrim(result));
+    irBuilder.add(new ir.LetPrim(result));
     return result;
   }
 
   ir.Primitive visitLiteralSymbol(ast.LiteralSymbol node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     return translateConstant(node);
   }
 
   ir.Primitive visitIdentifier(ast.Identifier node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     // "this" is the only identifier that should be met by the visitor.
     assert(node.isThis());
     return lookupThis();
   }
 
   ir.Primitive visitParenthesizedExpression(
       ast.ParenthesizedExpression node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     return visit(node.expression);
   }
 
   // Stores the result of visiting a CascadeReceiver, so we can return it from
   // its enclosing Cascade.
   ir.Primitive _currentCascadeReceiver;
 
   ir.Primitive visitCascadeReceiver(ast.CascadeReceiver node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     return _currentCascadeReceiver = visit(node.expression);
   }
 
   ir.Primitive visitCascade(ast.Cascade node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     var oldCascadeReceiver = _currentCascadeReceiver;
     // Throw away the result of visiting the expression.
     // Instead we return the result of visiting the CascadeReceiver.
     this.visit(node.expression);
     ir.Primitive receiver = _currentCascadeReceiver;
     _currentCascadeReceiver = oldCascadeReceiver;
     return receiver;
   }
 
   ir.Primitive lookupThis() {
     ir.Primitive result = new ir.This();
-    add(new ir.LetPrim(result));
+    irBuilder.add(new ir.LetPrim(result));
     return result;
   }
 
   // ==== Sends ====
   ir.Primitive visitAssert(ast.Send node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     return giveup(node, 'Assert');
   }
 
   ir.Primitive visitNamedArgument(ast.NamedArgument node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     return visit(node.expression);
   }
 
   ir.Primitive translateClosureCall(ir.Primitive receiver,
                                     Selector closureSelector,
                                     ast.NodeList arguments) {
     Selector namedCallSelector = new Selector(closureSelector.kind,
                      "call",
                      closureSelector.library,
                      closureSelector.argumentCount,
                      closureSelector.namedArguments);
     List<ir.Primitive> args = arguments.nodes.mapToList(visit, growable:false);
-    return continueWithExpression(
+    return irBuilder.continueWithExpression(
         (k) => new ir.InvokeMethod(receiver, namedCallSelector, k, args));
   }
 
   ir.Primitive visitClosureSend(ast.Send node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     Element element = elements[node];
     ir.Primitive closureTarget;
     if (element == null) {
       closureTarget = visit(node.selector);
     } else if (isClosureVariable(element)) {
       LocalElement local = element;
       closureTarget = new ir.GetClosureVariable(local);
-      add(new ir.LetPrim(closureTarget));
+      irBuilder.add(new ir.LetPrim(closureTarget));
     } else {
       assert(Elements.isLocal(element));
-      closureTarget = environment.lookup(element);
+      closureTarget = irBuilder.environment.lookup(element);
     }
     Selector closureSelector = elements.getSelector(node);
     return translateClosureCall(closureTarget, closureSelector,
         node.argumentsNode);
   }
 
   /// If [node] is null, returns this.
   /// If [node] is super, returns null (for special handling)
   /// Otherwise visits [node] and returns the result.
   ir.Primitive visitReceiver(ast.Expression node) {
     if (node == null) return lookupThis();
     if (node.isSuper()) return null;
     return visit(node);
   }
 
   /// Makes an [InvokeMethod] unless [node.receiver.isSuper()], in that case
   /// makes an [InvokeSuperMethod] ignoring [receiver].
   ir.Expression createDynamicInvoke(ast.Send node,
-                             Selector selector,
-                             ir.Definition receiver,
-                             ir.Continuation k,
-                             List<ir.Definition> arguments) {
+                                    Selector selector,
+                                    ir.Definition receiver,
+                                    ir.Continuation k,
+                                    List<ir.Definition> arguments) {
     return node != null && node.receiver != null && node.receiver.isSuper()
         ? new ir.InvokeSuperMethod(selector, k, arguments)
         : new ir.InvokeMethod(receiver, selector, k, arguments);
   }
 
   ir.Primitive visitDynamicSend(ast.Send node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     Selector selector = elements.getSelector(node);
     ir.Primitive receiver = visitReceiver(node.receiver);
     List<ir.Primitive> arguments = new List<ir.Primitive>();
     for (ast.Node n in node.arguments) {
       arguments.add(visit(n));
     }
-    return continueWithExpression(
+    return irBuilder.continueWithExpression(
         (k) => createDynamicInvoke(node, selector, receiver, k, arguments));
   }
 
   _GetterElements translateGetter(ast.Send node, Selector selector) {
     Element element = elements[node];
     ir.Primitive result;
     ir.Primitive receiver;
     ir.Primitive index;
 
     if (element != null && element.isConst) {
       // Reference to constant local, top-level or static field
       result = translateConstant(node);
     } else if (isClosureVariable(element)) {
       LocalElement local = element;
       result = new ir.GetClosureVariable(local);
-      add(new ir.LetPrim(result));
+      irBuilder.add(new ir.LetPrim(result));
     } else if (Elements.isLocal(element)) {
       // Reference to local variable
-      result = buildGetLocal(element);
+      result = irBuilder.buildGetLocal(element);
     } else if (element == null ||
                Elements.isInstanceField(element) ||
                Elements.isInstanceMethod(element) ||
                selector.isIndex ||
                // TODO(johnniwinther): clean up semantics of resolution.
                node.isSuperCall) {
       // Dynamic dispatch to a getter. Sometimes resolution will suggest a
       // target element, but in these cases we must still emit a dynamic
       // dispatch. The target element may be an instance method in case we are
       // converting a method to a function object.
 
       receiver = visitReceiver(node.receiver);
       List<ir.Primitive> arguments = new List<ir.Primitive>();
       if (selector.isIndex) {
         index = visit(node.arguments.head);
         arguments.add(index);
       }
 
       assert(selector.kind == SelectorKind.GETTER ||
              selector.kind == SelectorKind.INDEX);
-      result = continueWithExpression(
+      result = irBuilder.continueWithExpression(
           (k) => createDynamicInvoke(node, selector, receiver, k, arguments));
     } else if (element.isField || element.isGetter || element.isErroneous ||
                element.isSetter) {
       // TODO(johnniwinther): Change handling of setter selectors.
       // Access to a static field or getter (non-static case handled above).
       // Even if there is only a setter, we compile as if it was a getter,
       // so the vm can fail at runtime.
       assert(selector.kind == SelectorKind.GETTER ||
              selector.kind == SelectorKind.SETTER);
-      result = buildGetStatic(element, selector);
+      result = irBuilder.buildGetStatic(element, selector);
     } else if (Elements.isStaticOrTopLevelFunction(element)) {
       // Convert a top-level or static function to a function object.
       result = translateConstant(node);
     } else {
       throw "Unexpected SendSet getter: $node, $element";
     }
     return new _GetterElements(
         result: result,index: index, receiver: receiver);
   }
 
   ir.Primitive visitGetterSend(ast.Send node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     return translateGetter(node, elements.getSelector(node)).result;
 
   }
 
   ir.Primitive buildNegation(ir.Primitive condition) {
     // ! e is translated as e ? false : true
 
     // Add a continuation parameter for the result of the expression.
     ir.Parameter resultParameter = new ir.Parameter(null);
 
     ir.Continuation joinContinuation = new ir.Continuation([resultParameter]);
     ir.Continuation thenContinuation = new ir.Continuation([]);
     ir.Continuation elseContinuation = new ir.Continuation([]);
 
-    ir.Constant trueConstant = makePrimConst(constantSystem.createBool(true));
-    ir.Constant falseConstant = makePrimConst(constantSystem.createBool(false));
+    ir.Constant trueConstant = irBuilder.makePrimConst(
+        irBuilder.state.constantSystem.createBool(true));
+    ir.Constant falseConstant = irBuilder.makePrimConst(
+        irBuilder.state.constantSystem.createBool(false));
 
     thenContinuation.body = new ir.LetPrim(falseConstant)
         ..plug(new ir.InvokeContinuation(joinContinuation, [falseConstant]));
     elseContinuation.body = new ir.LetPrim(trueConstant)
         ..plug(new ir.InvokeContinuation(joinContinuation, [trueConstant]));
 
-    add(new ir.LetCont(joinContinuation,
+    irBuilder.add(new ir.LetCont(joinContinuation,
           new ir.LetCont(thenContinuation,
             new ir.LetCont(elseContinuation,
               new ir.Branch(new ir.IsTrue(condition),
                             thenContinuation,
                             elseContinuation)))));
     return resultParameter;
   }
 
   ir.Primitive translateLogicalOperator(ast.Operator op,
                                         ast.Expression left,
                                         ast.Expression right) {
     // e0 && e1 is translated as if e0 ? (e1 == true) : false.
     // e0 || e1 is translated as if e0 ? true : (e1 == true).
     // The translation must convert both e0 and e1 to booleans and handle
     // local variable assignments in e1.
 
     ir.Primitive leftValue = visit(left);
-    IrBuilderVisitor rightBuilder = new IrBuilderVisitor.delimited(this);
-    ir.Primitive rightValue = rightBuilder.visit(right);
+    IrBuilder rightBuilder = new IrBuilder.delimited(irBuilder);
+    ir.Primitive rightValue =
+        withBuilder(rightBuilder, () => visit(right));
     // A dummy empty target for the branch on the left subexpression branch.
     // This enables using the same infrastructure for join-point continuations
     // as in visitIf and visitConditional.  It will hold a definition of the
     // appropriate constant and an invocation of the join-point continuation.
-    IrBuilderVisitor emptyBuilder = new IrBuilderVisitor.delimited(this);
+    IrBuilder emptyBuilder = new IrBuilder.delimited(irBuilder);
     // Dummy empty targets for right true and right false.  They hold
     // definitions of the appropriate constant and an invocation of the
     // join-point continuation.
-    IrBuilderVisitor rightTrueBuilder = new IrBuilderVisitor.delimited(rightBuilder);
-    IrBuilderVisitor rightFalseBuilder = new IrBuilderVisitor.delimited(rightBuilder);
+    IrBuilder rightTrueBuilder = new IrBuilder.delimited(rightBuilder);
+    IrBuilder rightFalseBuilder = new IrBuilder.delimited(rightBuilder);
 
     // If we don't evaluate the right subexpression, the value of the whole
     // expression is this constant.
     ir.Constant leftBool = emptyBuilder.makePrimConst(
-        constantSystem.createBool(op.source == '||'));
+        emptyBuilder.state.constantSystem.createBool(op.source == '||'));
     // If we do evaluate the right subexpression, the value of the expression
     // is a true or false constant.
     ir.Constant rightTrue = rightTrueBuilder.makePrimConst(
-        constantSystem.createBool(true));
+        rightTrueBuilder.state.constantSystem.createBool(true));
     ir.Constant rightFalse = rightFalseBuilder.makePrimConst(
-        constantSystem.createBool(false));
+        rightFalseBuilder.state.constantSystem.createBool(false));
     emptyBuilder.add(new ir.LetPrim(leftBool));
     rightTrueBuilder.add(new ir.LetPrim(rightTrue));
     rightFalseBuilder.add(new ir.LetPrim(rightFalse));
 
     // Treat the result values as named values in the environment, so they
     // will be treated as arguments to the join-point continuation.
-    assert(environment.length == emptyBuilder.environment.length);
-    assert(environment.length == rightTrueBuilder.environment.length);
-    assert(environment.length == rightFalseBuilder.environment.length);
+    assert(irBuilder.environment.length == emptyBuilder.environment.length);
+    assert(irBuilder.environment.length == rightTrueBuilder.environment.length);
+    assert(irBuilder.environment.length ==
+               rightFalseBuilder.environment.length);
     emptyBuilder.environment.extend(null, leftBool);
     rightTrueBuilder.environment.extend(null, rightTrue);
     rightFalseBuilder.environment.extend(null, rightFalse);
 
     // Wire up two continuations for the left subexpression, two continuations
     // for the right subexpression, and a three-way join continuation.
     JumpCollector jumps = new JumpCollector(null);
     jumps.addJump(emptyBuilder);
     jumps.addJump(rightTrueBuilder);
     jumps.addJump(rightFalseBuilder);
     ir.Continuation joinContinuation =
-        createJoin(environment.length + 1, jumps);
+        createJoin(irBuilder.environment.length + 1, jumps);
     ir.Continuation leftTrueContinuation = new ir.Continuation([]);
     ir.Continuation leftFalseContinuation = new ir.Continuation([]);
     ir.Continuation rightTrueContinuation = new ir.Continuation([]);
     ir.Continuation rightFalseContinuation = new ir.Continuation([]);
     rightTrueContinuation.body = rightTrueBuilder._root;
     rightFalseContinuation.body = rightFalseBuilder._root;
     // The right subexpression has two continuations.
     rightBuilder.add(
         new ir.LetCont(rightTrueContinuation,
             new ir.LetCont(rightFalseContinuation,
                 new ir.Branch(new ir.IsTrue(rightValue),
                               rightTrueContinuation,
                               rightFalseContinuation))));
     // Depending on the operator, the left subexpression's continuations are
     // either the right subexpression or an invocation of the join-point
     // continuation.
     if (op.source == '&&') {
       leftTrueContinuation.body = rightBuilder._root;
       leftFalseContinuation.body = emptyBuilder._root;
     } else {
       leftTrueContinuation.body = emptyBuilder._root;
       leftFalseContinuation.body = rightBuilder._root;
     }
 
-    add(new ir.LetCont(joinContinuation,
+    irBuilder.add(new ir.LetCont(joinContinuation,
             new ir.LetCont(leftTrueContinuation,
                 new ir.LetCont(leftFalseContinuation,
                     new ir.Branch(new ir.IsTrue(leftValue),
                                   leftTrueContinuation,
                                   leftFalseContinuation)))));
     // There is always a join parameter for the result value, because it
     // is different on at least two paths.
     return joinContinuation.parameters.last;
   }
 
   ir.Primitive visitOperatorSend(ast.Send node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     ast.Operator op = node.selector;
     if (isUserDefinableOperator(op.source)) {
       return visitDynamicSend(node);
     }
     if (op.source == '&&' || op.source == '||') {
       assert(node.receiver != null);
       assert(!node.arguments.isEmpty);
       assert(node.arguments.tail.isEmpty);
       return translateLogicalOperator(op, node.receiver, node.arguments.head);
     }
     if (op.source == "!") {
       assert(node.receiver != null);
       assert(node.arguments.isEmpty);
       return buildNegation(visit(node.receiver));
     }
     if (op.source == "!=") {
       assert(node.receiver != null);
       assert(!node.arguments.isEmpty);
       assert(node.arguments.tail.isEmpty);
       return buildNegation(visitDynamicSend(node));
     }
     assert(invariant(node, op.source == "is" || op.source == "as",
            message: "unexpected operator $op"));
     DartType type = elements.getType(node.typeAnnotationFromIsCheckOrCast);
     ir.Primitive receiver = visit(node.receiver);
-    ir.Primitive check = continueWithExpression(
+    ir.Primitive check = irBuilder.continueWithExpression(
         (k) => new ir.TypeOperator(op.source, receiver, type, k));
     return node.isIsNotCheck ? buildNegation(check) : check;
   }
 
   // Build(StaticSend(f, arguments), C) = C[C'[InvokeStatic(f, xs)]]
   //   where (C', xs) = arguments.fold(Build, C)
   ir.Primitive visitStaticSend(ast.Send node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     Element element = elements[node];
     assert(!element.isConstructor);
     // TODO(lry): support foreign functions.
     if (element.isForeign(compiler.backend)) {
       return giveup(node, 'StaticSend: foreign');
     }
 
     Selector selector = elements.getSelector(node);
 
     // TODO(lry): support default arguments, need support for locals.
     List<ir.Definition> arguments = node.arguments.mapToList(visit,
                                                              growable:false);
-    return buildStaticInvocation(element, selector, arguments);
+    return irBuilder.buildStaticInvocation(element, selector, arguments);
   }
 
 
   ir.Primitive visitSuperSend(ast.Send node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     if (node.isPropertyAccess) {
       return visitGetterSend(node);
     } else {
       return visitDynamicSend(node);
     }
   }
 
   visitTypePrefixSend(ast.Send node) {
     compiler.internalError(node, "visitTypePrefixSend should not be called.");
   }
 
   ir.Primitive visitTypeLiteralSend(ast.Send node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     // If the user is trying to invoke the type literal or variable,
     // it must be treated as a function call.
     if (node.argumentsNode != null) {
       // TODO(sigurdm): Handle this to match proposed semantics of issue #19725.
       return giveup(node, 'Type literal invoked as function');
     }
 
     DartType type = elements.getTypeLiteralType(node);
     if (type is TypeVariableType) {
       ir.Primitive prim = new ir.ReifyTypeVar(type.element);
-      add(new ir.LetPrim(prim));
+      irBuilder.add(new ir.LetPrim(prim));
       return prim;
     } else {
       return translateConstant(node);
     }
   }
 
   /// True if [element] is a local variable, local function, or parameter that
   /// is accessed from an inner function. Recursive self-references in a local
   /// function count as closure accesses.
   ///
   /// If `true`, [element] is a [LocalElement].
   bool isClosureVariable(Element element) {
-    return closureLocals.isClosureVariable(element);
+    return irBuilder.state.closureLocals.contains(element);
   }
 
   void setLocal(Element element, ir.Primitive valueToStore) {
     if (isClosureVariable(element)) {
       LocalElement local = element;
-      add(new ir.SetClosureVariable(local, valueToStore));
+      irBuilder.add(new ir.SetClosureVariable(local, valueToStore));
     } else {
       valueToStore.useElementAsHint(element);
-      environment.update(element, valueToStore);
+      irBuilder.environment.update(element, valueToStore);
     }
   }
 
   void setStatic(Element element,
                  Selector selector,
                  ir.Primitive valueToStore) {
     assert(element.isErroneous || element.isField || element.isSetter);
-    continueWithExpression(
+    irBuilder.continueWithExpression(
         (k) => new ir.InvokeStatic(element, selector, k, [valueToStore]));
   }
 
   void setDynamic(ast.Node node,
                   ir.Primitive receiver, Selector selector,
                   ir.Primitive valueToStore) {
     List<ir.Definition> arguments = [valueToStore];
-    continueWithExpression(
+    irBuilder.continueWithExpression(
         (k) => createDynamicInvoke(node, selector, receiver, k, arguments));
   }
 
   void setIndex(ast.Node node,
                 ir.Primitive receiver,
                 Selector selector,
                 ir.Primitive index,
                 ir.Primitive valueToStore) {
     List<ir.Definition> arguments = [index, valueToStore];
-    continueWithExpression(
+    irBuilder.continueWithExpression(
         (k) => createDynamicInvoke(node, selector, receiver, k, arguments));
   }
 
   ir.Primitive visitSendSet(ast.SendSet node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     Element element = elements[node];
     ast.Operator op = node.assignmentOperator;
     // For complex operators, this is the result of getting (before assigning)
     ir.Primitive originalValue;
     // For []+= style operators, this saves the index.
     ir.Primitive index;
     ir.Primitive receiver;
     // This is what gets assigned.
     ir.Primitive valueToStore;
     Selector selector = elements.getSelector(node);
@@ skipping 30 matching lines @@
       assert(ast.Operator.COMPLEX_OPERATORS.contains(op.source));
 
       _GetterElements getterResult = translateGetter(node, getterSelector);
       index = getterResult.index;
       receiver = getterResult.receiver;
       originalValue = getterResult.result;
 
       // Do the modification of the value in getter.
       ir.Primitive arg;
       if (ast.Operator.INCREMENT_OPERATORS.contains(op.source)) {
-        arg = makePrimConst(constantSystem.createInt(1));
-        add(new ir.LetPrim(arg));
+        arg = irBuilder.makePrimConst(
+            irBuilder.state.constantSystem.createInt(1));
+        irBuilder.add(new ir.LetPrim(arg));
       } else {
         arg = visit(getAssignArgument());
       }
       valueToStore = new ir.Parameter(null);
       ir.Continuation k = new ir.Continuation([valueToStore]);
       ir.Expression invoke =
           new ir.InvokeMethod(originalValue, operatorSelector, k, [arg]);
-      add(new ir.LetCont(k, invoke));
+      irBuilder.add(new ir.LetCont(k, invoke));
     }
 
     if (Elements.isLocal(element)) {
       setLocal(element, valueToStore);
     } else if ((!node.isSuperCall && Elements.isErroneousElement(element)) ||
                 Elements.isStaticOrTopLevel(element)) {
       setStatic(element, elements.getSelector(node), valueToStore);
     } else {
       // Setter or index-setter invocation
       Selector selector = elements.getSelector(node);
       assert(selector.kind == SelectorKind.SETTER ||
           selector.kind == SelectorKind.INDEX);
       if (selector.isIndexSet) {
         setIndex(node, receiver, selector, index, valueToStore);
       } else {
         setDynamic(node, receiver, selector, valueToStore);
       }
     }
 
     if (node.isPostfix) {
       assert(originalValue != null);
       return originalValue;
     } else {
       return valueToStore;
     }
   }
 
   ir.Primitive visitNewExpression(ast.NewExpression node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     if (node.isConst) {
       return translateConstant(node);
     }
     FunctionElement element = elements[node.send];
     Selector selector = elements.getSelector(node.send);
     ast.Node selectorNode = node.send.selector;
     DartType type = elements.getType(node);
     List<ir.Primitive> args =
         node.send.arguments.mapToList(visit, growable:false);
-    return continueWithExpression(
+    return irBuilder.continueWithExpression(
         (k) => new ir.InvokeConstructor(type, element,selector, k, args));
   }
 
   ir.Primitive visitStringJuxtaposition(ast.StringJuxtaposition node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     ir.Primitive first = visit(node.first);
     ir.Primitive second = visit(node.second);
-    return continueWithExpression(
+    return irBuilder.continueWithExpression(
         (k) => new ir.ConcatenateStrings(k, [first, second]));
   }
 
   ir.Primitive visitStringInterpolation(ast.StringInterpolation node) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     List<ir.Primitive> arguments = [];
     arguments.add(visitLiteralString(node.string));
     var it = node.parts.iterator;
     while (it.moveNext()) {
       ast.StringInterpolationPart part = it.current;
       arguments.add(visit(part.expression));
       arguments.add(visitLiteralString(part.string));
     }
-    return continueWithExpression(
+    return irBuilder.continueWithExpression(
         (k) => new ir.ConcatenateStrings(k, arguments));
   }
 
   ir.Primitive translateConstant(ast.Node node, [ConstantExpression constant]) {
-    assert(isOpen);
+    assert(irBuilder.isOpen);
     if (constant == null) {
       constant = getConstantForNode(node);
     }
-    ir.Primitive primitive = makeConst(constant);
-    add(new ir.LetPrim(primitive));
+    ir.Primitive primitive = irBuilder.makeConst(constant);
+    irBuilder.add(new ir.LetPrim(primitive));
     return primitive;
   }
 
   ir.FunctionDefinition makeSubFunction(ast.FunctionExpression node) {
+    // TODO(johnniwinther): Share the visitor.
     return new IrBuilderVisitor(elements, compiler, sourceFile)
            .buildFunctionInternal(elements[node]);
   }
 
   ir.Primitive visitFunctionExpression(ast.FunctionExpression node) {
     FunctionElement element = elements[node];
     ir.FunctionDefinition inner = makeSubFunction(node);
     ir.CreateFunction prim = new ir.CreateFunction(inner);
-    add(new ir.LetPrim(prim));
+    irBuilder.add(new ir.LetPrim(prim));
     return prim;
   }
 
   ir.Primitive visitFunctionDeclaration(ast.FunctionDeclaration node) {
     LocalFunctionElement element = elements[node.function];
     ir.FunctionDefinition inner = makeSubFunction(node.function);
     if (isClosureVariable(element)) {
-      add(new ir.DeclareFunction(element, inner));
+      irBuilder.add(new ir.DeclareFunction(element, inner));
     } else {
       ir.CreateFunction prim = new ir.CreateFunction(inner);
-      add(new ir.LetPrim(prim));
-      environment.extend(element, prim);
+      irBuilder.add(new ir.LetPrim(prim));
+      irBuilder.environment.extend(element, prim);
       prim.useElementAsHint(element);
     }
     return null;
   }
 
   static final String ABORT_IRNODE_BUILDER = "IrNode builder aborted";
 
   dynamic giveup(ast.Node node, [String reason]) {
     throw ABORT_IRNODE_BUILDER;
   }
@@ skipping 49 matching lines @@
   }
 
   visitFunctionExpression(ast.FunctionExpression node) {
     FunctionElement oldFunction = currentFunction;
     currentFunction = elements[node];
     visit(node.body);
     currentFunction = oldFunction;
   }
 
 }