Removed transitions from the accessor pair descriptors.

src/property.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 218 matching lines @@
     ASSERT(IsFound());
     return IsTransition() || type() != NORMAL;
   }
 
   // Property callbacks does not include transitions to callbacks.
   bool IsPropertyCallbacks() {
     ASSERT(!(details_.type() == CALLBACKS && !IsFound()));
     return details_.type() == CALLBACKS;
   }
 
-  // Is callbacks contains both property callbacks and transitions to callbacks.
-  bool IsCallbacks() {
-    return IsPropertyCallbacks() ||
-           (IsTransition() && GetTransitionValue()->IsAccessorPair());
-  }
-
   bool IsReadOnly() {
     ASSERT(IsFound());
     ASSERT(!IsTransition());
     ASSERT(details_.type() != NONEXISTENT);
     return details_.IsReadOnly();
   }
 
   bool IsField() {
     ASSERT(!(details_.type() == FIELD && !IsFound()));
     return details_.type() == FIELD;
@@ skipping 37 matching lines @@
         }
         return value;
       }
       case CONSTANT_FUNCTION:
         return GetConstantFunction();
       default:
         return Smi::FromInt(0);
     }
   }
 
-  Object* GetTransitionValue() {
+  Map* GetTransitionTarget() {
     ASSERT(IsTransition());
     TransitionArray* transitions = holder()->map()->transitions();
-    Object* value = transitions->GetValue(number_);
-    return value;
+    return transitions->GetTarget(number_);
   }
 
   PropertyDetails GetTransitionDetails(Map* map) {
     ASSERT(IsTransition());
     TransitionArray* transitions = map->transitions();
     return transitions->GetTargetDetails(number_);
   }
 
   PropertyDetails GetTransitionDetails() {
     return GetTransitionDetails(holder()->map());
   }
 
   bool IsTransitionToField(Map* map) {
     return IsTransition() && GetTransitionDetails(map).type() == FIELD;
   }
 
   Map* GetTransitionMap() {
     ASSERT(IsTransition());
     return Map::cast(GetValue());
   }
 
   Map* GetTransitionMapFromMap(Map* map) {
     ASSERT(IsTransition());
-    return Map::cast(map->transitions()->GetValue(number_));
+    return map->transitions()->GetTarget(number_);
   }
 
   int GetTransitionIndex() {
     ASSERT(IsTransition());
     return number_;
   }
 
   int GetFieldIndex() {
     ASSERT(lookup_type_ == DESCRIPTOR_TYPE);
     ASSERT(IsField());
@@ skipping 15 matching lines @@
     ASSERT(type() == CONSTANT_FUNCTION);
     return JSFunction::cast(GetValue());
   }
 
   JSFunction* GetConstantFunctionFromMap(Map* map) {
     ASSERT(type() == CONSTANT_FUNCTION);
     return JSFunction::cast(GetValueFromMap(map));
   }
 
   Object* GetCallbackObject() {
-    switch (lookup_type_) {
-      case CONSTANT_TYPE:
-        return HEAP->prototype_accessors();
-      case TRANSITION_TYPE:
-        return GetTransitionValue();
-      default:
-        return GetValue();
+    ASSERT(!IsTransition());
+    if (lookup_type_ == CONSTANT_TYPE) {
+      return HEAP->prototype_accessors();
+    } else {
+      return GetValue();

[Sven Panne, 2012/07/16 13:49:43]

Can we put an ASSERT here about the lookup_type_?

     }
   }
 
 #ifdef OBJECT_PRINT
   void Print(FILE* out);
 #endif
 
   Object* GetValue() {
     if (lookup_type_ == DESCRIPTOR_TYPE) {
       return GetValueFromMap(holder()->map());
@@ skipping 28 matching lines @@
   JSReceiver* holder_;
   int number_;
   bool cacheable_;
   PropertyDetails details_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_PROPERTY_H_