Add UInt32 and UInt31 types to better infer bit operations.

sdk/lib/_internal/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.
 
 part of ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 171 matching lines @@
       continueAction = new Map<Element, ElementAction>();
 
   Compiler get compiler => backend.compiler;
   NativeEmitter get nativeEmitter => backend.emitter.nativeEmitter;
   CodegenEnqueuer get world => backend.compiler.enqueuer.codegen;
 
   bool isGenerateAtUseSite(HInstruction instruction) {
     return generateAtUseSite.contains(instruction);
   }
 
-  bool isNonNegativeInt32Constant(HInstruction instruction) {
-    if (instruction.isConstantInteger()) {
-      HConstant constantInstruction = instruction;
-      PrimitiveConstant primitiveConstant = constantInstruction.constant;
-      int value = primitiveConstant.value;
-      if (value >= 0 && value < (1 << 31)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
   bool hasNonBitOpUser(HInstruction instruction, Set<HPhi> phiSet) {
     for (HInstruction user in instruction.usedBy) {
       if (user is HPhi) {
         if (!phiSet.contains(user)) {
           phiSet.add(user);
           if (hasNonBitOpUser(user, phiSet)) return true;
         }
       } else if (user is! HBitNot && user is! HBinaryBitOp) {
         return true;
       }
     }
     return false;
   }
 
-  // We want the outcome of bit-operations to be positive. However, if
-  // the result of a bit-operation is only used by other bit
-  // operations we do not have to convert to an unsigned
-  // integer. Also, if we are using & with a positive constant we know
-  // that the result is positive already and need no conversion.
-  bool requiresUintConversion(HInstruction instruction) {
-    if (instruction is HShiftRight) {
-      return false;
-    }
-    if (instruction is HBitAnd) {
-      HBitAnd bitAnd = instruction;
-      if (isNonNegativeInt32Constant(bitAnd.left) ||
-          isNonNegativeInt32Constant(bitAnd.right)) {
-        return false;
-      }
-    }
+  bool requiresUintConversion(instruction) {
+    if (instruction.isUInt31(compiler)) return false;
+    // If the result of a bit-operation is only used by other bit
+    // operations, we do not have to convert to an unsigned integer.
     return hasNonBitOpUser(instruction, new Set<HPhi>());
   }
 
   /**
    * If the [instruction] is not `null` it will be used to attach the position
    * to the [statement].
    */
   void pushStatement(js.Statement statement, [HInstruction instruction]) {
     assert(expressionStack.isEmpty);
     if (instruction != null) {
@@ skipping 2338 matching lines @@
     if (left.isConstantNull() || right.isConstantNull() ||
         (left.isPrimitive(compiler) &&
          left.instructionType == right.instructionType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }