Simplify and compact transitions storage

test/cctest/test-migrations.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 "src/v8.h"
 
 #include "src/code-stubs.h"
@@ skipping 324 matching lines @@
 
   Handle<Map> FollowDataTransition(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);
-    int t = map->SearchTransition(kData, *name, attributes);
-    CHECK_NE(TransitionArray::kNotFound, t);
-    return handle(map->GetTransition(t));
+    Map* target =
+        TransitionArray::SearchTransition(*map, kData, *name, attributes);
+    CHECK(target != NULL);
+    return handle(target);
   }
 
   Handle<Map> AddAccessorConstant(Handle<Map> map,
                                   PropertyAttributes attributes,
                                   Handle<AccessorPair> pair) {
     CHECK_EQ(number_of_properties_, map->NumberOfOwnDescriptors());
     int property_index = number_of_properties_++;
     SetAccessorConstant(property_index, attributes, pair);
 
     Handle<String> name = MakeName("prop", property_index);
@@ skipping 1112 matching lines @@
   const int kSplitProp = kPropCount / 2;
   Handle<Map> split_map;
   Handle<Map> map2 = initial_map;
   {
     for (int i = 0; i < kSplitProp + 1; i++) {
       if (i == kSplitProp) {
         split_map = map2;
       }
 
       Handle<String> name = MakeName("prop", i);
-      int t = map2->SearchTransition(kData, *name, NONE);
-      CHECK_NE(TransitionArray::kNotFound, t);
-      map2 = handle(map2->GetTransition(t));
+      Map* target =
+          TransitionArray::SearchTransition(*map2, kData, *name, NONE);
+      CHECK(target != NULL);
+      map2 = handle(target);
     }
 
     map2 = Map::ReconfigureProperty(map2, kSplitProp, kData, NONE,
                                     Representation::Double(), any_type,
                                     FORCE_FIELD);
     expectations.SetDataField(kSplitProp, Representation::Double(), any_type);
 
     CHECK(expectations.Check(*split_map, kSplitProp));
     CHECK(expectations.Check(*map2, kSplitProp + 1));
   }
 
   // At this point |map| should be deprecated and disconnected from the
   // transition tree.
   CHECK(map->is_deprecated());
   CHECK(!split_map->is_deprecated());
   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(map2->CanHaveMoreTransitions());
+    CHECK(TransitionArray::CanHaveMoreTransitions(map2));
     Handle<String> name = MakeName("foo", i);
     Map::CopyWithField(map2, name, any_type, NONE, Representation::Smi(),
                        INSERT_TRANSITION).ToHandleChecked();
   }
-  CHECK(!map2->CanHaveMoreTransitions());
+  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);
   }
   CHECK(expectations.Check(*updated_map));
@@ skipping 559 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)