Using PropertyKind in transitions instead of PropertyType.

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 87 matching lines @@
   DCHECK_EQ(is_special_transition, IsSpecialTransition(*name));
   PropertyDetails details = is_special_transition
                                 ? PropertyDetails(NONE, FIELD, 0)
                                 : GetTargetDetails(*name, *target);
 
   int insertion_index = kNotFound;
   int index =
       is_special_transition
           ? map->transitions()->SearchSpecial(Symbol::cast(*name),
                                               &insertion_index)
-          : map->transitions()->Search(details.type(), *name,
+          : map->transitions()->Search(details.kind(), *name,
                                        details.attributes(), &insertion_index);
   if (index == kNotFound) {
     ++new_nof;
   } else {
     insertion_index = index;
   }
   DCHECK(insertion_index >= 0 && insertion_index <= number_of_transitions);
 
   CHECK(new_nof <= kMaxNumberOfTransitions);
 
@@ skipping 31 matching lines @@
   if (array->number_of_transitions() != number_of_transitions) {
     DCHECK(array->number_of_transitions() < number_of_transitions);
 
     number_of_transitions = array->number_of_transitions();
     new_nof = number_of_transitions;
 
     insertion_index = kNotFound;
     index = is_special_transition ? map->transitions()->SearchSpecial(
                                         Symbol::cast(*name), &insertion_index)
                                   : map->transitions()->Search(
-                                        details.type(), *name,
+                                        details.kind(), *name,
                                         details.attributes(), &insertion_index);
     if (index == kNotFound) {
       ++new_nof;
     } else {
       insertion_index = index;
     }
     DCHECK(insertion_index >= 0 && insertion_index <= number_of_transitions);
 
     result->Shrink(ToKeyIndex(new_nof));
     result->SetNumberOfTransitions(new_nof);
@@ skipping 11 matching lines @@
   for (int i = insertion_index; i < number_of_transitions; ++i) {
     result->NoIncrementalWriteBarrierCopyFrom(array, i, i + 1);
   }
 
   result->set_back_pointer_storage(array->back_pointer_storage());
   SLOW_DCHECK(result->IsSortedNoDuplicates());
   return result;
 }
 
 
-int TransitionArray::SearchDetails(int transition, PropertyType type,
+int TransitionArray::SearchDetails(int transition, PropertyKind kind,
                                    PropertyAttributes attributes,
                                    int* out_insertion_index) {
   int nof_transitions = number_of_transitions();
   DCHECK(transition < nof_transitions);
   Name* key = GetKey(transition);
-  bool is_data = type == FIELD || type == CONSTANT;
   for (; transition < nof_transitions && GetKey(transition) == key;
        transition++) {
     Map* target = GetTarget(transition);
     PropertyDetails target_details = GetTargetDetails(key, target);
 
-    bool target_is_data =
-        target_details.type() == FIELD || target_details.type() == CONSTANT;
-
-    int cmp = CompareDetails(is_data, attributes, target_is_data,
+    int cmp = CompareDetails(kind, attributes, target_details.kind(),
                              target_details.attributes());
     if (cmp == 0) {
       return transition;
     } else if (cmp < 0) {
       break;
     }
   }
   if (out_insertion_index != NULL) *out_insertion_index = transition;
   return kNotFound;
 }
 
 
-int TransitionArray::Search(PropertyType type, Name* name,
+int TransitionArray::Search(PropertyKind kind, Name* name,
                             PropertyAttributes attributes,
                             int* out_insertion_index) {
   int transition = SearchName(name, out_insertion_index);
   if (transition == kNotFound) {
     return kNotFound;
   }
-  return SearchDetails(transition, type, attributes, out_insertion_index);
+  return SearchDetails(transition, kind, attributes, out_insertion_index);
 }
 } }  // namespace v8::internal