Support assignment of locals in analyzer2dart.

pkg/analyzer2dart/lib/src/cps_generator.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 analyzer2dart.cps_generator;
 
 import 'package:analyzer/analyzer.dart';
 
 import 'package:compiler/implementation/dart_types.dart' as dart2js;
 import 'package:compiler/implementation/elements/elements.dart' as dart2js;
@@ skipping 28 matching lines @@
     dart2js.FunctionElement element = converter.convertElement(function);
     return withBuilder(
         new IrBuilder(DART_CONSTANT_SYSTEM,
                       element,
                       // TODO(johnniwinther): Supported closure variables.
                       const <dart2js.Local>[]),
         () {
       function.parameters.forEach((analyzer.ParameterElement parameter) {
         // TODO(johnniwinther): Support "closure variables", that is variables
         // accessed from an inner function.
-        irBuilder.createParameter(converter.convertElement(parameter),
-                                  isClosureVariable: false);
+        irBuilder.createParameter(converter.convertElement(parameter));
       });
       // Visit the body directly to avoid processing the signature as
       // expressions.
       visit(node.functionExpression.body);
       return irBuilder.buildFunctionDefinition(element, const []);
     });
   }
 
   List<ir.Definition> visitArguments(ArgumentList argumentList) {
     List<ir.Definition> arguments = <ir.Definition>[];
@@ skipping 123 matching lines @@
 
   @override
   visitVariableDeclaration(VariableDeclaration node) {
     // TODO(johnniwinther): Handle constant local variables.
     ir.Node initialValue = build(node.initializer);
     irBuilder.declareLocalVariable(
         converter.convertElement(node.element),
         initialValue: initialValue);
   }
 
-  ir.Primitive handleLocalAccess(AstNode node, AccessSemantics semantics) {
+  dart2js.Element getLocal(AstNode node, AccessSemantics semantics) {
     analyzer.Element element = semantics.element;
     dart2js.Element target = converter.convertElement(element);
     assert(invariant(node, target.isLocal, '$target expected to be local.'));
-    return irBuilder.buildLocalGet(target);
+    return target;
+  }
+
+  ir.Primitive handleLocalAccess(AstNode node, AccessSemantics semantics) {
+    return irBuilder.buildLocalGet(getLocal(node, semantics));
+  }
+
+  ir.Primitive handleLocalAssignment(AssignmentExpression node,
+                                     AccessSemantics semantics) {
+    if (node.operator.lexeme != '=') {
+      return giveUp(node, 'Assignment operator: ${node.operator.lexeme}');
+    }
+    return irBuilder.buildLocalSet(
+        getLocal(node, semantics),
+        build(node.rightHandSide));
   }
 
   @override
+  ir.Node visitAssignmentExpression(AssignmentExpression node) {
+    // Avoid eager visiting of left and right hand side.
+    return handleAssignmentExpression(node);
+  }
+
+  @override
+  ir.Node visitLocalVariableAssignment(AssignmentExpression node,
+                                       AccessSemantics semantics) {
+    return handleLocalAssignment(node, semantics);
+  }
+
+  @override
+  ir.Node visitParameterAssignment(AssignmentExpression node,
+                                   AccessSemantics semantics) {
+    return handleLocalAssignment(node, semantics);
+  }
+
+  @override
   ir.Node visitDynamicAccess(AstNode node, AccessSemantics semantics) {
     // TODO(johnniwinther): Handle implicit `this`.
     ir.Primitive receiver = build(semantics.target);
     return irBuilder.buildDynamicGet(receiver,
         new Selector.getter(semantics.identifier.name,
                             converter.convertElement(element.library)));
   }
 
   @override
   ir.Node visitStaticFieldAccess(AstNode node, AccessSemantics semantics) {
@@ skipping 53 matching lines @@
         build(node.condition),
         subbuild(node.thenStatement),
         subbuild(node.elseStatement));
   }
 
   @override
   visitBlock(Block node) {
     irBuilder.buildBlock(node.statements, build);
   }
 }