fix set index bug in frog.

frog/minfrog

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives dart:core **************
 /**
  * Generates a dynamic call stub for a function.
  * Our goal is to create a stub method like this on-the-fly:
  *   function($0, $1, capture) { return this($0, $1, true, capture); }
  *
  * This stub then replaces the dynamic one on Function, with one that is
  * specialized for that particular function, taking into account its default
@@ skipping 331 matching lines @@
 };
 Object.prototype.substring$2 = function($0, $1) {
   return this.noSuchMethod("substring", [$0, $1]);
 };
 Object.prototype.toString$0 = function() {
   return this.toString();
 };
 Object.prototype.visit$1 = function($0) {
   return this.noSuchMethod("visit", [$0]);
 };
+Object.prototype.visitBinaryExpression$1 = function($0) {
+  return this.noSuchMethod("visitBinaryExpression", [$0]);
+};
 Object.prototype.visitPostfixExpression$1 = function($0) {
   return this.noSuchMethod("visitPostfixExpression", [$0]);
 };
 Object.prototype.visitSources$0 = function() {
   return this.noSuchMethod("visitSources", []);
 };
 Object.prototype.writeDefinition$2 = function($0, $1) {
   return this.noSuchMethod("writeDefinition", [$0, $1]);
 };
 // ********** Code for NoSuchMethodException **************
@@ skipping 2572 matching lines @@
 }
 MethodGenerator.prototype.visitTypedValue = function(node, expectedType) {
   return this.visitValue(node).convertTo$3(this, expectedType, node);
 }
 MethodGenerator.prototype.visitVoid = function(node) {
   if ((node instanceof PostfixExpression)) {
     var value = this.visitPostfixExpression(node, true);
     value.checkFirstClass$1(node.span);
     return value;
   }
+  else if ((node instanceof BinaryExpression)) {
+    var value = this.visitBinaryExpression(node, true);
+    value.checkFirstClass$1(node.span);
+    return value;
+  }
   return this.visitValue(node);
 }
 MethodGenerator.prototype.visitDietStatement = function(node) {
   var parser = new Parser(node.span.file, false, false, false, node.span.start);
   this.visitStatementsInBlock(parser.block$0());
   return false;
 }
 MethodGenerator.prototype.visitVariableDefinition = function(node) {
   var isFinal = false;
   if (node.modifiers != null && $eq(node.modifiers.$index(0).get$kind(), 98/*TokenKind.FINAL*/)) {
@@ skipping 443 matching lines @@
   else {
     target = node.target.visit(this);
   }
   return target.invoke$4(this, name, position, this._makeArgs(node.arguments));
 }
 MethodGenerator.prototype.visitIndexExpression = function(node) {
   var target = this.visitValue(node.target);
   var index = this.visitValue(node.index);
   return target.invoke$4(this, ':index', node, new Arguments(null, [index]));
 }
