Cleaning up usage of lookup results.

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 171 matching lines @@
 
 
 class LookupResult BASE_EMBEDDED {
  public:
   explicit LookupResult(Isolate* isolate)
       : isolate_(isolate),
         next_(isolate->top_lookup_result()),
         lookup_type_(NOT_FOUND),
         holder_(NULL),
         cacheable_(true),
-        details_(NONE, NORMAL) {
+        details_(NONE, NONEXISTENT) {
     isolate->SetTopLookupResult(this);
   }
 
   ~LookupResult() {
     ASSERT(isolate_->top_lookup_result() == this);
     isolate_->SetTopLookupResult(next_);
   }
 
   void DescriptorResult(JSObject* holder, PropertyDetails details, int number) {
     lookup_type_ = DESCRIPTOR_TYPE;
@@ skipping 27 matching lines @@
   }
 
   void InterceptorResult(JSObject* holder) {
     lookup_type_ = INTERCEPTOR_TYPE;
     holder_ = holder;
     details_ = PropertyDetails(NONE, INTERCEPTOR);
   }
 
   void NotFound() {
     lookup_type_ = NOT_FOUND;
+    details_ = PropertyDetails(NONE, NONEXISTENT);
     holder_ = NULL;
   }
 
   JSObject* holder() {
     ASSERT(IsFound());
     return JSObject::cast(holder_);
   }
 
   JSProxy* proxy() {
     ASSERT(IsFound());
     return JSProxy::cast(holder_);
   }
 
+
   PropertyType type() {
     ASSERT(IsFound());
     return details_.type();
   }
 
   PropertyAttributes GetAttributes() {
     ASSERT(IsFound());
     return details_.attributes();
   }
 
   PropertyDetails GetPropertyDetails() {
     return details_;
   }
 
+  bool IsFastPropertyType() { return type() != NORMAL; }

[danno, 2012/06/21 14:34:30]

Add asserts for (IsFound());

   bool IsReadOnly() { return details_.IsReadOnly(); }
+  bool IsCallbacks() { return details_.type() == CALLBACKS; }

[danno, 2012/06/21 14:34:30]

Add asserts for (IsFound());

   bool IsDontDelete() { return details_.IsDontDelete(); }
   bool IsDontEnum() { return details_.IsDontEnum(); }
   bool IsDeleted() { return details_.IsDeleted(); }
   bool IsFound() { return lookup_type_ != NOT_FOUND; }
   bool IsHandler() { return lookup_type_ == HANDLER_TYPE; }
+  bool IsInterceptor() { return lookup_type_ == INTERCEPTOR_TYPE; }
+  bool IsField() { return details_.type() == FIELD; }

[danno, 2012/06/21 14:34:30]

Add asserts for (IsFound());

+  bool IsNormal() { return details_.type() == NORMAL; }

[danno, 2012/06/21 14:34:30]

Add asserts for (IsFound());

+  bool IsConstantFunction() { return details_.type() == CONSTANT_FUNCTION; }

[danno, 2012/06/21 14:34:30]

Add asserts for (IsFound());

 
   // Is the result is a property excluding transitions and the null descriptor?
   bool IsProperty() {
     return IsFound() && IsPropertyDescriptor(this);
   }
 
   bool IsCacheable() { return cacheable_; }
   void DisallowCaching() { cacheable_ = false; }
 
   Object* GetLazyValue() {
     switch (type()) {
       case FIELD:
         return holder()->FastPropertyAt(GetFieldIndex());
       case NORMAL: {
         Object* value;
         value = holder()->property_dictionary()->ValueAt(GetDictionaryEntry());
         if (holder()->IsGlobalObject()) {
           value = JSGlobalPropertyCell::cast(value)->value();
         }
         return value;
       }
       case CONSTANT_FUNCTION:
         return GetConstantFunction();
       default:
         return Smi::FromInt(0);
     }
   }
 
-
   Map* GetTransitionMap() {
     ASSERT(lookup_type_ == DESCRIPTOR_TYPE);
     ASSERT(type() == MAP_TRANSITION ||
            type() == CONSTANT_TRANSITION);
     return Map::cast(GetValue());
   }
 
   Map* GetTransitionMapFromMap(Map* map) {
     ASSERT(lookup_type_ == DESCRIPTOR_TYPE);
     ASSERT(type() == MAP_TRANSITION);
     return Map::cast(map->instance_descriptors()->GetValue(number_));
   }
 
   int GetFieldIndex() {
     ASSERT(lookup_type_ == DESCRIPTOR_TYPE);
-    ASSERT(type() == FIELD);
+    ASSERT(IsField());
     return Descriptor::IndexFromValue(GetValue());
   }
 
   int GetLocalFieldIndexFromMap(Map* map) {
     ASSERT(lookup_type_ == DESCRIPTOR_TYPE);
-    ASSERT(type() == FIELD);
+    ASSERT(IsField());
     return Descriptor::IndexFromValue(
         map->instance_descriptors()->GetValue(number_)) -
         map->inobject_properties();
   }
 
   int GetDictionaryEntry() {
     ASSERT(lookup_type_ == DICTIONARY_TYPE);
     return number_;
   }
 
@@ skipping 49 matching lines @@
   JSReceiver* holder_;
   int number_;
   bool cacheable_;
   PropertyDetails details_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_PROPERTY_H_