Rename ClosureVariable, use separate IR forms for declaration and assignment.

pkg/compiler/lib/src/cps_ir/cps_ir_builder.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library dart2js.ir_builder;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_types.dart';
 import '../dart2jslib.dart';
@@ skipping 1505 matching lines @@
         environment.index2value[i] = parameters[index++];
       }
     }
 
     return join;
   }
 }
 
 /// Shared state between DartIrBuilders within the same method.
 class DartIrBuilderSharedState {
-  /// Maps local variables to their corresponding [ClosureVariable] object.
-  final Map<Local, ir.ClosureVariable> local2closure =
-      <Local, ir.ClosureVariable>{};
+  /// Maps local variables to their corresponding [MutableVariable] object.
+  final Map<Local, ir.MutableVariable> local2mutable =
+      <Local, ir.MutableVariable>{};
 
-  /// Maps functions to the list of closure variables declared in that function.
-  final Map<ExecutableElement, List<ir.ClosureVariable>> function2closures =
-      <ExecutableElement, List<ir.ClosureVariable>>{};
+  final DartCapturedVariableInfo capturedVariables;
 
-  final DartCapturedVariableInfo closureVariables;
-
-  /// Returns the closure variables declared in the given function.
-  List<ir.ClosureVariable> getClosureList(ExecutableElement element) {
-    return function2closures.putIfAbsent(element, () => <ir.ClosureVariable>[]);
+  /// Creates a [MutableVariable] for the given local.
+  void makeMutableVariable(Local local) {
+    ir.MutableVariable variable =
+        new ir.MutableVariable(local.executableContext, local);
+    local2mutable[local] = variable;
   }
 
-  /// Creates a closure variable for the given local.
-  void makeClosureVariable(Local local) {
-    ir.ClosureVariable variable =
-        new ir.ClosureVariable(local.executableContext, local);
-    local2closure[local] = variable;
-    getClosureList(local.executableContext).add(variable);
-  }
+  /// [MutableVariable]s that should temporarily be treated as registers.
+  final Set<Local> registerizedMutableVariables = new Set<Local>();
 
-  /// Closure variables that should temporarily be treated as registers.
-  final Set<Local> registerizedClosureVariables = new Set<Local>();
-
-  DartIrBuilderSharedState(this.closureVariables) {
-    closureVariables.capturedVariables.forEach(makeClosureVariable);
+  DartIrBuilderSharedState(this.capturedVariables) {
+    capturedVariables.capturedVariables.forEach(makeMutableVariable);
   }
 }
 
 /// Dart-specific subclass of [IrBuilder].
 ///
 /// Inner functions are represented by a [FunctionDefinition] with the
 /// IR for the inner function nested inside.
 ///
-/// Captured variables are translated to ref cells (see [ClosureVariable])
-/// using [GetClosureVariable] and [SetClosureVariable].
+/// Captured variables are translated to ref cells (see [MutableVariable])
+/// using [GetMutableVariable] and [SetMutableVariable].
 class DartIrBuilder extends IrBuilder {
   final DartIrBuilderSharedState dartState;
 
   IrBuilder _makeInstance() => new DartIrBuilder._blank(dartState);
   DartIrBuilder._blank(this.dartState);
 
   DartIrBuilder(ConstantSystem constantSystem,
                 ExecutableElement currentElement,
-                DartCapturedVariableInfo closureVariables)
-      : dartState = new DartIrBuilderSharedState(closureVariables) {
+                DartCapturedVariableInfo capturedVariables)
+      : dartState = new DartIrBuilderSharedState(capturedVariables) {
     _init(constantSystem, currentElement);
   }
 
-  /// True if [local] should currently be accessed from a [ClosureVariable].
-  bool isInClosureVariable(Local local) {
-    return dartState.local2closure.containsKey(local) &&
-           !dartState.registerizedClosureVariables.contains(local);
+  /// True if [local] should currently be accessed from a [MutableVariable].
+  bool isInMutableVariable(Local local) {
+    return dartState.local2mutable.containsKey(local) &&
+           !dartState.registerizedMutableVariables.contains(local);
   }
 
-  /// Gets the [ClosureVariable] containing the value of [local].
-  ir.ClosureVariable getClosureVariable(Local local) {
-    return dartState.local2closure[local];
+  /// Gets the [MutableVariable] containing the value of [local].
+  ir.MutableVariable getMutableVariable(Local local) {
+    return dartState.local2mutable[local];
   }
 
   void _enterScope(ClosureScope scope) {
     assert(scope == null);
   }
 
   void _enterClosureEnvironment(ClosureEnvironment env) {
     assert(env == null);
   }
 
   void _enterForLoopInitializer(ClosureScope scope,
                                 List<LocalElement> loopVariables) {
     assert(scope == null);
     for (LocalElement loopVariable in loopVariables) {
-      if (dartState.local2closure.containsKey(loopVariable)) {
+      if (dartState.local2mutable.containsKey(loopVariable)) {
         // Temporarily keep the loop variable in a primitive.
         // The loop variable will be added to environment when
         // [declareLocalVariable] is called.
-        dartState.registerizedClosureVariables.add(loopVariable);
+        dartState.registerizedMutableVariables.add(loopVariable);
       }
     }
   }
 
   void _enterForLoopBody(ClosureScope scope,
                          List<LocalElement> loopVariables) {
     assert(scope == null);
     for (LocalElement loopVariable in loopVariables) {
-      if (dartState.local2closure.containsKey(loopVariable)) {
-        // Move from primitive into ClosureVariable.
-        dartState.registerizedClosureVariables.remove(loopVariable);
-        add(new ir.SetClosureVariable(getClosureVariable(loopVariable),
-                                      environment.lookup(loopVariable),
-                                      isDeclaration: true));
+      if (dartState.local2mutable.containsKey(loopVariable)) {
+        // Move from [Primitive] into [MutableVariable].
+        dartState.registerizedMutableVariables.remove(loopVariable);
+        add(new ir.LetMutable(getMutableVariable(loopVariable),
+                              environment.lookup(loopVariable)));
       }
     }
   }
 
   void _enterForLoopUpdate(ClosureScope scope,
                            List<LocalElement> loopVariables) {
     assert(scope == null);
     // Move captured loop variables back into the local environment.
     // The update expression will use the values we put in the environment,
     // and then the environments for the initializer and update will be
     // joined at the head of the body.
     for (LocalElement loopVariable in loopVariables) {
-      if (isInClosureVariable(loopVariable)) {
-        ir.ClosureVariable closureVariable = getClosureVariable(loopVariable);
-        ir.Primitive get = new ir.GetClosureVariable(closureVariable);
+      if (isInMutableVariable(loopVariable)) {
+        ir.MutableVariable mutableVariable = getMutableVariable(loopVariable);
+        ir.Primitive get = new ir.GetMutableVariable(mutableVariable);
         add(new ir.LetPrim(get));
         environment.update(loopVariable, get);
-        dartState.registerizedClosureVariables.add(loopVariable);
+        dartState.registerizedMutableVariables.add(loopVariable);
       }
     }
   }
 
   void _createFunctionParameter(ParameterElement parameterElement) {
     ir.Parameter parameter = new ir.Parameter(parameterElement);
     _parameters.add(parameter);
-    if (isInClosureVariable(parameterElement)) {
-      state.functionParameters.add(getClosureVariable(parameterElement));
+    if (isInMutableVariable(parameterElement)) {
+      state.functionParameters.add(getMutableVariable(parameterElement));
     } else {
       state.functionParameters.add(parameter);
       environment.extend(parameterElement, parameter);
     }
   }
 
   void declareLocalVariable(LocalVariableElement variableElement,
                             {ir.Primitive initialValue}) {
     assert(isOpen);
     if (initialValue == null) {
       initialValue = buildNullLiteral();
     }
-    if (isInClosureVariable(variableElement)) {
-      add(new ir.SetClosureVariable(getClosureVariable(variableElement),
-                                    initialValue,
-                                    isDeclaration: true));
+    if (isInMutableVariable(variableElement)) {
+      add(new ir.LetMutable(getMutableVariable(variableElement),
+                            initialValue));
     } else {
       initialValue.useElementAsHint(variableElement);
       environment.extend(variableElement, initialValue);
     }
   }
 
   /// Add [functionElement] to the environment with provided [definition].
   void declareLocalFunction(LocalFunctionElement functionElement,
                             ir.FunctionDefinition definition) {
     assert(isOpen);
-    if (isInClosureVariable(functionElement)) {
-      ir.ClosureVariable variable = getClosureVariable(functionElement);
+    if (isInMutableVariable(functionElement)) {
+      ir.MutableVariable variable = getMutableVariable(functionElement);
       add(new ir.DeclareFunction(variable, definition));
     } else {
       ir.CreateFunction prim = new ir.CreateFunction(definition);
       add(new ir.LetPrim(prim));
       environment.extend(functionElement, prim);
       prim.useElementAsHint(functionElement);
     }
   }
 
   /// Create a function expression from [definition].
   ir.Primitive buildFunctionExpression(ir.FunctionDefinition definition) {
     ir.CreateFunction prim = new ir.CreateFunction(definition);
     add(new ir.LetPrim(prim));
     return prim;
   }
 
   /// Create a read access of [local].
   ir.Primitive buildLocalGet(LocalElement local) {
     assert(isOpen);
-    if (isInClosureVariable(local)) {
+    if (isInMutableVariable(local)) {
       // Do not use [local] as a hint on [result]. The variable should always
       // be inlined, but the hint prevents it.
       ir.Primitive result =
-          new ir.GetClosureVariable(getClosureVariable(local));
+          new ir.GetMutableVariable(getMutableVariable(local));
       add(new ir.LetPrim(result));
       return result;
     } else {
       return environment.lookup(local);
     }
   }
 
   /// Create a write access to [local] with the provided [value].
   ir.Primitive buildLocalSet(LocalElement local, ir.Primitive value) {
     assert(isOpen);
-    if (isInClosureVariable(local)) {
-      add(new ir.SetClosureVariable(getClosureVariable(local), value));
+    if (isInMutableVariable(local)) {
+      add(new ir.SetMutableVariable(getMutableVariable(local), value));
     } else {
       value.useElementAsHint(local);
       environment.update(local, value);
     }
     return value;
   }
 
   ir.Primitive buildThis() {
     ir.Primitive thisPrim = new ir.This();
     add(new ir.LetPrim(thisPrim));
@@ skipping 308 matching lines @@
   ClosureEnvironment(this.selfReference, this.thisLocal, this.freeVariables);
 }
 
 /// Information about which variables are captured by a nested function.
 ///
 /// This is used by the [DartIrBuilder] instead of [ClosureScope] and
 /// [ClosureEnvironment].
 abstract class DartCapturedVariableInfo {
   Iterable<Local> get capturedVariables;
 }