Massive renaming of PropertyType values and other implied stuff.

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 49 matching lines @@
 
   int next_field_offset = 0;
   for (int i = 0; i < kPropsCount; i++) {
     EmbeddedVector<char, 64> buffer;
     SNPrintF(buffer, "prop%d", i);
     Handle<String> name = factory->InternalizeUtf8String(buffer.start());
 
     TestPropertyKind kind = props[i];
 
     if (kind == PROP_CONSTANT) {
-      ConstantDescriptor d(name, func, NONE);
+      DataConstantDescriptor d(name, func, NONE);
       descriptors->Append(&d);
 
     } else {
-      FieldDescriptor f(name, next_field_offset, NONE, representations[kind]);
+      DataDescriptor f(name, next_field_offset, NONE, representations[kind]);
       next_field_offset += f.GetDetails().field_width_in_words();
       descriptors->Append(&f);
     }
   }
   return descriptors;
 }
 
 
 TEST(LayoutDescriptorBasicFast) {
   CcTest::InitializeVM();
@@ skipping 449 matching lines @@
     DCHECK(layout_descriptor->IsConsistentWithMap(*map));
   }
 
   {
     int inobject_properties = kPropsCount / 2;
     Handle<Map> map = Map::Create(isolate, inobject_properties);
     layout_descriptor = LayoutDescriptor::New(map, descriptors, kPropsCount);
     CHECK_NE(LayoutDescriptor::FastPointerLayout(), *layout_descriptor);
     CHECK(layout_descriptor->IsSlowLayout());
     for (int i = 0; i < inobject_properties; i++) {
-      // PROP_DOUBLE has index 1 among FIELD properties.
+      // PROP_DOUBLE has index 1 among DATA properties.
       const bool tagged = (i % (PROP_KIND_NUMBER - 1)) != 1;
       CHECK_EQ(tagged, layout_descriptor->IsTagged(i));
     }
     // Every property after inobject_properties must be tagged.
     for (int i = inobject_properties; i < kPropsCount; i++) {
       CHECK_EQ(true, layout_descriptor->IsTagged(i));
     }
     map->InitializeDescriptors(*descriptors, *layout_descriptor);
     DCHECK(layout_descriptor->IsConsistentWithMap(*map));
 
@@ skipping 38 matching lines @@
 
   int next_field_offset = 0;
   for (int i = 0; i < kPropsCount; i++) {
     EmbeddedVector<char, 64> buffer;
     SNPrintF(buffer, "prop%d", i);
     Handle<String> name = factory->InternalizeUtf8String(buffer.start());
 
     Handle<LayoutDescriptor> layout_descriptor;
     TestPropertyKind kind = props[i];
     if (kind == PROP_CONSTANT) {
-      ConstantDescriptor d(name, func, NONE);
+      DataConstantDescriptor d(name, func, NONE);
       layout_descriptor = LayoutDescriptor::Append(map, d.GetDetails());
       descriptors->Append(&d);
 
     } else {
-      FieldDescriptor f(name, next_field_offset, NONE, representations[kind]);
+      DataDescriptor f(name, next_field_offset, NONE, representations[kind]);
       int field_width_in_words = f.GetDetails().field_width_in_words();
       next_field_offset += field_width_in_words;
       layout_descriptor = LayoutDescriptor::Append(map, f.GetDetails());
       descriptors->Append(&f);
 
       int field_index = f.GetDetails().field_index();
       bool is_inobject = field_index < map->inobject_properties();
       for (int bit = 0; bit < field_width_in_words; bit++) {
         CHECK_EQ(is_inobject && (kind == PROP_DOUBLE),
                  !layout_descriptor->IsTagged(field_index + bit));
@@ skipping 110 matching lines @@
     map = Map::CopyInstallDescriptorsForTesting(map, i, descriptors,
                                                 full_layout_descriptor);
 
     LayoutDescriptor* layout_desc = map->layout_descriptor();
 
     if (layout_desc->IsSlowLayout()) {
       switched_to_slow_mode = true;
       CHECK_EQ(*full_layout_descriptor, layout_desc);
     } else {
       CHECK(!switched_to_slow_mode);
-      if (details.type() == FIELD) {
+      if (details.type() == DATA) {
         nof++;
         int field_index = details.field_index();
         int field_width_in_words = details.field_width_in_words();
 
         bool is_inobject = field_index < map->inobject_properties();
         for (int bit = 0; bit < field_width_in_words; bit++) {
           CHECK_EQ(is_inobject && details.representation().IsDouble(),
                    !layout_desc->IsTagged(field_index + bit));
         }
         CHECK(layout_desc->IsTagged(field_index + field_width_in_words));
@@ skipping 214 matching lines @@
 
   LayoutDescriptorHelper helper(*map);
   bool all_fields_tagged = true;
 
   int instance_size = map->instance_size();
 
   int end_offset = instance_size * 2;
   int first_non_tagged_field_offset = end_offset;
   for (int i = 0; i < number_of_descriptors; i++) {
     PropertyDetails details = descriptors->GetDetails(i);
-    if (details.type() != FIELD) continue;
+    if (details.type() != DATA) continue;
     FieldIndex index = FieldIndex::ForDescriptor(*map, i);
     if (!index.is_inobject()) continue;
     all_fields_tagged &= !details.representation().IsDouble();
     bool expected_tagged = !index.is_double();
     if (!expected_tagged) {
       first_non_tagged_field_offset =
           Min(first_non_tagged_field_offset, index.offset());
     }
 
     int end_of_region_offset;
@@ skipping 168 matching lines @@
   MemoryChunk* chunk = MemoryChunk::FromAddress(obj->address());
   chunk->set_scan_on_scavenge(true);
 
   // Trigger GCs and force evacuation. Should not crash there.
   CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags);
 
   CHECK_EQ(boom_value, GetDoubleFieldValue(*obj, field_index));
 }
 
 #endif