[proxies] Implement Symbol/DONT_ENUM filtering for GetKeys()

src/key-accumulator.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/key-accumulator.h"
 
 #include "src/elements.h"
 #include "src/factory.h"
+#include "src/isolate-inl.h"
 #include "src/objects-inl.h"
+#include "src/property-descriptor.h"
 
 
 namespace v8 {
 namespace internal {
 
 
 KeyAccumulator::~KeyAccumulator() {
   for (size_t i = 0; i < elements_.size(); i++) {
     delete elements_[i];
   }
@@ skipping 190 matching lines @@
   // elements and properties, which breaks the normal assumption for the
   // KeyAccumulator.
   AddKeys(array_like, PROXY_MAGIC);
   // Invert the current length to indicate a present proxy, so we can ignore
   // element keys for this level. Otherwise we would not fully respect the order
   // given by the proxy.
   level_string_length_ = -level_string_length_;
 }
 
 
-void KeyAccumulator::AddKeysFromProxy(Handle<FixedArray> keys) {
+MaybeHandle<FixedArray> FilterProxyKeys(Isolate* isolate, Handle<JSProxy> owner,
+                                        Handle<FixedArray> keys,
+                                        KeyFilter filter,
+                                        Enumerability enum_policy) {
+  if (filter == INCLUDE_SYMBOLS && enum_policy == IGNORE_ENUMERABILITY) {
+    // Nothing to do.
+    return keys;
+  }
+  int store_position = 0;
+  for (int i = 0; i < keys->length(); ++i) {
+    Handle<Name> key(Name::cast(keys->get(i)), isolate);
+    if (filter == SKIP_SYMBOLS && key->IsSymbol()) continue;  // Skip this key.
+    if (enum_policy == RESPECT_ENUMERABILITY) {
+      PropertyDescriptor desc;
+      bool found =
+          JSProxy::GetOwnPropertyDescriptor(isolate, owner, key, &desc);
+      if (isolate->has_pending_exception()) return MaybeHandle<FixedArray>();
+      if (!found || !desc.enumerable()) continue;  // Skip this key.
+    }
+    // Keep this key.
+    if (store_position != i) {
+      keys->set(store_position, *key);
+    }
+    store_position++;
+  }
+  if (store_position == 0) return isolate->factory()->empty_fixed_array();
+  keys->Shrink(store_position);
+  return keys;
+}
+
+
+// Returns "false" in case of exception, "true" on success.
+bool KeyAccumulator::AddKeysFromProxy(Handle<JSProxy> proxy,
+                                      Handle<FixedArray> keys, KeyFilter filter,
+                                      Enumerability enum_policy) {
+  ASSIGN_RETURN_ON_EXCEPTION_VALUE(
+      isolate_, keys,
+      FilterProxyKeys(isolate_, proxy, keys, filter, enum_policy), false);
   // Proxies define a complete list of keys with no distinction of
   // elements and properties, which breaks the normal assumption for the
   // KeyAccumulator.
   AddKeys(keys, PROXY_MAGIC);
   // Invert the current length to indicate a present proxy, so we can ignore
   // element keys for this level. Otherwise we would not fully respect the order
   // given by the proxy.
   level_string_length_ = -level_string_length_;
+  return true;
 }
 
 
 void KeyAccumulator::AddElementKeysFromInterceptor(
     Handle<JSObject> array_like) {
   AddKeys(array_like, CONVERT_TO_ARRAY_INDEX);
   // The interceptor might introduce duplicates for the current level, since
   // these keys get added after the objects's normal element keys.
   SortCurrentElementsListRemoveDuplicates();
 }
@@ skipping 27 matching lines @@
     level_lengths_.push_back(level_symbol_length_);
   }
   elements_.push_back(new std::vector<uint32_t>());
   level_string_length_ = 0;
   level_symbol_length_ = 0;
 }
 
 
 }  // namespace internal
 }  // namespace v8