Replace HeapType with a non-templated FieldType class.

test/cctest/test-unboxed-doubles.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 <stdlib.h>
 #include <utility>
 
 #include "src/v8.h"
 
 #include "src/compilation-cache.h"
@@ skipping 929 matching lines @@
 
 TEST(DescriptorArrayTrimming) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
 
   const int kFieldCount = 128;
   const int kSplitFieldIndex = 32;
   const int kTrimmedLayoutDescriptorLength = 64;
 
-  Handle<HeapType> any_type = HeapType::Any(isolate);
+  Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<Map> map = Map::Create(isolate, kFieldCount);
   for (int i = 0; i < kSplitFieldIndex; i++) {
     map = Map::CopyWithField(map, MakeName("prop", i), any_type, NONE,
                              Representation::Smi(),
                              INSERT_TRANSITION).ToHandleChecked();
   }
   map = Map::CopyWithField(map, MakeName("dbl", kSplitFieldIndex), any_type,
                            NONE, Representation::Double(),
                            INSERT_TRANSITION).ToHandleChecked();
   CHECK(map->layout_descriptor()->IsConsistentWithMap(*map, true));
@@ skipping 67 matching lines @@
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
 
   // The plan: create |obj| with double field in new space, do scanvenge so
   // that |obj| is moved to old space, construct a double value that looks like
   // a pointer to "from space" pointer. Do scavenge one more time and ensure
   // that it didn't crash or corrupt the double value stored in the object.
 
-  Handle<HeapType> any_type = HeapType::Any(isolate);
+  Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<Map> map = Map::Create(isolate, 10);
   map = Map::CopyWithField(map, MakeName("prop", 0), any_type, NONE,
                            Representation::Double(),
                            INSERT_TRANSITION).ToHandleChecked();
 
   // Create object in new space.
   Handle<JSObject> obj = factory->NewJSObjectFromMap(map, NOT_TENURED);
 
   Handle<HeapNumber> heap_number = factory->NewHeapNumber(42.5);
   obj->WriteToField(0, *heap_number);
@@ skipping 41 matching lines @@
   Factory* factory = isolate->factory();
   Heap* heap = CcTest::heap();
   PagedSpace* old_space = heap->old_space();
 
   // The plan: create |obj_value| in old space and ensure that it is allocated
   // on evacuation candidate page, create |obj| with double and tagged fields
   // in new space and write |obj_value| to tagged field of |obj|, do two
   // scavenges to promote |obj| to old space, a GC in old space and ensure that
   // the tagged value was properly updated after candidates evacuation.
 
-  Handle<HeapType> any_type = HeapType::Any(isolate);
+  Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<Map> map = Map::Create(isolate, 10);
   map = Map::CopyWithField(map, MakeName("prop", 0), any_type, NONE,
                            Representation::Double(),
                            INSERT_TRANSITION).ToHandleChecked();
   map = Map::CopyWithField(map, MakeName("prop", 1), any_type, NONE,
                            Representation::Tagged(),
                            INSERT_TRANSITION).ToHandleChecked();
 
   // Create |obj_value| in old space.
   Handle<HeapObject> obj_value;
@@ skipping 203 matching lines @@
                              kPropsCount);
 
   TestLayoutDescriptorHelper(isolate, kPropsCount, descriptors, kPropsCount);
 }
 
 
 TEST(LayoutDescriptorSharing) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
-  Handle<HeapType> any_type = HeapType::Any(isolate);
+  Handle<FieldType> any_type = FieldType::Any(isolate);
 
   Handle<Map> split_map;
   {
     Handle<Map> map = Map::Create(isolate, 64);
     for (int i = 0; i < 32; i++) {
       Handle<String> name = MakeName("prop", i);
       map = Map::CopyWithField(map, name, any_type, NONE, Representation::Smi(),
                                INSERT_TRANSITION).ToHandleChecked();
     }
     split_map = Map::CopyWithField(map, MakeString("dbl"), any_type, NONE,
@@ skipping 27 matching lines @@
   CHECK(map2->layout_descriptor()->IsConsistentWithMap(*map2, true));
 }
 
 
 TEST(StoreBufferScanOnScavenge) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
   v8::HandleScope scope(CcTest::isolate());
 
-  Handle<HeapType> any_type = HeapType::Any(isolate);
+  Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<Map> map = Map::Create(isolate, 10);
   map = Map::CopyWithField(map, MakeName("prop", 0), any_type, NONE,
                            Representation::Double(),
                            INSERT_TRANSITION).ToHandleChecked();
 
   // Create object in new space.
   Handle<JSObject> obj = factory->NewJSObjectFromMap(map, NOT_TENURED);
 
   Handle<HeapNumber> heap_number = factory->NewHeapNumber(42.5);
   obj->WriteToField(0, *heap_number);
@@ skipping 190 matching lines @@
 }
 
 
 enum WriteBarrierKind { OLD_TO_OLD_WRITE_BARRIER, OLD_TO_NEW_WRITE_BARRIER };
 static void TestWriteBarrierObjectShiftFieldsRight(
     WriteBarrierKind write_barrier_kind) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   v8::HandleScope scope(CcTest::isolate());
 
-  Handle<HeapType> any_type = HeapType::Any(isolate);
+  Handle<FieldType> any_type = FieldType::Any(isolate);
 
   CompileRun("function func() { return 1; }");
 
   Handle<JSObject> func = GetObject("func");
 
   Handle<Map> map = Map::Create(isolate, 10);
   map = Map::CopyWithConstant(map, MakeName("prop", 0), func, NONE,
                               INSERT_TRANSITION).ToHandleChecked();
   map = Map::CopyWithField(map, MakeName("prop", 1), any_type, NONE,
                            Representation::Double(),
@@ skipping 28 matching lines @@
 
 // TODO(ishell): add respective tests for property kind reconfiguring from
 // accessor field to double, once accessor fields are supported by
 // Map::ReconfigureProperty().
 
 
 // TODO(ishell): add respective tests for fast property removal case once
 // Map::ReconfigureProperty() supports that.
 
 #endif