unary operators

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 1414 matching lines @@
       world.warning('not allowed in static method', node.span);
     }
   }
 
   _makeSuperValue(Node node) {
     var parentType = method.declaringType.parent;
     _checkNonStatic(node);
     if (parentType == null) {
       world.error('no super class', node.span);
     }
-    return new Value(parentType, 'this', true);
+    return new Value(parentType, 'this',
+      /*isSuper:*/true, /*needsTemp:*/false);
   }
 
   _getOutermostMethod() {
     var result = this;
     while (result.enclosingMethod != null) {
       result = result.enclosingMethod;
     }
     return result;
   }
 
   /**
    * Creates a reference to the enclosing type ('this') that can be used within
    * closures.
    */
   _makeThisValue(Node node) {
     if (enclosingMethod != null) {
       var outermostMethod = _getOutermostMethod();
       outermostMethod._checkNonStatic(node);
       outermostMethod.needsThis = true;
-      return new Value(outermostMethod.method.declaringType, '\$this');
+      return new Value(outermostMethod.method.declaringType, '\$this',
+        /*isSuper:*/false, /*needsTemp:*/false);
     } else {
       _checkNonStatic(node);
-      return new Value(method.declaringType, 'this');
+      return new Value(method.declaringType, 'this',
+        /*isSuper:*/false, /*needsTemp:*/false);
     }
   }
 
   // ******************* Expressions *******************
   visitLambdaExpression(LambdaExpression node) {
     var name = '';
     if (node.func.name != null) {
       name = world.toJsIdentifier(node.func.name.name);
     }
 
@@ skipping 188 matching lines @@
       Value captureOriginal(Value right)) {
     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);

[Jennifer Messerly, 2011/11/07 21:29:53]

for consistency, I'd remove this line, and change the invoke of "\$setindex"
below to be:

var ret = assignTemp(tmptarget, target).invoke(this, '\$setindex',
    position, new Arguments(null, [assignTemp(tmpindex, index), y]));

using assignTemp inline prevents someone from accidentally assigning twice. The
code is correct as it is though.

       var right = tmptarget.invoke(this, '\$index',
-          position, new Arguments(null, [assignTemp(tmpindex, index)]));
+          position, new Arguments(null, [tmpindex]));
       right = captureOriginal(right);
       y = right.invoke(this, TokenKind.binaryMethodName(kind),
           position, new Arguments(null, [y]));
     }
     var ret = assignTemp(tmptarget, target).invoke(this, '\$setindex',
         position, new Arguments(null, [index, y]));
     if (tmptarget != target) freeTemp(tmptarget);
     if (tmpindex != index) freeTemp(tmpindex);
     return ret;
   }
@@ skipping 31 matching lines @@
           // --x becomes x -= 1
           // TODO(jimhug): Confirm that --x becomes x -= 1 as it is in VM.
           var kind = (TokenKind.INCR == node.op.kind ?
               TokenKind.ADD : TokenKind.SUB);
           var operand = new LiteralExpression(1,
             new TypeReference(node.span, world.numType), '1', node.span);
 
           return _visitAssign(kind, node.self, operand, node, null);
         }
       case TokenKind.NOT:
-        // TODO(jimhug): turn into method invoke?
+        // TODO(jimhug): Issue #359 seeks to clarify this behavior.
         if (value.type.isBool && value.isConst) {
           var newVal = !value.actualValue;
           return new EvaluatedValue(value.type, newVal, '${newVal}', node.span);
         } else {
-          return new Value(world.boolType, '!${value.code}');
+          var newVal = value.convertToNonNullBool(this, node);

[Jennifer Messerly, 2011/11/07 21:29:53]

Ah. I was wondering why we had the extra non-null bool converts in the generated
code.

FWIW, I could not find anything in the spec that says this should use a "boolean
conversion" here. Although it does say we should be using them for && and ||,
which I don't think we are currently (unless you fixed that in another CR). So
this seems consistent & I agree the right fix.

+          return new Value(world.boolType, '!${newVal.code}');
         }
 
-      case TokenKind.ADD: // this should be a noop?
+      case TokenKind.ADD:
+        // TODO(jimhug): Issue #359 seeks to clarify this behavior.
+        return value.convertTo(this, world.numType, node);
+
       case TokenKind.SUB:
       case TokenKind.BIT_NOT:
-        // TODO(jimhug): turn into method invokes more thoroughly
-        if (value.type.isNum) {
-          if (value.isConst) {
-            if (node.op.kind == TokenKind.ADD) {
-              return value;
-            } else if (node.op.kind == TokenKind.SUB) {
-              var newVal = -value.actualValue;
-              return new EvaluatedValue(
-                  value.type, newVal, '$newVal', node.span);
-            } else {
-              var newVal = (~value.actualValue.toInt()).toDouble();
-              return new EvaluatedValue(
-                  value.type, newVal, '$newVal', node.span);
-            }
-          }
-          return new Value(value.type, '${node.op}${value.code}');
+        if (node.op.kind == TokenKind.BIT_NOT) {

[Jennifer Messerly, 2011/11/07 21:29:53]

this is so much nicer.

+          return value.invoke(this, '\$bit_not', node, Arguments.EMPTY);
+        } else if (node.op.kind == TokenKind.SUB) {
+          return value.invoke(this, '\$negate', node, Arguments.EMPTY);
         } else {
-          String name;
-          if (node.op.kind == TokenKind.BIT_NOT) name = '\$bit_not';
-          else if (node.op.kind == TokenKind.SUB) name = '\$negate';
-          else world.internalError(
-            'unimplemented: unary ${node.op} on var', node.span);
-          return new Value(world.varType, '$name(${value.code})');
+          world.internalError('unimplemented: unary ${node.op}',
+            node.span);
         }
       default:
         world.internalError('unimplemented: ${node.op}', node.span);
     }
   }
 
   visitPostfixExpression(PostfixExpression node, [bool isVoid = false]) {
     var value = visitValue(node.body);
     if (value.type.isNum) {
       return new Value(value.type, '${value.code}${node.op}');
@@ skipping 406 matching lines @@
       result.add(new Value(world.varType, '\$$i', false, /*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, false, /*needsTemp:*/false));
     }
     return new Arguments(nodes, result);
   }
 }