fix set index bug in frog.

frog/gen.dart

 // Copyright (c) 2011, 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.
 
 /**
  * Top level generator object for writing code and keeping track of
  * dependencies.
  *
  * Should have two compilation models, but only one implemented so far.
  *
@@ skipping 1160 matching lines @@
   visitTypedValue(Expression node, Type expectedType) {
     return visitValue(node).convertTo(this, expectedType, node);
   }
 
   visitVoid(Expression node) {
     // TODO(jmesserly): should we generalize this?
     if (node is PostfixExpression) {
       var value = visitPostfixExpression(node, /*isVoid:*/true);
       value.checkFirstClass(node.span);
       return value;
+    } else if (node is BinaryExpression) {
+      var value = visitBinaryExpression(node, /*isVoid:*/true);

[Jennifer Messerly, 2011/12/06 01:06:39]

you could actually pass "isVoid:true" now :)

+      value.checkFirstClass(node.span);
+      return value;
     }
     // TODO(jimhug): Some level of warnings for non-void things here?
     return visitValue(node);
   }
 
   // ******************* Statements *******************
 
   bool visitDietStatement(DietStatement node) {
     var parser = new Parser(node.span.file, startOffset: node.span.start);
     visitStatementsInBlock(parser.block());
@@ skipping 551 matching lines @@
 
     return target.invoke(this, name, position, _makeArgs(node.arguments));
   }
 
   visitIndexExpression(IndexExpression node) {
     var target = visitValue(node.target);
     var index = visitValue(node.index);
     return target.invoke(this, ':index', node, new Arguments(null, [index]));
   }
 
-  visitBinaryExpression(BinaryExpression node) {
+  visitBinaryExpression(BinaryExpression node, [bool isVoid = false]) {
     final kind = node.op.kind;
     // TODO(jimhug): Ensure these have same semantics as JS!
     if (kind == TokenKind.AND || kind == TokenKind.OR) {
       var x = visitTypedValue(node.x, world.nonNullBool);
       var y = visitTypedValue(node.y, world.nonNullBool);
       final code = '${x.code} ${node.op} ${y.code}';
       if (x.isConst && y.isConst) {
         var value = (kind == TokenKind.AND)
             ? x.actualValue && y.actualValue : x.actualValue || y.actualValue;
         return new EvaluatedValue(world.nonNullBool, value, '$value',
@@ skipping 46 matching lines @@
       var name = TokenKind.binaryMethodName(node.op.kind);
       if (node.op.kind == TokenKind.NE) {
         name = ':ne';
       }
       if (name == null) {
         world.internalError('unimplemented binary op ${node.op}', node.span);
         return;
       }
       return x.invoke(this, name, node, new Arguments(null, [y]));
     } else {
-      return _visitAssign(assignKind, node.x, node.y, node, null);
+      return _visitAssign(assignKind, node.x, node.y, node, null, isVoid);
     }
   }
 
   /**
    * Visits an assignment expression.
    * Note: captureOriginal can optionally capture the original value of the
    * left side. This is used by postfix expressions to ensure they return the
    * original value, before it has been modified.
    */
   _visitAssign(int kind, Expression xn, Expression yn, Node position,
-      Value captureOriginal(Value right)) {
+      Value captureOriginal(Value right), [bool isVoid = false]) {
 
     if (captureOriginal == null) {
       captureOriginal = (x) => x;
     }
 
     // TODO(jimhug): The usual battle with making assign impl not look ugly.
     if (xn is VarExpression) {
       return _visitVarAssign(kind, xn, yn, position, captureOriginal);
     } else if (xn is IndexExpression) {
-      return _visitIndexAssign(kind, xn, yn, position, captureOriginal);
+      return _visitIndexAssign(kind, xn, yn, position, captureOriginal, isVoid);
     } else if (xn is DotExpression) {
       return _visitDotAssign(kind, xn, yn, position, captureOriginal);
     } else {
       world.error('illegal lhs', xn.span);
     }
   }
 
   // TODO(jmesserly): it'd be nice if we didn't have to deal directly with
   // MemberSets here and in visitVarExpression.
   _visitVarAssign(int kind, VarExpression xn, Expression yn, Node position,
@@ skipping 70 matching lines @@
     } else {
       var right = x;
       right = captureOriginal(right);
       y = right.invoke(this, TokenKind.binaryMethodName(kind),
         position, new Arguments(null, [y]));
       return new Value(y.type, '${x.code} = ${y.code}', position.span);
     }
   }
 
   _visitIndexAssign(int kind, IndexExpression xn, Expression yn, Node position,
-      Value captureOriginal(Value right)) {
+      Value captureOriginal(Value right), [bool isVoid = false]) {
     var target = visitValue(xn.target);
     var index = visitValue(xn.index);
     var y = visitValue(yn);
 
     var tmptarget = target;
     var tmpindex = index;
     if (kind != 0) {
       tmptarget = getTemp(target);
       tmpindex = getTemp(index);
       index = assignTemp(tmpindex, index);
       var right = tmptarget.invoke(this, ':index',
           position, new Arguments(null, [tmpindex]));
       right = captureOriginal(right);
       y = right.invoke(this, TokenKind.binaryMethodName(kind),
           position, new Arguments(null, [y]));
     }
+
+    var tmpy = null;
+    // If the assignment is an expression statement (x[i] = y;) it is translated
+    // as (x.$setindex(i, y)), otherwise as (x.$setindex(i, t = y), t).
+    if (!isVoid) {
+      tmpy = getTemp(y);
+      y = assignTemp(tmpy, y);
+    }
     var ret = assignTemp(tmptarget, target).invoke(this, ':setindex',
         position, new Arguments(null, [index, y]));
+    if (tmpy != null) {
+      ret = new Value(ret.type, '(${ret.code}, ${tmpy.code})', ret.span);
+      if (tmpy != y) freeTemp(tmpy);
+    }
     if (tmptarget != target) freeTemp(tmptarget);
     if (tmpindex != index) freeTemp(tmpindex);
     return ret;
   }
 
   _visitDotAssign(int kind, DotExpression xn, Expression yn, Node position,
       Value captureOriginal(Value right)) {
 
     // This is not visitValue because types are assignable through .
     var target = xn.self.visit(this);
@@ skipping 489 matching lines @@
       result.add(new Value(world.varType, '\$$i', null, /*needsTemp:*/false));
     }
     for (int i = bareCount; i < length; i++) {
       var name = getName(i);
       if (name == null) name = '\$$i';
       result.add(new Value(world.varType, name, null, /*needsTemp:*/false));
     }
     return new Arguments(nodes, result);
   }
 }