Add UInt32 and UInt31 types to better infer bit operations.

sdk/lib/_internal/compiler/implementation/constants.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 dart2js;
 
 abstract class ConstantVisitor<R> {
   R visitFunction(FunctionConstant constant);
   R visitNull(NullConstant constant);
   R visitInt(IntConstant constant);
@@ skipping 30 matching lines @@
   bool isType() => false;
   bool isSentinel() => false;
   bool isInterceptor() => false;
 
   bool isNaN() => false;
   bool isMinusZero() => false;
 
   // TODO(johnniwinther): Replace with a 'type' getter.
   DartType computeType(Compiler compiler);
 
+  ti.TypeMask computeMask(Compiler compiler);
+
   List<Constant> getDependencies();
 
   accept(ConstantVisitor visitor);
 }
 
 class FunctionConstant extends Constant {
   Element element;
 
   FunctionConstant(this.element);
 
   bool isFunction() => true;
 
   bool operator ==(var other) {
     if (other is !FunctionConstant) return false;
     return identical(other.element, element);
   }
 
   String toString() => element.toString();
   List<Constant> getDependencies() => const <Constant>[];
   DartString toDartString() {
     return new DartString.literal(element.name);
   }
 
   DartType computeType(Compiler compiler) {
     return compiler.functionClass.computeType(compiler);
   }
 
+  ti.TypeMask computeMask(Compiler compiler) {
+    return compiler.typesTask.functionType;
+  }
+
   int get hashCode => (17 * element.hashCode) & 0x7fffffff;
 
   accept(ConstantVisitor visitor) => visitor.visitFunction(this);
 }
 
 abstract class PrimitiveConstant extends Constant {
   get value;
   const PrimitiveConstant();
   bool isPrimitive() => true;
 
@@ skipping 18 matching lines @@
 
   factory NullConstant() => const NullConstant._internal();
   const NullConstant._internal();
   bool isNull() => true;
   get value => null;
 
   DartType computeType(Compiler compiler) {
     return compiler.nullClass.computeType(compiler);
   }
 
+  ti.TypeMask computeMask(Compiler compiler) {
+    return compiler.typesTask.nullType;
+  }
+
   void _writeJsCode(CodeBuffer buffer, ConstantHandler handler) {
     buffer.write(JsNull);
   }
 
   // The magic constant has no meaning. It is just a random value.
   int get hashCode => 785965825;
   DartString toDartString() => const LiteralDartString("null");
 
   accept(ConstantVisitor visitor) => visitor.visitNull(this);
 }
@@ skipping 19 matching lines @@
       case 8: return const IntConstant._internal(8);
       case 9: return const IntConstant._internal(9);
       case 10: return const IntConstant._internal(10);
       case -1: return const IntConstant._internal(-1);
       case -2: return const IntConstant._internal(-2);
       default: return new IntConstant._internal(value);
     }
   }
   const IntConstant._internal(this.value);
   bool isInt() => true;
+  bool isUInt31() => value >= 0 && value < (1 << 31);
+  bool isUInt32() => value >= 0 && value < (1 << 32);
 
   DartType computeType(Compiler compiler) {
     return compiler.intClass.computeType(compiler);
   }
 
+  ti.TypeMask computeMask(Compiler compiler) {
+    if (isUInt31()) return compiler.typesTask.uint31Type;
+    if (isUInt32()) return compiler.typesTask.uint32Type;
+    return compiler.typesTask.intType;
+  }
+
   // We have to override the equality operator so that ints and doubles are
   // treated as separate constants.
   // The is [:!IntConstant:] check at the beginning of the function makes sure
   // that we compare only equal to integer constants.
   bool operator ==(var other) {
     if (other is !IntConstant) return false;
     IntConstant otherInt = other;
     return value == otherInt.value;
   }
 
@@ skipping 23 matching lines @@
   const DoubleConstant._internal(this.value);
   bool isDouble() => true;
   bool isNaN() => value.isNaN;
   // We need to check for the negative sign since -0.0 == 0.0.
   bool isMinusZero() => value == 0.0 && value.isNegative;
 
   DartType computeType(Compiler compiler) {
     return compiler.doubleClass.computeType(compiler);
   }
 
