[turbofan] Remove usage of Unique<T> from graph.

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 217 matching lines @@
     EXPECT_FALSE(r.Changed());
   }
 }
 
 
 TEST_F(JSTypedLoweringTest, ParameterWithNull) {
   Handle<HeapObject> null = factory()->null_value();
   {
     Reduction r = Reduce(Parameter(Type::Constant(null, zone())));
     ASSERT_TRUE(r.Changed());
-    EXPECT_THAT(r.replacement(),
-                IsHeapConstant(Unique<HeapObject>::CreateImmovable(null)));
+    EXPECT_THAT(r.replacement(), IsHeapConstant(null));
   }
   {
     Reduction r = Reduce(Parameter(Type::Null()));
     ASSERT_TRUE(r.Changed());
-    EXPECT_THAT(r.replacement(),
-                IsHeapConstant(Unique<HeapObject>::CreateImmovable(null)));
+    EXPECT_THAT(r.replacement(), IsHeapConstant(null));
   }
 }
 
 
 TEST_F(JSTypedLoweringTest, ParameterWithNaN) {
   const double kNaNs[] = {-std::numeric_limits<double>::quiet_NaN(),
                           std::numeric_limits<double>::quiet_NaN(),
                           std::numeric_limits<double>::signaling_NaN()};
   TRACED_FOREACH(double, nan, kNaNs) {
     Handle<Object> constant = factory()->NewNumber(nan);
@@ skipping 28 matching lines @@
     EXPECT_THAT(r.replacement(), IsNumberConstant(value));
   }
 }
 
 
 TEST_F(JSTypedLoweringTest, ParameterWithUndefined) {
   Handle<HeapObject> undefined = factory()->undefined_value();
   {
     Reduction r = Reduce(Parameter(Type::Undefined()));
     ASSERT_TRUE(r.Changed());
-    EXPECT_THAT(r.replacement(),
-                IsHeapConstant(Unique<HeapObject>::CreateImmovable(undefined)));
+    EXPECT_THAT(r.replacement(), IsHeapConstant(undefined));
   }
   {
     Reduction r = Reduce(Parameter(Type::Constant(undefined, zone())));
     ASSERT_TRUE(r.Changed());
-    EXPECT_THAT(r.replacement(),
-                IsHeapConstant(Unique<HeapObject>::CreateImmovable(undefined)));
+    EXPECT_THAT(r.replacement(), IsHeapConstant(undefined));
   }
 }
 
 
 // -----------------------------------------------------------------------------
 // JSToBoolean
 
 
 TEST_F(JSTypedLoweringTest, JSToBooleanWithBoolean) {
   Node* input = Parameter(Type::Boolean(), 0);
@@ skipping 566 matching lines @@
 // JSLoadGlobal
 
 
 TEST_F(JSTypedLoweringTest, JSLoadGlobalConstants) {
   Handle<String> names[] = {
       Handle<String>(isolate()->heap()->undefined_string(), isolate()),
       Handle<String>(isolate()->heap()->infinity_string(), isolate()),
       Handle<String>(isolate()->heap()->nan_string(), isolate())  // --
   };
   Matcher<Node*> matches[] = {
-      IsHeapConstant(Unique<HeapObject>::CreateImmovable(
-          Handle<HeapObject>(isolate()->heap()->undefined_value(), isolate()))),
+      IsHeapConstant(
+          Handle<HeapObject>(isolate()->heap()->undefined_value(), isolate())),
       IsNumberConstant(std::numeric_limits<double>::infinity()),
       IsNumberConstant(IsNaN())  // --
   };
 
   VectorSlotPair feedback;
   Node* global = UndefinedConstant();
   Node* vector = UndefinedConstant();
   Node* context = UndefinedConstant();
   Node* effect = graph()->start();
   Node* control = graph()->start();
 
   for (size_t i = 0; i < arraysize(names); i++) {
-    Unique<Name> name = Unique<Name>::CreateImmovable(names[i]);
     Reduction r = Reduce(graph()->NewNode(
-        javascript()->LoadGlobal(name, feedback), context, global, vector,
+        javascript()->LoadGlobal(names[i], feedback), context, global, vector,
         context, EmptyFrameState(), EmptyFrameState(), effect, control));
 
     ASSERT_TRUE(r.Changed());
     EXPECT_THAT(r.replacement(), matches[i]);
   }
 }
 
 
 // -----------------------------------------------------------------------------
 // JSLoadNamed
 
 
 TEST_F(JSTypedLoweringTest, JSLoadNamedStringLength) {
   VectorSlotPair feedback;
-  Unique<Name> name = Unique<Name>::CreateImmovable(factory()->length_string());
+  Handle<Name> name = factory()->length_string();
   Node* const receiver = Parameter(Type::String(), 0);
   Node* const vector = Parameter(Type::Internal(), 1);
   Node* const context = UndefinedConstant();
   Node* const effect = graph()->start();
   Node* const control = graph()->start();
   TRACED_FOREACH(LanguageMode, language_mode, kLanguageModes) {
     Reduction const r = Reduce(
         graph()->NewNode(javascript()->LoadNamed(name, feedback, language_mode),
                          receiver, vector, context, EmptyFrameState(),
                          EmptyFrameState(), effect, control));
@@ skipping 85 matching lines @@
     Node* rhs = Parameter(Type::String(), 1);
     Node* context = Parameter(Type::Any(), 2);
     Node* frame_state0 = EmptyFrameState();
     Node* frame_state1 = EmptyFrameState();
     Node* effect = graph()->start();
     Node* control = graph()->start();
     Reduction r = Reduce(graph()->NewNode(javascript()->Add(language_mode), lhs,
                                           rhs, context, frame_state0,
                                           frame_state1, effect, control));
     ASSERT_TRUE(r.Changed());
-    EXPECT_THAT(
-        r.replacement(),
-        IsCall(_, IsHeapConstant(Unique<HeapObject>::CreateImmovable(
-                      CodeFactory::StringAdd(isolate(), STRING_ADD_CHECK_NONE,
-                                             NOT_TENURED).code())),
-               lhs, rhs, context, frame_state0, effect, control));
+    EXPECT_THAT(r.replacement(),
+                IsCall(_, IsHeapConstant(CodeFactory::StringAdd(
+                                             isolate(), STRING_ADD_CHECK_NONE,
+                                             NOT_TENURED).code()),
+                       lhs, rhs, context, frame_state0, effect, control));
   }
 }
 
 
 // -----------------------------------------------------------------------------
 // JSCreateClosure
 
 
 TEST_F(JSTypedLoweringTest, JSCreateClosure) {
   Node* const context = UndefinedConstant();
   Node* const effect = graph()->start();
   Node* const control = graph()->start();
   Handle<SharedFunctionInfo> shared(isolate()->object_function()->shared());
   Reduction r =
       Reduce(graph()->NewNode(javascript()->CreateClosure(shared, NOT_TENURED),
                               context, context, effect, control));
   ASSERT_TRUE(r.Changed());
-  EXPECT_THAT(
-      r.replacement(),
-      IsCall(_,
-             IsHeapConstant(Unique<HeapObject>::CreateImmovable(
-                 CodeFactory::FastNewClosure(isolate(), shared->language_mode(),
-                                             shared->kind()).code())),
-             IsHeapConstant(Unique<HeapObject>::CreateImmovable(shared)),
-             effect, control));
+  EXPECT_THAT(r.replacement(),
+              IsCall(_, IsHeapConstant(CodeFactory::FastNewClosure(
+                                           isolate(), shared->language_mode(),
+                                           shared->kind()).code()),
+                     IsHeapConstant(shared), effect, control));
 }
 
 
 // -----------------------------------------------------------------------------
 // JSCreateLiteralArray
 
 
 TEST_F(JSTypedLoweringTest, JSCreateLiteralArray) {
   Node* const input0 = Parameter(0);
   Node* const input1 = Parameter(1);
   Node* const input2 = HeapConstant(factory()->NewFixedArray(12));
   Node* const context = UndefinedConstant();
   Node* const frame_state = EmptyFrameState();
   Node* const effect = graph()->start();
   Node* const control = graph()->start();
   Reduction const r = Reduce(graph()->NewNode(
       javascript()->CreateLiteralArray(ArrayLiteral::kShallowElements), input0,
       input1, input2, context, frame_state, effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(
       r.replacement(),
-      IsCall(_, IsHeapConstant(Unique<HeapObject>::CreateImmovable(
-                    CodeFactory::FastCloneShallowArray(isolate()).code())),
+      IsCall(_, IsHeapConstant(
+                    CodeFactory::FastCloneShallowArray(isolate()).code()),
              input0, input1, input2, context, frame_state, effect, control));
 }
 
 
 // -----------------------------------------------------------------------------
 // JSCreateLiteralObject
 
 
 TEST_F(JSTypedLoweringTest, JSCreateLiteralObject) {
   Node* const input0 = Parameter(0);
   Node* const input1 = Parameter(1);
   Node* const input2 = HeapConstant(factory()->NewFixedArray(2 * 6));
   Node* const context = UndefinedConstant();
   Node* const frame_state = EmptyFrameState();
   Node* const effect = graph()->start();
   Node* const control = graph()->start();
   Reduction const r = Reduce(graph()->NewNode(
       javascript()->CreateLiteralObject(ObjectLiteral::kShallowProperties),
       input0, input1, input2, context, frame_state, effect, control));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(
       r.replacement(),
-      IsCall(_, IsHeapConstant(Unique<HeapObject>::CreateImmovable(
-                    CodeFactory::FastCloneShallowObject(isolate(), 6).code())),
+      IsCall(_, IsHeapConstant(
+                    CodeFactory::FastCloneShallowObject(isolate(), 6).code()),
              input0, input1, input2, _, context, frame_state, effect, control));
 }
 
 
 // -----------------------------------------------------------------------------
 // JSCreateWithContext
 
 
 TEST_F(JSTypedLoweringTest, JSCreateWithContext) {
   FLAG_turbo_allocate = true;
@@ skipping 10 matching lines @@
   EXPECT_THAT(r.replacement(),
               IsFinish(IsAllocate(IsNumberConstant(Context::SizeFor(
                                       Context::MIN_CONTEXT_SLOTS)),
                                   effect, control),
                        _));
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8