Removed funky Maybe constructor and made fields private.

src/api.cc

 // Copyright 2012 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/api.h"
 
 #include <string.h>  // For memcpy, strlen.
 #ifdef V8_USE_ADDRESS_SANITIZER
 #include <sanitizer/asan_interface.h>
 #endif  // V8_USE_ADDRESS_SANITIZER
@@ skipping 1925 matching lines @@
 v8::Local<Value> v8::TryCatch::StackTrace() const {
   if (HasCaught()) {
     i::Object* raw_obj = reinterpret_cast<i::Object*>(exception_);
     if (!raw_obj->IsJSObject()) return v8::Local<Value>();
     i::HandleScope scope(isolate_);
     i::Handle<i::JSObject> obj(i::JSObject::cast(raw_obj), isolate_);
     i::Handle<i::String> name = isolate_->factory()->stack_string();
     {
       EXCEPTION_PREAMBLE(isolate_);
       Maybe<bool> maybe = i::JSReceiver::HasProperty(obj, name);
-      has_pending_exception = !maybe.has_value;
+      has_pending_exception = !maybe.IsJust();
       EXCEPTION_BAILOUT_CHECK(isolate_, v8::Local<Value>());
-      if (!maybe.value) return v8::Local<Value>();
+      if (!maybe.FromJust()) return v8::Local<Value>();
     }
     i::Handle<i::Object> value;
     EXCEPTION_PREAMBLE(isolate_);
     has_pending_exception = !i::Object::GetProperty(obj, name).ToHandle(&value);
     EXCEPTION_BAILOUT_CHECK(isolate_, v8::Local<Value>());
     return v8::Utils::ToLocal(scope.CloseAndEscape(value));
   } else {
     return v8::Local<Value>();
   }
 }
@@ skipping 1392 matching lines @@
   if (!key_obj->IsName()) {
     EXCEPTION_PREAMBLE(isolate);
     has_pending_exception = !i::Execution::ToString(
         isolate, key_obj).ToHandle(&key_obj);
     EXCEPTION_BAILOUT_CHECK(isolate, static_cast<PropertyAttribute>(NONE));
   }
   i::Handle<i::Name> key_name = i::Handle<i::Name>::cast(key_obj);
   EXCEPTION_PREAMBLE(isolate);
   Maybe<PropertyAttributes> result =
       i::JSReceiver::GetPropertyAttributes(self, key_name);
-  has_pending_exception = !result.has_value;
+  has_pending_exception = !result.IsJust();
   EXCEPTION_BAILOUT_CHECK(isolate, static_cast<PropertyAttribute>(NONE));
-  if (result.value == ABSENT) return static_cast<PropertyAttribute>(NONE);
-  return static_cast<PropertyAttribute>(result.value);
+  if (result.FromJust() == ABSENT) return static_cast<PropertyAttribute>(NONE);
+  return static_cast<PropertyAttribute>(result.FromJust());
 }
 
 
 Local<Value> v8::Object::GetOwnPropertyDescriptor(Local<String> key) {
   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
   ON_BAILOUT(isolate, "v8::Object::GetOwnPropertyDescriptor()",
              return Local<Value>());
   ENTER_V8(isolate);
   i::Handle<i::JSObject> obj = Utils::OpenHandle(this);
   i::Handle<i::Name> key_name = Utils::OpenHandle(*key);
@@ skipping 215 matching lines @@
   uint32_t index;
   if (key_obj->ToArrayIndex(&index)) {
     maybe = i::JSReceiver::HasElement(self, index);
   } else {
     // Convert the key to a name - possibly by calling back into JavaScript.
     i::Handle<i::Name> name;
     if (i::Runtime::ToName(isolate, key_obj).ToHandle(&name)) {
       maybe = i::JSReceiver::HasProperty(self, name);
     }
   }
-  if (!maybe.has_value) has_pending_exception = true;
+  if (!maybe.IsJust()) has_pending_exception = true;
   EXCEPTION_BAILOUT_CHECK(isolate, false);
-  DCHECK(maybe.has_value);
-  return maybe.value;
+  DCHECK(maybe.IsJust());
+  return maybe.FromJust();
 }
 
 
 bool v8::Object::HasPrivate(v8::Handle<Private> key) {
   // TODO(rossberg): this should use HasOwnProperty, but we'd need to
   // generalise that to a (noy yet existant) Name argument first.
   return Has(v8::Handle<Value>(reinterpret_cast<Value*>(*key)));
 }
 
 
