[ESnext] Implement Object Rest

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 HasElementInArguments(Arguments* arguments,
+                           Handle<Object> search_element) {
+  // TODO(gsathya): Maybe optimize this to be a hashtable.
+  for (int i = 0; i < arguments->length(); i++) {
+    if (*search_element == (*arguments)[i]) {

[adamk, 2017/01/12 22:43:08]

Pointer equality isn't sufficient for strings. Use Object::SameValue() instead.

[gsathya, 2017/01/17 19:28:59]

Done.

+      return true;
+    }
+  }
+
+  return false;
+}
+
 MUST_USE_RESULT Maybe<bool> FastAssign(Handle<JSReceiver> target,
-                                       Handle<Object> source, bool use_set) {
+                                       Handle<Object> source,
+                                       Arguments* 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 52 matching lines @@
     }
 
     if (use_set) {
       LookupIterator it(target, next_key, target);
       bool call_to_js = it.IsFound() && it.state() != LookupIterator::DATA;
       Maybe<bool> result = Object::SetProperty(
           &it, prop_value, STRICT, Object::CERTAINLY_NOT_STORE_FROM_KEYED);
       if (result.IsNothing()) return result;
       if (stable && call_to_js) stable = from->map() == *map;
     } else {
+      if (excluded_properties != nullptr &&
+          HasElementInArguments(excluded_properties, next_key)) {
+        continue;
+      }
+
       // 4a ii 2. Perform ? CreateDataProperty(target, nextKey, propValue).
       bool success;
       LookupIterator it = LookupIterator::PropertyOrElement(
           isolate, target, next_key, &success, LookupIterator::OWN);
       CHECK(success);
       CHECK(
           JSObject::CreateDataProperty(&it, prop_value, Object::THROW_ON_ERROR)
               .FromJust());
     }
   }
 
   return Just(true);
 }
-
 }  // namespace
 
 // static
 Maybe<bool> JSReceiver::SetOrCopyDataProperties(Isolate* isolate,
                                                 Handle<JSReceiver> target,
                                                 Handle<Object> source,
+                                                Arguments* excluded_properties,
                                                 bool use_set) {
-  Maybe<bool> fast_assign = FastAssign(target, source, 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::kKeepNumbers),
@@ skipping 16 matching lines @@
           Runtime::GetObjectProperty(isolate, from, next_key), Nothing<bool>());
 
       if (use_set) {
         // 4c ii 2. Let status be ? Set(to, nextKey, propValue, true).
         Handle<Object> status;
         ASSIGN_RETURN_ON_EXCEPTION_VALUE(
             isolate, status, Runtime::SetObjectProperty(
                                  isolate, target, next_key, prop_value, STRICT),
             Nothing<bool>());
       } else {
+        if (excluded_properties != nullptr &&
+            HasElementInArguments(excluded_properties, next_key)) {
+          continue;
+        }
+
         // 4a ii 2. Perform ! CreateDataProperty(target, nextKey, propValue).
         bool success;
         LookupIterator it = LookupIterator::PropertyOrElement(
             isolate, target, next_key, &success, LookupIterator::OWN);
         CHECK(success);
         CHECK(JSObject::CreateDataProperty(&it, prop_value,
                                            Object::THROW_ON_ERROR)
                   .FromJust());
       }
     }
@@ skipping 17745 matching lines @@
       // depend on this.
       return DICTIONARY_ELEMENTS;
     }
     DCHECK_LE(kind, LAST_ELEMENTS_KIND);
     return kind;
   }
 }
 
 }  // namespace internal
 }  // namespace v8