[turbofan] Fix the node matchers.

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/v8.h"
 #include "test/cctest/cctest.h"
 
 #include "src/compiler/graph-inl.h"
 #include "src/compiler/js-typed-lowering.h"
 #include "src/compiler/node-properties-inl.h"
@@ skipping 90 matching lines @@
     return graph.NewNode(javascript.ToNumber(), node, context(), node,
                          control());
   }
 
   void CheckEffectInput(Node* effect, Node* use) {
     CHECK_EQ(effect, NodeProperties::GetEffectInput(use));
   }
 
   void CheckInt32Constant(int32_t expected, Node* result) {
     CHECK_EQ(IrOpcode::kInt32Constant, result->opcode());
-    CHECK_EQ(expected, ValueOf<int32_t>(result->op()));
+    CHECK_EQ(expected, OpParameter<int32_t>(result));
   }
 
   void CheckNumberConstant(double expected, Node* result) {
     CHECK_EQ(IrOpcode::kNumberConstant, result->opcode());
-    CHECK_EQ(expected, ValueOf<double>(result->op()));
+    CHECK_EQ(expected, OpParameter<double>(result));
   }
 
   void CheckNaN(Node* result) {
     CHECK_EQ(IrOpcode::kNumberConstant, result->opcode());
-    double value = ValueOf<double>(result->op());
+    double value = OpParameter<double>(result);
     CHECK(std::isnan(value));
   }
 
   void CheckTrue(Node* result) {
     CheckHandle(isolate->factory()->true_value(), result);
   }
 
   void CheckFalse(Node* result) {
     CheckHandle(isolate->factory()->false_value(), result);
   }
 
   void CheckHandle(Handle<Object> expected, Node* result) {
     CHECK_EQ(IrOpcode::kHeapConstant, result->opcode());
-    Handle<Object> value = ValueOf<Handle<Object> >(result->op());
+    Handle<Object> value = OpParameter<Unique<Object> >(result).handle();
     CHECK_EQ(*expected, *value);
   }
 };
 
 static Type* kStringTypes[] = {Type::InternalizedString(), Type::OtherString(),
                                Type::String()};
 
 
 static Type* kInt32Types[] = {
     Type::UnsignedSmall(),   Type::OtherSignedSmall(), Type::OtherUnsigned31(),
@@ skipping 87 matching lines @@
 }
 
 
 static void CheckToI32(Node* old_input, Node* new_input, bool is_signed) {
   Type* old_type = NodeProperties::GetBounds(old_input).upper;
   Type* expected_type = I32Type(is_signed);
   if (old_type->Is(expected_type)) {
     CHECK_EQ(old_input, new_input);
   } else if (new_input->opcode() == IrOpcode::kNumberConstant) {
     CHECK(NodeProperties::GetBounds(new_input).upper->Is(expected_type));
-    double v = ValueOf<double>(new_input->op());
+    double v = OpParameter<double>(new_input);
     double e = static_cast<double>(is_signed ? FastD2I(v) : FastD2UI(v));
     CHECK_EQ(e, v);
   } else {
     CHECK_EQ(NumberToI32(is_signed), new_input->opcode());
   }
 }
 
 
 // A helper class for testing lowering of bitwise shift operators.
 class JSBitwiseShiftTypedLoweringTester : public JSTypedLoweringTester {
@@ skipping 1089 matching lines @@
           CHECK_EQ(p1, r->InputAt(0));
           CHECK_EQ(p0, r->InputAt(1));
         } else {
           CHECK_EQ(p0, r->InputAt(0));
           CHECK_EQ(p1, r->InputAt(1));
         }
       }
     }
   }
 }