[pattern rewriter] Only desugar to call %ToName on computed properties

src/objects.cc

 // Copyright 2015 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/objects.h"
 
 #include <cmath>
 #include <iomanip>
 #include <memory>
 #include <sstream>
@@ skipping 1985 matching lines @@
     if (!iter.AdvanceFollowingProxies()) return Nothing<bool>();
     if (iter.IsAtEnd()) return Just(false);
     if (PrototypeIterator::GetCurrent(iter).is_identical_to(proto)) {
       return Just(true);
     }
   }
 }
 
 namespace {
 
-bool HasExcludedProperty(const ScopedVector<Handle<Name>>* excluded_properties,
-                         Handle<Object> search_element) {
+bool HasExcludedProperty(
+    const ScopedVector<Handle<Object>>* excluded_properties,
+    Handle<Object> search_element) {
   // TODO(gsathya): Change this to be a hashtable.
   for (int i = 0; i < excluded_properties->length(); i++) {
     if (search_element->SameValue(*excluded_properties->at(i))) {
       return true;
     }
   }
 
   return false;
 }
 
 MUST_USE_RESULT Maybe<bool> FastAssign(
     Handle<JSReceiver> target, Handle<Object> source,
-    const ScopedVector<Handle<Name>>* excluded_properties, bool use_set) {
+    const ScopedVector<Handle<Object>>* excluded_properties, bool use_set) {
   // Non-empty strings are the only non-JSReceivers that need to be handled
   // explicitly by Object.assign.
   if (!source->IsJSReceiver()) {
     return Just(!source->IsString() || String::cast(*source)->length() == 0);
   }
 
   // If the target is deprecated, the object will be updated on first store. If
   // the source for that store equals the target, this will invalidate the
   // cached representation of the source. Preventively upgrade the target.
   // Do this on each iteration since any property load could cause deprecation.
@@ skipping 75 matching lines @@
     }
   }
 
   return Just(true);
 }
 }  // namespace
 
 // static
 Maybe<bool> JSReceiver::SetOrCopyDataProperties(
     Isolate* isolate, Handle<JSReceiver> target, Handle<Object> source,
-    const ScopedVector<Handle<Name>>* excluded_properties, bool use_set) {
+    const ScopedVector<Handle<Object>>* excluded_properties, bool use_set) {
   Maybe<bool> fast_assign =
       FastAssign(target, source, excluded_properties, use_set);
   if (fast_assign.IsNothing()) return Nothing<bool>();
   if (fast_assign.FromJust()) return Just(true);
 
   Handle<JSReceiver> from = Object::ToObject(isolate, source).ToHandleChecked();
   // 3b. Let keys be ? from.[[OwnPropertyKeys]]().
   Handle<FixedArray> keys;
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
       isolate, keys,
       KeyAccumulator::GetKeys(from, KeyCollectionMode::kOwnOnly, ALL_PROPERTIES,
-                              GetKeysConversion::kConvertToString),
+                              GetKeysConversion::kKeepNumbers),
       Nothing<bool>());
 
   // 4. Repeat for each element nextKey of keys in List order,
   for (int j = 0; j < keys->length(); ++j) {
     Handle<Object> next_key(keys->get(j), isolate);
     // 4a i. Let desc be ? from.[[GetOwnProperty]](nextKey).
     PropertyDescriptor desc;
     Maybe<bool> found =
         JSReceiver::GetOwnPropertyDescriptor(isolate, from, next_key, &desc);
     if (found.IsNothing()) return Nothing<bool>();
@@ skipping 4524 matching lines @@
 
 // TODO(jkummerow): Consider unification with FastAsArrayLength() in
 // accessors.cc.
 bool PropertyKeyToArrayLength(Handle<Object> value, uint32_t* length) {
   DCHECK(value->IsNumber() || value->IsName());
   if (value->ToArrayLength(length)) return true;
   if (value->IsString()) return String::cast(*value)->AsArrayIndex(length);
   return false;
 }
 
-
 bool PropertyKeyToArrayIndex(Handle<Object> index_obj, uint32_t* output) {
   return PropertyKeyToArrayLength(index_obj, output) && *output != kMaxUInt32;
 }
 
 
 // ES6 9.4.2.1
 // static
 Maybe<bool> JSArray::DefineOwnProperty(Isolate* isolate, Handle<JSArray> o,
                                        Handle<Object> name,
                                        PropertyDescriptor* desc,
@@ skipping 13232 matching lines @@
       // depend on this.
       return DICTIONARY_ELEMENTS;
     }
     DCHECK_LE(kind, LAST_ELEMENTS_KIND);
     return kind;
   }
 }
 
 }  // namespace internal
 }  // namespace v8