TransitionArray now uses <is_data_property, name, attributes> tuple as a key, which allows to have …

src/transitions.cc

 // Copyright 2012 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 "src/v8.h"
 
 #include "src/objects.h"
 #include "src/transitions-inl.h"
 #include "src/utils.h"
 
@@ skipping 78 matching lines @@
                                                     Handle<Name> name,
                                                     Handle<Map> target,
                                                     SimpleTransitionFlag flag) {
   if (!map->HasTransitionArray()) {
     return TransitionArray::NewWith(map, name, target, flag);
   }
 
   int number_of_transitions = map->transitions()->number_of_transitions();
   int new_size = number_of_transitions;
 
-  int insertion_index = map->transitions()->Search(*name);
+  bool is_special_transition = IsSpecialTransition(*name);
+  PropertyDetails details = is_special_transition
+                                ? PropertyDetails(NONE, NORMAL, 0)
+                                : GetTargetDetails(*name, *target);
+
+  int insertion_index =
+      is_special_transition
+          ? map->transitions()->SearchSpecial(Symbol::cast(*name))
+          : map->transitions()->Search(details.type(), *name,
+                                       details.attributes());
   if (insertion_index == kNotFound) ++new_size;
 
   Handle<TransitionArray> result = Allocate(map->GetIsolate(), new_size);
 
   // The map's transition array may grown smaller during the allocation above as
   // it was weakly traversed, though it is guaranteed not to disappear. Trim the
   // result copy if needed, and recompute variables.
   DCHECK(map->HasTransitionArray());
   DisallowHeapAllocation no_gc;
   TransitionArray* array = map->transitions();
   if (array->number_of_transitions() != number_of_transitions) {
     DCHECK(array->number_of_transitions() < number_of_transitions);
 
     number_of_transitions = array->number_of_transitions();
     new_size = number_of_transitions;
 
-    insertion_index = array->Search(*name);
+    insertion_index =
+        is_special_transition
+            ? map->transitions()->SearchSpecial(Symbol::cast(*name))
+            : map->transitions()->Search(details.type(), *name,
+                                         details.attributes());
     if (insertion_index == kNotFound) ++new_size;
 
     result->Shrink(ToKeyIndex(new_size));
   }
 
   if (array->HasPrototypeTransitions()) {
     result->SetPrototypeTransitions(array->GetPrototypeTransitions());
   }
 
   if (insertion_index != kNotFound) {
     for (int i = 0; i < number_of_transitions; ++i) {
       if (i != insertion_index) {
         result->NoIncrementalWriteBarrierCopyFrom(array, i, i);
       }
     }
+
+    DCHECK_NE(map->instance_descriptors(),
+              array->GetTarget(insertion_index)->instance_descriptors());
     result->NoIncrementalWriteBarrierSet(insertion_index, *name, *target);
     result->set_back_pointer_storage(array->back_pointer_storage());
     return result;
   }
 
   insertion_index = 0;
   for (; insertion_index < number_of_transitions; ++insertion_index) {
     if (InsertionPointFound(array->GetKey(insertion_index), *name)) break;
     result->NoIncrementalWriteBarrierCopyFrom(
         array, insertion_index, insertion_index);
   }
 
   result->NoIncrementalWriteBarrierSet(insertion_index, *name, *target);
 
   for (; insertion_index < number_of_transitions; ++insertion_index) {
     result->NoIncrementalWriteBarrierCopyFrom(
         array, insertion_index, insertion_index + 1);
   }
 
   result->set_back_pointer_storage(array->back_pointer_storage());
   return result;
 }
 
 
+int TransitionArray::SearchNext(int transition, PropertyType type, Name* name,
+                                PropertyAttributes attributes) {
+  int nof_transitions = number_of_transitions();
+  bool is_data = type == FIELD || type == CONSTANT;
+  for (;;) {
+    Map* target = GetTarget(transition);
+    PropertyDetails target_details = GetTargetDetails(name, target);
+    bool target_is_data =
+        target_details.type() == FIELD || target_details.type() == CONSTANT;
+
+    if (target_is_data == is_data &&
+        target_details.attributes() == attributes) {
+      return transition;
+    }
+    transition++;
+    if ((transition >= nof_transitions) || !GetKey(transition)->Equals(name)) {
+      break;
+    }
+  }
+  return kNotFound;
+}
+
+
+int TransitionArray::Search(PropertyType type, Name* name,
+                            PropertyAttributes attributes) {
+  int transition = SearchFirst(name);
+  if (transition == kNotFound) {
+    return kNotFound;
+  }
+  return SearchNext(transition, type, name, attributes);
+}
 } }  // namespace v8::internal