[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 1984 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 {
 
-MUST_USE_RESULT Maybe<bool> FastAssign(Handle<JSReceiver> target,
-                                       Handle<Object> source, bool use_set) {
+bool HasElementInJSArray(Isolate* isolate, Handle<JSArray> array,
+                         Handle<Object> search_element) {
+  uint32_t len = 0;
+  bool success = array->length()->ToArrayLength(&len);
+  DCHECK(success);
+
+  if (len == 0) return false;
+
+  int32_t start = 0;
+  ElementsAccessor* elements = array->GetElementsAccessor();
+  Maybe<bool> result =
+      elements->IncludesValue(isolate, array, search_element, start, len);
+  return result.FromJust();
+}
+
+MUST_USE_RESULT Maybe<bool> FastAssign(
+    Handle<JSReceiver> target, Handle<Object> source,
+    MaybeHandle<JSArray> maybe_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.
   if (target->map()->is_deprecated()) {
     JSObject::MigrateInstance(Handle<JSObject>::cast(target));
   }
 
   Isolate* isolate = target->GetIsolate();
   Handle<Map> map(JSReceiver::cast(*source)->map(), isolate);
 
   if (!map->IsJSObjectMap()) return Just(false);
   if (!map->OnlyHasSimpleProperties()) return Just(false);
 
   Handle<JSObject> from = Handle<JSObject>::cast(source);
   if (from->elements() != isolate->heap()->empty_fixed_array()) {
     return Just(false);
   }
 
   Handle<DescriptorArray> descriptors(map->instance_descriptors(), isolate);
   int length = map->NumberOfOwnDescriptors();
 
   bool stable = true;
+  Handle<JSArray> excluded_properties;
+  if (!maybe_excluded_properties.is_null()) {
+    excluded_properties = maybe_excluded_properties.ToHandleChecked();

[adamk, 2017/01/10 23:22:56]

Pattern for this is:

const bool has_excluded_properties =
maybe_excluded_properties.ToHandle(&excluded_properties);

+  }
 
   for (int i = 0; i < length; i++) {
     Handle<Name> next_key(descriptors->GetKey(i), isolate);
     Handle<Object> prop_value;
     // Directly decode from the descriptor array if |from| did not change shape.
     if (stable) {
       PropertyDetails details = descriptors->GetDetails(i);
       if (!details.IsEnumerable()) continue;
       if (details.kind() == kData) {
         if (details.location() == kDescriptor) {
@@ skipping 23 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 (!maybe_excluded_properties.is_null() &&

[adamk, 2017/01/10 23:22:56]

and then this would be

if (has_excluded_properties && ...)

+          HasElementInJSArray(isolate, 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,
-                                                bool use_set) {
-  Maybe<bool> fast_assign = FastAssign(target, source, use_set);
+Maybe<bool> JSReceiver::SetOrCopyDataProperties(
+    Isolate* isolate, Handle<JSReceiver> target, Handle<Object> source,
+    MaybeHandle<JSArray> maybe_excluded_properties, bool use_set) {
+  Maybe<bool> fast_assign =
+      FastAssign(target, source, maybe_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),
       Nothing<bool>());
 
+  Handle<JSArray> excluded_properties;
+  if (!maybe_excluded_properties.is_null()) {
+    excluded_properties = maybe_excluded_properties.ToHandleChecked();

[adamk, 2017/01/10 23:22:56]

Same here as above

+  }
+
   // 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>();
     // 4a ii. If desc is not undefined and desc.[[Enumerable]] is true, then
     if (found.FromJust() && desc.enumerable()) {
       // 4a ii 1. Let propValue be ? Get(from, nextKey).
       Handle<Object> prop_value;
       ASSIGN_RETURN_ON_EXCEPTION_VALUE(
           isolate, prop_value,
           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 (!maybe_excluded_properties.is_null() &&

[adamk, 2017/01/10 23:22:55]

And here.

+            HasElementInJSArray(isolate, 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 17806 matching lines @@
       // depend on this.
       return DICTIONARY_ELEMENTS;
     }
     DCHECK_LE(kind, LAST_ELEMENTS_KIND);
     return kind;
   }
 }
 
 }  // namespace internal
 }  // namespace v8