[cleanup] [proxies] Unify style of recently written code

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 768 matching lines @@
     return Object::GetProperty(&it, language_mode);
   }
   // 8. Let trapResult be ? Call(trap, handler, «target, P, Receiver»).
   Handle<Object> trap_result;
   Handle<Object> args[] = {target, name, receiver};
   ASSIGN_RETURN_ON_EXCEPTION(
       isolate, trap_result,
       Execution::Call(isolate, trap, handler, arraysize(args), args), Object);
   // 9. Let targetDesc be ? target.[[GetOwnProperty]](P).
   PropertyDescriptor target_desc;
-  bool target_found =
+  Maybe<bool> target_found =
       JSReceiver::GetOwnPropertyDescriptor(isolate, target, name, &target_desc);
-  if (isolate->has_pending_exception()) return MaybeHandle<Object>();
+  MAYBE_RETURN_NULL(target_found);
   // 10. If targetDesc is not undefined, then
-  if (target_found) {
+  if (target_found.FromJust()) {
     // 10.a. If IsDataDescriptor(targetDesc) and targetDesc.[[Configurable]] is
     //       false and targetDesc.[[Writable]] is false, then
     // 10.a.i. If SameValue(trapResult, targetDesc.[[Value]]) is false,
     //        throw a TypeError exception.
     bool inconsistent = PropertyDescriptor::IsDataDescriptor(&target_desc) &&
                         !target_desc.configurable() &&
                         !target_desc.writable() &&
                         !trap_result->SameValue(*target_desc.value());
     // 10.b. If IsAccessorDescriptor(targetDesc) and targetDesc.[[Configurable]]
     //       is false and targetDesc.[[Get]] is undefined, then
@@ skipping 181 matching lines @@
       Execution::Call(isolate, trap, handler, arraysize(argv), argv), Object);
   // 8. If Type(handlerProto) is neither Object nor Null, throw a TypeError.
   if (!(handler_proto->IsJSReceiver() || handler_proto->IsNull())) {
     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>();
+  MAYBE_RETURN_NULL(is_extensible);
   // 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, target_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,
@@ skipping 2988 matching lines @@
         PropertyDetails details = own_lookup.property_details();
         if (details.IsReadOnly()) {
           return WriteToReadOnlyProperty(&own_lookup, value, should_throw);
         }
         return SetDataProperty(&own_lookup, value);
       }
 
       case LookupIterator::INTERCEPTOR:
       case LookupIterator::JSPROXY: {
         PropertyDescriptor desc;
-        bool owned = JSReceiver::GetOwnPropertyDescriptor(&own_lookup, &desc);
-        if (isolate->has_pending_exception()) return Nothing<bool>();
-        if (!owned) {
+        Maybe<bool> owned =
+            JSReceiver::GetOwnPropertyDescriptor(&own_lookup, &desc);
+        MAYBE_RETURN(owned, Nothing<bool>());
+        if (!owned.FromJust()) {
           return JSReceiver::CreateDataProperty(&own_lookup, value,
                                                 should_throw);
         }
         if (PropertyDescriptor::IsAccessorDescriptor(&desc) ||
             !desc.writable()) {
           return RedefineIncompatibleProperty(isolate, it->GetName(), value,
                                               should_throw);
         }
 
         PropertyDescriptor value_desc;
         value_desc.set_value(value);
-        bool result = JSReceiver::DefineOwnProperty(
-            isolate, receiver, it->GetName(), &value_desc, should_throw);
-        if (isolate->has_pending_exception()) return Nothing<bool>();
-        return Just(result);
+        return JSReceiver::DefineOwnProperty(isolate, receiver, it->GetName(),
+                                             &value_desc, should_throw);
       }
 
       case LookupIterator::NOT_FOUND:
       case LookupIterator::TRANSITION:
         UNREACHABLE();
     }
   }
 
   return JSObject::AddDataProperty(&own_lookup, value, NONE, should_throw,
                                    store_mode);
