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

src/transitions.h

 // 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.
 
 #ifndef V8_TRANSITIONS_H_
 #define V8_TRANSITIONS_H_
 
 #include "src/checks.h"
 #include "src/elements-kind.h"
 #include "src/heap/heap.h"
@@ skipping 69 matching lines @@
 
   // Create a transition array, copying from the owning map if it already has
   // one, otherwise creating a new one according to flag.
   // TODO(verwaest): This should not cause an existing transition to be
   // overwritten.
   static Handle<TransitionArray> CopyInsert(Handle<Map> map,
                                             Handle<Name> name,
                                             Handle<Map> target,
                                             SimpleTransitionFlag flag);
 
-  // Search a transition for a given property name.
-  inline int Search(Name* name);
+  // Search a  transition for a given type, property name and attributes.
+  int Search(PropertyType type, Name* name, PropertyAttributes attributes);
+
+  // Search a non-property transition (like elements kind, observe or frozen
+  // transitions).
+  inline int SearchSpecial(Symbol* symbol) { return SearchFirst(symbol); }
+
+  // Returns true for a non-property transitions like elements kind, observed
+  // or frozen transitions.
+  inline static bool IsSpecialTransition(Name* name);
+
+  inline static PropertyDetails GetTargetDetails(Name* name, Map* target);
 
   // Allocates a TransitionArray.
   static Handle<TransitionArray> Allocate(
       Isolate* isolate, int number_of_transitions);
 
   bool IsSimpleTransition() {
     return length() == kSimpleTransitionSize &&
         get(kSimpleTransitionTarget)->IsHeapObject() &&
         // The IntrusivePrototypeTransitionIterator may have set the map of the
         // prototype transitions array to a smi. In that case, there are
@@ skipping 68 matching lines @@
 
   static Handle<TransitionArray> AllocateSimple(
       Isolate* isolate, Handle<Map> target);
 
   // Allocate a new transition array with a single entry.
   static Handle<TransitionArray> NewWith(Handle<Map> map,
                                          Handle<Name> name,
                                          Handle<Map> target,
                                          SimpleTransitionFlag flag);
 
+  // Search a first transition for a given property name.
+  inline int SearchFirst(Name* name);
+  int SearchNext(int transition, PropertyType type, Name* name,
+                 PropertyAttributes attributes);
+
   inline void NoIncrementalWriteBarrierSet(int transition_number,
                                            Name* key,
                                            Map* target);
 
   // Copy a single transition from the origin array.
   inline void NoIncrementalWriteBarrierCopyFrom(TransitionArray* origin,
                                                 int origin_transition,
                                                 int target_transition);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(TransitionArray);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TRANSITIONS_H_