Refactored treatment of closure variables in dart2js CPS.

pkg/compiler/lib/src/tree_ir/tree_ir_builder.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 tree_ir_builder;
 
 import '../dart2jslib.dart' as dart2js;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../cps_ir/cps_ir_nodes.dart' as cps_ir;
@@ skipping 31 matching lines @@
  * particular, intermediate values and blocks used for local control flow are
  * still all named.
  */
 class Builder extends cps_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 local.
-  final Map<Local, Variable> local2closure = <Local, Variable>{};
+  /// Like [element2variables], except for closure variables.
+  final Map<cps_ir.ClosureVariable, Variable> local2closure =
+      <cps_ir.ClosureVariable, Variable>{};
 
   // Continuations with more than one use are replaced with Tree labels.  This
   // is the mapping from continuations to labels.
   final Map<cps_ir.Continuation, Label> labels = <cps_ir.Continuation, Label>{};
 
   ExecutableElement currentElement;
   cps_ir.Continuation returnContinuation;
 
   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(Local local) {
-    if (local.executableContext != currentElement) {
-      return parent.getClosureVariable(local);
+  Variable getClosureVariable(cps_ir.ClosureVariable irVariable) {
+    if (irVariable.host != currentElement) {
+      return parent.getClosureVariable(irVariable);
     }
-    Variable variable = local2closure[local];
-    if (variable == null) {
-      variable = new Variable(currentElement, local);
-      local2closure[local] = variable;
-    }
-    return variable;
+    return local2closure.putIfAbsent(irVariable,
+        () => new Variable(currentElement, irVariable.hint));
   }
 
   /// Obtains the variable representing the given primitive. Returns null for
   /// primitives that have no reference and do not need a variable.
   Variable getVariable(cps_ir.Primitive primitive) {
     if (primitive.registerIndex == null) {
       return null; // variable is unused
     }
-    List<Variable> variables = element2variables[primitive.hint];
-    if (variables == null) {
-      variables = <Variable>[];
-      element2variables[primitive.hint] = variables;
-    }
+    List<Variable> variables = element2variables.putIfAbsent(primitive.hint,
+        () => <Variable>[]);
     while (variables.length <= primitive.registerIndex) {
       variables.add(new Variable(currentElement, 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.
@@ skipping 23 matching lines @@
       currentElement = node.element;
       returnContinuation = node.returnContinuation;
 
       phiTempVar = new Variable(node.element, null);
 
       body = visit(node.body);
     }
     return new FieldDefinition(node.element, body);
   }
 
+  Variable getFunctionParameter(cps_ir.Definition variable) {
+    if (variable is cps_ir.Parameter) {
+      return getVariable(variable);
+    } else {
+      return getClosureVariable(variable as cps_ir.ClosureVariable);
+    }
+  }
+
   FunctionDefinition buildFunction(cps_ir.FunctionDefinition node) {
     currentElement = node.element;
     List<Variable> parameters = <Variable>[];
-    for (cps_ir.Parameter p in node.parameters) {
-      Variable parameter = getVariable(p);
+    for (cps_ir.Definition p in node.parameters) {
+      Variable parameter = getFunctionParameter(p);
       assert(parameter != null);
       ++parameter.writeCount; // Being a parameter counts as a write.
       parameters.add(parameter);
     }
     returnContinuation = node.returnContinuation;
 
     Statement body;
     if (!node.isAbstract) {
       phiTempVar = new Variable(node.element, null);
       body = visit(node.body);
@@ skipping 185 matching lines @@
     } else {
       assert(cont.parameters.length == 1);
       Function nextBuilder = cont.hasExactlyOneUse ?
           () => visit(cont.body) : () => new Break(labels[cont]);
       return buildContinuationAssignment(cont.parameters.single, expression,
           nextBuilder);
     }
   }
 
   Expression visitGetClosureVariable(cps_ir.GetClosureVariable node) {
-    return getClosureVariable(node.variable);
+    return getClosureVariable(node.variable.definition);
   }
 
   Statement visitSetClosureVariable(cps_ir.SetClosureVariable node) {
-    Variable variable = getClosureVariable(node.variable);
+    Variable variable = getClosureVariable(node.variable.definition);
     Expression value = getVariableReference(node.value);
     return new Assign(variable, value, visit(node.body),
                       isDeclaration: node.isDeclaration);
   }
 
   Statement visitDeclareFunction(cps_ir.DeclareFunction node) {
-    Variable variable = getClosureVariable(node.variable);
+    Variable variable = getClosureVariable(node.variable.definition);
     FunctionDefinition function = makeSubFunction(node.definition);
     return new FunctionDeclaration(variable, function, visit(node.body));
   }
 
   Statement visitTypeOperator(cps_ir.TypeOperator node) {
     Expression receiver = getVariableReference(node.receiver);
     Expression concat =
         new TypeOperator(receiver, node.type, isTypeTest: node.isTypeTest);
     return continueWithExpression(node.continuation, concat);
   }
@@ skipping 127 matching lines @@
 
   Expression visitIdentical(cps_ir.Identical node) {
     return new InvokeStatic(
         compiler.identicalFunction,
         identicalSelector,
         <Expression>[getVariableReference(node.left),
                      getVariableReference(node.right)]);
   }
 }