-MethodGenerator.prototype.visitBinaryExpression = function(node) {
+MethodGenerator.prototype.visitBinaryExpression = function(node, isVoid) {
   var kind = node.op.kind;
   if (kind == 35/*TokenKind.AND*/ || kind == 34/*TokenKind.OR*/) {
     var x = this.visitTypedValue(node.x, $globals.world.nonNullBool);
     var y = this.visitTypedValue(node.y, $globals.world.nonNullBool);
     var code = ('' + x.get$code() + ' ' + node.op + ' ' + y.get$code());
     if (x.get$isConst() && y.get$isConst()) {
       var value = (kind == 35/*TokenKind.AND*/) ? x.get$actualValue() && y.get$actualValue() : x.get$actualValue() || y.get$actualValue();
       return EvaluatedValue.EvaluatedValue$factory($globals.world.nonNullBool, value, ('' + value), node.span);
     }
     return new Value($globals.world.nonNullBool, code, node.span, true);
@@ skipping 33 matching lines @@
     if (node.op.kind == 49/*TokenKind.NE*/) {
       name = ':ne';
     }
     if (name == null) {
       $globals.world.internalError(('unimplemented binary op ' + node.op), node.span);
       return;
     }
     return x.invoke$4(this, name, node, new Arguments(null, [y]));
   }
   else {
-    return this._visitAssign(assignKind, node.x, node.y, node, to$call$1(null));
+    return this._visitAssign(assignKind, node.x, node.y, node, to$call$1(null), isVoid);
   }
 }
-MethodGenerator.prototype._visitAssign = function(kind, xn, yn, position, captureOriginal) {
+MethodGenerator.prototype._visitAssign = function(kind, xn, yn, position, captureOriginal, isVoid) {
   if (captureOriginal == null) {
     captureOriginal = (function (x) {
       return x;
     })
     ;
   }
   if ((xn instanceof VarExpression)) {
     return this._visitVarAssign(kind, xn, yn, position, captureOriginal);
   }
   else if ((xn instanceof IndexExpression)) {
-    return this._visitIndexAssign(kind, xn, yn, position, captureOriginal);
+    return this._visitIndexAssign(kind, xn, yn, position, captureOriginal, isVoid);
   }
   else if ((xn instanceof DotExpression)) {
     return this._visitDotAssign(kind, xn, yn, position, captureOriginal);
   }
   else {
     $globals.world.error('illegal lhs', xn.span);
   }
 }
 MethodGenerator.prototype._visitVarAssign = function(kind, xn, yn, position, captureOriginal) {
   var name = xn.name.name;
@@ skipping 52 matching lines @@
     var op = TokenKind.kindToString(kind);
     return new Value(y.get$type(), ('' + x.get$code() + ' ' + op + '= ' + y.get$code()), position.span, true);
   }
   else {
     var right = x;
     right = captureOriginal(right);
     y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
     return new Value(y.get$type(), ('' + x.get$code() + ' = ' + y.get$code()), position.span, true);
   }
 }
-MethodGenerator.prototype._visitIndexAssign = function(kind, xn, yn, position, captureOriginal) {
+MethodGenerator.prototype._visitIndexAssign = function(kind, xn, yn, position, captureOriginal, isVoid) {
   var target = this.visitValue(xn.target);
   var index = this.visitValue(xn.index);
   var y = this.visitValue(yn);
   var tmptarget = target;
   var tmpindex = index;
   if (kind != 0) {
     tmptarget = this.getTemp(target);
     tmpindex = this.getTemp(index);
     index = this.assignTemp(tmpindex, index);
     var right = tmptarget.invoke$4(this, ':index', position, new Arguments(null, [tmpindex]));
     right = captureOriginal(right);
     y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
   }
+  var tmpy = null;
+  if (!isVoid) {
+    tmpy = this.getTemp(y);
+    y = this.assignTemp(tmpy, y);
+  }
   var ret = this.assignTemp(tmptarget, target).invoke(this, ':setindex', position, new Arguments(null, [index, y]), false);
+  if ($ne(tmpy, null)) {
+    ret = new Value(ret.get$type(), ('(' + ret.get$code() + ', ' + tmpy.get$code() + ')'), ret.get$span(), true);
+    if ($ne(tmpy, y)) this.freeTemp(tmpy);
+  }
   if ($ne(tmptarget, target)) this.freeTemp(tmptarget);
   if ($ne(tmpindex, index)) this.freeTemp(tmpindex);
   return ret;
 }
 MethodGenerator.prototype._visitDotAssign = function(kind, xn, yn, position, captureOriginal) {
   var target = xn.self.visit(this);
   var y = this.visitValue(yn);
   var tmptarget = target;
   if (kind != 0) {
     tmptarget = this.getTemp(target);
@@ skipping 10 matching lines @@
   switch (node.op.kind) {
     case 16/*TokenKind.INCR*/:
     case 17/*TokenKind.DECR*/:
 
       if (value.get$type().get$isNum()) {
         return new Value(value.get$type(), ('' + node.op + value.get$code()), node.span, true);
       }
       else {
         var kind = (16/*TokenKind.INCR*/ == node.op.kind ? 42/*TokenKind.ADD*/ : 43/*TokenKind.SUB*/);
         var operand = new LiteralExpression(1, new TypeReference(node.span, $globals.world.numType), '1', node.span);
-        var assignValue = this._visitAssign(kind, node.self, operand, node, to$call$1(null));
+        var assignValue = this._visitAssign(kind, node.self, operand, node, to$call$1(null), false);
         return new Value(assignValue.get$type(), ('(' + assignValue.get$code() + ')'), node.span, true);
       }
 
     case 19/*TokenKind.NOT*/:
 
       if (value.get$type().get$isBool() && value.get$isConst()) {
         var newVal = !value.get$actualValue();
         return EvaluatedValue.EvaluatedValue$factory(value.get$type(), newVal, ('' + newVal), node.span);
       }
       else {
@@ skipping 40 matching lines @@
   var ret = this._visitAssign(kind, node.body, operand, node, (function (l) {
     if (isVoid) {
       return l;
     }
     else {
       left = l;
       tmpleft = $this.forceTemp(l);
       return $this.assignTemp(tmpleft, left);
     }
   })
-  );
+  , false);
   if ($ne(tmpleft, null)) {
     ret = new Value(ret.get$type(), ("(" + ret.get$code() + ", " + tmpleft.get$code() + ")"), node.span, true);
   }
   if ($ne(tmpleft, left)) {
     this.freeTemp(tmpleft);
   }
   return ret;
 }
 MethodGenerator.prototype.visitNewExpression = function(node) {
   var typeRef = node.type;
@@ skipping 195 matching lines @@
       text = toDoubleQuote(text);
       text = ('"' + text + '"');
     }
     if (text !== node.text) {
       node.value = text;
       node.text = text;
     }
   }
   return EvaluatedValue.EvaluatedValue$factory(type, node.value, node.text, null);
 }
+MethodGenerator.prototype.visitBinaryExpression$1 = function($0) {
+  return this.visitBinaryExpression($0, false);
+};
 MethodGenerator.prototype.visitPostfixExpression$1 = function($0) {
   return this.visitPostfixExpression($0, false);
 };
 MethodGenerator.prototype.writeDefinition$2 = MethodGenerator.prototype.writeDefinition;
 // ********** Code for Arguments **************
 function Arguments(nodes, values) {
   this.nodes = nodes;
   this.values = values;
   // Initializers done
 }
@@ skipping 6073 matching lines @@
   Expression.call(this, span);
 }
 $inherits(BinaryExpression, Expression);
 BinaryExpression.prototype.get$op = function() { return this.op; };
 BinaryExpression.prototype.set$op = function(value) { return this.op = value; };
 BinaryExpression.prototype.get$x = function() { return this.x; };
 BinaryExpression.prototype.set$x = function(value) { return this.x = value; };
 BinaryExpression.prototype.get$y = function() { return this.y; };
 BinaryExpression.prototype.set$y = function(value) { return this.y = value; };
 BinaryExpression.prototype.visit = function(visitor) {
-  return visitor.visitBinaryExpression(this);
+  return visitor.visitBinaryExpression$1(this);
 }
 BinaryExpression.prototype.visit$1 = BinaryExpression.prototype.visit;
 // ********** Code for UnaryExpression **************
 function UnaryExpression(op, self, span) {
   this.op = op;
   this.self = self;
   // Initializers done
   Expression.call(this, span);
 }
 $inherits(UnaryExpression, Expression);
@@ skipping 3001 matching lines @@
 $inheritsMembers(_DoubleLinkedQueueEntrySentinel_KeyValuePair_K$V, DoubleLinkedQueueEntry_KeyValuePair_K$V);
 //  ********** Globals **************
 function $static_init(){
 }
 var const$0 = new NoMoreElementsException()/*const NoMoreElementsException()*/;
 var const$2 = new EmptyQueueException()/*const EmptyQueueException()*/;
 var const$3 = new _DeletedKeySentinel()/*const _DeletedKeySentinel()*/;
 var $globals = {};
 $static_init();
 main();