[keys] Postpone shadowed key checking in the KeyAccumulator

src/keys.cc

 // Copyright 2013 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/keys.h"
 
 #include "src/api-arguments.h"
 #include "src/elements.h"
 #include "src/factory.h"
 #include "src/identity-map.h"
@@ skipping 99 matching lines @@
   for (int i = 0; i < keys->length(); ++i) {
     Handle<Name> key(Name::cast(keys->get(i)), isolate);
     if (key->FilterKey(filter)) continue;  // Skip this key.
     if (filter & ONLY_ENUMERABLE) {
       PropertyDescriptor desc;
       Maybe<bool> found =
           JSProxy::GetOwnPropertyDescriptor(isolate, owner, key, &desc);
       MAYBE_RETURN(found, MaybeHandle<FixedArray>());
       if (!found.FromJust()) continue;
       if (!desc.enumerable()) {
-        accumulator->AddShadowKey(key);
+        accumulator->AddShadowingKey(key);
         continue;
       }
     }
     // Keep this key.
     if (store_position != i) {
       keys->set(store_position, *key);
     }
     store_position++;
   }
   if (store_position == 0) return isolate->factory()->empty_fixed_array();
@@ skipping 28 matching lines @@
     MAYBE_RETURN(CollectOwnJSProxyKeys(receiver, Handle<JSProxy>::cast(object)),
                  Nothing<bool>());
     return Just(true);
   }
 
   PrototypeIterator::WhereToEnd end = mode_ == KeyCollectionMode::kOwnOnly
                                           ? PrototypeIterator::END_AT_NON_HIDDEN
                                           : PrototypeIterator::END_AT_NULL;
   for (PrototypeIterator iter(isolate_, object, kStartAtReceiver, end);
        !iter.IsAtEnd();) {
+    // Start the shadow checks only after the first prototype has added
+    // shadowing keys.
+    if (HasShadowingKeys()) skip_shadow_check_ = false;
     Handle<JSReceiver> current =
         PrototypeIterator::GetCurrent<JSReceiver>(iter);
     Maybe<bool> result = Just(false);  // Dummy initialization.
     if (current->IsJSProxy()) {
       result = CollectOwnJSProxyKeys(receiver, Handle<JSProxy>::cast(current));
     } else {
       DCHECK(current->IsJSObject());
       result = CollectOwnKeys(receiver, Handle<JSObject>::cast(current));
     }
     MAYBE_RETURN(result, Nothing<bool>());
     if (!result.FromJust()) break;  // |false| means "stop iterating".
     // Iterate through proxies but ignore access checks for the ALL_CAN_READ
     // case on API objects for OWN_ONLY keys handled in CollectOwnKeys.
     if (!iter.AdvanceFollowingProxiesIgnoringAccessChecks()) {
       return Nothing<bool>();
     }
     if (!last_non_empty_prototype_.is_null() &&
         *last_non_empty_prototype_ == *current) {
       break;
     }
   }
   return Just(true);
 }
 
+bool KeyAccumulator::HasShadowingKeys() { return !shadowing_keys_.is_null(); }
+
 bool KeyAccumulator::IsShadowed(Handle<Object> key) {
-  if (shadowed_keys_.is_null()) return false;
-  return shadowed_keys_->Has(isolate_, key);
+  if (!HasShadowingKeys() || skip_shadow_check_) return false;
+  return shadowing_keys_->Has(isolate_, key);
 }
 
-void KeyAccumulator::AddShadowKey(Object* key) {
+void KeyAccumulator::AddShadowingKey(Object* key) {
   if (mode_ == KeyCollectionMode::kOwnOnly) return;
-  AddShadowKey(handle(key, isolate_));
+  AddShadowingKey(handle(key, isolate_));
 }
-void KeyAccumulator::AddShadowKey(Handle<Object> key) {
+void KeyAccumulator::AddShadowingKey(Handle<Object> key) {
   if (mode_ == KeyCollectionMode::kOwnOnly) return;
-  if (shadowed_keys_.is_null()) {
-    shadowed_keys_ = ObjectHashSet::New(isolate_, 16);
+  if (shadowing_keys_.is_null()) {
+    shadowing_keys_ = ObjectHashSet::New(isolate_, 16);
   }
-  shadowed_keys_ = ObjectHashSet::Add(shadowed_keys_, key);
+  shadowing_keys_ = ObjectHashSet::Add(shadowing_keys_, key);
 }
 
 namespace {
 
 void TrySettingEmptyEnumCache(JSReceiver* object) {
   Map* map = object->map();
   DCHECK_EQ(kInvalidEnumCacheSentinel, map->EnumLength());
   if (!map->OnlyHasSimpleProperties()) return;
   if (map->IsJSProxyMap()) return;
   if (map->NumberOfOwnDescriptors() > 0) {
@@ skipping 323 matching lines @@
     }
 
     Name* key = descs->GetKey(i);
     if (skip_symbols == key->IsSymbol()) {
       if (first_skipped == -1) first_skipped = i;
       continue;
     }
     if (key->FilterKey(keys->filter())) continue;
 
     if (is_shadowing_key) {
-      keys->AddShadowKey(key);
+      keys->AddShadowingKey(key);
     } else {
       keys->AddKey(key, DO_NOT_CONVERT);
     }
   }
   return first_skipped;
 }
 
 template <class T>
 Handle<FixedArray> GetOwnEnumPropertyDictionaryKeys(Isolate* isolate,
                                                     KeyCollectionMode mode,
@@ skipping 21 matching lines @@
       // we do not have to filter out non-enumerable ones
       Map* map = object->map();
       int nof_descriptors = map->NumberOfOwnDescriptors();
       if (enum_keys->length() != nof_descriptors) {
         Handle<DescriptorArray> descs =
             Handle<DescriptorArray>(map->instance_descriptors(), isolate_);
         for (int i = 0; i < nof_descriptors; i++) {
           PropertyDetails details = descs->GetDetails(i);
           if (!details.IsDontEnum()) continue;
           Object* key = descs->GetKey(i);
-          this->AddShadowKey(key);
+          this->AddShadowingKey(key);
         }
       }
     } else if (object->IsJSGlobalObject()) {
       enum_keys = GetOwnEnumPropertyDictionaryKeys(
           isolate_, mode_, this, object, object->global_dictionary());
     } else {
       enum_keys = GetOwnEnumPropertyDictionaryKeys(
           isolate_, mode_, this, object, object->property_dictionary());
     }
     AddKeys(enum_keys, DO_NOT_CONVERT);
@@ skipping 256 matching lines @@
       Nothing<bool>());
   bool prev_filter_proxy_keys_ = filter_proxy_keys_;
   filter_proxy_keys_ = false;
   Maybe<bool> result = AddKeysFromJSProxy(proxy, keys);
   filter_proxy_keys_ = prev_filter_proxy_keys_;
   return result;
 }
 
 }  // namespace internal
 }  // namespace v8