Rossberg's suggested changes to the LookupIterator.

src/lookup.cc

 // Copyright 2014 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/bootstrapper.h"
 #include "src/lookup.h"
 
 namespace v8 {
 namespace internal {
 
 
 void LookupIterator::Next() {
   has_property_ = false;
   do {
-    LookupInHolder();
+    state_ = LookupInHolder();
   } while (!IsFound() && NextHolder());
 }
 
 
-Handle<JSReceiver> LookupIterator::GetOrigin() const {
+Handle<JSReceiver> LookupIterator::GetRoot() const {
   Handle<Object> receiver = GetReceiver();
   if (receiver->IsJSReceiver()) return Handle<JSReceiver>::cast(receiver);
   Context* native_context = isolate_->context()->native_context();
   JSFunction* function;
   if (receiver->IsNumber()) {
     function = native_context->number_function();
   } else if (receiver->IsString()) {
     function = native_context->string_function();
   } else if (receiver->IsSymbol()) {
     function = native_context->symbol_function();
@@ skipping 27 matching lines @@
       !next->map()->is_hidden_prototype()) {
     return false;
   }
 
   holder_map_ = handle(next->map());
   maybe_holder_ = next;
   return true;
 }
 
 
-void LookupIterator::LookupInHolder() {
-  State old_state = state_;
-  state_ = NOT_FOUND;
-  switch (old_state) {
+LookupIterator::State LookupIterator::LookupInHolder() {
+  switch (state_) {
     case NOT_FOUND:
       if (holder_map_->IsJSProxyMap()) {
-        state_ = JSPROXY;
-        return;
+        return JSPROXY;
       }
       if (check_access_check() && holder_map_->is_access_check_needed()) {
-        state_ = ACCESS_CHECK;
-        return;
+        return ACCESS_CHECK;
       }
+      // Fall through.
     case ACCESS_CHECK:
       if (check_interceptor() && holder_map_->has_named_interceptor()) {
-        state_ = INTERCEPTOR;
-        return;
+        return INTERCEPTOR;
       }
+      // Fall through.
     case INTERCEPTOR:
       if (holder_map_->is_dictionary_map()) {
         property_encoding_ = DICTIONARY;
       } else {
         DescriptorArray* descriptors = holder_map_->instance_descriptors();
         number_ = descriptors->SearchWithCache(*name_, *holder_map_);
-        if (number_ == DescriptorArray::kNotFound) return;
+        if (number_ == DescriptorArray::kNotFound) return NOT_FOUND;
         property_encoding_ = DESCRIPTOR;
       }
-      state_ = PROPERTY;
+      return PROPERTY;
     case PROPERTY:
-      return;
+      return NOT_FOUND;
     case JSPROXY:
       UNREACHABLE();
   }
+  UNREACHABLE();
+  return state_;
 }
 
 
 bool LookupIterator::IsBootstrapping() const {
   return isolate_->bootstrapper()->IsActive();
 }
 
 
 bool LookupIterator::HasAccess(v8::AccessType access_type) const {
   ASSERT_EQ(ACCESS_CHECK, state_);
@@ skipping 20 matching lines @@
     }
   } else {
     property_details_ = holder_map_->instance_descriptors()->GetDetails(
         number_);
   }
 
   switch (property_details_.type()) {
     case v8::internal::FIELD:
     case v8::internal::NORMAL:
     case v8::internal::CONSTANT:
-      property_type_ = DATA;
+      property_kind_ = DATA;
       break;
     case v8::internal::CALLBACKS:
-      property_type_ = ACCESSORS;
+      property_kind_ = ACCESSOR;
       break;
     case v8::internal::HANDLER:
     case v8::internal::NONEXISTENT:
     case v8::internal::INTERCEPTOR:
       UNREACHABLE();
   }
 
   has_property_ = true;
   return true;
 }
@@ skipping 16 matching lines @@
             GetHolder(), property_details_.representation(), field_index);
       }
       result = holder_map_->instance_descriptors()->GetValue(number_);
   }
   return handle(result, isolate_);
 }
 
 
 Handle<Object> LookupIterator::GetAccessors() const {
   ASSERT(has_property_);
-  ASSERT_EQ(ACCESSORS, property_type_);
+  ASSERT_EQ(ACCESSOR, property_kind_);
   return FetchValue();
 }
 
 
 Handle<Object> LookupIterator::GetDataValue() const {
   ASSERT(has_property_);
-  ASSERT_EQ(DATA, property_type_);
+  ASSERT_EQ(DATA, property_kind_);
   Handle<Object> value = FetchValue();
   if (value->IsTheHole()) {
     ASSERT_EQ(DICTIONARY, property_encoding_);
     ASSERT(GetHolder()->IsGlobalObject());
     ASSERT(property_details_.IsReadOnly());
     return factory()->undefined_value();
   }
   return value;
 }
 
 
 } }  // namespace v8::internal