@@ skipping 623 matching lines @@
   Handle<Object> args[] = {target, name};
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
       isolate, trap_result_obj,
       Execution::Call(isolate, trap, handler, arraysize(args), args),
       Nothing<bool>());
   bool boolean_trap_result = trap_result_obj->BooleanValue();
   // 9. If booleanTrapResult is false, then:
   if (!boolean_trap_result) {
     // 9a. Let targetDesc be ? target.[[GetOwnProperty]](P).
     PropertyDescriptor target_desc;
-    bool target_found = JSReceiver::GetOwnPropertyDescriptor(
+    Maybe<bool> target_found = JSReceiver::GetOwnPropertyDescriptor(
         isolate, target, name, &target_desc);
+    MAYBE_RETURN(target_found, Nothing<bool>());
     // 9b. If targetDesc is not undefined, then:
-    if (target_found) {
+    if (target_found.FromJust()) {
       // 9b i. If targetDesc.[[Configurable]] is false, throw a TypeError
       //       exception.
       if (!target_desc.configurable()) {
         isolate->Throw(*isolate->factory()->NewTypeError(
             MessageTemplate::kProxyTargetPropNotConfigurable, name));
         return Nothing<bool>();
       }
       // 9b ii. Let extensibleTarget be ? IsExtensible(target).
-      Maybe<bool> maybe_extensible = JSReceiver::IsExtensible(target);
-      if (maybe_extensible.IsNothing()) return maybe_extensible;
-      bool extensible_target = maybe_extensible.FromJust();
+      Maybe<bool> extensible_target = JSReceiver::IsExtensible(target);
+      MAYBE_RETURN(extensible_target, Nothing<bool>());
       // 9b iii. If extensibleTarget is false, throw a TypeError exception.
-      if (!extensible_target) {
+      if (!extensible_target.FromJust()) {
         isolate->Throw(*isolate->factory()->NewTypeError(
             MessageTemplate::kProxyTargetNotExtensible));
         return Nothing<bool>();
       }
     }
   }
   // 10. Return booleanTrapResult.
   return Just(boolean_trap_result);
 }
 
 
 Maybe<bool> JSProxy::SetProperty(Handle<JSProxy> proxy, Handle<Name> name,
                                  Handle<Object> value, Handle<Object> receiver,
                                  LanguageMode language_mode) {
   Isolate* isolate = proxy->GetIsolate();
   Factory* factory = isolate->factory();
   Handle<String> trap_name = factory->set_string();
   ShouldThrow should_throw =
       is_sloppy(language_mode) ? DONT_THROW : THROW_ON_ERROR;
 
   if (proxy->IsRevoked()) {
     isolate->Throw(
         *factory->NewTypeError(MessageTemplate::kProxyRevoked, trap_name));
     return Nothing<bool>();
   }
   Handle<JSReceiver> target(proxy->target(), isolate);
   Handle<JSReceiver> handler(JSReceiver::cast(proxy->handler()), isolate);
 
   Handle<Object> trap;
-  ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate, trap, GetTrap(proxy, trap_name),
-                                   Nothing<bool>());
+  ASSIGN_RETURN_ON_EXCEPTION_VALUE(
+      isolate, trap, Object::GetMethod(handler, trap_name), Nothing<bool>());
   if (trap->IsUndefined()) {
     LookupIterator it =
         LookupIterator::PropertyOrElement(isolate, receiver, name, target);
     return Object::SetSuperProperty(&it, value, language_mode,
                                     Object::MAY_BE_STORE_FROM_KEYED);
   }
 
   Handle<Object> trap_result;
   Handle<Object> args[] = {target, name, value, receiver};
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
       isolate, trap_result,
       Execution::Call(isolate, trap, handler, arraysize(args), args),
       Nothing<bool>());
   if (!trap_result->BooleanValue()) {
     RETURN_FAILURE(isolate, should_throw,
                    NewTypeError(MessageTemplate::kProxyHandlerReturned, handler,
                                 factory->false_string(), trap_name));
   }
 
   // Enforce the invariant.
   PropertyDescriptor target_desc;
-  bool owned =
+  Maybe<bool> owned =
       JSReceiver::GetOwnPropertyDescriptor(isolate, target, name, &target_desc);
-  if (isolate->has_pending_exception()) return Nothing<bool>();
-  if (owned) {
+  MAYBE_RETURN(owned, Nothing<bool>());
+  if (owned.FromJust()) {
     bool inconsistent =
         (PropertyDescriptor::IsDataDescriptor(&target_desc) &&
          !target_desc.configurable() && !target_desc.writable() &&
          !value->SameValue(*target_desc.value())) ||
         (PropertyDescriptor::IsAccessorDescriptor(&target_desc) &&
          !target_desc.configurable() && target_desc.set()->IsUndefined());
     if (inconsistent) {
       isolate->Throw(*isolate->factory()->NewTypeError(
           MessageTemplate::kProxyTrapViolatesInvariant, trap_name));
       return Nothing<bool>();
@@ skipping 14 matching lines @@
 
   if (proxy->IsRevoked()) {
     isolate->Throw(
         *factory->NewTypeError(MessageTemplate::kProxyRevoked, trap_name));
     return Nothing<bool>();
   }
   Handle<JSReceiver> target(proxy->target(), isolate);
   Handle<JSReceiver> handler(JSReceiver::cast(proxy->handler()), isolate);
 
   Handle<Object> trap;
-  ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate, trap, GetTrap(proxy, trap_name),
-                                   Nothing<bool>());
+  ASSIGN_RETURN_ON_EXCEPTION_VALUE(
+      isolate, trap, Object::GetMethod(handler, trap_name), Nothing<bool>());
   if (trap->IsUndefined()) {
     return JSReceiver::DeletePropertyOrElement(target, name, language_mode);
   }
 
   Handle<Object> trap_result;
   Handle<Object> args[] = {target, name};
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
       isolate, trap_result,
       Execution::Call(isolate, trap, handler, arraysize(args), args),
       Nothing<bool>());
   if (!trap_result->BooleanValue()) {
     RETURN_FAILURE(isolate, should_throw,
                    NewTypeError(MessageTemplate::kProxyHandlerReturned, handler,
                                 factory->false_string(), trap_name));
   }
 
   // Enforce the invariant.
   PropertyDescriptor target_desc;
-  bool owned =
+  Maybe<bool> owned =
       JSReceiver::GetOwnPropertyDescriptor(isolate, target, name, &target_desc);
-  if (isolate->has_pending_exception()) return Nothing<bool>();
-  if (owned && !target_desc.configurable()) {
+  MAYBE_RETURN(owned, Nothing<bool>());
+  if (owned.FromJust() && !target_desc.configurable()) {
     isolate->Throw(*factory->NewTypeError(
         MessageTemplate::kProxyDeletePropertyViolatesInvariant, name));
     return Nothing<bool>();
   }
   return Just(true);
 }
 
 
 // static
 MaybeHandle<Context> JSProxy::GetFunctionRealm(Handle<JSProxy> proxy) {
@@ skipping 33 matching lines @@
   }
 
   return JSObject::GetFunctionRealm(Handle<JSObject>::cast(receiver));
 }
 
 
 Maybe<PropertyAttributes> JSProxy::GetPropertyAttributes(LookupIterator* it) {
   Isolate* isolate = it->isolate();
   HandleScope scope(isolate);
   PropertyDescriptor desc;
-  bool found = JSProxy::GetOwnPropertyDescriptor(
+  Maybe<bool> found = JSProxy::GetOwnPropertyDescriptor(
       isolate, it->GetHolder<JSProxy>(), it->GetName(), &desc);
-  if (isolate->has_pending_exception()) return Nothing<PropertyAttributes>();
-  if (!found) return Just(ABSENT);
+  MAYBE_RETURN(found, Nothing<PropertyAttributes>());
+  if (!found.FromJust()) return Just(ABSENT);
   return Just(desc.ToAttributes());
 }
 
 
-MaybeHandle<Object> JSProxy::GetTrap(Handle<JSProxy> proxy,
-                                     Handle<String> trap_name) {
-  DCHECK(!proxy->IsRevoked());
-  Isolate* isolate = proxy->GetIsolate();
-  Handle<JSReceiver> handler(JSReceiver::cast(proxy->handler()), isolate);
-  return Object::GetMethod(handler, trap_name);
-}
-
-
 void JSObject::AllocateStorageForMap(Handle<JSObject> object, Handle<Map> map) {
   DCHECK(object->map()->GetInObjectProperties() ==
          map->GetInObjectProperties());
   ElementsKind obj_kind = object->map()->elements_kind();
   ElementsKind map_kind = map->elements_kind();
   if (map_kind != obj_kind) {
     ElementsKind to_kind = GetMoreGeneralElementsKind(map_kind, obj_kind);
     if (IsDictionaryElementsKind(obj_kind)) {
       to_kind = obj_kind;
     }
@@ skipping 1223 matching lines @@
   // 2. Let key be ToPropertyKey(P).
   // 3. ReturnIfAbrupt(key).
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, key, ToPropertyKey(isolate, key));
   // 4. Let desc be ToPropertyDescriptor(Attributes).
   // 5. ReturnIfAbrupt(desc).
   PropertyDescriptor desc;
   if (!PropertyDescriptor::ToPropertyDescriptor(isolate, attributes, &desc)) {
     return isolate->heap()->exception();
   }
   // 6. Let success be DefinePropertyOrThrow(O,key, desc).
-  bool success = DefineOwnProperty(isolate, Handle<JSReceiver>::cast(object),
-                                   key, &desc, THROW_ON_ERROR);
+  Maybe<bool> success = DefineOwnProperty(
+      isolate, Handle<JSReceiver>::cast(object), key, &desc, THROW_ON_ERROR);
   // 7. ReturnIfAbrupt(success).
-  if (isolate->has_pending_exception()) return isolate->heap()->exception();
-  CHECK(success == true);
+  MAYBE_RETURN(success, isolate->heap()->exception());
+  CHECK(success.FromJust());
   // 8. Return O.
   return *object;
 }
 
 
 // ES6 19.1.2.3.1
 // static
 Object* JSReceiver::DefineProperties(Isolate* isolate, Handle<Object> object,
                                      Handle<Object> properties) {
   // 1. If Type(O) is not Object, throw a TypeError exception.
@@ skipping 49 matching lines @@
     //       desc to the end of descriptors.
     descriptors[descriptors_index].set_name(next_key);
     descriptors_index++;
   }
   // 8. For each pair from descriptors in list order,
   for (size_t i = 0; i < descriptors_index; ++i) {
     PropertyDescriptor* desc = &descriptors[i];
     // 8a. Let P be the first element of pair.
     // 8b. Let desc be the second element of pair.
     // 8c. Let status be DefinePropertyOrThrow(O, P, desc).
-    bool status = DefineOwnProperty(isolate, Handle<JSReceiver>::cast(object),
-                                    desc->name(), desc, THROW_ON_ERROR);
+    Maybe<bool> status =
+        DefineOwnProperty(isolate, Handle<JSReceiver>::cast(object),
+                          desc->name(), desc, THROW_ON_ERROR);
     // 8d. ReturnIfAbrupt(status).
-    if (isolate->has_pending_exception()) return isolate->heap()->exception();
-    CHECK(status == true);
+    MAYBE_RETURN(status, isolate->heap()->exception());
+    CHECK(status.FromJust());
   }
   // 9. Return o.
   return *object;
 }
 
 
 // static
-bool JSReceiver::DefineOwnProperty(Isolate* isolate, Handle<JSReceiver> object,
-                                   Handle<Object> key, PropertyDescriptor* desc,
-                                   ShouldThrow should_throw) {
+Maybe<bool> JSReceiver::DefineOwnProperty(Isolate* isolate,
+                                          Handle<JSReceiver> object,
+                                          Handle<Object> key,
+                                          PropertyDescriptor* desc,
+                                          ShouldThrow should_throw) {
   if (object->IsJSArray()) {
     return JSArray::DefineOwnProperty(isolate, Handle<JSArray>::cast(object),
                                       key, desc, should_throw);
   }
   if (object->IsJSProxy()) {
     return JSProxy::DefineOwnProperty(isolate, Handle<JSProxy>::cast(object),
                                       key, desc, should_throw);
   }
   // TODO(jkummerow): Support Modules (ES6 9.4.6.6)
 
   // OrdinaryDefineOwnProperty, by virtue of calling
   // DefineOwnPropertyIgnoreAttributes, can handle arguments (ES6 9.4.4.2)
   // and IntegerIndexedExotics (ES6 9.4.5.3), with one exception:
   // TODO(jkummerow): Setting an indexed accessor on a typed array should throw.
   return OrdinaryDefineOwnProperty(isolate, Handle<JSObject>::cast(object), key,
                                    desc, should_throw);
 }
 
 
 // static
-bool JSReceiver::OrdinaryDefineOwnProperty(Isolate* isolate,
-                                           Handle<JSObject> object,
-                                           Handle<Object> key,
-                                           PropertyDescriptor* desc,
-                                           ShouldThrow should_throw) {
+Maybe<bool> JSReceiver::OrdinaryDefineOwnProperty(Isolate* isolate,
+                                                  Handle<JSObject> object,
+                                                  Handle<Object> key,
+                                                  PropertyDescriptor* desc,
+                                                  ShouldThrow should_throw) {
   bool success = false;
   DCHECK(key->IsName() || key->IsNumber());  // |key| is a PropertyKey...
   LookupIterator it = LookupIterator::PropertyOrElement(
       isolate, object, key, &success, LookupIterator::HIDDEN);
   DCHECK(success);  // ...so creating a LookupIterator can't fail.
 
   // Deal with access checks first.
   if (it.state() == LookupIterator::ACCESS_CHECK) {
     if (!it.HasAccess()) {
       isolate->ReportFailedAccessCheck(it.GetHolder<JSObject>());
-      RETURN_VALUE_IF_SCHEDULED_EXCEPTION(isolate, false);
-      return false;
+      RETURN_VALUE_IF_SCHEDULED_EXCEPTION(isolate, Nothing<bool>());
+      return Just(false);
     }
     it.Next();
   }
 
   return OrdinaryDefineOwnProperty(&it, desc, should_throw);
 }
 
 
 // ES6 9.1.6.1
 // static
-bool JSReceiver::OrdinaryDefineOwnProperty(LookupIterator* it,
-                                           PropertyDescriptor* desc,
-                                           ShouldThrow should_throw) {
+Maybe<bool> JSReceiver::OrdinaryDefineOwnProperty(LookupIterator* it,
+                                                  PropertyDescriptor* desc,
+                                                  ShouldThrow should_throw) {
   Isolate* isolate = it->isolate();
   // 1. Let current be O.[[GetOwnProperty]](P).
   // 2. ReturnIfAbrupt(current).
   PropertyDescriptor current;
-  if (!GetOwnPropertyDescriptor(it, &current) &&
-      isolate->has_pending_exception()) {
-    return false;
-  }
+  MAYBE_RETURN(GetOwnPropertyDescriptor(it, &current), Nothing<bool>());
+
   // TODO(jkummerow/verwaest): It would be nice if we didn't have to reset
   // the iterator every time. Currently, the reasons why we need it are:
   // - handle interceptors correctly
   // - handle accessors correctly (which might change the holder's map)
   it->Restart();
   // 3. Let extensible be the value of the [[Extensible]] internal slot of O.
   Handle<JSObject> object = Handle<JSObject>::cast(it->GetReceiver());
   bool extensible = JSObject::IsExtensible(object);
 
   return ValidateAndApplyPropertyDescriptor(isolate, it, extensible, desc,
                                             &current, should_throw);
 }
 
 
 // ES6 9.1.6.2
 // static
-bool JSReceiver::IsCompatiblePropertyDescriptor(Isolate* isolate,
-                                                bool extensible,
-                                                PropertyDescriptor* desc,
-                                                PropertyDescriptor* current,
-                                                Handle<Name> property_name) {
+Maybe<bool> JSReceiver::IsCompatiblePropertyDescriptor(
+    Isolate* isolate, bool extensible, PropertyDescriptor* desc,
+    PropertyDescriptor* current, Handle<Name> property_name) {
   // 1. Return ValidateAndApplyPropertyDescriptor(undefined, undefined,
   //    Extensible, Desc, Current).
   return ValidateAndApplyPropertyDescriptor(
       isolate, NULL, extensible, desc, current, THROW_ON_ERROR, property_name);
 }
 
 
 // ES6 9.1.6.3
 // static
-bool JSReceiver::ValidateAndApplyPropertyDescriptor(
+Maybe<bool> JSReceiver::ValidateAndApplyPropertyDescriptor(
     Isolate* isolate, LookupIterator* it, bool extensible,
     PropertyDescriptor* desc, PropertyDescriptor* current,
     ShouldThrow should_throw, Handle<Name> property_name) {
   // We either need a LookupIterator, or a property name.
   DCHECK((it == NULL) != property_name.is_null());
   Handle<JSObject> object;
   if (it != NULL) object = Handle<JSObject>::cast(it->GetReceiver());
   bool desc_is_data_descriptor = PropertyDescriptor::IsDataDescriptor(desc);
   bool desc_is_accessor_descriptor =
       PropertyDescriptor::IsAccessorDescriptor(desc);
   bool desc_is_generic_descriptor =
       PropertyDescriptor::IsGenericDescriptor(desc);
   // 1. (Assert)
   // 2. If current is undefined, then
   if (current->is_empty()) {
     // 2a. If extensible is false, return false.
     if (!extensible) {
-      if (should_throw == THROW_ON_ERROR) {
-        isolate->Throw(*isolate->factory()->NewTypeError(
-            MessageTemplate::kDefineDisallowed,
-            it != NULL ? it->GetName() : property_name));
-      }
-      return false;
+      RETURN_FAILURE(isolate, should_throw,
+                     NewTypeError(MessageTemplate::kDefineDisallowed,
+                                  it != NULL ? it->GetName() : property_name));
     }
     // 2c. If IsGenericDescriptor(Desc) or IsDataDescriptor(Desc) is true, then:
     // (This is equivalent to !IsAccessorDescriptor(desc).)
     DCHECK((desc_is_generic_descriptor || desc_is_data_descriptor) ==
            !desc_is_accessor_descriptor);
     if (!desc_is_accessor_descriptor) {
       // 2c i. If O is not undefined, create an own data property named P of
       // object O whose [[Value]], [[Writable]], [[Enumerable]] and
       // [[Configurable]] attribute values are described by Desc. If the value
       // of an attribute field of Desc is absent, the attribute of the newly
       // created property is set to its default value.
       if (it != NULL) {
         if (!desc->has_writable()) desc->set_writable(false);
         if (!desc->has_enumerable()) desc->set_enumerable(false);
         if (!desc->has_configurable()) desc->set_configurable(false);
         Handle<Object> value(
             desc->has_value()
                 ? desc->value()
                 : Handle<Object>::cast(isolate->factory()->undefined_value()));
         MaybeHandle<Object> result =
             JSObject::DefineOwnPropertyIgnoreAttributes(
                 it, value, desc->ToAttributes(), JSObject::DONT_FORCE_FIELD);
-        if (result.is_null()) return false;
+        if (result.is_null()) return Nothing<bool>();
       }
     } else {
       // 2d. Else Desc must be an accessor Property Descriptor,
       DCHECK(desc_is_accessor_descriptor);
       // 2d i. If O is not undefined, create an own accessor property named P
       // of object O whose [[Get]], [[Set]], [[Enumerable]] and
       // [[Configurable]] attribute values are described by Desc. If the value
       // of an attribute field of Desc is absent, the attribute of the newly
       // created property is set to its default value.
       if (it != NULL) {
         if (!desc->has_enumerable()) desc->set_enumerable(false);
         if (!desc->has_configurable()) desc->set_configurable(false);
         Handle<Object> getter(
             desc->has_get()
                 ? desc->get()
                 : Handle<Object>::cast(isolate->factory()->null_value()));
         Handle<Object> setter(
             desc->has_set()
                 ? desc->set()
                 : Handle<Object>::cast(isolate->factory()->null_value()));
         MaybeHandle<Object> result =
             JSObject::DefineAccessor(it, getter, setter, desc->ToAttributes());
-        if (result.is_null()) return false;
+        if (result.is_null()) return Nothing<bool>();
       }
     }
     // 2e. Return true.
-    return true;
+    return Just(true);
   }
   // 3. Return true, if every field in Desc is absent.
   // 4. Return true, if every field in Desc also occurs in current and the
   // value of every field in Desc is the same value as the corresponding field
   // in current when compared using the SameValue algorithm.
   if ((!desc->has_enumerable() ||
        desc->enumerable() == current->enumerable()) &&
       (!desc->has_configurable() ||
        desc->configurable() == current->configurable()) &&
       (!desc->has_value() ||
        (current->has_value() && current->value()->SameValue(*desc->value()))) &&
       (!desc->has_writable() ||
        (current->has_writable() && current->writable() == desc->writable())) &&
       (!desc->has_get() ||
        (current->has_get() && current->get()->SameValue(*desc->get()))) &&
       (!desc->has_set() ||
        (current->has_set() && current->set()->SameValue(*desc->set())))) {
-    return true;
+    return Just(true);
   }
   // 5. If the [[Configurable]] field of current is false, then
   if (!current->configurable()) {
     // 5a. Return false, if the [[Configurable]] field of Desc is true.
     if (desc->has_configurable() && desc->configurable()) {
-      if (should_throw == THROW_ON_ERROR) {
-        isolate->Throw(*isolate->factory()->NewTypeError(
-            MessageTemplate::kRedefineDisallowed,
-            it != NULL ? it->GetName() : property_name));
-      }
-      return false;
+      RETURN_FAILURE(isolate, should_throw,
+                     NewTypeError(MessageTemplate::kRedefineDisallowed,
+                                  it != NULL ? it->GetName() : property_name));
     }
     // 5b. Return false, if the [[Enumerable]] field of Desc is present and the
     // [[Enumerable]] fields of current and Desc are the Boolean negation of
     // each other.
     if (desc->has_enumerable() && desc->enumerable() != current->enumerable()) {
-      if (should_throw == THROW_ON_ERROR) {
-        isolate->Throw(*isolate->factory()->NewTypeError(
-            MessageTemplate::kRedefineDisallowed,
-            it != NULL ? it->GetName() : property_name));
-      }
-      return false;
+      RETURN_FAILURE(isolate, should_throw,
+                     NewTypeError(MessageTemplate::kRedefineDisallowed,
+                                  it != NULL ? it->GetName() : property_name));
     }
   }
 
   bool current_is_data_descriptor =
       PropertyDescriptor::IsDataDescriptor(current);
   // 6. If IsGenericDescriptor(Desc) is true, no further validation is required.
   if (desc_is_generic_descriptor) {
     // Nothing to see here.
 
     // 7. Else if IsDataDescriptor(current) and IsDataDescriptor(Desc) have
     // different results, then:
   } else if (current_is_data_descriptor != desc_is_data_descriptor) {
     // 7a. Return false, if the [[Configurable]] field of current is false.
     if (!current->configurable()) {
-      if (should_throw == THROW_ON_ERROR) {
-        isolate->Throw(*isolate->factory()->NewTypeError(
-            MessageTemplate::kRedefineDisallowed,
-            it != NULL ? it->GetName() : property_name));
-      }
-      return false;
+      RETURN_FAILURE(isolate, should_throw,
+                     NewTypeError(MessageTemplate::kRedefineDisallowed,
+                                  it != NULL ? it->GetName() : property_name));
     }
     // 7b. If IsDataDescriptor(current) is true, then:
     if (current_is_data_descriptor) {
       // 7b i. If O is not undefined, convert the property named P of object O
       // from a data property to an accessor property. Preserve the existing
       // values of the converted property's [[Configurable]] and [[Enumerable]]
       // attributes and set the rest of the property's attributes to their
       // default values.
       // --> Folded into step 10.
     } else {
       // 7c i. If O is not undefined, convert the property named P of object O
       // from an accessor property to a data property. Preserve the existing
       // values of the converted property’s [[Configurable]] and [[Enumerable]]
       // attributes and set the rest of the property’s attributes to their
       // default values.
       // --> Folded into step 10.
     }
 
     // 8. Else if IsDataDescriptor(current) and IsDataDescriptor(Desc) are both
     // true, then:
   } else if (current_is_data_descriptor && desc_is_data_descriptor) {
     // 8a. If the [[Configurable]] field of current is false, then:
     if (!current->configurable()) {
       // [Strong mode] Disallow changing writable -> readonly for
       // non-configurable properties.
       if (it != NULL && current->writable() && desc->has_writable() &&
           !desc->writable() && object->map()->is_strong()) {
-        if (should_throw == THROW_ON_ERROR) {
-          isolate->Throw(*isolate->factory()->NewTypeError(
-              MessageTemplate::kStrongRedefineDisallowed, object,
-              it->GetName()));
-        }
-        return false;
+        RETURN_FAILURE(isolate, should_throw,
+                       NewTypeError(MessageTemplate::kStrongRedefineDisallowed,
+                                    object, it->GetName()));
       }
       // 8a i. Return false, if the [[Writable]] field of current is false and
       // the [[Writable]] field of Desc is true.
       if (!current->writable() && desc->has_writable() && desc->writable()) {
-        if (should_throw == THROW_ON_ERROR) {
-          isolate->Throw(*isolate->factory()->NewTypeError(
-              MessageTemplate::kRedefineDisallowed,
-              it != NULL ? it->GetName() : property_name));
-        }
-        return false;
+        RETURN_FAILURE(
+            isolate, should_throw,
+            NewTypeError(MessageTemplate::kRedefineDisallowed,
+                         it != NULL ? it->GetName() : property_name));
       }
       // 8a ii. If the [[Writable]] field of current is false, then:
       if (!current->writable()) {
         // 8a ii 1. Return false, if the [[Value]] field of Desc is present and
         // SameValue(Desc.[[Value]], current.[[Value]]) is false.
         if (desc->has_value() && !desc->value()->SameValue(*current->value())) {
-          if (should_throw == THROW_ON_ERROR) {
-            isolate->Throw(*isolate->factory()->NewTypeError(
-                MessageTemplate::kRedefineDisallowed,
-                it != NULL ? it->GetName() : property_name));
-          }
-          return false;
+          RETURN_FAILURE(
+              isolate, should_throw,
+              NewTypeError(MessageTemplate::kRedefineDisallowed,
+                           it != NULL ? it->GetName() : property_name));
         }
       }
     }
   } else {
     // 9. Else IsAccessorDescriptor(current) and IsAccessorDescriptor(Desc)
     // are both true,
     DCHECK(PropertyDescriptor::IsAccessorDescriptor(current) &&
            desc_is_accessor_descriptor);
     // 9a. If the [[Configurable]] field of current is false, then:
     if (!current->configurable()) {
       // 9a i. Return false, if the [[Set]] field of Desc is present and
       // SameValue(Desc.[[Set]], current.[[Set]]) is false.
       if (desc->has_set() && !desc->set()->SameValue(*current->set())) {
-        if (should_throw == THROW_ON_ERROR) {
-          isolate->Throw(*isolate->factory()->NewTypeError(
-              MessageTemplate::kRedefineDisallowed,
-              it != NULL ? it->GetName() : property_name));
-        }
-        return false;
+        RETURN_FAILURE(
+            isolate, should_throw,
+            NewTypeError(MessageTemplate::kRedefineDisallowed,
+                         it != NULL ? it->GetName() : property_name));
       }
       // 9a ii. Return false, if the [[Get]] field of Desc is present and
       // SameValue(Desc.[[Get]], current.[[Get]]) is false.
       if (desc->has_get() && !desc->get()->SameValue(*current->get())) {
-        if (should_throw == THROW_ON_ERROR) {
-          isolate->Throw(*isolate->factory()->NewTypeError(
-              MessageTemplate::kRedefineDisallowed,
-              it != NULL ? it->GetName() : property_name));
-        }
-        return false;
+        RETURN_FAILURE(
+            isolate, should_throw,
+            NewTypeError(MessageTemplate::kRedefineDisallowed,
+                         it != NULL ? it->GetName() : property_name));
       }
     }
   }
 
   // 10. If O is not undefined, then:
   if (it != NULL) {
     // 10a. For each field of Desc that is present, set the corresponding
     // attribute of the property named P of object O to the value of the field.
     PropertyAttributes attrs = NONE;
 
@@ skipping 21 matching lines @@
             attrs | (current->writable() ? NONE : READ_ONLY));
       }
       Handle<Object> value(
           desc->has_value() ? desc->value()
                             : current->has_value()
                                   ? current->value()
                                   : Handle<Object>::cast(
                                         isolate->factory()->undefined_value()));
       MaybeHandle<Object> result = JSObject::DefineOwnPropertyIgnoreAttributes(
           it, value, attrs, JSObject::DONT_FORCE_FIELD);
-      if (result.is_null()) return false;
+      if (result.is_null()) return Nothing<bool>();
     } else {
       DCHECK(desc_is_accessor_descriptor ||
              (desc_is_generic_descriptor &&
               PropertyDescriptor::IsAccessorDescriptor(current)));
       Handle<Object> getter(
           desc->has_get()
               ? desc->get()
               : current->has_get()
                     ? current->get()
                     : Handle<Object>::cast(isolate->factory()->null_value()));
       Handle<Object> setter(
           desc->has_set()
               ? desc->set()
               : current->has_set()
                     ? current->set()
                     : Handle<Object>::cast(isolate->factory()->null_value()));
       MaybeHandle<Object> result =
           JSObject::DefineAccessor(it, getter, setter, attrs);
-      if (result.is_null()) return false;
+      if (result.is_null()) return Nothing<bool>();
     }
   }
 
   // 11. Return true.
-  return true;
+  return Just(true);
 }
 
 
 // static
 Maybe<bool> JSReceiver::CreateDataProperty(LookupIterator* it,
                                            Handle<Object> value,
                                            ShouldThrow should_throw) {
   DCHECK(!it->check_prototype_chain());
   Handle<JSReceiver> receiver = Handle<JSReceiver>::cast(it->GetReceiver());
   Isolate* isolate = receiver->GetIsolate();
 
   if (receiver->IsJSObject()) {
     return JSObject::CreateDataProperty(it, value);  // Shortcut.
   }
 
   PropertyDescriptor new_desc;
   new_desc.set_value(value);
   new_desc.set_writable(true);
   new_desc.set_enumerable(true);
   new_desc.set_configurable(true);
 
-  bool result = JSReceiver::DefineOwnProperty(isolate, receiver, it->GetName(),
-                                              &new_desc, should_throw);
-  if (isolate->has_pending_exception()) return Nothing<bool>();
-  return Just(result);
+  return JSReceiver::DefineOwnProperty(isolate, receiver, it->GetName(),
+                                       &new_desc, should_throw);
 }
 
 
 Maybe<bool> JSObject::CreateDataProperty(LookupIterator* it,
                                          Handle<Object> value) {
   DCHECK(it->GetReceiver()->IsJSObject());
-  Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(it);
-  if (maybe.IsNothing()) return Nothing<bool>();
+  MAYBE_RETURN(JSReceiver::GetPropertyAttributes(it), Nothing<bool>());
 
   if (it->IsFound()) {
     if (!it->IsConfigurable()) return Just(false);
   } else {
     if (!JSObject::IsExtensible(Handle<JSObject>::cast(it->GetReceiver())))
       return Just(false);
   }
 
   RETURN_ON_EXCEPTION_VALUE(
       it->isolate(),
@@ skipping 14 matching lines @@
 }
 
 
 bool PropertyKeyToArrayIndex(Handle<Object> index_obj, uint32_t* output) {
   return PropertyKeyToArrayLength(index_obj, output) && *output != kMaxUInt32;
 }
 
 
 // ES6 9.4.2.1
 // static
-bool JSArray::DefineOwnProperty(Isolate* isolate, Handle<JSArray> o,
-                                Handle<Object> name, PropertyDescriptor* desc,
-                                ShouldThrow should_throw) {
+Maybe<bool> JSArray::DefineOwnProperty(Isolate* isolate, Handle<JSArray> o,
+                                       Handle<Object> name,
+                                       PropertyDescriptor* desc,
+                                       ShouldThrow should_throw) {
   // 1. Assert: IsPropertyKey(P) is true. ("P" is |name|.)
   // 2. If P is "length", then:
   // TODO(jkummerow): Check if we need slow string comparison.
   if (*name == isolate->heap()->length_string()) {
     // 2a. Return ArraySetLength(A, Desc).
     return ArraySetLength(isolate, o, desc, should_throw);
   }
   // 3. Else if P is an array index, then:
   uint32_t index = 0;
   if (PropertyKeyToArrayIndex(name, &index)) {
     // 3a. Let oldLenDesc be OrdinaryGetOwnProperty(A, "length").
     PropertyDescriptor old_len_desc;
-    bool success = GetOwnPropertyDescriptor(
+    Maybe<bool> success = GetOwnPropertyDescriptor(
         isolate, o, isolate->factory()->length_string(), &old_len_desc);
     // 3b. (Assert)
-    DCHECK(success);
+    DCHECK(success.FromJust());
     USE(success);
     // 3c. Let oldLen be oldLenDesc.[[Value]].
     uint32_t old_len = 0;
     CHECK(old_len_desc.value()->ToArrayLength(&old_len));
     // 3d. Let index be ToUint32(P).
     // (Already done above.)
     // 3e. (Assert)
     // 3f. If index >= oldLen and oldLenDesc.[[Writable]] is false,
     //     return false.
     if (index >= old_len && old_len_desc.has_writable() &&
         !old_len_desc.writable()) {
-      if (should_throw == THROW_ON_ERROR) {
-        isolate->Throw(*isolate->factory()->NewTypeError(
-            MessageTemplate::kDefineDisallowed, name));
-      }
-      return false;
+      RETURN_FAILURE(isolate, should_throw,
+                     NewTypeError(MessageTemplate::kDefineDisallowed, name));
     }
     // 3g. Let succeeded be OrdinaryDefineOwnProperty(A, P, Desc).
-    bool succeeded =
+    Maybe<bool> succeeded =
         OrdinaryDefineOwnProperty(isolate, o, name, desc, should_throw);
-    // 3h. (Assert)
+    // 3h. Assert: succeeded is not an abrupt completion.
+    //     In our case, if should_throw == THROW_ON_ERROR, it can be!
     // 3i. If succeeded is false, return false.
-    if (!succeeded) return false;
+    if (succeeded.IsNothing() || !succeeded.FromJust()) return succeeded;
     // 3j. If index >= oldLen, then:
     if (index >= old_len) {
       // 3j i. Set oldLenDesc.[[Value]] to index + 1.
       old_len_desc.set_value(isolate->factory()->NewNumberFromUint(index + 1));
       // 3j ii. Let succeeded be
       //        OrdinaryDefineOwnProperty(A, "length", oldLenDesc).
-      OrdinaryDefineOwnProperty(isolate, o, isolate->factory()->length_string(),
-                                &old_len_desc, should_throw);
-      // 3j iii. (Assert)
+      succeeded = OrdinaryDefineOwnProperty(isolate, o,
+                                            isolate->factory()->length_string(),
+                                            &old_len_desc, should_throw);
+      // 3j iii. Assert: succeeded is true.
+      DCHECK(succeeded.FromJust());
+      USE(succeeded);
     }
     // 3k. Return true.
-    return true;
+    return Just(true);
   }
 
   // 4. Return OrdinaryDefineOwnProperty(A, P, Desc).
   return OrdinaryDefineOwnProperty(isolate, o, name, desc, should_throw);
 }
 
 
 // Part of ES6 9.4.2.4 ArraySetLength.
 // static
 bool JSArray::AnythingToArrayLength(Isolate* isolate,
@@ skipping 26 matching lines @@
     isolate->Throw(*exception);
     return false;
   }
   CHECK(uint32_v->ToArrayLength(output));
   return true;
 }
 
 
 // ES6 9.4.2.4
 // static
-bool JSArray::ArraySetLength(Isolate* isolate, Handle<JSArray> a,
-                             PropertyDescriptor* desc,
-                             ShouldThrow should_throw) {
+Maybe<bool> JSArray::ArraySetLength(Isolate* isolate, Handle<JSArray> a,
+                                    PropertyDescriptor* desc,
+                                    ShouldThrow should_throw) {
   // 1. If the [[Value]] field of Desc is absent, then
   if (!desc->has_value()) {
     // 1a. Return OrdinaryDefineOwnProperty(A, "length", Desc).
     return OrdinaryDefineOwnProperty(
         isolate, a, isolate->factory()->length_string(), desc, should_throw);
   }
   // 2. Let newLenDesc be a copy of Desc.
   // (Actual copying is not necessary.)
   PropertyDescriptor* new_len_desc = desc;
   // 3. - 7. Convert Desc.[[Value]] to newLen.
   uint32_t new_len = 0;
   if (!AnythingToArrayLength(isolate, desc->value(), &new_len)) {
-    if (should_throw == THROW_ON_ERROR && !isolate->has_pending_exception()) {
-      isolate->Throw(*isolate->factory()->NewTypeError(
-          MessageTemplate::kCannotConvertToPrimitive));
-    }
-    return false;
+    DCHECK(isolate->has_pending_exception());
+    return Nothing<bool>();
   }
   // 8. Set newLenDesc.[[Value]] to newLen.
   // (Done below, if needed.)
   // 9. Let oldLenDesc be OrdinaryGetOwnProperty(A, "length").
   PropertyDescriptor old_len_desc;
-  bool success = GetOwnPropertyDescriptor(
+  Maybe<bool> success = GetOwnPropertyDescriptor(
       isolate, a, isolate->factory()->length_string(), &old_len_desc);
   // 10. (Assert)
-  DCHECK(success);
+  DCHECK(success.FromJust());
   USE(success);
   // 11. Let oldLen be oldLenDesc.[[Value]].
   uint32_t old_len = 0;
   CHECK(old_len_desc.value()->ToArrayLength(&old_len));
   // 12. If newLen >= oldLen, then
   if (new_len >= old_len) {
     // 8. Set newLenDesc.[[Value]] to newLen.
     // 12a. Return OrdinaryDefineOwnProperty(A, "length", newLenDesc).
     new_len_desc->set_value(isolate->factory()->NewNumberFromUint(new_len));
     return OrdinaryDefineOwnProperty(isolate, a,
                                      isolate->factory()->length_string(),
                                      new_len_desc, should_throw);
   }
   // 13. If oldLenDesc.[[Writable]] is false, return false.
   if (!old_len_desc.writable()) {
-    if (should_throw == THROW_ON_ERROR)
-      isolate->Throw(*isolate->factory()->NewTypeError(
-          MessageTemplate::kRedefineDisallowed,
-          isolate->factory()->length_string()));
-    return false;
+    RETURN_FAILURE(isolate, should_throw,
+                   NewTypeError(MessageTemplate::kRedefineDisallowed,
+                                isolate->factory()->length_string()));
   }
   // 14. If newLenDesc.[[Writable]] is absent or has the value true,
   // let newWritable be true.
   bool new_writable = false;
   if (!new_len_desc->has_writable() || new_len_desc->writable()) {
     new_writable = true;
   } else {
     // 15. Else,
     // 15a. Need to defer setting the [[Writable]] attribute to false in case
     //      any elements cannot be deleted.
     // 15b. Let newWritable be false. (It's initialized as "false" anyway.)
     // 15c. Set newLenDesc.[[Writable]] to true.
     // (Not needed.)
   }
   // Most of steps 16 through 19 is implemented by JSArray::SetLength.
   if (JSArray::ObservableSetLength(a, new_len).is_null()) {
     DCHECK(isolate->has_pending_exception());
-    return false;
+    return Nothing<bool>();
   }
   // Steps 19d-ii, 20.
   if (!new_writable) {
     PropertyDescriptor readonly;
     readonly.set_writable(false);
-    OrdinaryDefineOwnProperty(isolate, a, isolate->factory()->length_string(),
-                              &readonly, should_throw);
+    Maybe<bool> success = OrdinaryDefineOwnProperty(
+        isolate, a, isolate->factory()->length_string(), &readonly,
+        should_throw);
+    DCHECK(success.FromJust());
+    USE(success);
   }
   uint32_t actual_new_len = 0;
   CHECK(a->length()->ToArrayLength(&actual_new_len));
   // Steps 19d-v, 21. Return false if there were non-deletable elements.
-  success = actual_new_len == new_len;
-  if (!success && should_throw == THROW_ON_ERROR) {
-    isolate->Throw(*isolate->factory()->NewTypeError(
-        MessageTemplate::kStrictDeleteProperty,
-        isolate->factory()->NewNumberFromUint(actual_new_len - 1), a));
+  bool result = actual_new_len == new_len;
+  if (!result) {
+    RETURN_FAILURE(
+        isolate, should_throw,
+        NewTypeError(MessageTemplate::kStrictDeleteProperty,
+                     isolate->factory()->NewNumberFromUint(actual_new_len - 1),
+                     a));
   }
-  return success;
+  return Just(result);
 }
 
 
 // ES6 9.5.6
 // static
-bool JSProxy::DefineOwnProperty(Isolate* isolate, Handle<JSProxy> proxy,
-                                Handle<Object> key, PropertyDescriptor* desc,
-                                ShouldThrow should_throw) {
+Maybe<bool> JSProxy::DefineOwnProperty(Isolate* isolate, Handle<JSProxy> proxy,
+                                       Handle<Object> key,
+                                       PropertyDescriptor* desc,
+                                       ShouldThrow should_throw) {
   Handle<String> trap_name = isolate->factory()->defineProperty_string();
   // 1. Assert: IsPropertyKey(P) is true.
   DCHECK(key->IsName() || key->IsNumber());
   // 2. Let handler be the value of the [[ProxyHandler]] internal slot of O.
   Handle<Object> handler(proxy->handler(), isolate);
   // 3. If handler is null, throw a TypeError exception.
   // 4. Assert: Type(handler) is Object.
   if (proxy->IsRevoked()) {
     isolate->Throw(*isolate->factory()->NewTypeError(
         MessageTemplate::kProxyRevoked, trap_name));
-    return false;
+    return Nothing<bool>();
   }
   // 5. Let target be the value of the [[ProxyTarget]] internal slot of O.
   Handle<JSReceiver> target(proxy->target(), isolate);
   // 6. Let trap be ? GetMethod(handler, "defineProperty").
   Handle<Object> trap;
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
       isolate, trap,
-      Object::GetMethod(Handle<JSReceiver>::cast(handler), trap_name), false);
+      Object::GetMethod(Handle<JSReceiver>::cast(handler), trap_name),
+      Nothing<bool>());
   // 7. If trap is undefined, then:
   if (trap->IsUndefined()) {
     // 7a. Return target.[[DefineOwnProperty]](P, Desc).
     return JSReceiver::DefineOwnProperty(isolate, target, key, desc,
                                          should_throw);
   }
   // 8. Let descObj be FromPropertyDescriptor(Desc).
   Handle<Object> desc_obj = desc->ToObject(isolate);
   // 9. Let booleanTrapResult be
   //    ToBoolean(? Call(trap, handler, «target, P, descObj»)).
   Handle<Name> property_name =
       key->IsName()
           ? Handle<Name>::cast(key)
           : Handle<Name>::cast(isolate->factory()->NumberToString(key));
   Handle<Object> trap_result_obj;
   Handle<Object> args[] = {target, property_name, desc_obj};
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
       isolate, trap_result_obj,
-      Execution::Call(isolate, trap, handler, arraysize(args), args), false);
+      Execution::Call(isolate, trap, handler, arraysize(args), args),
+      Nothing<bool>());
   // 10. If booleanTrapResult is false, return false.
   if (!trap_result_obj->BooleanValue()) {
-    if (should_throw == THROW_ON_ERROR) {
-      // TODO(jkummerow): Better error message?
-      isolate->Throw(*isolate->factory()->NewTypeError(
-          MessageTemplate::kProxyHandlerReturned, handler, trap_result_obj,
-          trap_name));
-    }
-    return false;
+    // TODO(jkummerow): Better error message?
+    RETURN_FAILURE(isolate, should_throw,
+                   NewTypeError(MessageTemplate::kProxyHandlerReturned, handler,
+                                trap_result_obj, trap_name));
   }
   // 11. Let targetDesc be ? target.[[GetOwnProperty]](P).
   PropertyDescriptor target_desc;
-  bool target_found =
+  Maybe<bool> target_found =
       JSReceiver::GetOwnPropertyDescriptor(isolate, target, key, &target_desc);
-  if (isolate->has_pending_exception()) return false;
+  MAYBE_RETURN(target_found, Nothing<bool>());
   // 12. Let extensibleTarget be ? IsExtensible(target).
   Maybe<bool> maybe_extensible = JSReceiver::IsExtensible(target);
-  if (maybe_extensible.IsNothing()) return false;
+  MAYBE_RETURN(maybe_extensible, Nothing<bool>());
   bool extensible_target = maybe_extensible.FromJust();
   // 13. If Desc has a [[Configurable]] field and if Desc.[[Configurable]]
   //     is false, then:
   // 13a. Let settingConfigFalse be true.
   // 14. Else let settingConfigFalse be false.
   bool setting_config_false = desc->has_configurable() && !desc->configurable();
   // 15. If targetDesc is undefined, then
-  if (!target_found) {
+  if (!target_found.FromJust()) {
     // 15a. If extensibleTarget is false, throw a TypeError exception.
     if (!extensible_target) {
       isolate->Throw(*isolate->factory()->NewTypeError(
           MessageTemplate::kProxyTargetNotExtensible));
-      return false;
+      return Nothing<bool>();
     }
     // 15b. If settingConfigFalse is true, throw a TypeError exception.
     if (setting_config_false) {
       // TODO(jkummerow): Better error message?
       isolate->Throw(*isolate->factory()->NewTypeError(
           MessageTemplate::kRedefineDisallowed, key));
-      return false;
+      return Nothing<bool>();
     }
   } else {
     // 16. Else targetDesc is not undefined,
     // 16a. If IsCompatiblePropertyDescriptor(extensibleTarget, Desc,
     //      targetDesc) is false, throw a TypeError exception.
-    bool valid = IsCompatiblePropertyDescriptor(
+    Maybe<bool> valid = IsCompatiblePropertyDescriptor(
         isolate, extensible_target, desc, &target_desc, property_name);
-    if (!valid) {
-      DCHECK(isolate->has_pending_exception());
-      return false;
-    }
+    MAYBE_RETURN(valid, Nothing<bool>());
+    DCHECK(valid.FromJust());
     // 16b. If settingConfigFalse is true and targetDesc.[[Configurable]] is
     //      true, throw a TypeError exception.
     if (setting_config_false && target_desc.configurable()) {
       // TODO(jkummerow): Better error message?
       isolate->Throw(*isolate->factory()->NewTypeError(
           MessageTemplate::kRedefineDisallowed, key));
-      return false;
+      return Nothing<bool>();
     }
   }
   // 17. Return true.
-  return true;
+  return Just(true);
 }
 
 
 // static
-bool JSReceiver::GetOwnPropertyDescriptor(Isolate* isolate,
-                                          Handle<JSReceiver> object,
-                                          Handle<Object> key,
-                                          PropertyDescriptor* desc) {
+Maybe<bool> JSReceiver::GetOwnPropertyDescriptor(Isolate* isolate,
+                                                 Handle<JSReceiver> object,
+                                                 Handle<Object> key,
+                                                 PropertyDescriptor* desc) {
   bool success = false;
   DCHECK(key->IsName() || key->IsNumber());  // |key| is a PropertyKey...
   LookupIterator it = LookupIterator::PropertyOrElement(
       isolate, object, key, &success, LookupIterator::HIDDEN);
   DCHECK(success);  // ...so creating a LookupIterator can't fail.
   return GetOwnPropertyDescriptor(&it, desc);
 }
 
 
-// TODO(jkummerow): Any chance to unify this with
-// "MaybeHandle<Object> GetOwnProperty()" in runtime-object.cc?
-
 // ES6 9.1.5.1
-// Returns true on success; false if there was an exception or no property.
+// Returns true on success, false if the property didn't exist, nothing if
+// an exception was thrown.
 // static
-bool JSReceiver::GetOwnPropertyDescriptor(LookupIterator* it,
-                                          PropertyDescriptor* desc) {
+Maybe<bool> JSReceiver::GetOwnPropertyDescriptor(LookupIterator* it,
+                                                 PropertyDescriptor* desc) {
   Isolate* isolate = it->isolate();
   // "Virtual" dispatch.
   if (it->IsFound() && it->GetHolder<JSReceiver>()->IsJSProxy()) {
     return JSProxy::GetOwnPropertyDescriptor(isolate, it->GetHolder<JSProxy>(),
                                              it->GetName(), desc);
   }
 
   // 1. (Assert)
   // 2. If O does not have an own property with key P, return undefined.
   Maybe<PropertyAttributes> maybe = JSObject::GetPropertyAttributes(it);
-
-  if (!maybe.IsJust()) return false;
+  MAYBE_RETURN(maybe, Nothing<bool>());
   PropertyAttributes attrs = maybe.FromJust();
-  if (attrs == ABSENT) return false;
+  if (attrs == ABSENT) return Just(false);
   DCHECK(!isolate->has_pending_exception());
 
   // 3. Let D be a newly created Property Descriptor with no fields.
   DCHECK(desc->is_empty());
   // 4. Let X be O's own property whose key is P.
   // 5. If X is a data property, then
   bool is_accessor_pair = it->state() == LookupIterator::ACCESSOR &&
                           it->GetAccessors()->IsAccessorPair();
   if (!is_accessor_pair) {
     // 5a. Set D.[[Value]] to the value of X's [[Value]] attribute.
     Handle<Object> value;
     if (!JSObject::GetProperty(it).ToHandle(&value)) {
       DCHECK(isolate->has_pending_exception());
-      return false;
+      return Nothing<bool>();
     }
     desc->set_value(value);
     // 5b. Set D.[[Writable]] to the value of X's [[Writable]] attribute
     desc->set_writable((attrs & READ_ONLY) == 0);
   } else {
     // 6. Else X is an accessor property, so
     Handle<AccessorPair> accessors =
         Handle<AccessorPair>::cast(it->GetAccessors());
     // 6a. Set D.[[Get]] to the value of X's [[Get]] attribute.
     desc->set_get(handle(accessors->GetComponent(ACCESSOR_GETTER), isolate));
     // 6b. Set D.[[Set]] to the value of X's [[Set]] attribute.
     desc->set_set(handle(accessors->GetComponent(ACCESSOR_SETTER), isolate));
   }
 
   // 7. Set D.[[Enumerable]] to the value of X's [[Enumerable]] attribute.
   desc->set_enumerable((attrs & DONT_ENUM) == 0);
   // 8. Set D.[[Configurable]] to the value of X's [[Configurable]] attribute.
   desc->set_configurable((attrs & DONT_DELETE) == 0);
   // 9. Return D.
   DCHECK(PropertyDescriptor::IsAccessorDescriptor(desc) !=
          PropertyDescriptor::IsDataDescriptor(desc));
-  return true;
+  return Just(true);
 }
 
 
 // ES6 9.5.5
 // static
-bool JSProxy::GetOwnPropertyDescriptor(Isolate* isolate, Handle<JSProxy> proxy,
-                                       Handle<Name> name,
-                                       PropertyDescriptor* desc) {
+Maybe<bool> JSProxy::GetOwnPropertyDescriptor(Isolate* isolate,
+                                              Handle<JSProxy> proxy,
+                                              Handle<Name> name,
+                                              PropertyDescriptor* desc) {
   Handle<String> trap_name =
       isolate->factory()->getOwnPropertyDescriptor_string();
   // 1. (Assert)
   // 2. Let handler be the value of the [[ProxyHandler]] internal slot of O.
   Handle<Object> handler(proxy->handler(), isolate);
   // 3. If handler is null, throw a TypeError exception.
   // 4. Assert: Type(handler) is Object.
   if (proxy->IsRevoked()) {
     isolate->Throw(*isolate->factory()->NewTypeError(
         MessageTemplate::kProxyRevoked, trap_name));
-    return false;
+    return Nothing<bool>();
   }
   // 5. Let target be the value of the [[ProxyTarget]] internal slot of O.
   Handle<JSReceiver> target(proxy->target(), isolate);
   // 6. Let trap be ? GetMethod(handler, "getOwnPropertyDescriptor").
   Handle<Object> trap;
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
       isolate, trap,
-      Object::GetMethod(Handle<JSReceiver>::cast(handler), trap_name), false);
+      Object::GetMethod(Handle<JSReceiver>::cast(handler), trap_name),
+      Nothing<bool>());
   // 7. If trap is undefined, then
   if (trap->IsUndefined()) {
     // 7a. Return target.[[GetOwnProperty]](P).
     return JSReceiver::GetOwnPropertyDescriptor(isolate, target, name, desc);
   }
   // 8. Let trapResultObj be ? Call(trap, handler, «target, P»).
   Handle<Object> trap_result_obj;
   Handle<Object> args[] = {target, name};
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
       isolate, trap_result_obj,
-      Execution::Call(isolate, trap, handler, arraysize(args), args), false);
+      Execution::Call(isolate, trap, handler, arraysize(args), args),
+      Nothing<bool>());
   // 9. If Type(trapResultObj) is neither Object nor Undefined, throw a
   //    TypeError exception.
   if (!trap_result_obj->IsJSReceiver() && !trap_result_obj->IsUndefined()) {
     isolate->Throw(*isolate->factory()->NewTypeError(
         MessageTemplate::kProxyHandlerReturned, handler, trap_result_obj,
         name));
-    return false;
+    return Nothing<bool>();
   }
   // 10. Let targetDesc be ? target.[[GetOwnProperty]](P).
   PropertyDescriptor target_desc;
-  JSReceiver::GetOwnPropertyDescriptor(isolate, target, name, &target_desc);
-  if (isolate->has_pending_exception()) return false;
+  Maybe<bool> found =
+      JSReceiver::GetOwnPropertyDescriptor(isolate, target, name, &target_desc);
+  MAYBE_RETURN(found, Nothing<bool>());
   // 11. If trapResultObj is undefined, then
   if (trap_result_obj->IsUndefined()) {
     // 11a. If targetDesc is undefined, return undefined.
-    if (target_desc.is_empty()) return false;
+    if (!found.FromJust()) return Just(false);
     // 11b. If targetDesc.[[Configurable]] is false, throw a TypeError
     //      exception.
     if (!target_desc.configurable()) {
       isolate->Throw(*isolate->factory()->NewTypeError(
           MessageTemplate::kProxyTargetPropNotConfigurable, name));
-      return false;
+      return Nothing<bool>();
     }
     // 11c. Let extensibleTarget be ? IsExtensible(target).
-    Maybe<bool> maybe_extensible = JSReceiver::IsExtensible(target);
-    if (maybe_extensible.IsNothing()) return false;
-    bool extensible_target = maybe_extensible.FromJust();
+    Maybe<bool> extensible_target = JSReceiver::IsExtensible(target);
+    MAYBE_RETURN(extensible_target, Nothing<bool>());
     // 11d. (Assert)
     // 11e. If extensibleTarget is false, throw a TypeError exception.
-    if (!extensible_target) {
+    if (!extensible_target.FromJust()) {
       isolate->Throw(*isolate->factory()->NewTypeError(
           MessageTemplate::kProxyTargetNotExtensible));
-      return false;
+      return Nothing<bool>();
     }
     // 11f. Return undefined.
-    return false;  // |desc->is_empty()| is what JavaScript calls "undefined".
+    return Just(false);
   }
   // 12. Let extensibleTarget be ? IsExtensible(target).
-  Maybe<bool> maybe_extensible = JSReceiver::IsExtensible(target);
-  if (maybe_extensible.IsNothing()) return false;
-  bool extensible_target = maybe_extensible.FromJust();
+  Maybe<bool> extensible_target = JSReceiver::IsExtensible(target);
+  MAYBE_RETURN(extensible_target, Nothing<bool>());
   // 13. Let resultDesc be ? ToPropertyDescriptor(trapResultObj).
   if (!PropertyDescriptor::ToPropertyDescriptor(isolate, trap_result_obj,
                                                 desc)) {
     DCHECK(isolate->has_pending_exception());
-    return false;
+    return Nothing<bool>();
   }
   // 14. Call CompletePropertyDescriptor(resultDesc).
   PropertyDescriptor::CompletePropertyDescriptor(isolate, desc);
   // 15. Let valid be IsCompatiblePropertyDescriptor (extensibleTarget,
   //     resultDesc, targetDesc).
-  bool valid = IsCompatiblePropertyDescriptor(isolate, extensible_target, desc,
-                                              &target_desc, name);
+  Maybe<bool> valid = IsCompatiblePropertyDescriptor(
+      isolate, extensible_target.FromJust(), desc, &target_desc, name);
   // 16. If valid is false, throw a TypeError exception.
-  if (!valid) {
-    DCHECK(isolate->has_pending_exception());
-    return false;
-  }
+  MAYBE_RETURN(valid, Nothing<bool>());
+  DCHECK(valid.FromJust());
   // 17. If resultDesc.[[Configurable]] is false, then
   if (!desc->configurable()) {
     // 17a. If targetDesc is undefined or targetDesc.[[Configurable]] is true:
     if (target_desc.is_empty() || target_desc.configurable()) {
       // 17a i. Throw a TypeError exception.
       isolate->Throw(*isolate->factory()->NewTypeError(
           MessageTemplate::kRedefineDisallowed, name));
-      return false;
+      return Nothing<bool>();
     }
   }
   // 18. Return resultDesc.
-  return true;
+  return Just(true);
 }
 
 
 bool JSObject::ReferencesObjectFromElements(FixedArray* elements,
                                             ElementsKind kind,
                                             Object* object) {
   DCHECK(IsFastObjectElementsKind(kind) ||
          kind == DICTIONARY_ELEMENTS);
   if (IsFastObjectElementsKind(kind)) {
     int length = IsJSArray()
@@ skipping 157 matching lines @@
   PropertyDescriptor no_conf;
   no_conf.set_configurable(false);
 
   PropertyDescriptor no_conf_no_write;
   no_conf_no_write.set_configurable(false);
   no_conf_no_write.set_writable(false);
 
   if (level == SEALED) {
     for (int i = 0; i < keys->length(); ++i) {
       Handle<Object> key(keys->get(i), isolate);
-      DefineOwnProperty(isolate, receiver, key, &no_conf, THROW_ON_ERROR);
-      if (isolate->has_pending_exception()) return Nothing<bool>();
+      MAYBE_RETURN(
+          DefineOwnProperty(isolate, receiver, key, &no_conf, THROW_ON_ERROR),
+          Nothing<bool>());
     }
     return Just(true);
   }
 
   for (int i = 0; i < keys->length(); ++i) {
     Handle<Object> key(keys->get(i), isolate);
     PropertyDescriptor current_desc;
-    bool owned = JSReceiver::GetOwnPropertyDescriptor(isolate, receiver, key,
-                                                      &current_desc);
-    if (isolate->has_pending_exception()) return Nothing<bool>();
-    if (owned) {
+    Maybe<bool> owned = JSReceiver::GetOwnPropertyDescriptor(
+        isolate, receiver, key, &current_desc);
+    MAYBE_RETURN(owned, Nothing<bool>());
+    if (owned.FromJust()) {
       PropertyDescriptor desc =
           PropertyDescriptor::IsAccessorDescriptor(&current_desc)
               ? no_conf
               : no_conf_no_write;
-      DefineOwnProperty(isolate, receiver, key, &desc, THROW_ON_ERROR);
-      if (isolate->has_pending_exception()) return Nothing<bool>();
+      MAYBE_RETURN(
+          DefineOwnProperty(isolate, receiver, key, &desc, THROW_ON_ERROR),
+          Nothing<bool>());
     }
   }
   return Just(true);
 }
 
 
 Maybe<bool> JSReceiver::TestIntegrityLevel(Handle<JSReceiver> object,
                                            IntegrityLevel level) {
   DCHECK(level == SEALED || level == FROZEN);
   Isolate* isolate = object->GetIsolate();
 
   Maybe<bool> extensible = JSReceiver::IsExtensible(object);
   MAYBE_RETURN(extensible, Nothing<bool>());
   if (extensible.FromJust()) return Just(false);
 
   Handle<FixedArray> keys;
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
       isolate, keys, JSReceiver::OwnPropertyKeys(object), Nothing<bool>());
 
   for (int i = 0; i < keys->length(); ++i) {
     Handle<Object> key(keys->get(i), isolate);
     PropertyDescriptor current_desc;
-    bool owned = JSReceiver::GetOwnPropertyDescriptor(isolate, object, key,
-                                                      &current_desc);
-    if (isolate->has_pending_exception()) return Nothing<bool>();
-    if (owned) {
+    Maybe<bool> owned = JSReceiver::GetOwnPropertyDescriptor(
+        isolate, object, key, &current_desc);
+    MAYBE_RETURN(owned, Nothing<bool>());
+    if (owned.FromJust()) {
       if (current_desc.configurable()) return Just(false);
       if (level == FROZEN &&
           PropertyDescriptor::IsDataDescriptor(&current_desc) &&
           current_desc.writable()) {
         return Just(false);
       }
     }
   }
   return Just(true);
 }
@@ skipping 19 matching lines @@
 
   if (proxy->IsRevoked()) {
     isolate->Throw(
         *factory->NewTypeError(MessageTemplate::kProxyRevoked, trap_name));
     return Nothing<bool>();
   }
   Handle<JSReceiver> target(proxy->target(), isolate);
   Handle<JSReceiver> handler(JSReceiver::cast(proxy->handler()), isolate);
 
   Handle<Object> trap;
-  ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate, trap, GetTrap(proxy, trap_name),
-                                   Nothing<bool>());
+  ASSIGN_RETURN_ON_EXCEPTION_VALUE(
+      isolate, trap, Object::GetMethod(handler, trap_name), Nothing<bool>());
   if (trap->IsUndefined()) {
     return JSReceiver::PreventExtensions(target, should_throw);
   }
 
   Handle<Object> trap_result;
   Handle<Object> args[] = {target};
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
       isolate, trap_result,
       Execution::Call(isolate, trap, handler, arraysize(args), args),
       Nothing<bool>());
@@ skipping 87 matching lines @@
 
   if (proxy->IsRevoked()) {
     isolate->Throw(
         *factory->NewTypeError(MessageTemplate::kProxyRevoked, trap_name));
     return Nothing<bool>();
   }
   Handle<JSReceiver> target(proxy->target(), isolate);
   Handle<JSReceiver> handler(JSReceiver::cast(proxy->handler()), isolate);
 
   Handle<Object> trap;
-  ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate, trap, GetTrap(proxy, trap_name),
-                                   Nothing<bool>());
+  ASSIGN_RETURN_ON_EXCEPTION_VALUE(
+      isolate, trap, Object::GetMethod(handler, trap_name), Nothing<bool>());
   if (trap->IsUndefined()) {
     return JSReceiver::IsExtensible(target);
   }
 
   Handle<Object> trap_result;
   Handle<Object> args[] = {target};
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
       isolate, trap_result,
       Execution::Call(isolate, trap, handler, arraysize(args), args),
       Nothing<bool>());
@@ skipping 758 matching lines @@
     Handle<FixedArray> storage = isolate->factory()->NewFixedArray(length);
     dictionary->CopyEnumKeysTo(*storage);
     return storage;
   }
 }
 
 
 enum IndexedOrNamed { kIndexed, kNamed };
 
 
-// Returns false iff there was an exception.
+// Returns |true| on success, |nothing| on exception.
 template <class Callback, IndexedOrNamed type>
-static bool GetKeysFromInterceptor(Isolate* isolate,
-                                   Handle<JSReceiver> receiver,
-                                   Handle<JSObject> object,
-                                   PropertyFilter filter,
-                                   KeyAccumulator* accumulator) {
+static Maybe<bool> GetKeysFromInterceptor(Isolate* isolate,
+                                          Handle<JSReceiver> receiver,
+                                          Handle<JSObject> object,
+                                          PropertyFilter filter,
+                                          KeyAccumulator* accumulator) {
   if (type == kIndexed) {
-    if (!object->HasIndexedInterceptor()) return true;
+    if (!object->HasIndexedInterceptor()) return Just(true);
   } else {
-    if (!object->HasNamedInterceptor()) return true;
+    if (!object->HasNamedInterceptor()) return Just(true);
   }
   Handle<InterceptorInfo> interceptor(type == kIndexed
                                           ? object->GetIndexedInterceptor()
                                           : object->GetNamedInterceptor(),
                                       isolate);
   if ((filter & ONLY_ALL_CAN_READ) && !interceptor->all_can_read()) {
-    return true;
+    return Just(true);
   }
   PropertyCallbackArguments args(isolate, interceptor->data(), *receiver,
                                  *object);
   v8::Local<v8::Object> result;
   if (!interceptor->enumerator()->IsUndefined()) {
     Callback enum_fun = v8::ToCData<Callback>(interceptor->enumerator());
     const char* log_tag = type == kIndexed ? "interceptor-indexed-enum"
                                            : "interceptor-named-enum";
     LOG(isolate, ApiObjectAccess(log_tag, *object));
     result = args.Call(enum_fun);
   }
-  RETURN_VALUE_IF_SCHEDULED_EXCEPTION(isolate, false);
-  if (result.IsEmpty()) return true;
+  RETURN_VALUE_IF_SCHEDULED_EXCEPTION(isolate, Nothing<bool>());
+  if (result.IsEmpty()) return Just(true);
   DCHECK(v8::Utils::OpenHandle(*result)->IsJSArray() ||
          (v8::Utils::OpenHandle(*result)->IsJSObject() &&
           Handle<JSObject>::cast(v8::Utils::OpenHandle(*result))
               ->HasSloppyArgumentsElements()));
   // The accumulator takes care of string/symbol filtering.
   if (type == kIndexed) {
     accumulator->AddElementKeysFromInterceptor(
         Handle<JSObject>::cast(v8::Utils::OpenHandle(*result)));
   } else {
     accumulator->AddKeys(
         Handle<JSObject>::cast(v8::Utils::OpenHandle(*result)));
   }
-  return true;
+  return Just(true);
 }
 
 
-static bool GetKeysFromJSObject(Isolate* isolate, Handle<JSReceiver> receiver,
-                                Handle<JSObject> object, PropertyFilter* filter,
-                                JSReceiver::KeyCollectionType type,
-                                KeyAccumulator* accumulator) {
+// Returns |true| on success, |false| if prototype walking should be stopped,
+// |nothing| if an exception was thrown.
+static Maybe<bool> GetKeysFromJSObject(Isolate* isolate,
+                                       Handle<JSReceiver> receiver,
+                                       Handle<JSObject> object,
+                                       PropertyFilter* filter,
+                                       JSReceiver::KeyCollectionType type,
+                                       KeyAccumulator* accumulator) {
   accumulator->NextPrototype();
   // Check access rights if required.
   if (object->IsAccessCheckNeeded() &&
       !isolate->MayAccess(handle(isolate->context()), object)) {
     // The cross-origin spec says that [[Enumerate]] shall return an empty
     // iterator when it doesn't have access...
     if (type == JSReceiver::INCLUDE_PROTOS) {
-      return false;
+      return Just(false);
     }
     // ...whereas [[OwnPropertyKeys]] shall return whitelisted properties.
     DCHECK(type == JSReceiver::OWN_ONLY);
     *filter = static_cast<PropertyFilter>(*filter | ONLY_ALL_CAN_READ);
   }
 
   JSObject::CollectOwnElementKeys(object, accumulator, *filter);
 
   // Add the element keys from the interceptor.
-  if (!GetKeysFromInterceptor<v8::IndexedPropertyEnumeratorCallback, kIndexed>(
-          isolate, receiver, object, *filter, accumulator)) {
-    DCHECK(isolate->has_pending_exception());
-    return false;
-  }
+  Maybe<bool> success =
+      GetKeysFromInterceptor<v8::IndexedPropertyEnumeratorCallback, kIndexed>(
+          isolate, receiver, object, *filter, accumulator);
+  MAYBE_RETURN(success, Nothing<bool>());
 
   if (*filter == ENUMERABLE_STRINGS) {
     // We can cache the computed property keys if access checks are
     // not needed and no interceptors are involved.
     //
     // We do not use the cache if the object has elements and
     // therefore it does not make sense to cache the property names
     // for arguments objects.  Arguments objects will always have
     // elements.
     // Wrapped strings have elements, but don't have an elements
     // array or dictionary.  So the fast inline test for whether to
     // use the cache says yes, so we should not create a cache.
     Handle<JSFunction> arguments_function(
         JSFunction::cast(isolate->sloppy_arguments_map()->GetConstructor()));
     bool cache_enum_length =
         ((object->map()->GetConstructor() != *arguments_function) &&
          !object->IsJSValue() && !object->IsAccessCheckNeeded() &&
          !object->HasNamedInterceptor() && !object->HasIndexedInterceptor());
     // Compute the property keys and cache them if possible.
     Handle<FixedArray> enum_keys =
         JSObject::GetEnumPropertyKeys(object, cache_enum_length);
     accumulator->AddKeys(enum_keys);
   } else {
     object->CollectOwnPropertyNames(accumulator, *filter);
   }
 
   // Add the property keys from the interceptor.
-  if (!GetKeysFromInterceptor<v8::GenericNamedPropertyEnumeratorCallback,
-                              kNamed>(isolate, receiver, object, *filter,
-                                      accumulator)) {
-    DCHECK(isolate->has_pending_exception());
-    return false;
-  }
-  return true;
+  success = GetKeysFromInterceptor<v8::GenericNamedPropertyEnumeratorCallback,
+                                   kNamed>(isolate, receiver, object, *filter,
+                                           accumulator);
+  MAYBE_RETURN(success, Nothing<bool>());
+  return Just(true);
 }
 
 
 // Helper function for JSReceiver::GetKeys() below. Can be called recursively.
-// Returns false iff an exception was thrown.
-static bool GetKeys_Internal(Isolate* isolate, Handle<JSReceiver> receiver,
-                             Handle<JSReceiver> object,
-                             JSReceiver::KeyCollectionType type,
-                             PropertyFilter filter,
-                             KeyAccumulator* accumulator) {
+// Returns |true| or |nothing|.
+static Maybe<bool> GetKeys_Internal(Isolate* isolate,
+                                    Handle<JSReceiver> receiver,
+                                    Handle<JSReceiver> object,
+                                    JSReceiver::KeyCollectionType type,
+                                    PropertyFilter filter,
+                                    KeyAccumulator* accumulator) {
   PrototypeIterator::WhereToEnd end = type == JSReceiver::OWN_ONLY
                                           ? PrototypeIterator::END_AT_NON_HIDDEN
                                           : PrototypeIterator::END_AT_NULL;
   for (PrototypeIterator iter(isolate, object,
                               PrototypeIterator::START_AT_RECEIVER);
        !iter.IsAtEnd(end); iter.Advance()) {
     Handle<JSReceiver> current =
         PrototypeIterator::GetCurrent<JSReceiver>(iter);
-    bool result = false;
+    Maybe<bool> result = Just(false);  // Dummy initialization.
     if (current->IsJSProxy()) {
       if (type == JSReceiver::OWN_ONLY) {
         result = JSProxy::OwnPropertyKeys(isolate, receiver,
                                           Handle<JSProxy>::cast(current),
                                           filter, accumulator);
       } else {
         DCHECK(type == JSReceiver::INCLUDE_PROTOS);
         result = JSProxy::Enumerate(
             isolate, receiver, Handle<JSProxy>::cast(current), accumulator);
       }
     } else {
       DCHECK(current->IsJSObject());
       result = GetKeysFromJSObject(isolate, receiver,
                                    Handle<JSObject>::cast(current), &filter,
                                    type, accumulator);
     }
-    if (!result) {
-      if (isolate->has_pending_exception()) {
-        return false;
-      }
-      // If there was no exception, then "false" means "stop iterating".
-      break;
-    }
+    MAYBE_RETURN(result, Nothing<bool>());
+    if (!result.FromJust()) break;  // |false| means "stop iterating".
   }
-  return true;
+  return Just(true);
 }
 
 
 // ES6 9.5.11
 // Returns false in case of exception.
 // static
-bool JSProxy::Enumerate(Isolate* isolate, Handle<JSReceiver> receiver,
-                        Handle<JSProxy> proxy, KeyAccumulator* accumulator) {
+Maybe<bool> JSProxy::Enumerate(Isolate* isolate, Handle<JSReceiver> receiver,
+                               Handle<JSProxy> proxy,
+                               KeyAccumulator* accumulator) {
   // 1. Let handler be the value of the [[ProxyHandler]] internal slot of O.
   Handle<Object> handler(proxy->handler(), isolate);
   // 2. If handler is null, throw a TypeError exception.
   // 3. Assert: Type(handler) is Object.
   if (proxy->IsRevoked()) {
     isolate->Throw(*isolate->factory()->NewTypeError(
         MessageTemplate::kProxyRevoked,
         isolate->factory()->enumerate_string()));
-    return false;
+    return Nothing<bool>();
   }
   // 4. Let target be the value of the [[ProxyTarget]] internal slot of O.
   Handle<JSReceiver> target(proxy->target(), isolate);
   // 5. Let trap be ? GetMethod(handler, "enumerate").
   Handle<Object> trap;
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
       isolate, trap, Object::GetMethod(Handle<JSReceiver>::cast(handler),
                                        isolate->factory()->enumerate_string()),
-      false);
+      Nothing<bool>());
   // 6. If trap is undefined, then
   if (trap->IsUndefined()) {
     // 6a. Return target.[[Enumerate]]().
     return GetKeys_Internal(isolate, receiver, target, INCLUDE_PROTOS,
                             ENUMERABLE_STRINGS, accumulator);
   }
   // The "proxy_enumerate" helper calls the trap (steps 7 - 9), which returns
   // a generator; it then iterates over that generator until it's exhausted
   // and returns an array containing the generated values.
   Handle<Object> trap_result_array;
   Handle<Object> args[] = {trap, handler, target};
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
       isolate, trap_result_array,
       Execution::Call(isolate, isolate->proxy_enumerate(),
                       isolate->factory()->undefined_value(), arraysize(args),
                       args),
-      false);
+      Nothing<bool>());
   accumulator->NextPrototype();
   accumulator->AddKeysFromProxy(Handle<JSObject>::cast(trap_result_array));
-  return true;
+  return Just(true);
 }
 
 
 // ES6 7.3.17 for elementTypes = (String, Symbol)
 static MaybeHandle<FixedArray> CreateListFromArrayLike_StringSymbol(
     Isolate* isolate, Handle<Object> object) {
   // 1. ReturnIfAbrupt(object).
   // 2. (default elementTypes -- not applicable.)
   // 3. If Type(obj) is not Object, throw a TypeError exception.
   if (!object->IsJSReceiver()) {
@@ skipping 42 matching lines @@
     next = isolate->factory()->InternalizeName(Handle<Name>::cast(next));
     list->set(index, *next);
     // 7e. Set index to index + 1. (See loop header.)
   }
   // 8. Return list.
   return list;
 }
 
 
 // ES6 9.5.12
-// Returns "false" in case of exception.
+// Returns |true| on success, |nothing| in case of exception.
 // static
-bool JSProxy::OwnPropertyKeys(Isolate* isolate, Handle<JSReceiver> receiver,
-                              Handle<JSProxy> proxy, PropertyFilter filter,
-                              KeyAccumulator* accumulator) {
+Maybe<bool> JSProxy::OwnPropertyKeys(Isolate* isolate,
+                                     Handle<JSReceiver> receiver,
+                                     Handle<JSProxy> proxy,
+                                     PropertyFilter filter,
+                                     KeyAccumulator* accumulator) {
   // 1. Let handler be the value of the [[ProxyHandler]] internal slot of O.
   Handle<Object> handler(proxy->handler(), isolate);
   // 2. If handler is null, throw a TypeError exception.
   // 3. Assert: Type(handler) is Object.
   if (proxy->IsRevoked()) {
     isolate->Throw(*isolate->factory()->NewTypeError(
         MessageTemplate::kProxyRevoked, isolate->factory()->ownKeys_string()));
-    return false;
+    return Nothing<bool>();
   }
   // 4. Let target be the value of the [[ProxyTarget]] internal slot of O.
   Handle<JSReceiver> target(proxy->target(), isolate);
   // 5. Let trap be ? GetMethod(handler, "ownKeys").
   Handle<Object> trap;
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
       isolate, trap, Object::GetMethod(Handle<JSReceiver>::cast(handler),
                                        isolate->factory()->ownKeys_string()),
-      false);
+      Nothing<bool>());
   // 6. If trap is undefined, then
   if (trap->IsUndefined()) {
     // 6a. Return target.[[OwnPropertyKeys]]().
     return GetKeys_Internal(isolate, receiver, target, OWN_ONLY, filter,
                             accumulator);
   }
   // 7. Let trapResultArray be Call(trap, handler, «target»).
   Handle<Object> trap_result_array;
   Handle<Object> args[] = {target};
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
       isolate, trap_result_array,
-      Execution::Call(isolate, trap, handler, arraysize(args), args), false);
+      Execution::Call(isolate, trap, handler, arraysize(args), args),
+      Nothing<bool>());
   // 8. Let trapResult be ? CreateListFromArrayLike(trapResultArray,
   //    «String, Symbol»).
   Handle<FixedArray> trap_result;
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
       isolate, trap_result,
-      CreateListFromArrayLike_StringSymbol(isolate, trap_result_array), false);
+      CreateListFromArrayLike_StringSymbol(isolate, trap_result_array),
+      Nothing<bool>());
   // 9. Let extensibleTarget be ? IsExtensible(target).
   Maybe<bool> maybe_extensible = JSReceiver::IsExtensible(target);
