[runtime] Support Proxy setPrototypeOf trap

src/objects.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/objects.h"
 
 #include <cmath>
 #include <iomanip>
 #include <sstream>
 
@@ skipping 606 matching lines @@
   // TODO(dcarney): this should just be read from the symbol registry so as not
   // to be context dependent.
   auto key = isolate->factory()->promise_status_symbol();
   // Shouldn't be possible to throw here.
   return JSObject::HasRealNamedProperty(js_object, key).FromJust();
 }
 
 
 // static
 MaybeHandle<Object> Object::GetMethod(Handle<JSReceiver> receiver,
-                                      Handle<Name> name) {
+                                      Handle<Name> name,
+                                      ShouldThrow should_throw) {
   Handle<Object> func;
   Isolate* isolate = receiver->GetIsolate();
-  ASSIGN_RETURN_ON_EXCEPTION(isolate, func,
-                             JSReceiver::GetProperty(receiver, name), Object);
+  // TODO(cbruni,neis): Propagage should_throw here.

[Toon Verwaest, 2015/11/13 17:28:21]

Propagate

+  if (!JSReceiver::GetProperty(receiver, name).ToHandle(&func)) {
+    return MaybeHandle<Object>();
+  }
   if (func->IsNull() || func->IsUndefined()) {
     return isolate->factory()->undefined_value();
   }
   if (!func->IsCallable()) {
     // TODO(bmeurer): Better error message here?

[Toon Verwaest, 2015/11/13 17:28:21]

The spec says you actually have to throw a TypeError here. This does not return
false, so ShouldThrow shouldn't be passed in.

I'll wait with reviewing the CL until this is fixed (as discussed offline).

-    THROW_NEW_ERROR(isolate,
-                    NewTypeError(MessageTemplate::kCalledNonCallable, func),
-                    Object);
+    if (should_throw == Object::THROW_ON_ERROR) {
+      THROW_NEW_ERROR(isolate,
+                      NewTypeError(MessageTemplate::kCalledNonCallable, func),
+                      Object);
+    } else {
+      return MaybeHandle<Object>();
+    }
   }
   return func;
 }
 
 
 // static
 Maybe<bool> JSReceiver::HasProperty(LookupIterator* it) {
   for (; it->IsFound(); it->Next()) {
     switch (it->state()) {
       case LookupIterator::NOT_FOUND:
@@ skipping 188 matching lines @@
   Handle<FixedArray> elems(FixedArray::cast(object->elements()), isolate);
   if (elems->map() != isolate->heap()->fixed_cow_array_map()) return elems;
   Handle<FixedArray> writable_elems = isolate->factory()->CopyFixedArrayWithMap(
       elems, isolate->factory()->fixed_array_map());
   object->set_elements(*writable_elems);
   isolate->counters()->cow_arrays_converted()->Increment();
   return writable_elems;
 }
 
 
-// ES6 9.5.1
+// ES6: Section 9.5.1 [[GetPrototypeOf]] ( )
 // static
 MaybeHandle<Object> JSProxy::GetPrototype(Handle<JSProxy> proxy) {
   Isolate* isolate = proxy->GetIsolate();
+  Handle<Object> trap;
+  Handle<JSReceiver> handle;
+  Handle<Name> trap_name = isolate->factory()->getPrototypeOf_string();
   // 1. Let handler be the value of the [[ProxyHandler]] internal slot.
   Handle<Object> raw_handler(proxy->handler(), isolate);
   // 2. If handler is null, throw a TypeError exception.
   // 3. Assert: Type(handler) is Object.
   if (!raw_handler->IsSpecObject()) {
+    DCHECK(raw_handler->IsNull());
+    DCHECK(proxy->target()->IsNull());
     // TODO(cbruni): Throw correct error message.
     THROW_NEW_ERROR(
         isolate, NewTypeError(MessageTemplate::kProxyHandlerNonObject), Object);
   }
   Handle<JSReceiver> handler = Handle<JSReceiver>::cast(raw_handler);
   // 4. Let target be the value of the [[ProxyTarget]] internal slot.
   // TODO(cbruni): Change target type to JSReceiver by default.
   Handle<JSReceiver> target(JSReceiver::cast(proxy->target()), isolate);
   // 5. Let trap be ? GetMethod(handler, "getPrototypeOf").
-  Handle<Object> trap;
-  Handle<String> trap_name = isolate->factory()->getPrototypeOf_string();
   ASSIGN_RETURN_ON_EXCEPTION(isolate, trap, GetMethod(handler, trap_name),
                              Object);
   // 6. If trap is undefined, then return target.[[GetPrototypeOf]]().
   if (trap->IsUndefined()) {
     return Object::GetPrototype(isolate, target);
   }
   // 7. Let handlerProto be ? Call(trap, handler, «target»).
   Handle<Object> argv[] = {target};
   Handle<Object> handler_proto;
   ASSIGN_RETURN_ON_EXCEPTION(
       isolate, handler_proto,
       Execution::Call(isolate, trap, handler, arraysize(argv), argv), Object);
   // 8. If Type(handlerProto) is neither Object nor Null, throw a TypeError.
   if (!(handler_proto->IsSpecObject() || handler_proto->IsNull())) {
+    // TODO(cbruni): throw correct error message
     THROW_NEW_ERROR(isolate,
                     NewTypeError(MessageTemplate::kProxyHandlerTrapMissing,
                                  handler, trap_name),
                     Object);
   }
   // 9. Let extensibleTarget be ? IsExtensible(target).
   Maybe<bool> is_extensible = JSReceiver::IsExtensible(target);
   if (is_extensible.IsNothing()) return MaybeHandle<Object>();
   // 10. If extensibleTarget is true, return handlerProto.
   if (is_extensible.FromJust()) return handler_proto;
   // 11. Let targetProto be ? target.[[GetPrototypeOf]]().
   Handle<Object> target_proto;
   ASSIGN_RETURN_ON_EXCEPTION(isolate, handler_proto,
                              Object::GetPrototype(isolate, target), Object);
   // 12. If SameValue(handlerProto, targetProto) is false, throw a TypeError.
   if (!handler_proto->SameValue(*target_proto)) {
     THROW_NEW_ERROR(isolate,
                     NewTypeError(MessageTemplate::kProxyHandlerTrapMissing,
                                  handler, trap_name),
                     Object);
   }
   // 13. Return handlerProto.
   return handler_proto;
 }
 
 
+// ES6: 9.5.2 [[SetPrototypeOf]] (V)
+// static
+Maybe<bool> JSProxy::SetPrototype(Handle<JSProxy> proxy, Handle<Object> value,
+                                  bool from_javascript,
+                                  Object::ShouldThrow should_throw) {
+  Isolate* isolate = proxy->GetIsolate();
+  Handle<Object> trap;
+  Handle<JSReceiver> handle;
+  Handle<Name> trap_name = isolate->factory()->setPrototypeOf_string();
+  // 1. Assert: Either Type(V) is Object or Type(V) is Null.
+  if (!(value->IsSpecObject() || value->IsNull())) {
+    RETURN_FAILURE(isolate, should_throw,
+                   NewTypeError(MessageTemplate::kProtoObjectOrNull, value));
+  }
+  Handle<Object> raw_handler(proxy->handler(), isolate);
+  // 2. If handler is null, throw a TypeError exception.
+  // 3. Assert: Type(handler) is Object.
+  if (!raw_handler->IsSpecObject()) {
+    DCHECK(raw_handler->IsNull());
+    DCHECK(proxy->target()->IsNull());
+    // TODO(cbruni): use proper error message here.
+    RETURN_FAILURE(isolate, should_throw,
+                   NewTypeError(MessageTemplate::kProxyHandlerNonObject));
+  }
+  Handle<JSReceiver> handler = Handle<JSReceiver>::cast(raw_handler);
+  // 4. Let target be the value of the [[ProxyTarget]] internal slot.
+  Handle<JSReceiver> target(JSReceiver::cast(proxy->target()), isolate);
+  // 5. Let trap be ? GetMethod(handler, "getPrototypeOf").
+  if (!Object::GetMethod(handler, trap_name, should_throw).ToHandle(&trap)) {
+    if (should_throw == Object::DONT_THROW) {
+      return Just(false);
+    } else {
+      return Nothing<bool>();
+    }
+  }
+  // 7. If trap is undefined, then return target.[[SetPrototypeOf]]().
+  if (trap->IsUndefined()) {
+    return JSReceiver::SetPrototype(target, value, from_javascript,
+                                    should_throw);
+  }
+  // 8. Let booleanTrapResult be ToBoolean(? Call(trap, handler, «target, V»)).
+  Handle<Object> argv[] = {target, value};
+  Handle<Object> trap_result;
+  ASSIGN_RETURN_ON_EXCEPTION_VALUE(
+      isolate, trap_result,
+      Execution::Call(isolate, trap, handler, arraysize(argv), argv),
+      Nothing<bool>());
+  Maybe<bool> result = Just(trap_result->BooleanValue());
+  // 9. Let extensibleTarget be ? IsExtensible(target).
+  Maybe<bool> is_extensible = JSReceiver::IsExtensible(target);
+  if (is_extensible.IsNothing()) return Nothing<bool>();
+  // 10. If extensibleTarget is true, return booleanTrapResult.
+  if (is_extensible.FromJust()) return result;
+  // 11. Let targetProto be ? target.[[GetPrototypeOf]]().
+  Handle<Object> target_proto;
+  ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate, target_proto,
+                                   Object::GetPrototype(isolate, target),
+                                   Nothing<bool>());
+  // 12. If booleanTrapResult is true and SameValue(V, targetProto) is false,
+  if (result.FromJust() && !value->SameValue(*target_proto)) {
+    RETURN_FAILURE(
+        isolate, should_throw,
+        NewTypeError(MessageTemplate::kObjectSetPrototypeNotExtensible));
+  }
+  // 13. Return booleanTrapResult.
+  return result;
+}
+
 MaybeHandle<Object> JSProxy::GetPropertyWithHandler(Handle<JSProxy> proxy,
                                                     Handle<Object> receiver,
                                                     Handle<Name> name) {
   Isolate* isolate = proxy->GetIsolate();
 
   // TODO(rossberg): adjust once there is a story for symbols vs proxies.
   if (name->IsSymbol()) return isolate->factory()->undefined_value();
 
   Handle<Object> args[] = { receiver, name };
   return CallTrap(
@@ skipping 13030 matching lines @@
     TransitionArray::PutPrototypeTransition(map, prototype, new_map);
     Map::SetPrototype(new_map, prototype, mode);
   }
   return new_map;
 }
 
 
 Maybe<bool> JSReceiver::SetPrototype(Handle<JSReceiver> object,
                                      Handle<Object> value, bool from_javascript,
                                      ShouldThrow should_throw) {
-  if (!object->IsJSObject()) return Just(false);
-  // TODO(neis): Deal with proxies.
+  if (!object->IsJSReceiver()) return Just(false);
+  if (object->IsJSProxy()) {
+    return JSProxy::SetPrototype(Handle<JSProxy>::cast(object), value,
+                                 from_javascript, should_throw);
+  }
   return JSObject::SetPrototype(Handle<JSObject>::cast(object), value,
                                 from_javascript, should_throw);
 }
 
 
 Maybe<bool> JSObject::SetPrototype(Handle<JSObject> object,
                                    Handle<Object> value, bool from_javascript,
                                    ShouldThrow should_throw) {
   Isolate* isolate = object->GetIsolate();
 
@@ skipping 3965 matching lines @@
   if (cell->value() != *new_value) {
     cell->set_value(*new_value);
     Isolate* isolate = cell->GetIsolate();
     cell->dependent_code()->DeoptimizeDependentCodeGroup(
         isolate, DependentCode::kPropertyCellChangedGroup);
   }
 }
 
 }  // namespace internal
 }  // namespace v8