[turbofan] Simplify BinaryOperationHints and CompareOperationHints.

test/cctest/compiler/test-js-typed-lowering.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/compilation-dependencies.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/js-typed-lowering.h"
 #include "src/compiler/machine-operator.h"
 #include "src/compiler/node-properties.h"
 #include "src/compiler/opcodes.h"
@@ skipping 33 matching lines @@
   const Operator* unop;
   JSOperatorBuilder javascript;
   MachineOperatorBuilder machine;
   SimplifiedOperatorBuilder simplified;
   CommonOperatorBuilder common;
   CompilationDependencies deps;
   Graph graph;
   Typer typer;
   Node* context_node;
   JSTypedLowering::Flags flags;
-  BinaryOperationHints const binop_hints = BinaryOperationHints::Any();
-  CompareOperationHints const compare_hints = CompareOperationHints::Any();
+  BinaryOperationHint const binop_hints = BinaryOperationHint::kAny;
+  CompareOperationHint const compare_hints = CompareOperationHint::kAny;
 
   Node* Parameter(Type* t, int32_t index = 0) {
     Node* n = graph.NewNode(common.Parameter(index), graph.start());
     NodeProperties::SetType(n, t);
     return n;
   }
 
   Node* UndefinedConstant() {
     Handle<HeapObject> value = isolate->factory()->undefined_value();
     return graph.NewNode(common.HeapConstant(value));
@@ skipping 174 matching lines @@
     }
   }
 }
 #endif
 
 TEST(AddNumber1) {
   JSTypedLoweringTester R;
   for (size_t i = 0; i < arraysize(kNumberTypes); ++i) {
     Node* p0 = R.Parameter(kNumberTypes[i], 0);
     Node* p1 = R.Parameter(kNumberTypes[i], 1);
-    Node* add = R.Binop(R.javascript.Add(BinaryOperationHints::Any()), p0, p1);
+    Node* add = R.Binop(R.javascript.Add(BinaryOperationHint::kAny), p0, p1);
     Node* r = R.reduce(add);
 
     R.CheckBinop(IrOpcode::kNumberAdd, r);
     CHECK_EQ(p0, r->InputAt(0));
     CHECK_EQ(p1, r->InputAt(1));
   }
 }
 
 TEST(NumberBinops) {
   JSTypedLoweringTester R;
@@ skipping 307 matching lines @@
     CHECK_EQ(n, add->InputAt(0));
     CHECK_EQ(r, add->InputAt(1));
     R.CheckEffectInput(R.start(), effect_use);
   }
 }
 
 TEST(StringComparison) {
   JSTypedLoweringTester R;
 
   const Operator* ops[] = {
-      R.javascript.LessThan(CompareOperationHints::Any()),
+      R.javascript.LessThan(CompareOperationHint::kAny),
       R.simplified.StringLessThan(),
-      R.javascript.LessThanOrEqual(CompareOperationHints::Any()),
+      R.javascript.LessThanOrEqual(CompareOperationHint::kAny),
       R.simplified.StringLessThanOrEqual(),
-      R.javascript.GreaterThan(CompareOperationHints::Any()),
+      R.javascript.GreaterThan(CompareOperationHint::kAny),
       R.simplified.StringLessThan(),
-      R.javascript.GreaterThanOrEqual(CompareOperationHints::Any()),
+      R.javascript.GreaterThanOrEqual(CompareOperationHint::kAny),
       R.simplified.StringLessThanOrEqual()};
 
   for (size_t i = 0; i < arraysize(kStringTypes); i++) {
     Node* p0 = R.Parameter(kStringTypes[i], 0);
     for (size_t j = 0; j < arraysize(kStringTypes); j++) {
       Node* p1 = R.Parameter(kStringTypes[j], 1);
 
       for (size_t k = 0; k < arraysize(ops); k += 2) {
         Node* cmp = R.Binop(ops[k], p0, p1);
         Node* r = R.reduce(cmp);
@@ skipping 21 matching lines @@
     if (converted->opcode() == IrOpcode::kNumberConstant) return;
     CHECK_EQ(IrOpcode::kJSToNumber, converted->opcode());
     CHECK_EQ(val, converted->InputAt(0));
   }
 }
 
 TEST(NumberComparison) {
   JSTypedLoweringTester R;
 
   const Operator* ops[] = {
-      R.javascript.LessThan(CompareOperationHints::Any()),
+      R.javascript.LessThan(CompareOperationHint::kAny),
       R.simplified.NumberLessThan(),
-      R.javascript.LessThanOrEqual(CompareOperationHints::Any()),
+      R.javascript.LessThanOrEqual(CompareOperationHint::kAny),
       R.simplified.NumberLessThanOrEqual(),
-      R.javascript.GreaterThan(CompareOperationHints::Any()),
+      R.javascript.GreaterThan(CompareOperationHint::kAny),
       R.simplified.NumberLessThan(),
-      R.javascript.GreaterThanOrEqual(CompareOperationHints::Any()),
+      R.javascript.GreaterThanOrEqual(CompareOperationHint::kAny),
       R.simplified.NumberLessThanOrEqual()};
 
   Node* const p0 = R.Parameter(Type::Number(), 0);
   Node* const p1 = R.Parameter(Type::Number(), 1);
 
   for (size_t k = 0; k < arraysize(ops); k += 2) {
     Node* cmp = R.Binop(ops[k], p0, p1);
     Node* r = R.reduce(cmp);
 
     R.CheckBinop(ops[k + 1], r);
@@ skipping 15 matching lines @@
   Type* types[] = {Type::Number(), Type::String(),
                    Type::Union(Type::Number(), Type::String(), R.main_zone())};
 
   for (size_t i = 0; i < arraysize(types); i++) {
     Node* p0 = R.Parameter(types[i], 0);
 
     for (size_t j = 0; j < arraysize(types); j++) {
       Node* p1 = R.Parameter(types[j], 1);
       {
         const Operator* less_than =
-            R.javascript.LessThan(CompareOperationHints::Any());
+            R.javascript.LessThan(CompareOperationHint::kAny);
         Node* cmp = R.Binop(less_than, p0, p1);
         Node* r = R.reduce(cmp);
         if (types[i]->Is(Type::String()) && types[j]->Is(Type::String())) {
           R.CheckBinop(R.simplified.StringLessThan(), r);
         } else if ((types[i]->Is(Type::Number()) &&
                     types[j]->Is(Type::Number())) ||
                    (!types[i]->Maybe(Type::String()) ||
                     !types[j]->Maybe(Type::String()))) {
           R.CheckBinop(R.simplified.NumberLessThan(), r);
         } else {
@@ skipping 125 matching lines @@
 
 // Helper function for strict and non-strict equality reductions.
 void CheckEqualityReduction(JSTypedLoweringTester* R, bool strict, Node* l,
                             Node* r, IrOpcode::Value expected) {
   for (int j = 0; j < 2; j++) {
     Node* p0 = j == 0 ? l : r;
     Node* p1 = j == 1 ? l : r;
 
     {
       const Operator* op =
-          strict ? R->javascript.StrictEqual(CompareOperationHints::Any())
-                 : R->javascript.Equal(CompareOperationHints::Any());
+          strict ? R->javascript.StrictEqual(CompareOperationHint::kAny)
+                 : R->javascript.Equal(CompareOperationHint::kAny);
       Node* eq = R->Binop(op, p0, p1);
       Node* r = R->reduce(eq);
       R->CheckBinop(expected, r);
     }
 
     {
       const Operator* op =
-          strict ? R->javascript.StrictNotEqual(CompareOperationHints::Any())
-                 : R->javascript.NotEqual(CompareOperationHints::Any());
+          strict ? R->javascript.StrictNotEqual(CompareOperationHint::kAny)
+                 : R->javascript.NotEqual(CompareOperationHint::kAny);
       Node* ne = R->Binop(op, p0, p1);
       Node* n = R->reduce(ne);
       CHECK_EQ(IrOpcode::kBooleanNot, n->opcode());
       Node* r = n->InputAt(0);
       R->CheckBinop(expected, r);
     }
   }
 }
 
 
@@ skipping 401 matching lines @@
           CHECK_EQ(p1, r->InputAt(1));
         }
       }
     }
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8