[turbofan] Simplify BinaryOperationHints and CompareOperationHints.

test/unittests/compiler/js-typed-lowering-unittest.cc

 // Copyright 2014 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/code-factory.h"
 #include "src/compiler/access-builder.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/js-typed-lowering.h"
 #include "src/compiler/machine-operator.h"
@@ skipping 376 matching lines @@
 // JSStrictEqual
 
 
 TEST_F(JSTypedLoweringTest, JSStrictEqualWithTheHole) {
   Node* const the_hole = HeapConstant(factory()->the_hole_value());
   Node* const context = UndefinedConstant();
   Node* const effect = graph()->start();
   Node* const control = graph()->start();
   TRACED_FOREACH(Type*, type, kJSTypes) {
     Node* const lhs = Parameter(type);
-    Reduction r = Reduce(graph()->NewNode(
-        javascript()->StrictEqual(CompareOperationHints::Any()), lhs, the_hole,
-        context, effect, control));
+    Reduction r = Reduce(
+        graph()->NewNode(javascript()->StrictEqual(CompareOperationHint::kAny),
+                         lhs, the_hole, context, effect, control));
     ASSERT_TRUE(r.Changed());
     EXPECT_THAT(r.replacement(), IsFalseConstant());
   }
 }
 
 
 TEST_F(JSTypedLoweringTest, JSStrictEqualWithUnique) {
   Node* const lhs = Parameter(Type::Unique(), 0);
   Node* const rhs = Parameter(Type::Unique(), 1);
   Node* const context = Parameter(Type::Any(), 2);
   Node* const effect = graph()->start();
   Node* const control = graph()->start();
   Reduction r = Reduce(
-      graph()->NewNode(javascript()->StrictEqual(CompareOperationHints::Any()),
+      graph()->NewNode(javascript()->StrictEqual(CompareOperationHint::kAny),
                        lhs, rhs, context, effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(), IsReferenceEqual(Type::Unique(), lhs, rhs));
 }
 
 
 // -----------------------------------------------------------------------------
 // JSShiftLeft
 
 TEST_F(JSTypedLoweringTest, JSShiftLeftWithSigned32AndConstant) {
-  BinaryOperationHints const hints = BinaryOperationHints::Any();
+  BinaryOperationHint const hint = BinaryOperationHint::kAny;
   Node* const lhs = Parameter(Type::Signed32());
   Node* const context = UndefinedConstant();
   Node* const effect = graph()->start();
   Node* const control = graph()->start();
   TRACED_FORRANGE(double, rhs, 0, 31) {
-    Reduction r = Reduce(graph()->NewNode(javascript()->ShiftLeft(hints), lhs,
+    Reduction r = Reduce(graph()->NewNode(javascript()->ShiftLeft(hint), lhs,
                                           NumberConstant(rhs), context,
                                           EmptyFrameState(), effect, control));
     ASSERT_TRUE(r.Changed());
     EXPECT_THAT(r.replacement(),
                 IsNumberShiftLeft(lhs, IsNumberConstant(BitEq(rhs))));
   }
 }
 
 TEST_F(JSTypedLoweringTest, JSShiftLeftWithSigned32AndUnsigned32) {
-  BinaryOperationHints const hints = BinaryOperationHints::Any();
+  BinaryOperationHint const hint = BinaryOperationHint::kAny;
   Node* const lhs = Parameter(Type::Signed32());
   Node* const rhs = Parameter(Type::Unsigned32());
   Node* const context = UndefinedConstant();
   Node* const effect = graph()->start();
   Node* const control = graph()->start();
   Reduction r =
-      Reduce(graph()->NewNode(javascript()->ShiftLeft(hints), lhs, rhs, context,
+      Reduce(graph()->NewNode(javascript()->ShiftLeft(hint), lhs, rhs, context,
                               EmptyFrameState(), effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(), IsNumberShiftLeft(lhs, rhs));
 }
 
 TEST_F(JSTypedLoweringTest, JSShiftLeftWithSignedSmallHint) {
-  BinaryOperationHints const hints(BinaryOperationHints::kSignedSmall,
-                                   BinaryOperationHints::kSignedSmall,
-                                   BinaryOperationHints::kSignedSmall);
+  BinaryOperationHint const hint = BinaryOperationHint::kSignedSmall;
   Node* lhs = Parameter(Type::Number(), 2);
   Node* rhs = Parameter(Type::Number(), 3);
   Node* effect = graph()->start();
   Node* control = graph()->start();
-  Reduction r = Reduce(graph()->NewNode(javascript()->ShiftLeft(hints), lhs,
-                                        rhs, UndefinedConstant(),
-                                        EmptyFrameState(), effect, control));
+  Reduction r = Reduce(graph()->NewNode(javascript()->ShiftLeft(hint), lhs, rhs,
+                                        UndefinedConstant(), EmptyFrameState(),
+                                        effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(),
               IsSpeculativeNumberShiftLeft(NumberOperationHint::kSignedSmall,
                                            lhs, rhs, effect, control));
 }
 
 TEST_F(JSTypedLoweringTest, JSShiftLeftWithSigned32Hint) {
-  BinaryOperationHints const hints(BinaryOperationHints::kSigned32,
-                                   BinaryOperationHints::kSigned32,
-                                   BinaryOperationHints::kSigned32);
+  BinaryOperationHint const hint = BinaryOperationHint::kSigned32;
   Node* lhs = Parameter(Type::Number(), 2);
   Node* rhs = Parameter(Type::Number(), 3);
   Node* effect = graph()->start();
   Node* control = graph()->start();
-  Reduction r = Reduce(graph()->NewNode(javascript()->ShiftLeft(hints), lhs,
-                                        rhs, UndefinedConstant(),
-                                        EmptyFrameState(), effect, control));
+  Reduction r = Reduce(graph()->NewNode(javascript()->ShiftLeft(hint), lhs, rhs,
+                                        UndefinedConstant(), EmptyFrameState(),
+                                        effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(),
               IsSpeculativeNumberShiftLeft(NumberOperationHint::kSigned32, lhs,
                                            rhs, effect, control));
 }
 
 TEST_F(JSTypedLoweringTest, JSShiftLeftWithNumberOrOddballHint) {
-  BinaryOperationHints const hints(BinaryOperationHints::kNumberOrOddball,
-                                   BinaryOperationHints::kNumberOrOddball,
-                                   BinaryOperationHints::kNumberOrOddball);
+  BinaryOperationHint const hint = BinaryOperationHint::kNumberOrOddball;
   Node* lhs = Parameter(Type::Number(), 2);
   Node* rhs = Parameter(Type::Number(), 3);
   Node* effect = graph()->start();
   Node* control = graph()->start();
-  Reduction r = Reduce(graph()->NewNode(javascript()->ShiftLeft(hints), lhs,
-                                        rhs, UndefinedConstant(),
-                                        EmptyFrameState(), effect, control));
+  Reduction r = Reduce(graph()->NewNode(javascript()->ShiftLeft(hint), lhs, rhs,
+                                        UndefinedConstant(), EmptyFrameState(),
+                                        effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(), IsSpeculativeNumberShiftLeft(
                                    NumberOperationHint::kNumberOrOddball, lhs,
                                    rhs, effect, control));
 }
 
 // -----------------------------------------------------------------------------
 // JSShiftRight
 
 
 TEST_F(JSTypedLoweringTest, JSShiftRightWithSigned32AndConstant) {
-  BinaryOperationHints const hints = BinaryOperationHints::Any();
+  BinaryOperationHint const hint = BinaryOperationHint::kAny;
   Node* const lhs = Parameter(Type::Signed32());
   Node* const context = UndefinedConstant();
   Node* const effect = graph()->start();
   Node* const control = graph()->start();
   TRACED_FORRANGE(double, rhs, 0, 31) {
-    Reduction r = Reduce(graph()->NewNode(javascript()->ShiftRight(hints), lhs,
+    Reduction r = Reduce(graph()->NewNode(javascript()->ShiftRight(hint), lhs,
                                           NumberConstant(rhs), context,
                                           EmptyFrameState(), effect, control));
     ASSERT_TRUE(r.Changed());
     EXPECT_THAT(r.replacement(),
                 IsNumberShiftRight(lhs, IsNumberConstant(BitEq(rhs))));
   }
 }
 
 
 TEST_F(JSTypedLoweringTest, JSShiftRightWithSigned32AndUnsigned32) {
-  BinaryOperationHints const hints = BinaryOperationHints::Any();
+  BinaryOperationHint const hint = BinaryOperationHint::kAny;
   Node* const lhs = Parameter(Type::Signed32());
   Node* const rhs = Parameter(Type::Unsigned32());
   Node* const context = UndefinedConstant();
   Node* const effect = graph()->start();
   Node* const control = graph()->start();
   Reduction r =
-      Reduce(graph()->NewNode(javascript()->ShiftRight(hints), lhs, rhs,
-                              context, EmptyFrameState(), effect, control));
+      Reduce(graph()->NewNode(javascript()->ShiftRight(hint), lhs, rhs, context,
+                              EmptyFrameState(), effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(), IsNumberShiftRight(lhs, rhs));
 }
 
 TEST_F(JSTypedLoweringTest, JSShiftRightWithSignedSmallHint) {
-  BinaryOperationHints const hints(BinaryOperationHints::kSignedSmall,
-                                   BinaryOperationHints::kSignedSmall,
-                                   BinaryOperationHints::kSignedSmall);
+  BinaryOperationHint const hint = BinaryOperationHint::kSignedSmall;
   Node* lhs = Parameter(Type::Number(), 2);
   Node* rhs = Parameter(Type::Number(), 3);
   Node* effect = graph()->start();
   Node* control = graph()->start();
-  Reduction r = Reduce(graph()->NewNode(javascript()->ShiftRight(hints), lhs,
+  Reduction r = Reduce(graph()->NewNode(javascript()->ShiftRight(hint), lhs,
                                         rhs, UndefinedConstant(),
                                         EmptyFrameState(), effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(),
               IsSpeculativeNumberShiftRight(NumberOperationHint::kSignedSmall,
                                             lhs, rhs, effect, control));
 }
 
 TEST_F(JSTypedLoweringTest, JSShiftRightWithSigned32Hint) {
-  BinaryOperationHints const hints(BinaryOperationHints::kSigned32,
-                                   BinaryOperationHints::kSigned32,
-                                   BinaryOperationHints::kSigned32);
+  BinaryOperationHint const hint = BinaryOperationHint::kSigned32;
   Node* lhs = Parameter(Type::Number(), 2);
   Node* rhs = Parameter(Type::Number(), 3);
   Node* effect = graph()->start();
   Node* control = graph()->start();
-  Reduction r = Reduce(graph()->NewNode(javascript()->ShiftRight(hints), lhs,
+  Reduction r = Reduce(graph()->NewNode(javascript()->ShiftRight(hint), lhs,
                                         rhs, UndefinedConstant(),
                                         EmptyFrameState(), effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(),
               IsSpeculativeNumberShiftRight(NumberOperationHint::kSigned32, lhs,
                                             rhs, effect, control));
 }
 
 TEST_F(JSTypedLoweringTest, JSShiftRightWithNumberOrOddballHint) {
-  BinaryOperationHints const hints(BinaryOperationHints::kNumberOrOddball,
-                                   BinaryOperationHints::kNumberOrOddball,
-                                   BinaryOperationHints::kNumberOrOddball);
+  BinaryOperationHint const hint = BinaryOperationHint::kNumberOrOddball;
   Node* lhs = Parameter(Type::Number(), 2);
   Node* rhs = Parameter(Type::Number(), 3);
   Node* effect = graph()->start();
   Node* control = graph()->start();
-  Reduction r = Reduce(graph()->NewNode(javascript()->ShiftRight(hints), lhs,
+  Reduction r = Reduce(graph()->NewNode(javascript()->ShiftRight(hint), lhs,
                                         rhs, UndefinedConstant(),
                                         EmptyFrameState(), effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(), IsSpeculativeNumberShiftRight(
                                    NumberOperationHint::kNumberOrOddball, lhs,
                                    rhs, effect, control));
 }
 
 // -----------------------------------------------------------------------------
 // JSShiftRightLogical
 
 
 TEST_F(JSTypedLoweringTest,
                    JSShiftRightLogicalWithUnsigned32AndConstant) {
-  BinaryOperationHints const hints = BinaryOperationHints::Any();
+  BinaryOperationHint const hint = BinaryOperationHint::kAny;
   Node* const lhs = Parameter(Type::Unsigned32());
   Node* const context = UndefinedConstant();
   Node* const effect = graph()->start();
   Node* const control = graph()->start();
   TRACED_FORRANGE(double, rhs, 0, 31) {
-    Reduction r = Reduce(graph()->NewNode(
-        javascript()->ShiftRightLogical(hints), lhs, NumberConstant(rhs),
-        context, EmptyFrameState(), effect, control));
+    Reduction r = Reduce(graph()->NewNode(javascript()->ShiftRightLogical(hint),
+                                          lhs, NumberConstant(rhs), context,
+                                          EmptyFrameState(), effect, control));
     ASSERT_TRUE(r.Changed());
     EXPECT_THAT(r.replacement(),
                 IsNumberShiftRightLogical(lhs, IsNumberConstant(BitEq(rhs))));
   }
 }
 
 
 TEST_F(JSTypedLoweringTest, JSShiftRightLogicalWithUnsigned32AndUnsigned32) {
-  BinaryOperationHints const hints = BinaryOperationHints::Any();
+  BinaryOperationHint const hint = BinaryOperationHint::kAny;
   Node* const lhs = Parameter(Type::Unsigned32());
   Node* const rhs = Parameter(Type::Unsigned32());
   Node* const context = UndefinedConstant();
   Node* const effect = graph()->start();
   Node* const control = graph()->start();
   Reduction r =
-      Reduce(graph()->NewNode(javascript()->ShiftRightLogical(hints), lhs, rhs,
+      Reduce(graph()->NewNode(javascript()->ShiftRightLogical(hint), lhs, rhs,
                               context, EmptyFrameState(), effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(), IsNumberShiftRightLogical(lhs, rhs));
 }
 
 TEST_F(JSTypedLoweringTest, JSShiftRightLogicalWithSignedSmallHint) {
-  BinaryOperationHints const hints(BinaryOperationHints::kSignedSmall,
-                                   BinaryOperationHints::kSignedSmall,
-                                   BinaryOperationHints::kSignedSmall);
+  BinaryOperationHint const hint = BinaryOperationHint::kSignedSmall;
   Node* lhs = Parameter(Type::Number(), 2);
   Node* rhs = Parameter(Type::Number(), 3);
   Node* effect = graph()->start();
   Node* control = graph()->start();
-  Reduction r = Reduce(graph()->NewNode(javascript()->ShiftRightLogical(hints),
+  Reduction r = Reduce(graph()->NewNode(javascript()->ShiftRightLogical(hint),
                                         lhs, rhs, UndefinedConstant(),
                                         EmptyFrameState(), effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(), IsSpeculativeNumberShiftRightLogical(
                                    NumberOperationHint::kSignedSmall, lhs, rhs,
                                    effect, control));
 }
 
 TEST_F(JSTypedLoweringTest, JSShiftRightLogicalWithSigned32Hint) {
-  BinaryOperationHints const hints(BinaryOperationHints::kSigned32,
-                                   BinaryOperationHints::kSigned32,
-                                   BinaryOperationHints::kSigned32);
+  BinaryOperationHint const hint = BinaryOperationHint::kSigned32;
   Node* lhs = Parameter(Type::Number(), 2);
   Node* rhs = Parameter(Type::Number(), 3);
   Node* effect = graph()->start();
   Node* control = graph()->start();
-  Reduction r = Reduce(graph()->NewNode(javascript()->ShiftRightLogical(hints),
+  Reduction r = Reduce(graph()->NewNode(javascript()->ShiftRightLogical(hint),
                                         lhs, rhs, UndefinedConstant(),
                                         EmptyFrameState(), effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(),
               IsSpeculativeNumberShiftRightLogical(
                   NumberOperationHint::kSigned32, lhs, rhs, effect, control));
 }
 
 TEST_F(JSTypedLoweringTest, JSShiftRightLogicalWithNumberOrOddballHint) {
-  BinaryOperationHints const hints(BinaryOperationHints::kNumberOrOddball,
-                                   BinaryOperationHints::kNumberOrOddball,
-                                   BinaryOperationHints::kNumberOrOddball);
+  BinaryOperationHint const hint = BinaryOperationHint::kNumberOrOddball;
   Node* lhs = Parameter(Type::Number(), 2);
   Node* rhs = Parameter(Type::Number(), 3);
   Node* effect = graph()->start();
   Node* control = graph()->start();
-  Reduction r = Reduce(graph()->NewNode(javascript()->ShiftRightLogical(hints),
+  Reduction r = Reduce(graph()->NewNode(javascript()->ShiftRightLogical(hint),
                                         lhs, rhs, UndefinedConstant(),
                                         EmptyFrameState(), effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(), IsSpeculativeNumberShiftRightLogical(
                                    NumberOperationHint::kNumberOrOddball, lhs,
                                    rhs, effect, control));
 }
 
 // -----------------------------------------------------------------------------
 // JSLoadContext
@@ skipping 299 matching lines @@
   EXPECT_THAT(r.replacement(), IsLoadField(AccessBuilder::ForStringLength(),
                                            receiver, effect, control));
 }
 
 
 // -----------------------------------------------------------------------------
 // JSAdd
 
 
 TEST_F(JSTypedLoweringTest, JSAddWithString) {
-  BinaryOperationHints const hints = BinaryOperationHints::Any();
+  BinaryOperationHint const hint = BinaryOperationHint::kAny;
   Node* lhs = Parameter(Type::String(), 0);
   Node* rhs = Parameter(Type::String(), 1);
   Node* context = Parameter(Type::Any(), 2);
   Node* frame_state = EmptyFrameState();
   Node* effect = graph()->start();
   Node* control = graph()->start();
-  Reduction r = Reduce(graph()->NewNode(javascript()->Add(hints), lhs, rhs,
+  Reduction r = Reduce(graph()->NewNode(javascript()->Add(hint), lhs, rhs,
                                         context, frame_state, effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(),
               IsCall(_, IsHeapConstant(
                             CodeFactory::StringAdd(
                                 isolate(), STRING_ADD_CHECK_NONE, NOT_TENURED)
                                 .code()),
                      lhs, rhs, context, frame_state, effect, control));
 }
 
 TEST_F(JSTypedLoweringTest, JSAddSmis) {
-  BinaryOperationHints const hints(BinaryOperationHints::kSignedSmall,
-                                   BinaryOperationHints::kSignedSmall,
-                                   BinaryOperationHints::kSignedSmall);
+  BinaryOperationHint const hint = BinaryOperationHint::kSignedSmall;
   Node* lhs = Parameter(Type::Number(), 0);
   Node* rhs = Parameter(Type::Number(), 1);
   Node* context = Parameter(Type::Any(), 2);
   Node* frame_state = EmptyFrameState();
   Node* effect = graph()->start();
   Node* control = graph()->start();
-  Reduction r = Reduce(graph()->NewNode(javascript()->Add(hints), lhs, rhs,
+  Reduction r = Reduce(graph()->NewNode(javascript()->Add(hint), lhs, rhs,
                                         context, frame_state, effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(),
               IsSpeculativeNumberAdd(NumberOperationHint::kSignedSmall, lhs,
                                      rhs, effect, control));
 }
 
 // -----------------------------------------------------------------------------
 // JSSubtract
 
 TEST_F(JSTypedLoweringTest, JSSubtractSmis) {
-  BinaryOperationHints const hints(BinaryOperationHints::kSignedSmall,
-                                   BinaryOperationHints::kSignedSmall,
-                                   BinaryOperationHints::kSignedSmall);
+  BinaryOperationHint const hint = BinaryOperationHint::kSignedSmall;
   Node* lhs = Parameter(Type::Number(), 0);
   Node* rhs = Parameter(Type::Number(), 1);
   Node* context = Parameter(Type::Any(), 2);
   Node* frame_state = EmptyFrameState();
   Node* effect = graph()->start();
   Node* control = graph()->start();
-  Reduction r = Reduce(graph()->NewNode(javascript()->Subtract(hints), lhs, rhs,
+  Reduction r = Reduce(graph()->NewNode(javascript()->Subtract(hint), lhs, rhs,
                                         context, frame_state, effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(),
               IsSpeculativeNumberSubtract(NumberOperationHint::kSignedSmall,
                                           lhs, rhs, effect, control));
 }
 
 // -----------------------------------------------------------------------------
 // JSInstanceOf
 // Test that instanceOf is reduced if and only if the right-hand side is a
@@ skipping 53 matching lines @@
                                  frame_state, effect, control);
   Reduction r = Reduce(instanceOf);
   ASSERT_FALSE(r.Changed());
   ASSERT_EQ(instanceOf, dummy->InputAt(0));
 }
 
 // -----------------------------------------------------------------------------
 // JSBitwiseAnd
 
 TEST_F(JSTypedLoweringTest, JSBitwiseAndWithSignedSmallHint) {
-  BinaryOperationHints const hints(BinaryOperationHints::kSignedSmall,
-                                   BinaryOperationHints::kSignedSmall,
-                                   BinaryOperationHints::kSignedSmall);
+  BinaryOperationHint const hint = BinaryOperationHint::kSignedSmall;
   Node* lhs = Parameter(Type::Number(), 2);
   Node* rhs = Parameter(Type::Number(), 3);
   Node* effect = graph()->start();
   Node* control = graph()->start();
-  Reduction r = Reduce(graph()->NewNode(javascript()->BitwiseAnd(hints), lhs,
+  Reduction r = Reduce(graph()->NewNode(javascript()->BitwiseAnd(hint), lhs,
                                         rhs, UndefinedConstant(),
                                         EmptyFrameState(), effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(),
               IsSpeculativeNumberBitwiseAnd(NumberOperationHint::kSignedSmall,
                                             lhs, rhs, effect, control));
 }
 
 TEST_F(JSTypedLoweringTest, JSBitwiseAndWithSigned32Hint) {
-  BinaryOperationHints const hints(BinaryOperationHints::kSigned32,
-                                   BinaryOperationHints::kSigned32,
-                                   BinaryOperationHints::kSigned32);
+  BinaryOperationHint const hint = BinaryOperationHint::kSigned32;
   Node* lhs = Parameter(Type::Number(), 2);
   Node* rhs = Parameter(Type::Number(), 3);
   Node* effect = graph()->start();
   Node* control = graph()->start();
-  Reduction r = Reduce(graph()->NewNode(javascript()->BitwiseAnd(hints), lhs,
+  Reduction r = Reduce(graph()->NewNode(javascript()->BitwiseAnd(hint), lhs,
                                         rhs, UndefinedConstant(),
                                         EmptyFrameState(), effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(),
               IsSpeculativeNumberBitwiseAnd(NumberOperationHint::kSigned32, lhs,
                                             rhs, effect, control));
 }
 
 TEST_F(JSTypedLoweringTest, JSBitwiseAndWithNumberOrOddballHint) {
-  BinaryOperationHints const hints(BinaryOperationHints::kNumberOrOddball,
-                                   BinaryOperationHints::kNumberOrOddball,
-                                   BinaryOperationHints::kNumberOrOddball);
+  BinaryOperationHint const hint = BinaryOperationHint::kNumberOrOddball;
   Node* lhs = Parameter(Type::Number(), 2);
   Node* rhs = Parameter(Type::Number(), 3);
   Node* effect = graph()->start();
   Node* control = graph()->start();
-  Reduction r = Reduce(graph()->NewNode(javascript()->BitwiseAnd(hints), lhs,
+  Reduction r = Reduce(graph()->NewNode(javascript()->BitwiseAnd(hint), lhs,
                                         rhs, UndefinedConstant(),
                                         EmptyFrameState(), effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(), IsSpeculativeNumberBitwiseAnd(
                                    NumberOperationHint::kNumberOrOddball, lhs,
                                    rhs, effect, control));
 }
 
 // -----------------------------------------------------------------------------
 // JSBitwiseOr
 
 TEST_F(JSTypedLoweringTest, JSBitwiseOrWithSignedSmallHint) {
-  BinaryOperationHints const hints(BinaryOperationHints::kSignedSmall,
-                                   BinaryOperationHints::kSignedSmall,
-                                   BinaryOperationHints::kSignedSmall);
+  BinaryOperationHint const hint = BinaryOperationHint::kSignedSmall;
   Node* lhs = Parameter(Type::Number(), 2);
   Node* rhs = Parameter(Type::Number(), 3);
   Node* effect = graph()->start();
   Node* control = graph()->start();
-  Reduction r = Reduce(graph()->NewNode(javascript()->BitwiseOr(hints), lhs,
-                                        rhs, UndefinedConstant(),
-                                        EmptyFrameState(), effect, control));
+  Reduction r = Reduce(graph()->NewNode(javascript()->BitwiseOr(hint), lhs, rhs,
+                                        UndefinedConstant(), EmptyFrameState(),
+                                        effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(),
               IsSpeculativeNumberBitwiseOr(NumberOperationHint::kSignedSmall,
                                            lhs, rhs, effect, control));
 }
 
 TEST_F(JSTypedLoweringTest, JSBitwiseOrWithSigned32Hint) {
-  BinaryOperationHints const hints(BinaryOperationHints::kSigned32,
-                                   BinaryOperationHints::kSigned32,
-                                   BinaryOperationHints::kSigned32);
+  BinaryOperationHint const hint = BinaryOperationHint::kSigned32;
   Node* lhs = Parameter(Type::Number(), 2);
   Node* rhs = Parameter(Type::Number(), 3);
   Node* effect = graph()->start();
   Node* control = graph()->start();
-  Reduction r = Reduce(graph()->NewNode(javascript()->BitwiseOr(hints), lhs,
-                                        rhs, UndefinedConstant(),
-                                        EmptyFrameState(), effect, control));
+  Reduction r = Reduce(graph()->NewNode(javascript()->BitwiseOr(hint), lhs, rhs,
+                                        UndefinedConstant(), EmptyFrameState(),
+                                        effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(),
               IsSpeculativeNumberBitwiseOr(NumberOperationHint::kSigned32, lhs,
                                            rhs, effect, control));
 }
 
 TEST_F(JSTypedLoweringTest, JSBitwiseOrWithNumberOrOddballHint) {
-  BinaryOperationHints const hints(BinaryOperationHints::kNumberOrOddball,
-                                   BinaryOperationHints::kNumberOrOddball,
-                                   BinaryOperationHints::kNumberOrOddball);
+  BinaryOperationHint const hint = BinaryOperationHint::kNumberOrOddball;
   Node* lhs = Parameter(Type::Number(), 2);
   Node* rhs = Parameter(Type::Number(), 3);
   Node* effect = graph()->start();
   Node* control = graph()->start();
-  Reduction r = Reduce(graph()->NewNode(javascript()->BitwiseOr(hints), lhs,
-                                        rhs, UndefinedConstant(),
-                                        EmptyFrameState(), effect, control));
+  Reduction r = Reduce(graph()->NewNode(javascript()->BitwiseOr(hint), lhs, rhs,
+                                        UndefinedConstant(), EmptyFrameState(),
+                                        effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(), IsSpeculativeNumberBitwiseOr(
                                    NumberOperationHint::kNumberOrOddball, lhs,
                                    rhs, effect, control));
 }
 
 // -----------------------------------------------------------------------------
 // JSBitwiseXor
 
 TEST_F(JSTypedLoweringTest, JSBitwiseXorWithSignedSmallHint) {
-  BinaryOperationHints const hints(BinaryOperationHints::kSignedSmall,
-                                   BinaryOperationHints::kSignedSmall,
-                                   BinaryOperationHints::kSignedSmall);
+  BinaryOperationHint const hint = BinaryOperationHint::kSignedSmall;
   Node* lhs = Parameter(Type::Number(), 2);
   Node* rhs = Parameter(Type::Number(), 3);
   Node* effect = graph()->start();
   Node* control = graph()->start();
-  Reduction r = Reduce(graph()->NewNode(javascript()->BitwiseXor(hints), lhs,
+  Reduction r = Reduce(graph()->NewNode(javascript()->BitwiseXor(hint), lhs,
                                         rhs, UndefinedConstant(),
                                         EmptyFrameState(), effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(),
               IsSpeculativeNumberBitwiseXor(NumberOperationHint::kSignedSmall,
                                             lhs, rhs, effect, control));
 }
 
 TEST_F(JSTypedLoweringTest, JSBitwiseXorWithSigned32Hint) {
-  BinaryOperationHints const hints(BinaryOperationHints::kSigned32,
-                                   BinaryOperationHints::kSigned32,
-                                   BinaryOperationHints::kSigned32);
+  BinaryOperationHint const hint = BinaryOperationHint::kSigned32;
   Node* lhs = Parameter(Type::Number(), 2);
   Node* rhs = Parameter(Type::Number(), 3);
   Node* effect = graph()->start();
   Node* control = graph()->start();
-  Reduction r = Reduce(graph()->NewNode(javascript()->BitwiseXor(hints), lhs,
+  Reduction r = Reduce(graph()->NewNode(javascript()->BitwiseXor(hint), lhs,
                                         rhs, UndefinedConstant(),
                                         EmptyFrameState(), effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(),
               IsSpeculativeNumberBitwiseXor(NumberOperationHint::kSigned32, lhs,
                                             rhs, effect, control));
 }
 
 TEST_F(JSTypedLoweringTest, JSBitwiseXorWithNumberOrOddballHint) {
-  BinaryOperationHints const hints(BinaryOperationHints::kNumberOrOddball,
-                                   BinaryOperationHints::kNumberOrOddball,
-                                   BinaryOperationHints::kNumberOrOddball);
+  BinaryOperationHint const hint = BinaryOperationHint::kNumberOrOddball;
   Node* lhs = Parameter(Type::Number(), 2);
   Node* rhs = Parameter(Type::Number(), 3);
   Node* effect = graph()->start();
   Node* control = graph()->start();
-  Reduction r = Reduce(graph()->NewNode(javascript()->BitwiseXor(hints), lhs,
+  Reduction r = Reduce(graph()->NewNode(javascript()->BitwiseXor(hint), lhs,
                                         rhs, UndefinedConstant(),
                                         EmptyFrameState(), effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(), IsSpeculativeNumberBitwiseXor(
                                    NumberOperationHint::kNumberOrOddball, lhs,
                                    rhs, effect, control));
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8