-  if (maybe_extensible.IsNothing()) return false;
+  MAYBE_RETURN(maybe_extensible, Nothing<bool>());
   bool extensible_target = maybe_extensible.FromJust();
   // 10. Let targetKeys be ? target.[[OwnPropertyKeys]]().
   Handle<FixedArray> target_keys;
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate, target_keys,
-                                   JSReceiver::OwnPropertyKeys(target), false);
+                                   JSReceiver::OwnPropertyKeys(target),
+                                   Nothing<bool>());
   // 11. (Assert)
   // 12. Let targetConfigurableKeys be an empty List.
   // To save memory, we're re-using target_keys and will modify it in-place.
   Handle<FixedArray> target_configurable_keys = target_keys;
   // 13. Let targetNonconfigurableKeys be an empty List.
   Handle<FixedArray> target_nonconfigurable_keys =
       isolate->factory()->NewFixedArray(target_keys->length());
   int nonconfigurable_keys_length = 0;
   // 14. Repeat, for each element key of targetKeys:
   for (int i = 0; i < target_keys->length(); ++i) {
     // 14a. Let desc be ? target.[[GetOwnProperty]](key).
     PropertyDescriptor desc;
-    bool found = JSReceiver::GetOwnPropertyDescriptor(
+    Maybe<bool> found = JSReceiver::GetOwnPropertyDescriptor(
         isolate, target, handle(target_keys->get(i), isolate), &desc);
-    if (isolate->has_pending_exception()) return false;
+    MAYBE_RETURN(found, Nothing<bool>());
     // 14b. If desc is not undefined and desc.[[Configurable]] is false, then
-    if (found && !desc.configurable()) {
+    if (found.FromJust() && !desc.configurable()) {
       // 14b i. Append key as an element of targetNonconfigurableKeys.
       target_nonconfigurable_keys->set(nonconfigurable_keys_length,
                                        target_keys->get(i));
       nonconfigurable_keys_length++;
       // The key was moved, null it out in the original list.
       target_keys->set(i, Smi::FromInt(0));
     } else {
       // 14c. Else,
       // 14c i. Append key as an element of targetConfigurableKeys.
       // (No-op, just keep it in |target_keys|.)
@@ skipping 18 matching lines @@
   }
   // 17. Repeat, for each key that is an element of targetNonconfigurableKeys:
   for (int i = 0; i < nonconfigurable_keys_length; ++i) {
     Object* key = target_nonconfigurable_keys->get(i);
     // 17a. If key is not an element of uncheckedResultKeys, throw a
     //      TypeError exception.
     int* found = unchecked_result_keys.Find(key);
     if (found == nullptr || *found == kGone) {
       isolate->Throw(*isolate->factory()->NewTypeError(
           MessageTemplate::kProxyTrapResultMustInclude, handle(key, isolate)));
-      return false;
+      return Nothing<bool>();
     }
     // 17b. Remove key from uncheckedResultKeys.
     *found = kGone;
     unchecked_result_keys_size--;
   }
   // 18. If extensibleTarget is true, return trapResult.
   if (extensible_target) {
     return accumulator->AddKeysFromProxy(proxy, trap_result);
   }
   // 19. Repeat, for each key that is an element of targetConfigurableKeys:
   for (int i = 0; i < target_configurable_keys->length(); ++i) {
     Object* key = target_configurable_keys->get(i);
     if (key->IsSmi()) continue;  // Zapped entry, was nonconfigurable.
     // 19a. If key is not an element of uncheckedResultKeys, throw a
     //      TypeError exception.
     int* found = unchecked_result_keys.Find(key);
     if (found == nullptr || *found == kGone) {
       isolate->Throw(*isolate->factory()->NewTypeError(
           MessageTemplate::kProxyTrapResultMustInclude, handle(key, isolate)));
-      return false;
+      return Nothing<bool>();
     }
     // 19b. Remove key from uncheckedResultKeys.
     *found = kGone;
     unchecked_result_keys_size--;
   }
   // 20. If uncheckedResultKeys is not empty, throw a TypeError exception.
   if (unchecked_result_keys_size != 0) {
     DCHECK_GT(unchecked_result_keys_size, 0);
     isolate->Throw(*isolate->factory()->NewTypeError(
         MessageTemplate::kProxyTargetNotExtensible));
-    return false;
+    return Nothing<bool>();
   }
   // 21. Return trapResult.
   return accumulator->AddKeysFromProxy(proxy, trap_result);
 }
 
 
 MaybeHandle<FixedArray> JSReceiver::GetKeys(Handle<JSReceiver> object,
                                             KeyCollectionType type,
                                             PropertyFilter filter,
                                             GetKeysConversion keys_conversion) {
   USE(ContainsOnlyValidKeys);
   Isolate* isolate = object->GetIsolate();
   KeyAccumulator accumulator(isolate, filter);
-  if (!GetKeys_Internal(isolate, object, object, type, filter, &accumulator)) {
-    DCHECK(isolate->has_pending_exception());
-    return MaybeHandle<FixedArray>();
-  }
+  MAYBE_RETURN(
+      GetKeys_Internal(isolate, object, object, type, filter, &accumulator),
+      MaybeHandle<FixedArray>());
   Handle<FixedArray> keys = accumulator.GetKeys(keys_conversion);
   DCHECK(ContainsOnlyValidKeys(keys));
   return keys;
 }
 
 
 bool Map::DictionaryElementsInPrototypeChainOnly() {
   if (IsDictionaryElementsKind(elements_kind())) {
     return false;
   }
@@ skipping 10517 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