[es6] Partially implement Reflect.preventExtensions.

src/objects.cc

Index: src/objects.cc
diff --git a/src/objects.cc b/src/objects.cc
index 2b6feb5c828b139d3ada33c35e9dcefe94d64883..0bbdb9879ce797b9765beeb36a29520ec0337532 100644
--- a/src/objects.cc
+++ b/src/objects.cc
@@ -6718,13 +6718,33 @@ bool JSObject::ReferencesObject(Object* obj) {
 }
 
 
-Maybe<bool> JSObject::PreventExtensionsInternal(Handle<JSObject> object) {
+#define RETURN_FAILURE(isolate, should_throw, call) \
+  do {                                              \
+    if ((should_throw) == DONT_THROW) {             \
+      return Just(false);                           \
+    } else {                                        \
+      isolate->Throw(*isolate->factory()->call);    \
+      return Nothing<bool>();                       \
+    }                                               \
+  } while (false)
+
+
+Maybe<bool> JSReceiver::PreventExtensions(Handle<JSReceiver> object,
+                                          ShouldThrow should_throw) {
+  if (!object->IsJSObject()) return Just(false);  // TODO(proxies)

[rossberg, 2015/10/19 14:33:08]

Style nit: TODO(neis): what

[neis, 2015/10/20 07:58:35]

Done.

+  return JSObject::PreventExtensions(Handle<JSObject>::cast(object),
+                                     should_throw);
+}
+
+
+Maybe<bool> JSObject::PreventExtensions(Handle<JSObject> object,
+                                        ShouldThrow should_throw) {
   Isolate* isolate = object->GetIsolate();
 
   if (!object->map()->is_extensible()) return Just(true);
 
   if (!object->HasSloppyArgumentsElements() && !object->map()->is_observed()) {
-    return PreventExtensionsWithTransition<NONE>(object);
+    return PreventExtensionsWithTransition<NONE>(object, should_throw);
   }
 
   if (object->IsAccessCheckNeeded() &&
@@ -6732,15 +6752,16 @@ Maybe<bool> JSObject::PreventExtensionsInternal(Handle<JSObject> object) {
     isolate->ReportFailedAccessCheck(object);
     RETURN_VALUE_IF_SCHEDULED_EXCEPTION(isolate, Nothing<bool>());
     UNREACHABLE();
-    return Just(false);
+    RETURN_FAILURE(isolate, should_throw,
+                   NewTypeError(MessageTemplate::kNoAccess));
   }
 
   if (object->IsJSGlobalProxy()) {
     PrototypeIterator iter(isolate, object);
     if (iter.IsAtEnd()) return Just(true);
     DCHECK(PrototypeIterator::GetCurrent(iter)->IsJSGlobalObject());
-    return PreventExtensionsInternal(
-        PrototypeIterator::GetCurrent<JSObject>(iter));
+    return PreventExtensions(PrototypeIterator::GetCurrent<JSObject>(iter),
+                             should_throw);
   }
 
   // It's not possible to seal objects with external array elements
@@ -6777,21 +6798,6 @@ Maybe<bool> JSObject::PreventExtensionsInternal(Handle<JSObject> object) {
 }
 
 
-static MaybeHandle<Object> ReturnObjectOrThrowTypeError(
-    Handle<JSObject> object, Maybe<bool> maybe, MessageTemplate::Template msg) {
-  if (!maybe.IsJust()) return MaybeHandle<Object>();
-  if (maybe.FromJust()) return object;
-  Isolate* isolate = object->GetIsolate();
-  THROW_NEW_ERROR(isolate, NewTypeError(msg), Object);
-}
-
-
-MaybeHandle<Object> JSObject::PreventExtensions(Handle<JSObject> object) {
-  return ReturnObjectOrThrowTypeError(object, PreventExtensionsInternal(object),
-                                      MessageTemplate::kCannotPreventExt);
-}
-
-
 bool JSObject::IsExtensible(Handle<JSObject> object) {
   Isolate* isolate = object->GetIsolate();
   if (object->IsAccessCheckNeeded() &&
@@ -6833,7 +6839,8 @@ static void ApplyAttributesToDictionary(Dictionary* dictionary,
 
 
 template <PropertyAttributes attrs>
-Maybe<bool> JSObject::PreventExtensionsWithTransition(Handle<JSObject> object) {
+Maybe<bool> JSObject::PreventExtensionsWithTransition(
+    Handle<JSObject> object, ShouldThrow should_throw) {
   STATIC_ASSERT(attrs == NONE || attrs == SEALED || attrs == FROZEN);
 
   // Sealing/freezing sloppy arguments should be handled elsewhere.
@@ -6846,6 +6853,8 @@ Maybe<bool> JSObject::PreventExtensionsWithTransition(Handle<JSObject> object) {
     isolate->ReportFailedAccessCheck(object);
     RETURN_VALUE_IF_SCHEDULED_EXCEPTION(isolate, Nothing<bool>());
     UNREACHABLE();
+    RETURN_FAILURE(isolate, should_throw,
+                   NewTypeError(MessageTemplate::kNoAccess));
   }
 
   if (object->IsJSGlobalProxy()) {
@@ -6853,7 +6862,7 @@ Maybe<bool> JSObject::PreventExtensionsWithTransition(Handle<JSObject> object) {
     if (iter.IsAtEnd()) return Just(true);
     DCHECK(PrototypeIterator::GetCurrent(iter)->IsJSGlobalObject());
     return PreventExtensionsWithTransition<attrs>(
-        PrototypeIterator::GetCurrent<JSObject>(iter));
+        PrototypeIterator::GetCurrent<JSObject>(iter), should_throw);
   }
 
   // It's not possible to seal or freeze objects with external array elements
@@ -6940,16 +6949,18 @@ Maybe<bool> JSObject::PreventExtensionsWithTransition(Handle<JSObject> object) {
 
 
 MaybeHandle<Object> JSObject::Freeze(Handle<JSObject> object) {
-  return ReturnObjectOrThrowTypeError(
-      object, PreventExtensionsWithTransition<FROZEN>(object),
-      MessageTemplate::kCannotPreventExt);
+  ASSIGN_OR_RETURN(bool, result, PreventExtensionsWithTransition<FROZEN>(
+                                     object, THROW_ON_ERROR),
+                   MaybeHandle<Object>());
+  return object;
 }
 
 
 MaybeHandle<Object> JSObject::Seal(Handle<JSObject> object) {
-  return ReturnObjectOrThrowTypeError(
-      object, PreventExtensionsWithTransition<SEALED>(object),
-      MessageTemplate::kCannotPreventExt);
+  ASSIGN_OR_RETURN(bool, result, PreventExtensionsWithTransition<SEALED>(
+                                     object, THROW_ON_ERROR),
+                   MaybeHandle<Object>());
+  return object;
 }