Make bit-operations return a positive result.

lib/compiler/implementation/ssa/codegen.dart

 // Copyright (c) 2012, 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.
 
 class SsaCodeGeneratorTask extends CompilerTask {
   SsaCodeGeneratorTask(Compiler compiler) : super(compiler);
   String get name() => 'SSA code generator';
 
 
   String buildJavaScriptFunction(FunctionElement element,
@@ skipping 1082 matching lines @@
       beginExpression(operatorPrecedences.precedence);
       use(node.left, operatorPrecedences.left);
       buffer.add(' $op ');
       use(node.right, operatorPrecedences.right);
       endExpression(operatorPrecedences.precedence);
     } else {
       visitInvokeStatic(node);
     }
   }
 
+  // We want the outcome of bit-operations to be positive. We use the unsigned
+  // shift operator to achieve this.
+  visitBitInvokeBinary(HBinaryBitOp node, String op) {
+    if (node.builtin){
+      JSBinaryOperatorPrecedence unsignedShiftPrecedences =

[kasperl, 2012/05/03 07:05:50]

Could this be cached somewhere? It feels a bit over the top to look it up every
single time.

[floitsch, 2012/05/03 11:10:36]

cached as instance field now.

+          JSPrecedence.binary['>>>'];
+      beginExpression(unsignedShiftPrecedences.precedence);
+      visitInvokeBinary(node, op);
+      buffer.add(' >>> 0');
+      endExpression(unsignedShiftPrecedences.precedence);
+    } else {
+      visitInvokeBinary(node, op);
+    }
+  }
+
   visitInvokeUnary(HInvokeUnary node, String op) {
     if (node.builtin) {
       beginExpression(JSPrecedence.PREFIX_PRECEDENCE);
       buffer.add('$op');
       use(node.operand, JSPrecedence.PREFIX_PRECEDENCE);
       endExpression(JSPrecedence.PREFIX_PRECEDENCE);
     } else {
       visitInvokeStatic(node);
     }
   }
 
+  // We want the outcome of bit-operations to be positive. We use the unsigned
+  // shift operator to achieve this.
+  visitBitInvokeUnary(HInvokeUnary node, String op) {
+    if (node.builtin){
+      JSBinaryOperatorPrecedence unsignedShiftPrecedences =
+          JSPrecedence.binary['>>>'];
+      beginExpression(unsignedShiftPrecedences.precedence);
+      visitInvokeUnary(node, op);
+      buffer.add(' >>> 0');
+      endExpression(unsignedShiftPrecedences.precedence);
+    } else {
+      visitInvokeUnary(node, op);
+    }
+  }
+
   visitEquals(HEquals node) {
     if (node.builtin) {
       beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
       use(node.left, JSPrecedence.EQUALITY_PRECEDENCE);
       buffer.add(' === ');
       use(node.right, JSPrecedence.RELATIONAL_PRECEDENCE);
       endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
     } else if (node.element === equalsNullElement ||
                node.element === boolifiedEqualsNullElement) {
       beginExpression(JSPrecedence.CALL_PRECEDENCE);
       use(node.target, JSPrecedence.CALL_PRECEDENCE);
       buffer.add('(');
       use(node.left, JSPrecedence.ASSIGNMENT_PRECEDENCE);
       buffer.add(')');
       endExpression(JSPrecedence.CALL_PRECEDENCE);
     } else {
       visitInvokeStatic(node);
     }
   }
 
   visitAdd(HAdd node)               => visitInvokeBinary(node, '+');
   visitDivide(HDivide node)         => visitInvokeBinary(node, '/');
   visitMultiply(HMultiply node)     => visitInvokeBinary(node, '*');
   visitSubtract(HSubtract node)     => visitInvokeBinary(node, '-');
   // Truncating divide does not have a JS equivalent.
   visitTruncatingDivide(HTruncatingDivide node) => visitInvokeStatic(node);
   // Modulo cannot be mapped to the native operator (different semantics).
   visitModulo(HModulo node)                     => visitInvokeStatic(node);
 
-  visitBitAnd(HBitAnd node)         => visitInvokeBinary(node, '&');
-  visitBitNot(HBitNot node)         => visitInvokeUnary(node, '~');
-  visitBitOr(HBitOr node)           => visitInvokeBinary(node, '|');
-  visitBitXor(HBitXor node)         => visitInvokeBinary(node, '^');
+  visitBitAnd(HBitAnd node)         => visitBitInvokeBinary(node, '&');
+  visitBitNot(HBitNot node)         => visitBitInvokeUnary(node, '~');
+  visitBitOr(HBitOr node)           => visitBitInvokeBinary(node, '|');
+  visitBitXor(HBitXor node)         => visitBitInvokeBinary(node, '^');
 
   // We need to check if the left operand is negative in order to use
   // the native operator.
   visitShiftRight(HShiftRight node) => visitInvokeStatic(node);
 
   // Shift left cannot be mapped to the native operator (different semantics).
   visitShiftLeft(HShiftLeft node)   => visitInvokeStatic(node);
 
   visitNegate(HNegate node)         => visitInvokeUnary(node, '-');
 
@@ skipping 1232 matching lines @@
       startBailoutSwitch();
     }
   }
 
   void endLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
     if (labeledBlockInfo.body.start.hasGuards()) {
       endBailoutSwitch();
     }
   }
 }