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 138 matching lines @@
   final Set<HInstruction> generateAtUseSite;
   final Map<HPhi, String> logicalOperations;
   final Map<Element, ElementAction> breakAction;
   final Map<Element, ElementAction> continueAction;
   final Equivalence<HPhi> phiEquivalence;
 
   Element equalsNullElement;
   Element boolifiedEqualsNullElement;
   int indent = 0;
   int expectedPrecedence = JSPrecedence.STATEMENT_PRECEDENCE;
+  JSBinaryOperatorPrecedence unsignedShiftPrecedences;
   HGraph currentGraph;
   /**
    * Whether the code-generation should try to generate an expression
    * instead of a sequence of statements.
    */
   int generationState = STATE_STATEMENT;
   /**
    * While generating expressions, we can't insert variable declarations.
    * Instead we declare them at the end of the function
    */
@@ skipping 18 matching lines @@
                    this.parameters,
                    this.parameterNames)
     : names = new Map<int, String>(),
       prefixes = new Map<String, int>(),
       usedNames = new Set<String>(),
       buffer = new StringBuffer(),
       generateAtUseSite = new Set<HInstruction>(),
       logicalOperations = new Map<HPhi, String>(),
       breakAction = new Map<Element, ElementAction>(),
       continueAction = new Map<Element, ElementAction>(),
-      phiEquivalence = new Equivalence<HPhi>() {
+      phiEquivalence = new Equivalence<HPhi>(),
+      unsignedShiftPrecedences = JSPrecedence.binary['>>>'] {
 
     for (final name in parameterNames.getValues()) {
       prefixes[name] = 0;
     }
 
     // Create a namespace for temporaries.
     prefixes[TEMPORARY_PREFIX] = 0;
 
     Interceptors interceptors = compiler.builder.interceptors;
     equalsNullElement = interceptors.getEqualsNullInterceptor();
@@ skipping 896 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){
+      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){
+      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();
     }
   }
 }