[turbofan] Simplify BinaryOperationHints and CompareOperationHints.

test/unittests/compiler/typer-unittest.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 <functional>
 
 #include "src/codegen.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/node-properties.h"
 #include "src/compiler/operator-properties.h"
@@ skipping 33 matching lines @@
     int32s.push_back(+1);
     int32s.push_back(kMinInt);
     int32s.push_back(kMaxInt);
     for (int i = 0; i < 10; ++i) {
       int32s.push_back(rng_->NextInt());
     }
   }
 
   Types types_;
   JSOperatorBuilder javascript_;
-  BinaryOperationHints const hints_ = BinaryOperationHints::Any();
+  BinaryOperationHint const hints_ = BinaryOperationHint::kAny;
   Node* context_node_;
   v8::base::RandomNumberGenerator* rng_;
   std::vector<double> integers;
   std::vector<double> int32s;
 
   Type* TypeBinaryOp(const Operator* op, Type* lhs, Type* rhs) {
     Node* p0 = Parameter(0);
     Node* p1 = Parameter(1);
     NodeProperties::SetType(p0, lhs);
     NodeProperties::SetType(p1, rhs);
@@ skipping 218 matching lines @@
   TestBinaryBitOp(javascript_.ShiftLeft(hints_), shift_left);
 }
 
 
 TEST_F(TyperTest, TypeJSShiftRight) {
   TestBinaryBitOp(javascript_.ShiftRight(hints_), shift_right);
 }
 
 
 TEST_F(TyperTest, TypeJSLessThan) {
-  TestBinaryCompareOp(javascript_.LessThan(CompareOperationHints::Any()),
+  TestBinaryCompareOp(javascript_.LessThan(CompareOperationHint::kAny),
                       std::less<double>());
 }
 
 
 TEST_F(TyperTest, TypeJSLessThanOrEqual) {
-  TestBinaryCompareOp(javascript_.LessThanOrEqual(CompareOperationHints::Any()),
+  TestBinaryCompareOp(javascript_.LessThanOrEqual(CompareOperationHint::kAny),
                       std::less_equal<double>());
 }
 
 
 TEST_F(TyperTest, TypeJSGreaterThan) {
-  TestBinaryCompareOp(javascript_.GreaterThan(CompareOperationHints::Any()),
+  TestBinaryCompareOp(javascript_.GreaterThan(CompareOperationHint::kAny),
                       std::greater<double>());
 }
 
 
 TEST_F(TyperTest, TypeJSGreaterThanOrEqual) {
   TestBinaryCompareOp(
-      javascript_.GreaterThanOrEqual(CompareOperationHints::Any()),
+      javascript_.GreaterThanOrEqual(CompareOperationHint::kAny),
       std::greater_equal<double>());
 }
 
 
 TEST_F(TyperTest, TypeJSEqual) {
-  TestBinaryCompareOp(javascript_.Equal(CompareOperationHints::Any()),
+  TestBinaryCompareOp(javascript_.Equal(CompareOperationHint::kAny),
                       std::equal_to<double>());
 }
 
 
 TEST_F(TyperTest, TypeJSNotEqual) {
-  TestBinaryCompareOp(javascript_.NotEqual(CompareOperationHints::Any()),
+  TestBinaryCompareOp(javascript_.NotEqual(CompareOperationHint::kAny),
                       std::not_equal_to<double>());
 }
 
 
 // For numbers there's no difference between strict and non-strict equality.
 TEST_F(TyperTest, TypeJSStrictEqual) {
-  TestBinaryCompareOp(javascript_.StrictEqual(CompareOperationHints::Any()),
+  TestBinaryCompareOp(javascript_.StrictEqual(CompareOperationHint::kAny),
                       std::equal_to<double>());
 }
 
 
 TEST_F(TyperTest, TypeJSStrictNotEqual) {
-  TestBinaryCompareOp(javascript_.StrictNotEqual(CompareOperationHints::Any()),
+  TestBinaryCompareOp(javascript_.StrictNotEqual(CompareOperationHint::kAny),
                       std::not_equal_to<double>());
 }
 
 
 //------------------------------------------------------------------------------
 // Monotonicity
 
-#define TEST_BINARY_MONOTONICITY(name)                                      \
-  TEST_F(TyperTest, Monotonicity_##name) {                                  \
-    TestBinaryMonotonicity(javascript_.name(CompareOperationHints::Any())); \
+#define TEST_BINARY_MONOTONICITY(name)                                    \
+  TEST_F(TyperTest, Monotonicity_##name) {                                \
+    TestBinaryMonotonicity(javascript_.name(CompareOperationHint::kAny)); \
   }
 TEST_BINARY_MONOTONICITY(Equal)
 TEST_BINARY_MONOTONICITY(NotEqual)
 TEST_BINARY_MONOTONICITY(StrictEqual)
 TEST_BINARY_MONOTONICITY(StrictNotEqual)
 TEST_BINARY_MONOTONICITY(LessThan)
 TEST_BINARY_MONOTONICITY(GreaterThan)
 TEST_BINARY_MONOTONICITY(LessThanOrEqual)
 TEST_BINARY_MONOTONICITY(GreaterThanOrEqual)
 #undef TEST_BINARY_MONOTONICITY
 
-#define TEST_BINARY_MONOTONICITY(name)                                     \
-  TEST_F(TyperTest, Monotonicity_##name) {                                 \
-    TestBinaryMonotonicity(javascript_.name(BinaryOperationHints::Any())); \
+#define TEST_BINARY_MONOTONICITY(name)                                   \
+  TEST_F(TyperTest, Monotonicity_##name) {                               \
+    TestBinaryMonotonicity(javascript_.name(BinaryOperationHint::kAny)); \
   }
 TEST_BINARY_MONOTONICITY(BitwiseOr)
 TEST_BINARY_MONOTONICITY(BitwiseXor)
 TEST_BINARY_MONOTONICITY(BitwiseAnd)
 TEST_BINARY_MONOTONICITY(ShiftLeft)
 TEST_BINARY_MONOTONICITY(ShiftRight)
 TEST_BINARY_MONOTONICITY(ShiftRightLogical)
 TEST_BINARY_MONOTONICITY(Add)
 TEST_BINARY_MONOTONICITY(Subtract)
 TEST_BINARY_MONOTONICITY(Multiply)
@@ skipping 11 matching lines @@
   for (auto i : values) {
     Node* c = graph()->NewNode(common()->Int32Constant(i));
     Type* type = NodeProperties::GetType(c);
     EXPECT_TRUE(type->Is(NewRange(i, i)));
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8