@@ skipping 13 matching lines @@
   return obj->IsTrue();
 }
 
 
 bool v8::Object::Has(uint32_t index) {
   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
   ON_BAILOUT(isolate, "v8::Object::HasProperty()", return false);
   i::Handle<i::JSObject> self = Utils::OpenHandle(this);
   EXCEPTION_PREAMBLE(isolate);
   Maybe<bool> maybe = i::JSReceiver::HasElement(self, index);
-  has_pending_exception = !maybe.has_value;
+  has_pending_exception = !maybe.IsJust();
   EXCEPTION_BAILOUT_CHECK(isolate, false);
-  return maybe.value;
+  return maybe.FromJust();
 }
 
 
 template<typename Getter, typename Setter, typename Data>
 static inline bool ObjectSetAccessor(Object* obj,
                                      Handle<Name> name,
                                      Getter getter,
                                      Setter setter,
                                      Data data,
                                      AccessControl settings,
@@ skipping 64 matching lines @@
 }
 
 
 bool v8::Object::HasOwnProperty(Handle<String> key) {
   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
   ON_BAILOUT(isolate, "v8::Object::HasOwnProperty()",
              return false);
   EXCEPTION_PREAMBLE(isolate);
   Maybe<bool> maybe = i::JSReceiver::HasOwnProperty(Utils::OpenHandle(this),
                                                     Utils::OpenHandle(*key));
-  has_pending_exception = !maybe.has_value;
+  has_pending_exception = !maybe.IsJust();
   EXCEPTION_BAILOUT_CHECK(isolate, false);
-  return maybe.value;
+  return maybe.FromJust();
 }
 
 
 bool v8::Object::HasRealNamedProperty(Handle<String> key) {
   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
   ON_BAILOUT(isolate, "v8::Object::HasRealNamedProperty()",
              return false);
   EXCEPTION_PREAMBLE(isolate);
   Maybe<bool> maybe = i::JSObject::HasRealNamedProperty(
       Utils::OpenHandle(this), Utils::OpenHandle(*key));
-  has_pending_exception = !maybe.has_value;
+  has_pending_exception = !maybe.IsJust();
   EXCEPTION_BAILOUT_CHECK(isolate, false);
-  return maybe.value;
+  return maybe.FromJust();
 }
 
 
 bool v8::Object::HasRealIndexedProperty(uint32_t index) {
   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
   ON_BAILOUT(isolate, "v8::Object::HasRealIndexedProperty()",
              return false);
   EXCEPTION_PREAMBLE(isolate);
   Maybe<bool> maybe =
       i::JSObject::HasRealElementProperty(Utils::OpenHandle(this), index);
-  has_pending_exception = !maybe.has_value;
+  has_pending_exception = !maybe.IsJust();
   EXCEPTION_BAILOUT_CHECK(isolate, false);
-  return maybe.value;
+  return maybe.FromJust();
 }
 
 
 bool v8::Object::HasRealNamedCallbackProperty(Handle<String> key) {
   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
   ON_BAILOUT(isolate,
              "v8::Object::HasRealNamedCallbackProperty()",
              return false);
   ENTER_V8(isolate);
   EXCEPTION_PREAMBLE(isolate);
   Maybe<bool> maybe = i::JSObject::HasRealNamedCallbackProperty(
       Utils::OpenHandle(this), Utils::OpenHandle(*key));
-  has_pending_exception = !maybe.has_value;
+  has_pending_exception = !maybe.IsJust();
   EXCEPTION_BAILOUT_CHECK(isolate, false);
-  return maybe.value;
+  return maybe.FromJust();
 }
 
 
 bool v8::Object::HasNamedLookupInterceptor() {
   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
   ON_BAILOUT(isolate, "v8::Object::HasNamedLookupInterceptor()",
              return false);
   return Utils::OpenHandle(this)->HasNamedInterceptor();
 }
 
@@ skipping 15 matching lines @@
 
   if (it->IsFound()) return Utils::ToLocal(result);
   return Local<Value>();
 }
 
 
 static Maybe<PropertyAttribute> GetPropertyAttributesByLookup(
     i::LookupIterator* it) {
   Maybe<PropertyAttributes> attr = i::JSReceiver::GetPropertyAttributes(it);
   return it->IsFound() ? Just<PropertyAttribute>(
-                             static_cast<PropertyAttribute>(attr.value))
+                             static_cast<PropertyAttribute>(attr.FromJust()))
                        : Nothing<PropertyAttribute>();
 }
 
 
 Local<Value> v8::Object::GetRealNamedPropertyInPrototypeChain(
     Handle<String> key) {
   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
   ON_BAILOUT(isolate,
              "v8::Object::GetRealNamedPropertyInPrototypeChain()",
              return Local<Value>());
@@ skipping 4055 matching lines @@
   Isolate* isolate = reinterpret_cast<Isolate*>(info.GetIsolate());
   Address callback_address =
       reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
   VMState<EXTERNAL> state(isolate);
   ExternalCallbackScope call_scope(isolate, callback_address);
   callback(info);
 }
 
 
 } }  // namespace v8::internal