Merged r19440 into 3.23 branch.

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 166 matching lines @@
 };
 
 
 class LookupResult BASE_EMBEDDED {
  public:
   explicit LookupResult(Isolate* isolate)
       : isolate_(isolate),
         next_(isolate->top_lookup_result()),
         lookup_type_(NOT_FOUND),
         holder_(NULL),
+        transition_(NULL),
         cacheable_(true),
         details_(NONE, NONEXISTENT, Representation::None()) {
     isolate->SetTopLookupResult(this);
   }
 
   ~LookupResult() {
     ASSERT(isolate()->top_lookup_result() == this);
     isolate()->SetTopLookupResult(next_);
   }
 
   Isolate* isolate() const { return isolate_; }
 
   void DescriptorResult(JSObject* holder, PropertyDetails details, int number) {
     lookup_type_ = DESCRIPTOR_TYPE;
     holder_ = holder;
     details_ = details;
     number_ = number;
+    transition_ = NULL;
   }
 
   bool CanHoldValue(Handle<Object> value) {
     if (IsNormal()) return true;
     ASSERT(!IsTransition());
     return value->FitsRepresentation(details_.representation());
   }
 
-  void TransitionResult(JSObject* holder, int number) {
+  void TransitionResult(JSObject* holder, Map* target) {
     lookup_type_ = TRANSITION_TYPE;
     details_ = PropertyDetails(NONE, TRANSITION, Representation::None());
     holder_ = holder;
-    number_ = number;
+    transition_ = target;
+    number_ = 0xAAAA;
   }
 
   void DictionaryResult(JSObject* holder, int entry) {
     lookup_type_ = DICTIONARY_TYPE;
     holder_ = holder;
+    transition_ = NULL;
     details_ = holder->property_dictionary()->DetailsAt(entry);
     number_ = entry;
   }
 
   void HandlerResult(JSProxy* proxy) {
     lookup_type_ = HANDLER_TYPE;
     holder_ = proxy;
+    transition_ = NULL;
     details_ = PropertyDetails(NONE, HANDLER, Representation::Tagged());
     cacheable_ = false;
   }
 
   void InterceptorResult(JSObject* holder) {
     lookup_type_ = INTERCEPTOR_TYPE;
     holder_ = holder;
+    transition_ = NULL;
     details_ = PropertyDetails(NONE, INTERCEPTOR, Representation::Tagged());
   }
 
   void NotFound() {
     lookup_type_ = NOT_FOUND;
     details_ = PropertyDetails(NONE, NONEXISTENT, Representation::None());
     holder_ = NULL;
   }
 
   JSObject* holder() {
     ASSERT(IsFound());
     return JSObject::cast(holder_);
   }
 
   JSProxy* proxy() {
-    ASSERT(IsFound());
+    ASSERT(IsHandler());
     return JSProxy::cast(holder_);
   }
 
   PropertyType type() {
     ASSERT(IsFound());
     return details_.type();
   }
 
   Representation representation() {
     ASSERT(IsFound());
@@ skipping 104 matching lines @@
       case HANDLER:
       case INTERCEPTOR:
       case TRANSITION:
       case NONEXISTENT:
         return isolate()->heap()->the_hole_value();
     }
     UNREACHABLE();
     return NULL;
   }
 
-  Map* GetTransitionTarget(Map* map) {
-    ASSERT(IsTransition());
-    TransitionArray* transitions = map->transitions();
-    return transitions->GetTarget(number_);
-  }
-
   Map* GetTransitionTarget() {
-    return GetTransitionTarget(holder()->map());
-  }
-
-  PropertyDetails GetTransitionDetails(Map* map) {
-    ASSERT(IsTransition());
-    TransitionArray* transitions = map->transitions();
-    return transitions->GetTargetDetails(number_);
+    return transition_;
   }
 
   PropertyDetails GetTransitionDetails() {
-    return GetTransitionDetails(holder()->map());
+    return transition_->GetLastDescriptorDetails();
   }
 
-  bool IsTransitionToField(Map* map) {
-    return IsTransition() && GetTransitionDetails(map).type() == FIELD;
+  bool IsTransitionToField() {
+    return IsTransition() && GetTransitionDetails().type() == FIELD;
   }
 
-  bool IsTransitionToConstant(Map* map) {
-    return IsTransition() && GetTransitionDetails(map).type() == CONSTANT;
-  }
-
-  Map* GetTransitionMap() {
-    ASSERT(IsTransition());
-    return Map::cast(GetValue());
-  }
-
-  Map* GetTransitionMapFromMap(Map* map) {
-    ASSERT(IsTransition());
-    return map->transitions()->GetTarget(number_);
+  bool IsTransitionToConstant() {
+    return IsTransition() && GetTransitionDetails().type() == CONSTANT;
   }
 
   int GetTransitionIndex() {
     ASSERT(IsTransition());
     return number_;
   }
 
   int GetDescriptorIndex() {
     ASSERT(lookup_type_ == DESCRIPTOR_TYPE);
     return number_;
@@ skipping 72 matching lines @@
   enum {
     NOT_FOUND,
     DESCRIPTOR_TYPE,
     TRANSITION_TYPE,
     DICTIONARY_TYPE,
     HANDLER_TYPE,
     INTERCEPTOR_TYPE
   } lookup_type_;
 
   JSReceiver* holder_;
+  Map* transition_;
   int number_;
   bool cacheable_;
   PropertyDetails details_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_PROPERTY_H_