+  ti.TypeMask computeMask(Compiler compiler) {
+    return compiler.typesTask.doubleType;
+  }
+
   bool operator ==(var other) {
     if (other is !DoubleConstant) return false;
     DoubleConstant otherDouble = other;
     double otherValue = otherDouble.value;
     if (value == 0.0 && otherValue == 0.0) {
       return value.isNegative == otherValue.isNegative;
     } else if (value.isNaN) {
       return otherValue.isNaN;
     } else {
       return value == otherValue;
@@ skipping 10 matching lines @@
   factory BoolConstant(value) {
     return value ? new TrueConstant() : new FalseConstant();
   }
   const BoolConstant._internal();
   bool isBool() => true;
 
   DartType computeType(Compiler compiler) {
     return compiler.boolClass.computeType(compiler);
   }
 
+  ti.TypeMask computeMask(Compiler compiler) {
+    return compiler.typesTask.boolType;
+  }
+
   BoolConstant negate();
 }
 
 class TrueConstant extends BoolConstant {
   final bool value = true;
 
   factory TrueConstant() => const TrueConstant._internal();
   const TrueConstant._internal() : super._internal();
   bool isTrue() => true;
 
@@ skipping 36 matching lines @@
   // DartString.
   StringConstant(DartString value, this.node)
       : this.value = value,
         this.hashCode = value.slowToString().hashCode;
   bool isString() => true;
 
   DartType computeType(Compiler compiler) {
     return compiler.stringClass.computeType(compiler);
   }
 
+  ti.TypeMask computeMask(Compiler compiler) {
+    return compiler.typesTask.stringType;
+  }
+
   bool operator ==(var other) {
     if (other is !StringConstant) return false;
     StringConstant otherString = other;
     return (hashCode == otherString.hashCode) && (value == otherString.value);
   }
 
   DartString toDartString() => value;
   int get length => value.length;
 
   accept(ConstantVisitor visitor) => visitor.visitString(this);
@@ skipping 17 matching lines @@
   final DartType representedType;
 
   TypeConstant(this.representedType, type) : super(type);
 
   bool isType() => true;
 
   bool operator ==(other) {
     return other is TypeConstant && representedType == other.representedType;
   }
 
+  ti.TypeMask computeMask(Compiler compiler) {
+    return compiler.typesTask.typeType;
+  }
+
   int get hashCode => representedType.hashCode * 13;
 
   List<Constant> getDependencies() => const <Constant>[];
 
   accept(ConstantVisitor visitor) => visitor.visitType(this);
 
   String toString() => 'TypeConstant(${Error.safeToString(representedType)})';
 }
 
 class ListConstant extends ObjectConstant {
@@ skipping 25 matching lines @@
     for (int i = 0; i < entries.length; i++) {
       if (entries[i] != otherList.entries[i]) return false;
     }
     return true;
   }
 
   List<Constant> getDependencies() => entries;
 
   int get length => entries.length;
 
+  ti.TypeMask computeMask(Compiler compiler) {
+    return compiler.typesTask.constListType;
+  }
+
   accept(ConstantVisitor visitor) => visitor.visitList(this);
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     sb.write('ListConstant([');
     for (int i = 0 ; i < entries.length ; i++) {
       if (i > 0) sb.write(',');
       sb.write(Error.safeToString(entries[i]));
     }
     sb.write('])');
@@ skipping 36 matching lines @@
   static int computeHash(DartType type, List<Constant> values) {
     // TODO(floitsch): create a better hash.
     int hash = 0;
     for (Constant value in values) {
       hash ^= value.hashCode;
     }
     hash ^= type.hashCode;
     return hash;
   }
 
+  ti.TypeMask computeMask(Compiler compiler) {
+    return compiler.typesTask.constMapType;
+  }
+
   bool operator ==(var other) {
     if (other is !MapConstant) return false;
     MapConstant otherMap = other;
     if (hashCode != otherMap.hashCode) return false;
     if (type != other.type) return false;
     if (keys != otherMap.keys) return false;
     for (int i = 0; i < values.length; i++) {
       if (values[i] != otherMap.values[i]) return false;
     }
     return true;
@@ skipping 45 matching lines @@
   }
 
   int get hashCode => dispatchedType.hashCode * 43;
 
   List<Constant> getDependencies() => const <Constant>[];
 
   accept(ConstantVisitor visitor) => visitor.visitInterceptor(this);
 
   DartType computeType(Compiler compiler) => compiler.types.dynamicType;
 
+  ti.TypeMask computeMask(Compiler compiler) {
+    return compiler.typesTask.nonNullType;
+  }
+
   String toString() {
     return 'InterceptorConstant(${Error.safeToString(dispatchedType)})';
   }
 }
 
 class ConstructedConstant extends ObjectConstant {
   final List<Constant> fields;
   final int hashCode;
 
   ConstructedConstant(DartType type, List<Constant> fields)
@@ skipping 21 matching lines @@
     if (type != other.type) return false;
     if (fields.length != other.fields.length) return false;
     for (int i = 0; i < fields.length; i++) {
       if (fields[i] != other.fields[i]) return false;
     }
     return true;
   }
 
   List<Constant> getDependencies() => fields;
 
+  ti.TypeMask computeMask(Compiler compiler) {
+    if (compiler.backend.isInterceptorClass(type.element)) {
+      return compiler.typesTask.nonNullType;
+    }
+    return new ti.TypeMask.nonNullExact(type.element);
+  }
+
   accept(ConstantVisitor visitor) => visitor.visitConstructed(this);
 
   Map<Element, Constant> get fieldElements {
     // TODO(ahe): Refactor constant system to store this information directly.
     ClassElement classElement = type.element;
     int count = 0;
     Map<Element, Constant> result = new Map<Element, Constant>();
     classElement.implementation.forEachInstanceField((holder, field) {
       result[field] = fields[count++];
     }, includeSuperAndInjectedMembers: true);
@@ skipping 10 matching lines @@
       if (i > 0) sb.write(',');
       sb.write(Error.safeToString(field.name));
       sb.write('=');
       sb.write(Error.safeToString(value));
       i++;
     });
     sb.write('))');
     return sb.toString();
   }
 }