[runtime] Do not use the enum-cache for non-prototype objects.

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"
@@ skipping 120 matching lines @@
     }
   }
   return AddStringKey(key, convert);
 }
 
 
 bool KeyAccumulator::AddKey(uint32_t key) { return AddIntegerKey(key); }
 
 
 bool KeyAccumulator::AddIntegerKey(uint32_t key) {
+  if (IsKeyHidden(key)) return false;
   // Make sure we do not add keys to a proxy-level (see AddKeysFromProxy).
   // We mark proxy-levels with a negative length
   DCHECK_LE(0, level_string_length_);
-  // Binary search over all but the last level. The last one might not be
+  // Binary search over all but the last level. The last level might not be
   // sorted yet.
   for (size_t i = 1; i < elements_.size(); i++) {
     if (AccumulatorHasKey(elements_[i - 1], key)) return false;
   }
   elements_.back()->push_back(key);
   length_++;
   return true;
 }
 
 
 bool KeyAccumulator::AddStringKey(Handle<Object> key,
                                   AddKeyConversion convert) {
+  if (IsKeyHidden(key)) return false;
   if (string_properties_.is_null()) {
     string_properties_ = OrderedHashSet::Allocate(isolate_, 16);
   }
-  // TODO(cbruni): remove this conversion once we throw the correct TypeError
-  // for non-string/symbol elements returned by proxies
   if (convert == PROXY_MAGIC && key->IsNumber()) {
     key = isolate_->factory()->NumberToString(key);
   }
   int prev_size = string_properties_->NumberOfElements();
   string_properties_ = OrderedHashSet::Add(string_properties_, key);
   if (prev_size < string_properties_->NumberOfElements()) {
     length_++;
     level_string_length_++;
     return true;
   } else {
     return false;
   }
 }
 
 
 bool KeyAccumulator::AddSymbolKey(Handle<Object> key) {
+  if (IsKeyHidden(key)) return false;
   if (symbol_properties_.is_null()) {
     symbol_properties_ = OrderedHashSet::Allocate(isolate_, 16);
   }
   int prev_size = symbol_properties_->NumberOfElements();
   symbol_properties_ = OrderedHashSet::Add(symbol_properties_, key);
   if (prev_size < symbol_properties_->NumberOfElements()) {
     length_++;
     level_symbol_length_++;
     return true;
   } else {
@@ skipping 104 matching lines @@
 }
 
 
 void KeyAccumulator::SortCurrentElementsList() {
   if (elements_.empty()) return;
   auto element_keys = elements_.back();
   std::sort(element_keys->begin(), element_keys->end());
 }
 
 
+void KeyAccumulator::Prepare() { NextPrototype(); }
+
+
 void KeyAccumulator::NextPrototype() {
   // Store the protoLength on the first call of this method.
   if (!elements_.empty()) {
     level_lengths_.push_back(level_string_length_);
     level_lengths_.push_back(level_symbol_length_);
   }
   elements_.push_back(new std::vector<uint32_t>());
   level_string_length_ = 0;
   level_symbol_length_ = 0;
 }
 
 
+void KeyAccumulator::HideKey(uint32_t key) { hidden_element_keys_.insert(key); }
+
+
+void KeyAccumulator::HideKey(Object* key) {
+  HideKey(Handle<Object>(key, isolate_));
+}
+
+
+void KeyAccumulator::HideKey(Handle<Object> key) {
+  if (hidden_keys_.is_null()) {
+    hidden_keys_ = OrderedHashSet::Allocate(isolate_, 8);
+  }
+  hidden_keys_ = OrderedHashSet::Add(hidden_keys_, key);
+}
+
+
+bool KeyAccumulator::IsKeyHidden(uint32_t key) {
+  return hidden_element_keys_.count(key);
+}
+
+
+bool KeyAccumulator::IsKeyHidden(Handle<Object> key) {
+  if (hidden_keys_.is_null()) return false;
+  return OrderedHashSet::HasKey(hidden_keys_, key);
+}
+
+
 }  // namespace internal
 }  // namespace v8