dart2dart: Support for inner functions in new IR.

sdk/lib/_internal/compiler/implementation/dart_backend/dart_tree.dart

 // Copyright (c) 2014, 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 dart_tree;
 
 import '../dart2jslib.dart' as dart2js;
 import '../elements/elements.dart';
 import '../universe/universe.dart';
 import '../ir/ir_nodes.dart' as ir;
 import '../dart_types.dart' show DartType, GenericType;
 import '../universe/universe.dart' show Selector;
 import '../ir/const_expression.dart';
 
 // The Tree language is the target of translation out of the CPS-based IR.
 //
 // The translation from CPS to Dart consists of several stages.  Among the
 // stages are translation to direct style, translation out of SSA, eliminating
 // unnecessary names, recognizing high-level control constructs.  Combining
 // these separate concerns is complicated and the constraints of the CPS-based
 // language do not permit a multi-stage translation.
 //
 // For that reason, CPS is translated to the direct-style language Tree.
 // Translation out of SSA, unnaming, and control-flow, as well as 'instruction
 // selection' are performed on the Tree language.
 //
 // In contrast to the CPS-based IR, non-primitive expressions can be named and
 // arguments (to calls, primitives, and blocks) can be arbitrary expressions.
+//
+// Additionally, variables are considered in scope within inner functions;
+// closure variables are thus handled directly instead of using ref cells.
 
 /**
  * The base class of all Tree nodes.
  */
 abstract class Node {
 }
 
 /**
  * The base class of [Expression]s.
  */
