Relax the type requirements for using the builtin bitops.

lib/compiler/implementation/ssa/nodes.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.
 
 interface HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
   R visitBitXor(HBitXor node);
@@ skipping 1363 matching lines @@
       clearAllSideEffects();
       setUseGvn();
     } else {
       setAllSideEffects();
     }
   }
 
   bool get builtin() => left.isNumber() && right.isNumber();
 
   HType computeTypeFromInputTypes() {
     if (left.isInteger() && right.isInteger()) return left.propagatedType;

[kasperl, 2012/06/22 04:54:36]

Maybe replace left.propagatedType with HType.INTEGER here?

     if (left.isNumber()) {
       if (left.isDouble() || right.isDouble()) return HType.DOUBLE;
       return HType.NUMBER;
     }
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input) {
     // If the desired output type should be an integer we want to get two
     // integers as arguments.
@@ skipping 122 matching lines @@
   bool dataEquals(HInstruction other) => true;
 }
 
 
 // TODO(floitsch): Should HBinaryArithmetic really be the super class of
 // HBinaryBitOp?
 class HBinaryBitOp extends HBinaryArithmetic {
   HBinaryBitOp(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
 
-  bool get builtin() => left.isInteger() && right.isInteger();
-
   HType computeTypeFromInputTypes() {
     // All bitwise operations on primitive types either produce an
     // integer or throw an error.
     if (left.isPrimitive()) return HType.INTEGER;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input) {
     // If the outgoing type should be a number we can get that only if both
     // inputs are integers. If we don't know the outgoing type we try to make
@@ skipping 14 matching lines @@
 }
 
 class HShiftLeft extends HBinaryBitOp {
   HShiftLeft(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitShiftLeft(this);
 
   // Shift left cannot be mapped to the native operator unless the
   // shift count is guaranteed to be an integer in the [0,31] range.
   bool get builtin() {
     if (!left.isInteger() || !right.isConstantInteger()) return false;

[kasperl, 2012/06/22 04:54:36]

Could this be !left.isNumber() now?

     HConstant rightConstant = right;
     IntConstant intConstant = rightConstant.constant;
     int count = intConstant.value;
     return count >= 0 && count <= 31;
   }
 
   ShiftLeftOperation get operation() => const ShiftLeftOperation();
   int typeCode() => 11;
   bool typeEquals(other) => other is HShiftLeft;
   bool dataEquals(HInstruction other) => true;
@@ skipping 93 matching lines @@
   NegateOperation get operation() => const NegateOperation();
   int typeCode() => 16;
   bool typeEquals(other) => other is HNegate;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitNot extends HInvokeUnary {
   HBitNot(HStatic target, HInstruction input) : super(target, input);
   accept(HVisitor visitor) => visitor.visitBitNot(this);
 
   bool get builtin() => operand.isInteger();

[kasperl, 2012/06/22 04:54:36]

Could we remove this and rely on the implementation in HInvokeUnary that checks
for number?

 
   HType computeTypeFromInputTypes() {
     // All bitwise operations on primitive types either produce an
     // integer or throw an error.
     if (operand.isPrimitive()) return HType.INTEGER;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input) {
     // Bit operations only work on integers. If there is no desired output
@@ skipping 934 matching lines @@
   HBasicBlock get start() => expression.start;
   HBasicBlock get end() {
     // We don't create a switch block if there are no cases.
     assert(!statements.isEmpty());
     return statements.last().end;
   }
 
   bool accept(HStatementInformationVisitor visitor) =>
       visitor.visitSwitchInfo(this);
 }