[proxies] Fix "with" statements for proxies

src/contexts.cc

 // Copyright 2011 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/contexts.h"
 
 #include "src/ast/scopeinfo.h"
 #include "src/bootstrapper.h"
 #include "src/debug/debug.h"
 #include "src/isolate-inl.h"
@@ skipping 128 matching lines @@
 
 void Context::set_global_proxy(JSObject* object) {
   native_context()->set_global_proxy_object(object);
 }
 
 
 /**
  * Lookups a property in an object environment, taking the unscopables into
  * account. This is used For HasBinding spec algorithms for ObjectEnvironment.
  */
-static Maybe<PropertyAttributes> UnscopableLookup(LookupIterator* it) {
+static Maybe<bool> UnscopableLookup(LookupIterator* it) {
   Isolate* isolate = it->isolate();
 
-  Maybe<PropertyAttributes> attrs = JSReceiver::GetPropertyAttributes(it);
-  DCHECK(attrs.IsJust() || isolate->has_pending_exception());
-  if (!attrs.IsJust() || attrs.FromJust() == ABSENT) return attrs;
+  Maybe<bool> found = JSReceiver::HasProperty(it);
+  if (!found.IsJust() || !found.FromJust()) return found;
 
-  Handle<Symbol> unscopables_symbol = isolate->factory()->unscopables_symbol();
-  Handle<Object> receiver = it->GetReceiver();
   Handle<Object> unscopables;
-  MaybeHandle<Object> maybe_unscopables =
-      Object::GetProperty(receiver, unscopables_symbol);
-  if (!maybe_unscopables.ToHandle(&unscopables)) {
-    return Nothing<PropertyAttributes>();
-  }
-  if (!unscopables->IsJSReceiver()) return attrs;
+  ASSIGN_RETURN_ON_EXCEPTION_VALUE(
+      isolate, unscopables,
+      Object::GetProperty(it->GetReceiver(),
+                          isolate->factory()->unscopables_symbol()),
+      Nothing<bool>());
+  if (!unscopables->IsJSReceiver()) return Just(true);
   Handle<Object> blacklist;
-  MaybeHandle<Object> maybe_blacklist =
-      Object::GetProperty(unscopables, it->name());
-  if (!maybe_blacklist.ToHandle(&blacklist)) {
-    DCHECK(isolate->has_pending_exception());
-    return Nothing<PropertyAttributes>();
-  }
-  return blacklist->BooleanValue() ? Just(ABSENT) : attrs;
+  ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate, blacklist,
+                                   Object::GetProperty(unscopables, it->name()),
+                                   Nothing<bool>());
+  return Just(!blacklist->BooleanValue());
 }
 
 static void GetAttributesAndBindingFlags(VariableMode mode,
                                          InitializationFlag init_flag,
                                          PropertyAttributes* attributes,
                                          BindingFlags* binding_flags) {
   switch (mode) {
     case VAR:
       *attributes = NONE;
       *binding_flags = MUTABLE_IS_INITIALIZED;
@@ skipping 99 matching lines @@
       Maybe<PropertyAttributes> maybe = Nothing<PropertyAttributes>();
       if ((flags & FOLLOW_PROTOTYPE_CHAIN) == 0 ||
           object->IsJSContextExtensionObject()) {
         maybe = JSReceiver::GetOwnPropertyAttributes(object, name);
       } else if (context->IsWithContext()) {
         // A with context will never bind "this".
         if (name->Equals(*isolate->factory()->this_string())) {
           maybe = Just(ABSENT);
         } else {
           LookupIterator it(object, name);
-          maybe = UnscopableLookup(&it);
+          Maybe<bool> found = UnscopableLookup(&it);
+          if (found.IsNothing()) {
+            maybe = Nothing<PropertyAttributes>();
+          } else {
+            // Luckily, consumers of |maybe| only care whether the property
+            // was absent or not, so we can return a dummy |NONE| value
+            // for its attributes when it was present.
+            maybe = Just(found.FromJust() ? NONE : ABSENT);
+          }
         }
       } else {
         maybe = JSReceiver::GetPropertyAttributes(object, name);
       }
 
       if (!maybe.IsJust()) return Handle<Object>();
       DCHECK(!isolate->has_pending_exception());
       *attributes = maybe.FromJust();
 
       if (maybe.FromJust() != ABSENT) {
@@ skipping 276 matching lines @@
 
   int previous_value = errors_thrown()->value();
   set_errors_thrown(Smi::FromInt(previous_value + 1));
 }
 
 
 int Context::GetErrorsThrown() { return errors_thrown()->value(); }
 
 }  // namespace internal
 }  // namespace v8