@@ skipping 36 matching lines @@
   int useCount = 0;
 
   /// The [LabeledStatement] or [WhileTrue] binding this label.
   JumpTarget binding;
 }
 
 /**
  * Variables are [Expression]s.
  */
 class Variable extends Expression {
+  /// Function that declares this variable.
+  FunctionDefinition host;
+
   /// Element used for synthesizing a name for the variable.
   /// Different variables may have the same element. May be null.
   Element element;
 
   int readCount = 0;
 
-  Variable(this.element);
+  /// Number of places where this variable occurs as:
+  /// - left-hand of an [Assign]
+  /// - left-hand of a [FunctionDeclaration]
+  /// - parameter in a [FunctionDefinition]
+  int writeCount = 0;
+
+  Variable(this.host, this.element) {
+    assert(host != null);
+  }
 
   accept(ExpressionVisitor visitor) => visitor.visitVariable(this);
 }
 
 /**
  * Common interface for invocations with arguments.
  */
 abstract class Invoke {
   List<Expression> get arguments;
   Selector get selector;
@@ skipping 31 matching lines @@
 
   accept(ExpressionVisitor visitor) => visitor.visitInvokeMethod(this);
 }
 
 class InvokeSuperMethod extends Expression implements Invoke {
   final Selector selector;
   final List<Expression> arguments;
 
   InvokeSuperMethod(this.selector, this.arguments) ;
 
-  accept(Visitor visitor) => visitor.visitInvokeSuperMethod(this);
+  accept(ExpressionVisitor visitor) => visitor.visitInvokeSuperMethod(this);
 }
 
 /**
  * Call to a factory or generative constructor.
  */
 class InvokeConstructor extends Expression implements Invoke {
   final GenericType type;
   final FunctionElement target;
   final List<Expression> arguments;
   final Selector selector;
@@ skipping 31 matching lines @@
         value = primitiveValue;
 
   accept(ExpressionVisitor visitor) => visitor.visitConstant(this);
 }
 
 class This extends Expression {
   accept(ExpressionVisitor visitor) => visitor.visitThis(this);
 }
 
 class ReifyTypeVar extends Expression {
-  TypeVariableElement element;
+  TypeVariableElement typeVariable;
 
-  ReifyTypeVar(this.element);
+  ReifyTypeVar(this.typeVariable);
 
   accept(ExpressionVisitor visitor) => visitor.visitReifyTypeVar(this);
 }
 
 class LiteralList extends Expression {
   final GenericType type;
   final List<Expression> values;
 
   LiteralList(this.type, this.values);
 
@@ skipping 49 matching lines @@
 
 /// Logical negation.
 class Not extends Expression {
   Expression operand;
 
   Not(this.operand);
 
   accept(ExpressionVisitor visitor) => visitor.visitNot(this);
 }
 
+class FunctionExpression extends Expression {
+  final FunctionDefinition definition;
+
+  FunctionExpression(this.definition) {
+    assert(definition.element.functionSignature.type.returnType.treatAsDynamic);
+  }
+
+  accept(ExpressionVisitor visitor) => visitor.visitFunctionExpression(this);
+}
+
+/// Declares a local function.
+/// Used for functions that may not occur in expression context due to
+/// being recursive or having a return type.
+/// The [variable] must not occur as the left-hand side of an [Assign] or
+/// any other [FunctionDeclaration].
+class FunctionDeclaration extends Statement {
+  Variable variable;
+  final FunctionDefinition definition;
+  Statement next;
+
+  FunctionDeclaration(this.variable, this.definition, this.next) {
+    ++variable.writeCount;
+  }
+
+  accept(StatementVisitor visitor) => visitor.visitFunctionDeclaration(this);
+}
+
 /// A [LabeledStatement] or [WhileTrue] or [WhileCondition].
 abstract class JumpTarget extends Statement {
   Label get label;
   Statement get body;
 }
 
 /**
  * A labeled statement.  Breaks to the label within the labeled statement
  * target the successor statement.
  */
 class LabeledStatement extends JumpTarget {
   Statement next;
   final Label label;
   Statement body;
 
   LabeledStatement(this.label, this.body, this.next) {
     assert(label.binding == null);
     label.binding = this;
   }
 
   accept(StatementVisitor visitor) => visitor.visitLabeledStatement(this);
 }
 
 /// A [WhileTrue] or [WhileCondition] loop.
 abstract class Loop extends JumpTarget {
-  /// When a [Continue] to a loop is executed, all update expressions are
-  /// evaluated right-to-left before control resumes at the head of the loop.
-  List<Expression> get updates;
 }
 
 /**
  * A labeled while(true) loop.
  */
 class WhileTrue extends Loop {
   final Label label;
   Statement body;
-  final List<Expression> updates = <Expression>[];
 
   WhileTrue(this.label, this.body) {
     assert(label.binding == null);
     label.binding = this;
   }
 
   Statement get next => null;
   void set next(Statement s) => throw 'UNREACHABLE';
 
   accept(StatementVisitor visitor) => visitor.visitWhileTrue(this);
 }
 
 /**
  * A while loop with a condition. If the condition is false, control resumes
  * at the [next] statement.
  *
  * It is NOT valid to target this statement with a [Break].
  * The only way to reach [next] is for the condition to evaluate to false.
  *
  * [WhileCondition] statements are introduced in the [LoopRewriter] and is
  * assumed not to occur before then.
  */
 class WhileCondition extends Loop {
   final Label label;
   Expression condition;
   Statement body;
   Statement next;
-  final List<Expression> updates;
 
   WhileCondition(this.label, this.condition, this.body,
-                 this.next, this.updates) {
+                 this.next) {
     assert(label.binding == null);
     label.binding = this;
   }
 
   accept(StatementVisitor visitor) => visitor.visitWhileCondition(this);
 }
 
 /// A [Break] or [Continue] statement.
 abstract class Jump extends Statement {
   Label get target;
@@ skipping 37 matching lines @@
  * An assignments of an [Expression] to a [Variable].
  *
  * In contrast to the CPS-based IR, non-primitive expressions can be assigned
  * to variables.
  */
 class Assign extends Statement {
   Statement next;
   final Variable variable;
   Expression definition;
 
-  Assign(this.variable, this.definition, this.next);
+  /// If true, this declares a new copy of the closure variable.
+  /// The consequences are similar to [ir.SetClosureVariable].
+  /// All uses of the variable must be nested inside the [next] statement.
+  bool isDeclaration;
+
+  Assign(this.variable, this.definition, this.next,
+         { this.isDeclaration: false }) {
+    variable.writeCount++;
+  }
 
   bool get hasExactlyOneUse => variable.readCount == 1;
 
   accept(StatementVisitor visitor) => visitor.visitAssign(this);
 }
 
 /**
  * A return exit from the function.
  *
  * In contrast to the CPS-based IR, the return value is an arbitrary
@@ skipping 30 matching lines @@
 class ExpressionStatement extends Statement {
   Statement next;
   Expression expression;
 
   ExpressionStatement(this.expression, this.next);
 
   accept(StatementVisitor visitor) => visitor.visitExpressionStatement(this);
 }
 
 class FunctionDefinition extends Node {
+  final FunctionElement element;
   final List<Variable> parameters;
   Statement body;
   final List<ConstDeclaration> localConstants;
 
-  FunctionDefinition(this.parameters, this.body, this.localConstants);
+  FunctionDefinition(this.element, this.parameters, this.body,
+      this.localConstants);
 }
 
 abstract class ExpressionVisitor<E> {
   E visitExpression(Expression e) => e.accept(this);
   E visitVariable(Variable node);
   E visitInvokeStatic(InvokeStatic node);
   E visitInvokeMethod(InvokeMethod node);
   E visitInvokeSuperMethod(InvokeSuperMethod node);
   E visitInvokeConstructor(InvokeConstructor node);
   E visitConcatenateStrings(ConcatenateStrings node);
   E visitConstant(Constant node);
   E visitThis(This node);
   E visitReifyTypeVar(ReifyTypeVar node);
   E visitConditional(Conditional node);
   E visitLogicalOperator(LogicalOperator node);
   E visitNot(Not node);
   E visitLiteralList(LiteralList node);
   E visitLiteralMap(LiteralMap node);
   E visitTypeOperator(TypeOperator node);
+  E visitFunctionExpression(FunctionExpression node);
 }
 
 abstract class StatementVisitor<S> {
   S visitStatement(Statement s) => s.accept(this);
   S visitLabeledStatement(LabeledStatement node);
   S visitAssign(Assign node);
   S visitReturn(Return node);
   S visitBreak(Break node);
   S visitContinue(Continue node);
   S visitIf(If node);
   S visitWhileTrue(WhileTrue node);
   S visitWhileCondition(WhileCondition node);
+  S visitFunctionDeclaration(FunctionDeclaration node);
   S visitExpressionStatement(ExpressionStatement node);
 }
 
 abstract class Visitor<S,E> implements ExpressionVisitor<E>,
                                        StatementVisitor<S> {
    E visitExpression(Expression e) => e.accept(this);
    S visitStatement(Statement s) => s.accept(this);
 }
 
+class RecursiveVisitor extends Visitor {
+  visitFunctionDefinition(FunctionDefinition node) {
+    visitStatement(node.body);
+  }
+
+  visitVariable(Variable node) {}
+
+  visitInvokeStatic(InvokeStatic node) {
+    node.arguments.forEach(visitExpression);
+  }
+
+  visitInvokeMethod(InvokeMethod node) {
+    visitExpression(node.receiver);
+    node.arguments.forEach(visitExpression);
+  }
+
+  visitInvokeSuperMethod(InvokeSuperMethod node) {
+    node.arguments.forEach(visitExpression);
+  }
+
+  visitInvokeConstructor(InvokeConstructor node) {
+    node.arguments.forEach(visitExpression);
+  }
+
+  visitConcatenateStrings(ConcatenateStrings node) {
+    node.arguments.forEach(visitExpression);
+  }
+
+  visitConstant(Constant node) {}
+
+  visitThis(This node) {}
+
+  visitReifyTypeVar(ReifyTypeVar node) {}
+
+  visitConditional(Conditional node) {
+    visitExpression(node.condition);
+    visitExpression(node.thenExpression);
+    visitExpression(node.elseExpression);
+  }
+
+  visitLogicalOperator(LogicalOperator node) {
+    visitExpression(node.left);
+    visitExpression(node.right);
+  }
+
+  visitNot(Not node) {
+    visitExpression(node.operand);
+  }
+
+  visitLiteralList(LiteralList node) {
+    node.values.forEach(visitExpression);
+  }
+
+  visitLiteralMap(LiteralMap node) {
+    for (int i=0; i<node.keys.length; i++) {
+      visitExpression(node.keys[i]);
+      visitExpression(node.values[i]);
+    }
+  }
+
+  visitTypeOperator(TypeOperator node) {
+    visitExpression(node.receiver);
+  }
+
+  visitFunctionExpression(FunctionExpression node) {
+    visitFunctionDefinition(node.definition);
+  }
+
+  visitLabeledStatement(LabeledStatement node) {
+    visitStatement(node.body);
+    visitStatement(node.next);
+  }
+
+  visitAssign(Assign node) {
+    visitExpression(node.definition);
+    visitVariable(node.variable);
+    visitStatement(node.next);
+  }
+
+  visitReturn(Return node) {
+    visitExpression(node.value);
+  }
+
+  visitBreak(Break node) {}
+
+  visitContinue(Continue node) {}
+
+  visitIf(If node) {
+    visitExpression(node.condition);
+    visitStatement(node.thenStatement);
+    visitStatement(node.elseStatement);
+  }
+
+  visitWhileTrue(WhileTrue node) {
+    visitStatement(node.body);
+  }
+
+  visitWhileCondition(WhileCondition node) {
+    visitExpression(node.condition);
+    visitStatement(node.body);
+    visitStatement(node.next);
+  }
+
+  visitFunctionDeclaration(FunctionDeclaration node) {
+    visitFunctionDefinition(node.definition);
+    visitStatement(node.next);
+  }
+
+  visitExpressionStatement(ExpressionStatement node) {
+    visitExpression(node.expression);
+    visitStatement(node.next);
+  }
+}
+
 /**
  * Builder translates from CPS-based IR to direct-style Tree.
  *
  * A call `Invoke(fun, cont, args)`, where cont is a singly-referenced
  * non-exit continuation `Cont(v, body)` is translated into a direct-style call
  * whose value is bound in the continuation body:
  *
  * `LetVal(v, Invoke(fun, args), body)`
  *
  * and the continuation definition is eliminated.  A similar translation is
@@ skipping 19 matching lines @@
  * particular, intermediate values and blocks used for local control flow are
  * still all named.
  */
 class Builder extends ir.Visitor<Node> {
   final dart2js.Compiler compiler;
 
   /// Maps variable/parameter elements to the Tree variables that represent it.
   final Map<Element, List<Variable>> element2variables =
       <Element,List<Variable>>{};
 
+  /// Like [element2variables], except for closure variables. Closure variables
+  /// are not subject to SSA, so at most one variable is used per element.
+  final Map<Element, Variable> element2closure = <Element, Variable>{};
+
   // Continuations with more than one use are replaced with Tree labels.  This
   // is the mapping from continuations to labels.
   final Map<ir.Continuation, Label> labels = <ir.Continuation, Label>{};
 
   FunctionDefinition function;
   ir.Continuation returnContinuation;
 
-  /// Variable used in [buildPhiAssignments] as a temporary when swapping
-  /// variables.
-  final Variable tempVar = new Variable(null);
+  Builder parent;
 
   Builder(this.compiler);
 
+  Builder.inner(Builder parent)
+      : this.parent = parent,
+        compiler = parent.compiler;
+
+  /// Variable used in [buildPhiAssignments] as a temporary when swapping
+  /// variables.
+  Variable phiTempVar;
+
+  Variable getClosureVariable(Element element) {
+    if (element.enclosingElement != function.element) {
+      return parent.getClosureVariable(element);
+    }
+    Variable variable = element2closure[element];
+    if (variable == null) {
+      variable = new Variable(function, element);
+      element2closure[element] = variable;
+    }
+    return variable;
+  }
+
   /// Obtains the variable representing the given primitive. Returns null for
   /// primitives that have no reference and do not need a variable.
   Variable getVariable(ir.Primitive primitive) {
     if (primitive.registerIndex == null) {
       return null; // variable is unused
     }
-    List<Variable> variables = element2variables[primitive.element];
+    List<Variable> variables = element2variables[primitive.hint];
     if (variables == null) {
       variables = <Variable>[];
-      element2variables[primitive.element] = variables;
+      element2variables[primitive.hint] = variables;
     }
     while (variables.length <= primitive.registerIndex) {
-      variables.add(new Variable(primitive.element));
+      variables.add(new Variable(function, primitive.hint));
     }
     return variables[primitive.registerIndex];
   }
 
   /// Obtains a reference to the tree Variable corresponding to the IR primitive
   /// referred to by [reference].
   /// This increments the reference count for the given variable, so the
   /// returned expression must be used in the tree.
   Expression getVariableReference(ir.Reference reference) {
     Variable variable = getVariable(reference.definition);
@@ skipping 82 matching lines @@
       }
       Variable param = getVariable(parameters[i]);
       Variable arg = arguments[i];
       if (param == null || param == arg) {
         return; // No assignment necessary.
       }
       if (assignmentSrc[i] != null) {
         // Cycle found; store argument in a temporary variable.
         // The temporary will then be used as right-hand side when the
         // assignment gets added.
-        if (assignmentSrc[i] != tempVar) { // Only move to temporary once.
-          assignmentSrc[i] = tempVar;
-          addAssignment(tempVar, arg);
+        if (assignmentSrc[i] != phiTempVar) { // Only move to temporary once.
+          assignmentSrc[i] = phiTempVar;
+          addAssignment(phiTempVar, arg);
         }
         return;
       }
       assignmentSrc[i] = arg;
       List<int> paramUses = rightHand[param];
       if (paramUses != null) {
         for (int useIndex in paramUses) {
           visitAssignment(useIndex);
         }
       }
       addAssignment(param, assignmentSrc[i]);
       done[i] = true;
     }
 
     for (int i = 0; i < parameters.length; i++) {
       if (done[i] == null) {
         visitAssignment(i);
       }
     }
 
     if (first == null) {
       first = buildRest();
     } else {
       current.next = buildRest();
     }
     return first;
   }
 
+  visitNode(ir.Node node) => throw "Unhandled node: $node";
+
   Expression visitFunctionDefinition(ir.FunctionDefinition node) {
+    List<Variable> parameters = <Variable>[];
+    function = new FunctionDefinition(node.element, parameters,
+        null, node.localConstants);
     returnContinuation = node.returnContinuation;
-    List<Variable> parameters = <Variable>[];
     for (ir.Parameter p in node.parameters) {
       Variable parameter = getVariable(p);
       assert(parameter != null);
+      ++parameter.writeCount; // Being a parameter counts as a write.
       parameters.add(parameter);
     }
-    function = new FunctionDefinition(parameters, visit(node.body),
-        node.localConstants);
+    phiTempVar = new Variable(function, null);
+    function.body = visit(node.body);
     return null;
   }
 
   Statement visitLetPrim(ir.LetPrim node) {
     Variable variable = getVariable(node.primitive);
-    return variable == null
-        ? visit(node.body)
-        : new Assign(variable, visit(node.primitive), visit(node.body));
+
+    // Don't translate unused primitives.
+    if (variable == null) return visit(node.body);
+
+    Node definition = visit(node.primitive);
+
+    // visitPrimitive returns a Statement without successor if it cannot occur
+    // in expression context (currently only the case for FunctionDeclarations).
+    if (definition is Statement) {
+      definition.next = visit(node.body);
+      return definition;
+    } else {
+      return new Assign(variable, definition, visit(node.body));
+    }
   }
 
   Statement visitLetCont(ir.LetCont node) {
     Label label;
     if (node.continuation.hasMultipleUses) {
       label = new Label();
       labels[node.continuation] = label;
     }
     Statement body = visit(node.body);
     // The continuation's body is not always translated directly here because
     // it may have been already translated:
     //   * For singly-used continuations, the continuation's body is
     //     translated at the site of the continuation invocation.
     //   * For recursive continuations, there is a single non-recursive
     //     invocation.  The continuation's body is translated at the site
     //     of the non-recursive continuation invocation.
     // See visitInvokeContinuation for the implementation.
     if (label == null || node.continuation.isRecursive) return body;
     return new LabeledStatement(label, body, visit(node.continuation.body));
   }
 
   Statement visitInvokeStatic(ir.InvokeStatic node) {
     // Calls are translated to direct style.
     List<Expression> arguments = translateArguments(node.arguments);
     Expression invoke = new InvokeStatic(node.target, node.selector, arguments);
-    ir.Continuation cont = node.continuation.definition;
-    if (cont == returnContinuation) {
-      return new Return(invoke);
-    } else {
-      assert(cont.hasExactlyOneUse);
-      assert(cont.parameters.length == 1);
-      return buildContinuationAssignment(cont.parameters.single, invoke,
-          () => visit(cont.body));
-    }
+    return continueWithExpression(node.continuation, invoke);
   }
 
   Statement visitInvokeMethod(ir.InvokeMethod node) {
     Expression receiver = getVariableReference(node.receiver);
     List<Expression> arguments = translateArguments(node.arguments);
     Expression invoke = new InvokeMethod(receiver, node.selector, arguments);
-    ir.Continuation cont = node.continuation.definition;
-    if (cont == returnContinuation) {
-      return new Return(invoke);
-    } else {
-      assert(cont.hasExactlyOneUse);
-      assert(cont.parameters.length == 1);
-      return buildContinuationAssignment(cont.parameters.single, invoke,
-          () => visit(cont.body));
-    }
+    return continueWithExpression(node.continuation, invoke);
   }
 
   Statement visitInvokeSuperMethod(ir.InvokeSuperMethod node) {
     List<Expression> arguments = translateArguments(node.arguments);
     Expression invoke = new InvokeSuperMethod(node.selector, arguments);
-    ir.Continuation cont = node.continuation.definition;
-    if (cont == returnContinuation) {
-      return new Return(invoke);
-    } else {
-      assert(cont.hasExactlyOneUse);
-      assert(cont.parameters.length == 1);
-      return buildContinuationAssignment(cont.parameters.single, invoke,
-          () => visit(cont.body));
-    }
+    return continueWithExpression(node.continuation, invoke);
   }
 
   Statement visitConcatenateStrings(ir.ConcatenateStrings node) {
     List<Expression> arguments = translateArguments(node.arguments);
     Expression concat = new ConcatenateStrings(arguments);
-    ir.Continuation cont = node.continuation.definition;
+    return continueWithExpression(node.continuation, concat);
+  }
+
+  Statement continueWithExpression(ir.Reference continuation,
+                                   Expression expression) {
+    ir.Continuation cont = continuation.definition;
     if (cont == returnContinuation) {
-      return new Return(concat);
+      return new Return(expression);
     } else {
       assert(cont.hasExactlyOneUse);
       assert(cont.parameters.length == 1);
-      return buildContinuationAssignment(cont.parameters.single, concat,
+      return buildContinuationAssignment(cont.parameters.single, expression,
           () => visit(cont.body));
     }
   }
 
+  Expression visitGetClosureVariable(ir.GetClosureVariable node) {
+    return getClosureVariable(node.variable);
+  }
+
+  Statement visitSetClosureVariable(ir.SetClosureVariable node) {
+    Variable variable = getClosureVariable(node.variable);
+    Expression value = getVariableReference(node.value);
+    return new Assign(variable, value, visit(node.body),
+                      isDeclaration: node.isDeclaration);
+  }
+
+  Statement visitDeclareFunction(ir.DeclareFunction node) {
+    Variable variable = getClosureVariable(node.variable);
+    FunctionDefinition function = makeSubFunction(node.definition);
+    return new FunctionDeclaration(variable, function, visit(node.body));
+  }
+
   Statement visitAsCast(ir.AsCast node) {
     Expression receiver = getVariableReference(node.receiver);
     Expression concat = new TypeOperator(receiver, node.type, "as");
-    ir.Continuation cont = node.continuation.definition;
-    if (cont == returnContinuation) {
-      return new Return(concat);
-    } else {
-      assert(cont.hasExactlyOneUse);
-      assert(cont.parameters.length == 1);
-      return buildContinuationAssignment(cont.parameters.single, concat,
-          () => visit(cont.body));
-    }
+    return continueWithExpression(node.continuation, concat);
   }
 
   Statement visitInvokeConstructor(ir.InvokeConstructor node) {
     List<Expression> arguments = translateArguments(node.arguments);
     Expression invoke =
         new InvokeConstructor(node.type, node.target, node.selector, arguments);
-    ir.Continuation cont = node.continuation.definition;
-    if (cont == returnContinuation) {
-      return new Return(invoke);
-    } else {
-      assert(cont.hasExactlyOneUse);
-      assert(cont.parameters.length == 1);
-      return buildContinuationAssignment(cont.parameters.single, invoke,
-          () => visit(cont.body));
-    }
+    return continueWithExpression(node.continuation, invoke);
   }
 
   Statement visitInvokeContinuation(ir.InvokeContinuation node) {
     // Invocations of the return continuation are translated to returns.
     // Other continuation invocations are replaced with assignments of the
     // arguments to formal parameter variables, followed by the body if
     // the continuation is singly reference or a break if it is multiply
     // referenced.
     ir.Continuation cont = node.continuation.definition;
     if (cont == returnContinuation) {
@@ skipping 43 matching lines @@
 
   Expression visitConstant(ir.Constant node) {
     return new Constant(node.expression, node.value);
   }
 
   Expression visitThis(ir.This node) {
     return new This();
   }
 
   Expression visitReifyTypeVar(ir.ReifyTypeVar node) {
-    return new ReifyTypeVar(node.element);
+    return new ReifyTypeVar(node.typeVariable);
   }
 
   Expression visitLiteralList(ir.LiteralList node) {
     return new LiteralList(
             node.type,
             translateArguments(node.values));
   }
 
   Expression visitLiteralMap(ir.LiteralMap node) {
     return new LiteralMap(
         node.type,
         translateArguments(node.keys),
         translateArguments(node.values));
   }
 
+  FunctionDefinition makeSubFunction(ir.FunctionDefinition function) {
+    return new Builder.inner(this).build(function);
+  }
+
+  Node visitCreateFunction(ir.CreateFunction node) {
+    FunctionDefinition def = makeSubFunction(node.definition);
+    FunctionSignature signature = node.definition.element.functionSignature;
+    bool hasReturnType = !signature.type.returnType.treatAsDynamic;
+    if (hasReturnType) {
+      // This function cannot occur in expression context.
+      // The successor will be filled in by visitLetPrim.
+      return new FunctionDeclaration(getVariable(node), def, null);
+    } else {
+      return new FunctionExpression(def);
+    }
+  }
+
   Expression visitIsCheck(ir.IsCheck node) {
     return new TypeOperator(getVariableReference(node.receiver),
                             node.type,
                             "is");
   }
 
   Expression visitParameter(ir.Parameter node) {
     // Continuation parameters are not visited (continuations themselves are
     // not visited yet).
     compiler.internalError(compiler.currentElement, 'Unexpected IR node.');
     return null;
   }
 
   Expression visitContinuation(ir.Continuation node) {
     // Until continuations with multiple uses are supported, they are not
     // visited.
     compiler.internalError(compiler.currentElement, 'Unexpected IR node.');
     return null;
   }
 
   Expression visitIsTrue(ir.IsTrue node) {
     return getVariableReference(node.value);
   }
 }
 
+/// Eliminates redundant variables and assignments that occur immediately after
+/// parameters are declared or after a function declaration.
+///
+/// These patterns arise when translating out of CPS where closure variables
+/// live in a separate space. Since function parameters are IR primitives they
+/// must be moved into a separate closure variable for inner functions to access
+/// them. For example:
+///
+///   foo(x) {
+///     let v1 = ref x in BODY
+///   }
+///    ==> (dart_tree Builder)
+///   foo(x) {
+///     var v1 = x;
+///     BODY..
+///   }
+///
+/// This phase attempts to merge v1 and x in the example above.
+/// A similar pattern can occur for local function declarations that are used
+/// from closures.
+class CopyPropagateClosureVariables extends RecursiveVisitor {
+
+  void rewrite(FunctionDefinition definition) {
+    visitFunctionDefinition(definition);
+  }
+
+  /// Performs the rewrite:
+  ///
+  ///   foo(x) { var v0 = x; S }
+  ///     ==> (move v0 into parameter)
+  ///   foo(v0) { S }
+  ///     ==> (change the name of v0 to be x, so we preserve the parameter name)
+  ///   foo(x) { S[v0\x] }
+  ///
+  ///   Condition: x cannot be used anywhere else.
+  visitFunctionDefinition(FunctionDefinition definition) {
+    while (definition.body is Assign) {
+      Assign assign = definition.body;
+      if (assign.definition is! Variable) break;
+
+      Variable rightHand = assign.definition;
+      if (rightHand.readCount != 1) break;
+
+      int paramIndex = definition.parameters.indexOf(rightHand);
+      if (paramIndex == -1) break;
+
+      // A variable may not occur as a parameter more than once.
+      if (definition.parameters.contains(assign.variable)) break;
+
+      definition.parameters[paramIndex] = assign.variable;
+      assign.variable.element = rightHand.element;
+      definition.body = assign.next;
+    }
+
+    visitStatement(definition.body); // Visit nested function definitions.
+  }
+
+  /// Performs the rewrite:
+  ///
+  ///   int v0() { S }
+  ///   foo = v0;
+  ///     ==>
+  ///   int foo() { S }
+  ///
+  ///   Condition: v0 cannot be used anywhere else.
+  visitFunctionDeclaration(FunctionDeclaration node) {
+    Statement next = node.next;
+    if (next is Assign &&
+        next.definition == node.variable &&
+        node.variable.readCount == 1 &&
+        next.variable.writeCount == 1) {
+      node.variable = next.variable;
+      node.next = next.next;
+    }
+    super.visitFunctionDeclaration(node);
+  }
+
+}
+
 /**
  * Performs the following transformations on the tree:
  * - Assignment propagation
  * - If-to-conditional conversion
  * - Flatten nested ifs
  * - Break inlining
  * - Redirect breaks
  *
  * The above transformations all eliminate statements from the tree, and may
  * introduce redexes of each other.
@@ skipping 192 matching lines @@
     environment.removeLast();
 
     return node;
   }
 
   Expression visitNot(Not node) {
     node.operand = visitExpression(node.operand);
     return node;
   }
 
+  Expression visitFunctionExpression(FunctionExpression node) {
+    new StatementRewriter().rewrite(node.definition);
+    return node;
+  }
+
+  Statement visitFunctionDeclaration(FunctionDeclaration node) {
+    new StatementRewriter().rewrite(node.definition);
+    node.next = visitStatement(node.next);
+    return node;
+  }
+
   Statement visitReturn(Return node) {
     node.value = visitExpression(node.value);
     return node;
   }
 
 
   Statement visitBreak(Break node) {
     // Redirect through chain of breaks.
     // Note that useCount was accounted for at visitLabeledStatement.
     // Note redirect may return either a Break or Continue statement.
@@ skipping 160 matching lines @@
   static Statement combineStatementsWithSubexpressions(
       Statement s,
       Statement t,
       Expression combine(Expression s, Expression t)) {
     if (s is Return && t is Return) {
       return new Return(combine(s.value, t.value));
     }
     if (s is Assign && t is Assign && s.variable == t.variable) {
       Statement next = combineStatements(s.next, t.next);
       if (next != null) {
+        --t.variable.writeCount; // Two assignments become one.
         return new Assign(s.variable,
                           combine(s.definition, t.definition),
                           next);
       }
     }
     if (s is ExpressionStatement && t is ExpressionStatement) {
       Statement next = combineStatements(s.next, t.next);
       if (next != null) {
         return new ExpressionStatement(combine(s.expression, t.expression),
                                        next);
@@ skipping 143 matching lines @@
 ///   L:
 ///   while (E) {
 ///     S1
 ///   };
 ///   S2
 ///
 /// A similar transformation is used when S2 occurs in the 'then' position.
 ///
 /// Note that the above pattern needs no iteration since nested ifs
 /// have been collapsed previously in the [StatementRewriter] phase.
-class LoopRewriter extends StatementVisitor<Statement> {
+class LoopRewriter extends RecursiveVisitor {
 
   Set<Label> usedContinueLabels = new Set<Label>();
 
   void rewrite(FunctionDefinition function) {
     function.body = visitStatement(function.body);
   }
 
   Statement visitLabeledStatement(LabeledStatement node) {
     node.body = visitStatement(node.body);
     node.next = visitStatement(node.next);
     return node;
   }
 
   Statement visitAssign(Assign node) {
+    visitExpression(node.definition);
     node.next = visitStatement(node.next);
     return node;
   }
 
   Statement visitReturn(Return node) {
+    visitExpression(node.value);
     return node;
   }
 
   Statement visitBreak(Break node) {
     return node;
   }
 
   Statement visitContinue(Continue node) {
     usedContinueLabels.add(node.target);
     return node;
   }
 
   Statement visitIf(If node) {
+    visitExpression(node.condition);
     node.thenStatement = visitStatement(node.thenStatement);
     node.elseStatement = visitStatement(node.elseStatement);
     return node;
   }
 
   Statement visitWhileTrue(WhileTrue node) {
     assert(!usedContinueLabels.contains(node.label));
     if (node.body is If) {
       If body = node.body;
       body.thenStatement = visitStatement(body.thenStatement);
       bool thenHasContinue = usedContinueLabels.remove(node.label);
       body.elseStatement = visitStatement(body.elseStatement);
       bool elseHasContinue = usedContinueLabels.remove(node.label);
       if (thenHasContinue && !elseHasContinue) {
         node.label.binding = null; // Prepare to rebind the label.
         return new WhileCondition(
             node.label,
             body.condition,
             body.thenStatement,
-            body.elseStatement,
-            node.updates);
+            body.elseStatement);
       } else if (!thenHasContinue && elseHasContinue) {
         node.label.binding = null;
         return new WhileCondition(
             node.label,
             new Not(body.condition),
             body.elseStatement,
-            body.thenStatement,
-            node.updates);
+            body.thenStatement);
       }
     } else {
       node.body = visitStatement(node.body);
       usedContinueLabels.remove(node.label);
     }
     return node;
   }
 
   Statement visitWhileCondition(WhileCondition node) {
     // Note: not reachable but the implementation is trivial
+    visitExpression(node.condition);
     node.body = visitStatement(node.body);
     node.next = visitStatement(node.next);
     return node;
   }
 
   Statement visitExpressionStatement(ExpressionStatement node) {
+    visitExpression(node.expression);
     node.next = visitStatement(node.next);
-    // for (;;) { ... E; continue* L ... }
-    //   ==>
-    // for(;;E) { ... continue* L ... }
-    if (node.next is Continue) {
-      Continue jump = node.next;
-      if (jump.target.useCount == 1) {
-        Loop target = jump.target.binding;
-        target.updates.add(node.expression);
-        return jump; // Return the continue statement.
-        // NOTE: The pattern may reclick in an enclosing expression statement.
-      }
-    }
     return node;
   }
 
+  Statement visitFunctionDeclaration(FunctionDeclaration node) {
+    new LoopRewriter().rewrite(node.definition);
+    node.next = visitStatement(node.next);
+    return node;
+  }
+
+  void visitFunctionExpression(FunctionExpression node) {
+    new LoopRewriter().rewrite(node.definition);
+  }
+
 }
 
 
 /// Rewrites logical expressions to be more compact.
 ///
 /// In this class an expression is said to occur in "boolean context" if
 /// its result is immediately applied to boolean conversion.
 ///
 /// IF STATEMENTS:
 ///
@@ skipping 194 matching lines @@
   }
 
   Expression visitThis(This node) {
     return node;
   }
 
   Expression visitReifyTypeVar(ReifyTypeVar node) {
     return node;
   }
 
+  Expression visitFunctionExpression(FunctionExpression node) {
+    new LogicalRewriter().rewrite(node.definition);
+    return node;
+  }
+
+  Statement visitFunctionDeclaration(FunctionDeclaration node) {
+    new LogicalRewriter().rewrite(node.definition);
+    node.next = visitStatement(node.next);
+    return node;
+  }
+
   Expression visitNot(Not node) {
     return toBoolean(makeCondition(node.operand, false, liftNots: false));
   }
 
   Expression visitConditional(Conditional node) {
     // node.condition will be visited after the then and else parts, because its
     // polarity depends on what rewrite we use.
     node.thenExpression = visitExpression(node.thenExpression);
     node.elseExpression = visitExpression(node.elseExpression);
 
@@ skipping 198 matching lines @@
     }
   }
 
   /// Destructively updates each entry of [l] with the result of visiting it.
   void _rewriteList(List<Expression> l) {
     for (int i = 0; i < l.length; i++) {
       l[i] = visitExpression(l[i]);
     }
   }
 }
+