[keys] Postpone shadowed key checking in the KeyAccumulator

src/keys.h

 // Copyright 2012 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.
 
 #ifndef V8_KEYS_H_
 #define V8_KEYS_H_
 
 #include "src/isolate.h"
 #include "src/objects.h"
 
@@ skipping 65 matching lines @@
   void set_is_for_in(bool value) { is_for_in_ = value; }
   void set_skip_indices(bool value) { skip_indices_ = value; }
   // The last_non_empty_prototype is used to limit the prototypes for which
   // we have to keep track of non-enumerable keys that can shadow keys
   // repeated on the prototype chain.
   void set_last_non_empty_prototype(Handle<JSReceiver> object) {
     last_non_empty_prototype_ = object;
   }
   // Shadowing keys are used to filter keys. This happens when non-enumerable
   // keys appear again on the prototype chain.
-  void AddShadowKey(Object* key);
-  void AddShadowKey(Handle<Object> key);
+  void AddShadowingKey(Object* key);
+  void AddShadowingKey(Handle<Object> key);
 
  private:
   Maybe<bool> CollectOwnKeys(Handle<JSReceiver> receiver,
                              Handle<JSObject> object);
   Maybe<bool> CollectOwnJSProxyKeys(Handle<JSReceiver> receiver,
                                     Handle<JSProxy> proxy);
   Maybe<bool> CollectOwnJSProxyTargetKeys(Handle<JSProxy> proxy,
                                           Handle<JSReceiver> target);
   Maybe<bool> AddKeysFromJSProxy(Handle<JSProxy> proxy,
                                  Handle<FixedArray> keys);
   bool IsShadowed(Handle<Object> key);
+  bool HasShadowingKeys();
   Handle<OrderedHashSet> keys() { return Handle<OrderedHashSet>::cast(keys_); }
 
   Isolate* isolate_;
   // keys_ is either an Handle<OrderedHashSet> or in the case of own JSProxy
   // keys a Handle<FixedArray>. The OrderedHashSet is in-place converted to the
   // result list, a FixedArray containing all collected keys.
   Handle<FixedArray> keys_;
   Handle<JSReceiver> last_non_empty_prototype_;
-  Handle<ObjectHashSet> shadowed_keys_;
+  Handle<ObjectHashSet> shadowing_keys_;
   KeyCollectionMode mode_;
   PropertyFilter filter_;
   bool filter_proxy_keys_ = true;
   bool is_for_in_ = false;
   bool skip_indices_ = false;
+  // For all the keys on the first receiver adding a shadowing key we can skip
+  // the shadow check.
+  bool skip_shadow_check_ = true;
 
   DISALLOW_COPY_AND_ASSIGN(KeyAccumulator);
 };
 
 // The FastKeyAccumulator handles the cases where there are no elements on the
 // prototype chain and forwords the complex/slow cases to the normal
 // KeyAccumulator. This significantly speeds up the cases where the OWN_ONLY
 // case where we do not have to walk the prototype chain.
 class FastKeyAccumulator {
  public:
@@ skipping 26 matching lines @@
   bool is_receiver_simple_enum_ = false;
   bool has_empty_prototype_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(FastKeyAccumulator);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_KEYS_H_