Allow bitwise operators to convert from intish to int in heap ops.

src/typing-asm.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/typing-asm.h"
 
 #include <limits>
 
 #include "src/v8.h"
 
@@ skipping 1095 matching lines @@
 
   intish_ = 0;
 
   if (left_type->Is(cache_.kAsmFixnum) && right_type->Is(cache_.kAsmInt)) {
     left_type = right_type;
   }
   if (right_type->Is(cache_.kAsmFixnum) && left_type->Is(cache_.kAsmInt)) {
     right_type = left_type;
   }
   if (!conversion) {
-    if (!left_type->Is(cache_.kAsmInt) || !right_type->Is(cache_.kAsmInt)) {
+    if (!left_type->Is(cache_.kAsmIntQ) || !right_type->Is(cache_.kAsmIntQ)) {
       FAIL(expr, "ill-typed bitwise operation");
     }
   }
   IntersectResult(expr, result_type);
 }
 
 
 void AsmTyper::VisitBinaryOperation(BinaryOperation* expr) {
   if (!in_function_) {
     if (expr->op() != Token::BIT_OR && expr->op() != Token::MUL) {
@@ skipping 23 matching lines @@
       RECURSE(VisitWithExpectation(expr->right(), Type::Any(),
                                    "right comma operand expected to be any"));
       IntersectResult(expr, computed_type_);
       return;
     }
     case Token::OR:
     case Token::AND:
       FAIL(expr, "illegal logical operator");
     case Token::BIT_OR: {
       // BIT_OR allows Any since it is used as a type coercion.
-      VisitIntegerBitwiseOperator(expr, Type::Any(), cache_.kAsmInt,
+      VisitIntegerBitwiseOperator(expr, Type::Any(), cache_.kAsmIntQ,
                                   cache_.kAsmSigned, true);
       if (expr->left()->IsCall() && expr->op() == Token::BIT_OR) {
         expr->left()->set_bounds(Bounds(cache_.kAsmSigned));
       }
       return;
     }
     case Token::BIT_XOR: {
       // Handle booleans specially to handle de-sugared !
       Literal* left = expr->left()->AsLiteral();
       if (left && left->value()->IsBoolean()) {
         if (left->ToBooleanIsTrue()) {
           left->set_bounds(Bounds(cache_.kSingletonOne));
-          RECURSE(VisitWithExpectation(expr->right(), cache_.kAsmInt,
+          RECURSE(VisitWithExpectation(expr->right(), cache_.kAsmIntQ,
                                        "not operator expects an integer"));
           IntersectResult(expr, cache_.kAsmSigned);
           return;
         } else {
           FAIL(left, "unexpected false");
         }
       }
-      // BIT_XOR allows Number since it is used as a type coercion (via ~~).
-      VisitIntegerBitwiseOperator(expr, Type::Number(), cache_.kAsmInt,
+      // BIT_XOR allows Any since it is used as a type coercion (via ~~).
+      VisitIntegerBitwiseOperator(expr, Type::Any(), cache_.kAsmIntQ,
                                   cache_.kAsmSigned, true);
       return;
     }
     case Token::SHR: {
-      VisitIntegerBitwiseOperator(expr, cache_.kAsmInt, cache_.kAsmInt,
+      VisitIntegerBitwiseOperator(expr, cache_.kAsmIntQ, cache_.kAsmIntQ,
                                   cache_.kAsmUnsigned, false);
       return;
     }
     case Token::SHL:
     case Token::SAR:
     case Token::BIT_AND: {
-      VisitIntegerBitwiseOperator(expr, cache_.kAsmInt, cache_.kAsmInt,
+      VisitIntegerBitwiseOperator(expr, cache_.kAsmIntQ, cache_.kAsmIntQ,
                                   cache_.kAsmSigned, false);
       return;
     }
     case Token::ADD:
     case Token::SUB:
     case Token::MUL:
     case Token::DIV:
     case Token::MOD: {
       RECURSE(VisitWithExpectation(
           expr->left(), Type::Number(),
@@ skipping 355 matching lines @@
 }
 
 
 void AsmTyper::VisitRewritableExpression(RewritableExpression* expr) {
   RECURSE(Visit(expr->expression()));
 }
 
 
 }  // namespace internal
 }  // namespace v8