Rename GeneralizeRepresentation term to GeneralizeField in tests.

test/cctest/test-field-type-tracking.cc

 // Copyright 2015 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 "test/cctest/test-api.h"
 
 #include "src/v8.h"
 
 #include "src/compilation-cache.h"
 #include "src/compilation-dependencies.h"
 #include "src/compilation-info.h"
 #include "src/execution.h"
 #include "src/factory.h"
 #include "src/field-type.h"
 #include "src/global-handles.h"
 #include "src/ic/stub-cache.h"
 #include "src/macro-assembler.h"
 
 using namespace v8::internal;
 
 
 // TODO(ishell): fix this once TransitionToPrototype stops generalizing
 // all field representations (similar to crbug/448711 where elements kind
-// and observed transitions caused generalization of all field representations).
+// and observed transitions caused generalization of all fields).
 const bool IS_PROTO_TRANS_ISSUE_FIXED = false;
 
 
 // TODO(ishell): fix this once TransitionToAccessorProperty is able to always
 // keep map in fast mode.
 const bool IS_ACCESSOR_FIELD_SUPPORTED = false;
 
 
 // Number of properties used in the tests.
 const int kPropCount = 7;
@@ skipping 176 matching lines @@
                            Handle<Object> setter) {
     SetAccessorConstant(index, attributes_[index], getter, setter);
   }
 
   void SetAccessorConstant(int index, Handle<AccessorPair> pair) {
     Handle<Object> getter = handle(pair->getter(), isolate_);
     Handle<Object> setter = handle(pair->setter(), isolate_);
     SetAccessorConstant(index, getter, setter);
   }
 
