[cctest] adding tests for elements kind map migrations

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/execution.h"
 #include "src/factory.h"
 #include "src/global-handles.h"
 #include "src/ic/stub-cache.h"
 #include "src/macro-assembler.h"
-#include "test/cctest/cctest.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).
 const bool IS_PROTO_TRANS_ISSUE_FIXED = false;
 
 
@@ skipping 252 matching lines @@
 
   Handle<Map> AddDataField(Handle<Map> map, PropertyAttributes attributes,
                            Representation representation,
                            Handle<HeapType> heap_type) {
     CHECK_EQ(number_of_properties_, map->NumberOfOwnDescriptors());
     int property_index = number_of_properties_++;
     SetDataField(property_index, attributes, representation, heap_type);
 
     Handle<String> name = MakeName("prop", property_index);
     return Map::CopyWithField(map, name, heap_type, attributes, representation,
-                              INSERT_TRANSITION).ToHandleChecked();
+                              INSERT_TRANSITION)
+        .ToHandleChecked();
   }
 
   Handle<Map> AddDataConstant(Handle<Map> map, PropertyAttributes attributes,
                               Handle<JSFunction> value) {
     CHECK_EQ(number_of_properties_, map->NumberOfOwnDescriptors());
     int property_index = number_of_properties_++;
     SetDataConstant(property_index, attributes, value);
 
     Handle<String> name = MakeName("prop", property_index);
     return Map::CopyWithConstant(map, name, value, attributes,
-                                 INSERT_TRANSITION).ToHandleChecked();
+                                 INSERT_TRANSITION)
+        .ToHandleChecked();
   }
 
   Handle<Map> TransitionToDataField(Handle<Map> map,
                                     PropertyAttributes attributes,
                                     Representation representation,
                                     Handle<HeapType> heap_type,
                                     Handle<Object> value) {
     CHECK_EQ(number_of_properties_, map->NumberOfOwnDescriptors());
     int property_index = number_of_properties_++;
     SetDataField(property_index, attributes, representation, heap_type);
@@ skipping 1265 matching lines @@
   CHECK(map->is_deprecated());
   CHECK(!split_map->is_deprecated());
   CHECK(map2->is_stable());
   CHECK(!map2->is_deprecated());
 
   // Fill in transition tree of |map2| so that it can't have more transitions.
   for (int i = 0; i < TransitionArray::kMaxNumberOfTransitions; i++) {
     CHECK(TransitionArray::CanHaveMoreTransitions(map2));
     Handle<String> name = MakeName("foo", i);
     Map::CopyWithField(map2, name, any_type, NONE, Representation::Smi(),
-                       INSERT_TRANSITION).ToHandleChecked();
+                       INSERT_TRANSITION)
+        .ToHandleChecked();
   }
   CHECK(!TransitionArray::CanHaveMoreTransitions(map2));
 
   // Try to update |map|, since there is no place for propX transition at |map2|
   // |map| should become "copy-generalized".
   Handle<Map> updated_map = Map::Update(map);
   CHECK(updated_map->GetBackPointer()->IsUndefined());
 
   for (int i = 0; i < kPropCount; i++) {
     expectations.SetDataField(i, Representation::Tagged(), any_type);
@@ skipping 147 matching lines @@
 
   struct TestConfig {
     Handle<Map> Transition(Handle<Map> map) {
       Isolate* isolate = CcTest::i_isolate();
       Handle<HeapType> any_type = HeapType::Any(isolate);
 
       // Add one more transition to |map| in order to prevent descriptors
       // ownership.
       CHECK(map->owns_descriptors());
       Map::CopyWithField(map, MakeString("foo"), any_type, NONE,
-                         Representation::Smi(),
-                         INSERT_TRANSITION).ToHandleChecked();
+                         Representation::Smi(), INSERT_TRANSITION)
+          .ToHandleChecked();
       CHECK(!map->owns_descriptors());
 
       return Map::CopyAsElementsKind(map, DICTIONARY_ELEMENTS,
                                      INSERT_TRANSITION);
     }
     // TODO(ishell): remove once IS_PROTO_TRANS_ISSUE_FIXED is removed.
     bool generalizes_representations() const { return false; }
     bool is_non_equevalent_transition() const { return false; }
   };
   TestConfig config;
@@ skipping 36 matching lines @@
 
   struct TestConfig {
     Handle<Map> Transition(Handle<Map> map) {
       Isolate* isolate = CcTest::i_isolate();
       Handle<HeapType> any_type = HeapType::Any(isolate);
 
       // Add one more transition to |map| in order to prevent descriptors
       // ownership.
       CHECK(map->owns_descriptors());
       Map::CopyWithField(map, MakeString("foo"), any_type, NONE,
-                         Representation::Smi(),
-                         INSERT_TRANSITION).ToHandleChecked();
+                         Representation::Smi(), INSERT_TRANSITION)
+          .ToHandleChecked();
       CHECK(!map->owns_descriptors());
 
       return Map::CopyForObserved(map);
     }
     // 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(
@@ skipping 55 matching lines @@
     }
 
     Handle<Map> Transition(Handle<Map> map) {
       Isolate* isolate = CcTest::i_isolate();
       Handle<HeapType> any_type = HeapType::Any(isolate);
 
       // Add one more transition to |map| in order to prevent descriptors
       // ownership.
       CHECK(map->owns_descriptors());
       Map::CopyWithField(map, MakeString("foo"), any_type, NONE,
-                         Representation::Smi(),
-                         INSERT_TRANSITION).ToHandleChecked();
+                         Representation::Smi(), INSERT_TRANSITION)
+          .ToHandleChecked();
       CHECK(!map->owns_descriptors());
 
       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; }
   };
@@ skipping 272 matching lines @@
   Handle<AccessorPair> pair = CreateAccessorPair(true, true);
   TransitionToAccessorConstantOperator transition_op(pair);
 
   SameMapChecker checker;
   TestTransitionTo(transition_op, transition_op, checker);
 }
 
 
 // TODO(ishell): add this test once IS_ACCESSOR_FIELD_SUPPORTED is supported.
 // TEST(TransitionAccessorConstantToAnotherAccessorConstant)