Fix ~ operator in asm typer, add more operator tests.

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/v8.h"
 
 #include "src/typing-asm.h"
 
 #include "src/ast.h"
 #include "src/codegen.h"
@@ skipping 823 matching lines @@
     case Token::COMMA: {
       RECURSE(VisitWithExpectation(expr->left(), Type::Any(),
                                    "left comma operand expected to be any"));
       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, "logical operator encountered");
+      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_.kIntegral32,
                                   cache_.kInt32, true);
       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_.kIntegral32,
+                                       "not operator expects an integer"));
+          IntersectResult(expr, cache_.kInt32);
+          return;
+        } else {
+          FAIL(left, "unexpected false");
+        }
+      }
       // BIT_XOR allows Number since it is used as a type coercion (via ~~).
       VisitIntegerBitwiseOperator(expr, Type::Number(), cache_.kIntegral32,
                                   cache_.kInt32, true);
       return;
     }
     case Token::SHR: {
       VisitIntegerBitwiseOperator(expr, cache_.kIntegral32, cache_.kIntegral32,
                                   cache_.kUint32, false);
       return;
     }
@@ skipping 65 matching lines @@
 
 
 void AsmTyper::VisitCompareOperation(CompareOperation* expr) {
   RECURSE(
       VisitWithExpectation(expr->left(), Type::Number(),
                            "left comparison operand expected to be number"));
   Type* left_type = computed_type_;
   RECURSE(
       VisitWithExpectation(expr->right(), Type::Number(),
                            "right comparison operand expected to be number"));
+  Token::Value op = expr->op();
+  if (op != Token::EQ && op != Token::NE && op != Token::LT &&
+      op != Token::LTE && op != Token::GT && op != Token::GTE) {
+    FAIL(expr, "illegal comparison operator");
+  }
   Type* right_type = computed_type_;
   Type* type = Type::Union(left_type, right_type, zone());
   expr->set_combined_type(type);
   if (type->Is(cache_.kInt32) || type->Is(cache_.kUint32) ||
       type->Is(cache_.kFloat32) || type->Is(cache_.kFloat64)) {
     IntersectResult(expr, cache_.kInt32);
   } else {
     FAIL(expr, "ill-typed comparison operation");
   }
 }
@@ skipping 159 matching lines @@
     computed_type_->Print();
     PrintF("Expected type: ");
     expected_type_->Print();
 #endif
     FAIL(expr, msg);
   }
   expected_type_ = save;
 }
 }  // namespace internal
 }  // namespace v8