-  void GeneralizeRepresentation(int index) {
+  void GeneralizeField(int index) {
     CHECK(index < number_of_properties_);
     representations_[index] = Representation::Tagged();
     if (locations_[index] == kField) {
       values_[index] = FieldType::Any(isolate_);
     }
   }
 
   bool Check(DescriptorArray* descriptors, int descriptor) const {
     PropertyDetails details = descriptors->GetDetails(descriptor);
 
@@ skipping 306 matching lines @@
   // Check that the property contains |value|.
   CHECK_EQ(1, obj->map()->NumberOfOwnDescriptors());
   FieldIndex index = FieldIndex::ForDescriptor(obj->map(), 0);
   Object* the_value = obj->RawFastPropertyAt(index);
   CHECK(the_value->IsSmi());
   CHECK_EQ(42, Smi::cast(the_value)->value());
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
-// A set of tests for representation generalization case.
+// A set of tests for field generalization case.
 //
 
 // <Constness, Representation, FieldType> data.
 struct CRFTData {
   PropertyConstness constness;
   Representation representation;
   Handle<FieldType> type;
 };
 
-// This test ensures that representation/field type generalization at
-// |property_index| is done correctly independently of the fact that the |map|
-// is detached from transition tree or not.
+// This test ensures that field generalization at |property_index| is done
+// correctly independently of the fact that the |map| is detached from
+// transition tree or not.
 //
 //  {} - p0 - p1 - p2: |detach_point_map|
 //                  |
 //                  X - detached at |detach_property_at_index|
 //                  |
 //                  + - p3 - p4: |map|
 //
 // Detaching does not happen if |detach_property_at_index| is -1.
 //
-static void TestGeneralizeRepresentation(
-    int detach_property_at_index, int property_index, const CRFTData& from,
-    const CRFTData& to, const CRFTData& expected, bool expected_deprecation,
-    bool expected_field_type_dependency) {
+static void TestGeneralizeField(int detach_property_at_index,
+                                int property_index, const CRFTData& from,
+                                const CRFTData& to, const CRFTData& expected,
+                                bool expected_deprecation,
+                                bool expected_field_type_dependency) {
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
   CHECK(detach_property_at_index >= -1 &&
         detach_property_at_index < kPropCount);
   CHECK(property_index < kPropCount);
   CHECK_NE(detach_property_at_index, property_index);
 
   const bool is_detached_map = detach_property_at_index >= 0;
 
@@ skipping 81 matching lines @@
     }
   }
 
   dependencies.Rollback();  // Properly cleanup compilation info.
 
   // Update all deprecated maps and check that they are now the same.
   Handle<Map> updated_map = Map::Update(map);
   CHECK_EQ(*new_map, *updated_map);
 }
 
-static void TestGeneralizeRepresentation(const CRFTData& from,
-                                         const CRFTData& to,
-                                         const CRFTData& expected,
-                                         bool expected_deprecation,
-                                         bool expected_field_type_dependency) {
+static void TestGeneralizeField(const CRFTData& from, const CRFTData& to,
+                                const CRFTData& expected,
+                                bool expected_deprecation,
+                                bool expected_field_type_dependency) {
   // Check the cases when the map being reconfigured is a part of the
   // transition tree.
   STATIC_ASSERT(kPropCount > 4);
   int indices[] = {0, 2, kPropCount - 1};
   for (int i = 0; i < static_cast<int>(arraysize(indices)); i++) {
-    TestGeneralizeRepresentation(-1, indices[i], from, to, expected,
-                                 expected_deprecation,
-                                 expected_field_type_dependency);
+    TestGeneralizeField(-1, indices[i], from, to, expected,
+                        expected_deprecation, expected_field_type_dependency);
   }
 
   if (!from.representation.IsNone()) {
     // Check the cases when the map being reconfigured is NOT a part of the
     // transition tree. "None -> anything" representation changes make sense
     // only for "attached" maps.
     int indices[] = {0, kPropCount - 1};
     for (int i = 0; i < static_cast<int>(arraysize(indices)); i++) {
-      TestGeneralizeRepresentation(indices[i], 2, from, to, expected,
-                                   expected_deprecation,
-                                   expected_field_type_dependency);
+      TestGeneralizeField(indices[i], 2, from, to, expected,
+                          expected_deprecation, expected_field_type_dependency);
     }
 
     // Check that reconfiguration to the very same field works correctly.
     CRFTData data = from;
-    TestGeneralizeRepresentation(-1, 2, data, data, data, false, false);
+    TestGeneralizeField(-1, 2, data, data, data, false, false);
   }
 }
 
-static void TestGeneralizeRepresentation(const CRFTData& from,
-                                         const CRFTData& to,
-                                         const CRFTData& expected) {
+static void TestGeneralizeField(const CRFTData& from, const CRFTData& to,
+                                const CRFTData& expected) {
   const bool expected_deprecation = true;
   const bool expected_field_type_dependency = false;
 
-  TestGeneralizeRepresentation(from, to, expected, expected_deprecation,
-                               expected_field_type_dependency);
+  TestGeneralizeField(from, to, expected, expected_deprecation,
+                      expected_field_type_dependency);
 }
 
-static void TestGeneralizeRepresentationTrivial(
+static void TestGeneralizeFieldTrivial(
     const CRFTData& from, const CRFTData& to, const CRFTData& expected,
     bool expected_field_type_dependency = true) {
   const bool expected_deprecation = false;
 
-  TestGeneralizeRepresentation(from, to, expected, expected_deprecation,
-                               expected_field_type_dependency);
+  TestGeneralizeField(from, to, expected, expected_deprecation,
+                      expected_field_type_dependency);
 }
 
-
-TEST(GeneralizeRepresentationSmiToDouble) {
+TEST(GeneralizeSmiFieldToDouble) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
-  TestGeneralizeRepresentation({kMutable, Representation::Smi(), any_type},
-                               {kMutable, Representation::Double(), any_type},
-                               {kMutable, Representation::Double(), any_type});
+  TestGeneralizeField({kMutable, Representation::Smi(), any_type},
+                      {kMutable, Representation::Double(), any_type},
+                      {kMutable, Representation::Double(), any_type});
 }
 
-
-TEST(GeneralizeRepresentationSmiToTagged) {
+TEST(GeneralizeSmiFieldToTagged) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<FieldType> value_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
-  TestGeneralizeRepresentation(
-      {kMutable, Representation::Smi(), any_type},
-      {kMutable, Representation::HeapObject(), value_type},
-      {kMutable, Representation::Tagged(), any_type});
+  TestGeneralizeField({kMutable, Representation::Smi(), any_type},
+                      {kMutable, Representation::HeapObject(), value_type},
+                      {kMutable, Representation::Tagged(), any_type});
 }
 
-
-TEST(GeneralizeRepresentationDoubleToTagged) {
+TEST(GeneralizeDoubleFieldToTagged) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<FieldType> value_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
-  TestGeneralizeRepresentation(
-      {kMutable, Representation::Double(), any_type},
-      {kMutable, Representation::HeapObject(), value_type},
-      {kMutable, Representation::Tagged(), any_type});
+  TestGeneralizeField({kMutable, Representation::Double(), any_type},
+                      {kMutable, Representation::HeapObject(), value_type},
+                      {kMutable, Representation::Tagged(), any_type});
 }
 
-
-TEST(GeneralizeRepresentationHeapObjectToTagged) {
+TEST(GeneralizeHeapObjectFieldToTagged) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<FieldType> value_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
-  TestGeneralizeRepresentation(
-      {kMutable, Representation::HeapObject(), value_type},
-      {kMutable, Representation::Smi(), any_type},
-      {kMutable, Representation::Tagged(), any_type});
+  TestGeneralizeField({kMutable, Representation::HeapObject(), value_type},
+                      {kMutable, Representation::Smi(), any_type},
+                      {kMutable, Representation::Tagged(), any_type});
 }
 
-
-TEST(GeneralizeRepresentationHeapObjectToHeapObject) {
+TEST(GeneralizeHeapObjectFieldToHeapObject) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
   Handle<FieldType> current_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
   Handle<FieldType> new_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
   Handle<FieldType> expected_type = any_type;
 
-  TestGeneralizeRepresentationTrivial(
+  TestGeneralizeFieldTrivial(
       {kMutable, Representation::HeapObject(), current_type},
       {kMutable, Representation::HeapObject(), new_type},
       {kMutable, Representation::HeapObject(), expected_type});
   current_type = expected_type;
 
   new_type = FieldType::Class(Map::Create(isolate, 0), isolate);
 
-  TestGeneralizeRepresentationTrivial(
-      {kMutable, Representation::HeapObject(), any_type},
-      {kMutable, Representation::HeapObject(), new_type},
-      {kMutable, Representation::HeapObject(), any_type}, false);
+  TestGeneralizeFieldTrivial({kMutable, Representation::HeapObject(), any_type},
+                             {kMutable, Representation::HeapObject(), new_type},
+                             {kMutable, Representation::HeapObject(), any_type},
+                             false);
 }
 
-
-TEST(GeneralizeRepresentationNoneToSmi) {
+TEST(GeneralizeNoneFieldToSmi) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> none_type = FieldType::None(isolate);
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
   // None -> Smi representation change is trivial.
-  TestGeneralizeRepresentationTrivial(
-      {kMutable, Representation::None(), none_type},
-      {kMutable, Representation::Smi(), any_type},
-      {kMutable, Representation::Smi(), any_type});
+  TestGeneralizeFieldTrivial({kMutable, Representation::None(), none_type},
+                             {kMutable, Representation::Smi(), any_type},
+                             {kMutable, Representation::Smi(), any_type});
 }
 
-
-TEST(GeneralizeRepresentationNoneToDouble) {
+TEST(GeneralizeNoneFieldToDouble) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> none_type = FieldType::None(isolate);
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
   // None -> Double representation change is NOT trivial.
-  TestGeneralizeRepresentation({kMutable, Representation::None(), none_type},
-                               {kMutable, Representation::Double(), any_type},
-                               {kMutable, Representation::Double(), any_type});
+  TestGeneralizeField({kMutable, Representation::None(), none_type},
+                      {kMutable, Representation::Double(), any_type},
+                      {kMutable, Representation::Double(), any_type});
 }
 
-
-TEST(GeneralizeRepresentationNoneToHeapObject) {
+TEST(GeneralizeNoneFieldToHeapObject) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> none_type = FieldType::None(isolate);
   Handle<FieldType> value_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
   // None -> HeapObject representation change is trivial.
-  TestGeneralizeRepresentationTrivial(
+  TestGeneralizeFieldTrivial(
       {kMutable, Representation::None(), none_type},
       {kMutable, Representation::HeapObject(), value_type},
       {kMutable, Representation::HeapObject(), value_type});
 }
 
-
-TEST(GeneralizeRepresentationNoneToTagged) {
+TEST(GeneralizeNoneFieldToTagged) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> none_type = FieldType::None(isolate);
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
   // None -> HeapObject representation change is trivial.
-  TestGeneralizeRepresentationTrivial(
-      {kMutable, Representation::None(), none_type},
-      {kMutable, Representation::Tagged(), any_type},
-      {kMutable, Representation::Tagged(), any_type});
+  TestGeneralizeFieldTrivial({kMutable, Representation::None(), none_type},
+                             {kMutable, Representation::Tagged(), any_type},
+                             {kMutable, Representation::Tagged(), any_type});
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
-// A set of tests for representation generalization case with kAccessor
-// properties.
+// A set of tests for field generalization case with kAccessor properties.
 //
 
-TEST(GeneralizeRepresentationWithAccessorProperties) {
+TEST(GeneralizeFieldWithAccessorProperties) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<AccessorPair> pair = CreateAccessorPair(true, true);
 
   const int kAccessorProp = kPropCount / 2;
   Expectations expectations(isolate);
 
   // Create a map, add required properties to it and initialize expectations.
@@ skipping 44 matching lines @@
     updated_map = Map::Update(maps[i]);
     CHECK_EQ(*active_map, *updated_map);
   }
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // A set of tests for attribute reconfiguration case.
 //
 
-// This test ensures that representation/field type generalization is correctly
-// propagated from one branch of transition tree (|map2|) to another (|map|).
+// This test ensures that field generalization is correctly propagated from one
+// branch of transition tree (|map2|) to another (|map|).
 //
 //             + - p2B - p3 - p4: |map2|
 //             |
 //  {} - p0 - p1 - p2A - p3 - p4: |map|
 //
 // where "p2A" and "p2B" differ only in the attributes.
 //
-static void TestReconfigureDataFieldAttribute_GeneralizeRepresentation(
+static void TestReconfigureDataFieldAttribute_GeneralizeField(
     const CRFTData& from, const CRFTData& to, const CRFTData& expected) {
   Isolate* isolate = CcTest::i_isolate();
 
   Expectations expectations(isolate);
 
   // Create a map, add required properties to it and initialize expectations.
   Handle<Map> initial_map = Map::Create(isolate, 0);
   Handle<Map> map = initial_map;
   for (int i = 0; i < kPropCount; i++) {
     map = expectations.AddDataField(map, NONE, from.constness,
@@ skipping 53 matching lines @@
   CHECK_NE(*map, *new_map);
 
   CHECK(!new_map->is_deprecated());
   CHECK(expectations.Check(*new_map));
 
   // Update deprecated |map|, it should become |new_map|.
   Handle<Map> updated_map = Map::Update(map);
   CHECK_EQ(*new_map, *updated_map);
 }
 
-
-// This test ensures that trivial representation/field type generalization
-// (from HeapObject to HeapObject) is correctly propagated from one branch of
-// transition tree (|map2|) to another (|map|).
+// This test ensures that trivial field generalization (from HeapObject to
+// HeapObject) is correctly propagated from one branch of transition tree
+// (|map2|) to another (|map|).
 //
 //             + - p2B - p3 - p4: |map2|
 //             |
 //  {} - p0 - p1 - p2A - p3 - p4: |map|
 //
 // where "p2A" and "p2B" differ only in the attributes.
 //
-static void TestReconfigureDataFieldAttribute_GeneralizeRepresentationTrivial(
+static void TestReconfigureDataFieldAttribute_GeneralizeFieldTrivial(
     const CRFTData& from, const CRFTData& to, const CRFTData& expected,
     bool expected_field_type_dependency = true) {
   Isolate* isolate = CcTest::i_isolate();
 
   Expectations expectations(isolate);
 
   // Create a map, add required properties to it and initialize expectations.
   Handle<Map> initial_map = Map::Create(isolate, 0);
   Handle<Map> map = initial_map;
   for (int i = 0; i < kPropCount; i++) {
@@ skipping 56 matching lines @@
   CHECK_EQ(expected_field_type_dependency, dependencies.HasAborted());
   dependencies.Rollback();  // Properly cleanup compilation info.
 
   CHECK(!new_map->is_deprecated());
   CHECK(expectations.Check(*new_map));
 
   Handle<Map> updated_map = Map::Update(map);
   CHECK_EQ(*new_map, *updated_map);
 }
 
-
-TEST(ReconfigureDataFieldAttribute_GeneralizeRepresentationSmiToDouble) {
+TEST(ReconfigureDataFieldAttribute_GeneralizeSmiFieldToDouble) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
-  TestReconfigureDataFieldAttribute_GeneralizeRepresentation(
+  TestReconfigureDataFieldAttribute_GeneralizeField(
       {kMutable, Representation::Smi(), any_type},
       {kMutable, Representation::Double(), any_type},
       {kMutable, Representation::Double(), any_type});
 }
 
-
-TEST(ReconfigureDataFieldAttribute_GeneralizeRepresentationSmiToTagged) {
+TEST(ReconfigureDataFieldAttribute_GeneralizeSmiFieldToTagged) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<FieldType> value_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
-  TestReconfigureDataFieldAttribute_GeneralizeRepresentation(
+  TestReconfigureDataFieldAttribute_GeneralizeField(
       {kMutable, Representation::Smi(), any_type},
       {kMutable, Representation::HeapObject(), value_type},
       {kMutable, Representation::Tagged(), any_type});
 }
 
-
-TEST(ReconfigureDataFieldAttribute_GeneralizeRepresentationDoubleToTagged) {
+TEST(ReconfigureDataFieldAttribute_GeneralizeDoubleFieldToTagged) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<FieldType> value_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
-  TestReconfigureDataFieldAttribute_GeneralizeRepresentation(
+  TestReconfigureDataFieldAttribute_GeneralizeField(
       {kMutable, Representation::Double(), any_type},
       {kMutable, Representation::HeapObject(), value_type},
       {kMutable, Representation::Tagged(), any_type});
 }
 
-
-TEST(ReconfigureDataFieldAttribute_GeneralizeRepresentationHeapObjToHeapObj) {
+TEST(ReconfigureDataFieldAttribute_GeneralizeHeapObjFieldToHeapObj) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
   Handle<FieldType> current_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
   Handle<FieldType> new_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
   Handle<FieldType> expected_type = any_type;
 
-  TestReconfigureDataFieldAttribute_GeneralizeRepresentationTrivial(
+  TestReconfigureDataFieldAttribute_GeneralizeFieldTrivial(
       {kMutable, Representation::HeapObject(), current_type},
       {kMutable, Representation::HeapObject(), new_type},
       {kMutable, Representation::HeapObject(), expected_type});
   current_type = expected_type;
 
   new_type = FieldType::Class(Map::Create(isolate, 0), isolate);
 
-  TestReconfigureDataFieldAttribute_GeneralizeRepresentationTrivial(
+  TestReconfigureDataFieldAttribute_GeneralizeFieldTrivial(
       {kMutable, Representation::HeapObject(), any_type},
       {kMutable, Representation::HeapObject(), new_type},
       {kMutable, Representation::HeapObject(), any_type}, false);
 }
 
-
-TEST(ReconfigureDataFieldAttribute_GeneralizeRepresentationHeapObjectToTagged) {
+TEST(ReconfigureDataFieldAttribute_GeneralizeHeapObjectFieldToTagged) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<FieldType> value_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
-  TestReconfigureDataFieldAttribute_GeneralizeRepresentation(
+  TestReconfigureDataFieldAttribute_GeneralizeField(
       {kMutable, Representation::HeapObject(), value_type},
       {kMutable, Representation::Smi(), any_type},
       {kMutable, Representation::Tagged(), any_type});
 }
 
 
 // Checks that given |map| is deprecated and that it updates to given |new_map|
 // which in turn should match expectations.
 struct CheckDeprecated {
   void Check(Handle<Map> map, Handle<Map> new_map,
@@ skipping 48 matching lines @@
 
 // Checks that given |map| is NOT deprecated, and |new_map| is a result of
 // copy-generalize-all-representations.
 struct CheckCopyGeneralizeAllFields {
   void Check(Handle<Map> map, Handle<Map> new_map, Expectations& expectations) {
     CHECK(!map->is_deprecated());
     CHECK_NE(*map, *new_map);
 
     CHECK(new_map->GetBackPointer()->IsUndefined(map->GetIsolate()));
     for (int i = 0; i < kPropCount; i++) {
-      expectations.GeneralizeRepresentation(i);
+      expectations.GeneralizeField(i);
     }
 
     CHECK(!new_map->is_deprecated());
     CHECK(expectations.Check(*new_map));
   }
 };
 
-
-// This test ensures that representation/field type generalization is correctly
-// propagated from one branch of transition tree (|map2|) to another (|map1|).
+// This test ensures that field generalization is correctly propagated from one
+// branch of transition tree (|map2|) to another (|map1|).
 //
 //             + - p2B - p3 - p4: |map2|
 //             |
 //  {} - p0 - p1: |map|
 //             |
 //             + - p2A - p3 - p4: |map1|
 //                        |
 //                        + - the property customized by the TestConfig provided
 //
 // where "p2A" and "p2B" differ only in the attributes.
@@ skipping 286 matching lines @@
   // These are completely separate branches in transition tree.
   CheckUnrelated checker;
   TestReconfigureProperty_CustomPropertyAfterTargetMap(config, checker);
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // A set of tests for elements kind reconfiguration case.
 //
 
-// This test ensures that representation/field type generalization is correctly
-// propagated from one branch of transition tree (|map2) to another (|map|).
+// This test ensures that field generalization is correctly propagated from one
+// branch of transition tree (|map2) to another (|map|).
 //
 //   + - p0 - p1 - p2A - p3 - p4: |map|
 //   |
 //  ek
 //   |
 //  {} - p0 - p1 - p2B - p3 - p4: |map2|
 //
 // where "p2A" and "p2B" differ only in the representation/field type.
 //
-static void TestReconfigureElementsKind_GeneralizeRepresentation(
+static void TestReconfigureElementsKind_GeneralizeField(
     const CRFTData& from, const CRFTData& to, const CRFTData& expected) {
   Isolate* isolate = CcTest::i_isolate();
 
   Expectations expectations(isolate, FAST_SMI_ELEMENTS);
 
   // Create a map, add required properties to it and initialize expectations.
   Handle<Map> initial_map = Map::Create(isolate, 0);
   initial_map->set_elements_kind(FAST_SMI_ELEMENTS);
 
   Handle<Map> map = initial_map;
@@ skipping 60 matching lines @@
   // Ensure Map::FindElementsKindTransitionedMap() is able to find the
   // transitioned map.
   {
     MapHandleList map_list;
     map_list.Add(updated_map);
     Map* transitioned_map = map2->FindElementsKindTransitionedMap(&map_list);
     CHECK_EQ(*updated_map, transitioned_map);
   }
 }
 
-// This test ensures that trivial representation/field type generalization
-// (from HeapObject to HeapObject) is correctly propagated from one branch of
-// transition tree (|map2|) to another (|map|).
+// This test ensures that trivial field generalization (from HeapObject to
+// HeapObject) is correctly propagated from one branch of transition tree
+// (|map2|) to another (|map|).
 //
 //   + - p0 - p1 - p2A - p3 - p4: |map|
 //   |
 //  ek
 //   |
 //  {} - p0 - p1 - p2B - p3 - p4: |map2|
 //
 // where "p2A" and "p2B" differ only in the representation/field type.
 //
-static void TestReconfigureElementsKind_GeneralizeRepresentationTrivial(
+static void TestReconfigureElementsKind_GeneralizeFieldTrivial(
     const CRFTData& from, const CRFTData& to, const CRFTData& expected,
     bool expected_field_type_dependency = true) {
   Isolate* isolate = CcTest::i_isolate();
 
   Expectations expectations(isolate, FAST_SMI_ELEMENTS);
 
   // Create a map, add required properties to it and initialize expectations.
   Handle<Map> initial_map = Map::Create(isolate, 0);
   initial_map->set_elements_kind(FAST_SMI_ELEMENTS);
 
@@ skipping 62 matching lines @@
   // Ensure Map::FindElementsKindTransitionedMap() is able to find the
   // transitioned map.
   {
     MapHandleList map_list;
     map_list.Add(updated_map);
     Map* transitioned_map = map2->FindElementsKindTransitionedMap(&map_list);
     CHECK_EQ(*updated_map, transitioned_map);
   }
 }
 
-TEST(ReconfigureElementsKind_GeneralizeRepresentationSmiToDouble) {
+TEST(ReconfigureElementsKind_GeneralizeSmiFieldToDouble) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
-  TestReconfigureElementsKind_GeneralizeRepresentation(
+  TestReconfigureElementsKind_GeneralizeField(
       {kMutable, Representation::Smi(), any_type},
       {kMutable, Representation::Double(), any_type},
       {kMutable, Representation::Double(), any_type});
 }
 
-TEST(ReconfigureElementsKind_GeneralizeRepresentationSmiToTagged) {
+TEST(ReconfigureElementsKind_GeneralizeSmiFieldToTagged) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<FieldType> value_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
-  TestReconfigureElementsKind_GeneralizeRepresentation(
+  TestReconfigureElementsKind_GeneralizeField(
       {kMutable, Representation::Smi(), any_type},
       {kMutable, Representation::HeapObject(), value_type},
       {kMutable, Representation::Tagged(), any_type});
 }
 
-TEST(ReconfigureElementsKind_GeneralizeRepresentationDoubleToTagged) {
+TEST(ReconfigureElementsKind_GeneralizeDoubleFieldToTagged) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<FieldType> value_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
-  TestReconfigureElementsKind_GeneralizeRepresentation(
+  TestReconfigureElementsKind_GeneralizeField(
       {kMutable, Representation::Double(), any_type},
       {kMutable, Representation::HeapObject(), value_type},
       {kMutable, Representation::Tagged(), any_type});
 }
 
-TEST(ReconfigureElementsKind_GeneralizeRepresentationHeapObjToHeapObj) {
+TEST(ReconfigureElementsKind_GeneralizeHeapObjFieldToHeapObj) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
   Handle<FieldType> current_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
   Handle<FieldType> new_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
   Handle<FieldType> expected_type = any_type;
 
-  TestReconfigureElementsKind_GeneralizeRepresentationTrivial(
+  TestReconfigureElementsKind_GeneralizeFieldTrivial(
       {kMutable, Representation::HeapObject(), current_type},
       {kMutable, Representation::HeapObject(), new_type},
       {kMutable, Representation::HeapObject(), expected_type});
   current_type = expected_type;
 
   new_type = FieldType::Class(Map::Create(isolate, 0), isolate);
 
-  TestReconfigureElementsKind_GeneralizeRepresentationTrivial(
+  TestReconfigureElementsKind_GeneralizeFieldTrivial(
       {kMutable, Representation::HeapObject(), any_type},
       {kMutable, Representation::HeapObject(), new_type},
       {kMutable, Representation::HeapObject(), any_type}, false);
 }
 
-TEST(ReconfigureElementsKind_GeneralizeRepresentationHeapObjectToTagged) {
+TEST(ReconfigureElementsKind_GeneralizeHeapObjectFieldToTagged) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<FieldType> value_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
-  TestReconfigureElementsKind_GeneralizeRepresentation(
+  TestReconfigureElementsKind_GeneralizeField(
       {kMutable, Representation::HeapObject(), value_type},
       {kMutable, Representation::Smi(), any_type},
       {kMutable, Representation::Tagged(), any_type});
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // A set of tests checking split map deprecation.
 //
 
 TEST(ReconfigurePropertySplitMapTransitionsOverflow) {
@@ skipping 67 matching lines @@
   }
   CHECK(expectations.Check(*updated_map));
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // A set of tests involving special transitions (such as elements kind
 // transition, observed transition or prototype transition).
 //
 
-// This test ensures that representation/field type generalization is correctly
-// propagated from one branch of transition tree (|map2|) to another (|map|).
+// This test ensures that field generalization is correctly propagated from one
+// branch of transition tree (|map2|) to another (|map|).
 //
 //                            p4B: |map2|
 //                             |
 //                             * - special transition
 //                             |
 //  {} - p0 - p1 - p2A - p3 - p4A: |map|
 //
 // where "p4A" and "p4B" are exactly the same properties.
 //
 // TODO(ishell): unify this test template with
-// TestReconfigureDataFieldAttribute_GeneralizeRepresentation once
+// TestReconfigureDataFieldAttribute_GeneralizeField once
 // IS_PROTO_TRANS_ISSUE_FIXED and IS_NON_EQUIVALENT_TRANSITION_SUPPORTED are
 // fixed.
 template <typename TestConfig>
-static void TestGeneralizeRepresentationWithSpecialTransition(
-    TestConfig& config, const CRFTData& from, const CRFTData& to,
-    const CRFTData& expected) {
+static void TestGeneralizeFieldWithSpecialTransition(TestConfig& config,
+                                                     const CRFTData& from,
+                                                     const CRFTData& to,
+                                                     const CRFTData& expected) {
   Isolate* isolate = CcTest::i_isolate();
 
   Expectations expectations(isolate);
 
   // Create a map, add required properties to it and initialize expectations.
   Handle<Map> initial_map = Map::Create(isolate, 0);
   Handle<Map> map = initial_map;
   for (int i = 0; i < kPropCount; i++) {
     map = expectations.AddDataField(map, NONE, from.constness,
                                     from.representation, from.type);
   }
   CHECK(!map->is_deprecated());
   CHECK(map->is_stable());
   CHECK(expectations.Check(*map));
 
   Expectations expectations2 = expectations;
 
   // Apply some special transition to |map|.
   CHECK(map->owns_descriptors());
   Handle<Map> map2 = config.Transition(map, expectations2);
 
   // |map| should still match expectations.
   CHECK(!map->is_deprecated());
   CHECK(expectations.Check(*map));
 
   if (config.generalizes_representations()) {
     for (int i = 0; i < kPropCount; i++) {
-      expectations2.GeneralizeRepresentation(i);
+      expectations2.GeneralizeField(i);
     }
   }
 
   CHECK(!map2->is_deprecated());
   CHECK(map2->is_stable());
   CHECK(expectations2.Check(*map2));
 
   // Create new maps by generalizing representation of propX field.
   Handle<Map> maps[kPropCount];
   for (int i = 0; i < kPropCount; i++) {
@@ skipping 17 matching lines @@
     if (Map::TryUpdate(map2).ToHandle(&tmp_map)) {
       // If Map::TryUpdate() manages to succeed the result must match the result
       // of Map::Update().
       CHECK_EQ(*new_map2, *tmp_map);
     }
 
     if (config.is_non_equevalent_transition()) {
       // In case of non-equivalent transition currently we generalize all
       // representations.
       for (int i = 0; i < kPropCount; i++) {
-        expectations2.GeneralizeRepresentation(i);
+        expectations2.GeneralizeField(i);
       }
       CHECK(new_map2->GetBackPointer()->IsUndefined(isolate));
       CHECK(expectations2.Check(*new_map2));
     } else {
       CHECK(!new_map2->GetBackPointer()->IsUndefined(isolate));
       CHECK(expectations2.Check(*new_map2));
     }
   }
 
   Handle<Map> active_map = maps[kPropCount - 1];
@@ skipping 22 matching lines @@
       Handle<Symbol> frozen_symbol(map->GetHeap()->frozen_symbol());
       expectations.SetElementsKind(DICTIONARY_ELEMENTS);
       return Map::CopyForPreventExtensions(map, NONE, frozen_symbol,
                                            "CopyForPreventExtensions");
     }
     // TODO(ishell): remove once IS_PROTO_TRANS_ISSUE_FIXED is removed.
     bool generalizes_representations() const { return false; }
     bool is_non_equevalent_transition() const { return true; }
   };
   TestConfig config;
-  TestGeneralizeRepresentationWithSpecialTransition(
+  TestGeneralizeFieldWithSpecialTransition(
       config, {kMutable, Representation::Smi(), any_type},
       {kMutable, Representation::HeapObject(), value_type},
       {kMutable, Representation::Tagged(), any_type});
 }
 
 
 TEST(ElementsKindTransitionFromMapNotOwningDescriptor) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
@@ skipping 17 matching lines @@
       Handle<Symbol> frozen_symbol(map->GetHeap()->frozen_symbol());
       expectations.SetElementsKind(DICTIONARY_ELEMENTS);
       return Map::CopyForPreventExtensions(map, NONE, frozen_symbol,
                                            "CopyForPreventExtensions");
     }
     // TODO(ishell): remove once IS_PROTO_TRANS_ISSUE_FIXED is removed.
     bool generalizes_representations() const { return false; }
     bool is_non_equevalent_transition() const { return true; }
   };
   TestConfig config;
-  TestGeneralizeRepresentationWithSpecialTransition(
+  TestGeneralizeFieldWithSpecialTransition(
       config, {kMutable, Representation::Smi(), any_type},
       {kMutable, Representation::HeapObject(), value_type},
       {kMutable, Representation::Tagged(), any_type});
 }
 
 
 TEST(PrototypeTransitionFromMapOwningDescriptor) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
@@ skipping 14 matching lines @@
     Handle<Map> Transition(Handle<Map> map, Expectations& expectations) {
       return Map::TransitionToPrototype(map, prototype_, REGULAR_PROTOTYPE);
     }
     // TODO(ishell): remove once IS_PROTO_TRANS_ISSUE_FIXED is removed.
     bool generalizes_representations() const {
       return !IS_PROTO_TRANS_ISSUE_FIXED;
     }
     bool is_non_equevalent_transition() const { return true; }
   };
   TestConfig config;
-  TestGeneralizeRepresentationWithSpecialTransition(
+  TestGeneralizeFieldWithSpecialTransition(
       config, {kMutable, Representation::Smi(), any_type},
       {kMutable, Representation::HeapObject(), value_type},
       {kMutable, Representation::Tagged(), any_type});
 }
 
 
 TEST(PrototypeTransitionFromMapNotOwningDescriptor) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
@@ skipping 25 matching lines @@
 
       return Map::TransitionToPrototype(map, prototype_, REGULAR_PROTOTYPE);
     }
     // TODO(ishell): remove once IS_PROTO_TRANS_ISSUE_FIXED is removed.
     bool generalizes_representations() const {
       return !IS_PROTO_TRANS_ISSUE_FIXED;
     }
     bool is_non_equevalent_transition() const { return true; }
   };
   TestConfig config;
-  TestGeneralizeRepresentationWithSpecialTransition(
+  TestGeneralizeFieldWithSpecialTransition(
       config, {kMutable, Representation::Smi(), any_type},
       {kMutable, Representation::HeapObject(), value_type},
       {kMutable, Representation::Tagged(), any_type});
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // A set of tests for higher level transitioning mechanics.
 //
 
@@ skipping 82 matching lines @@
                                         PropertyAttributes attributes = NONE)
       : descriptor_(descriptor), attributes_(attributes) {}
 
   Handle<Map> DoTransition(Expectations& expectations, Handle<Map> map) {
     expectations.SetAccessorField(descriptor_);
     return Map::ReconfigureExistingProperty(map, descriptor_, kAccessor,
                                             attributes_);
   }
 };
 
-
-// Checks that representation/field type generalization happened.
+// Checks that field generalization happened.
 struct FieldGeneralizationChecker {
   int descriptor_;
   PropertyConstness constness_;
   Representation representation_;
   PropertyAttributes attributes_;
   Handle<FieldType> heap_type_;
 
   FieldGeneralizationChecker(int descriptor, PropertyConstness constness,
                              Representation representation,
                              Handle<FieldType> heap_type,
@@ skipping 183 matching lines @@
   Isolate* isolate = CcTest::i_isolate();
 
   Zone zone(isolate->allocator(), ZONE_NAME);
 
   CHECK_EQ(FieldType::Any()->Convert(&zone), AstType::NonInternal());
   CHECK_EQ(FieldType::None()->Convert(&zone), AstType::None());
 }
 
 // TODO(ishell): add this test once IS_ACCESSOR_FIELD_SUPPORTED is supported.
 // TEST(TransitionAccessorConstantToAnotherAccessorConstant)