Support assignment of locals in analyzer2dart.

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 242 matching lines @@
   /// 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;
 
+  /// 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 state.closureLocals.contains(element);
+  }
+
   /// Create a parameter for [parameterElement] and add it to the current
   /// environment.
   ///
   /// [isClosureVariable] marks whether [parameterElement] is accessed from an
   /// inner function.
-  void createParameter(LocalElement parameterElement,
-                       {bool isClosureVariable: false}) {
+  void createParameter(LocalElement parameterElement) {
     ir.Parameter parameter = new ir.Parameter(parameterElement);
     _parameters.add(parameter);
-    if (isClosureVariable) {
+    if (isClosureVariable(parameterElement)) {
       add(new ir.SetClosureVariable(parameterElement, parameter));
     } else {
       environment.extend(parameterElement, parameter);
     }
   }
 
   /// Add the constant [variableElement] to the environment with [value] as its
   /// constant value.
   void declareLocalConstant(LocalVariableElement variableElement,
                             ConstantExpression value) {
     state.localConstants.add(new ConstDeclaration(variableElement, value));
   }
 
   /// Add [variableElement] to the environment with [initialValue] as its
   /// initial value.
   ///
   /// [isClosureVariable] marks whether [variableElement] is accessed from an
   /// inner function.
   void declareLocalVariable(LocalVariableElement variableElement,
-                            {ir.Primitive initialValue,
-                             bool isClosureVariable: false}) {
+                            {ir.Primitive initialValue}) {
     assert(isOpen);
     if (initialValue == null) {
       // TODO(kmillikin): Consider pooling constants.
       // The initial value is null.
       initialValue = buildNullLiteral();
     }
-    if (isClosureVariable) {
+    if (isClosureVariable(variableElement)) {
       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);
       environment.extend(variableElement, initialValue);
     }
   }
@@ skipping 102 matching lines @@
                 new ir.LetCont(elseContinuation,
                     new ir.Branch(new ir.IsTrue(condition),
                                   thenContinuation,
                                   elseContinuation)))));
     return (thenValue == elseValue)
         ? thenValue
         : joinContinuation.parameters.last;
 
   }
 
-  /// Create a get access of [local].
-  ir.Primitive buildLocalGet(Element local) {
+  /// Create a read access of [local].
+  ir.Primitive buildLocalGet(LocalElement local) {
     assert(isOpen);
-    return environment.lookup(local);
+    if (isClosureVariable(local)) {
+      ir.Primitive result = new ir.GetClosureVariable(local);
+      add(new ir.LetPrim(result));
+      return result;
+    } else {
+      return environment.lookup(local);
+    }
+  }
+
+  /// Create a write access to [local].
+  ir.Primitive buildLocalSet(LocalElement local, ir.Primitive valueToStore) {
+    assert(isOpen);
+    if (isClosureVariable(local)) {
+      add(new ir.SetClosureVariable(local, valueToStore));
+    } else {
+      valueToStore.useElementAsHint(local);
+      environment.update(local, valueToStore);
+    }
+    return valueToStore;
   }
 
   /// Create a get access of the static [element].
   ir.Primitive buildStaticGet(Element element, Selector selector) {
     assert(isOpen);
     assert(selector.isGetter);
     return continueWithExpression(
         (k) => new ir.InvokeStatic(
             element, selector, k, const <ir.Definition>[]));
   }
@@ skipping 431 matching lines @@
     index = 0;
     for (int i = 0; i < environment.length; ++i) {
       if (common[i] == null) {
         environment.index2value[i] = parameters[index++];
       }
     }
 
     return join;
   }
 }