Polish Maybe API a bit, removing useless creativity and fixing some signatures.

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 453 matching lines @@
   isolate->eternal_handles()->Create(isolate, object, index);
 }
 
 
 Local<Value> V8::GetEternal(Isolate* v8_isolate, int index) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
   return Utils::ToLocal(isolate->eternal_handles()->Get(index));
 }
 
 
+void V8::CheckIsJust(bool is_just) {
+  Utils::ApiCheck(is_just, "v8::FromJust", "Maybe value is Nothing.");
+}
+
+
 // --- H a n d l e s ---
 
 
 HandleScope::HandleScope(Isolate* isolate) {
   Initialize(isolate);
 }
 
 
 void HandleScope::Initialize(Isolate* isolate) {
   i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
@@ skipping 2505 matching lines @@
 
 void v8::RegExp::CheckCast(v8::Value* that) {
   i::Handle<i::Object> obj = Utils::OpenHandle(that);
   Utils::ApiCheck(obj->IsJSRegExp(),
                   "v8::RegExp::Cast()",
                   "Could not convert to regular expression");
 }
 
 
 Maybe<bool> Value::BooleanValue(Local<Context> context) const {
-  return maybe(Utils::OpenHandle(this)->BooleanValue());
+  return Just(Utils::OpenHandle(this)->BooleanValue());
 }
 
 
 bool Value::BooleanValue() const {
   return Utils::OpenHandle(this)->BooleanValue();
 }
 
 
 Maybe<double> Value::NumberValue(Local<Context> context) const {
   auto obj = Utils::OpenHandle(this);
-  if (obj->IsNumber()) return maybe(obj->Number());
+  if (obj->IsNumber()) return Just(obj->Number());
   CONTEXT_SCOPE_GET_ISOLATE(context, "NumberValue");
   EXCEPTION_PREAMBLE(isolate);
   i::Handle<i::Object> num;
   has_pending_exception = !i::Execution::ToNumber(isolate, obj).ToHandle(&num);
-  EXCEPTION_BAILOUT_CHECK(isolate, Maybe<double>());
-  return maybe(num->Number());
+  EXCEPTION_BAILOUT_CHECK(isolate, Nothing<double>());
+  return Just(num->Number());
 }
 
 
 double Value::NumberValue() const {
   auto obj = Utils::OpenHandle(this);
   if (obj->IsNumber()) return obj->Number();
   return NumberValue(ContextFromHeapObject(obj))
-      .From(std::numeric_limits<double>::quiet_NaN());
+      .FromMaybe(std::numeric_limits<double>::quiet_NaN());
 }
 
 
 Maybe<int64_t> Value::IntegerValue(Local<Context> context) const {
   auto obj = Utils::OpenHandle(this);
   i::Handle<i::Object> num;
   if (obj->IsNumber()) {
     num = obj;
   } else {
     CONTEXT_SCOPE_GET_ISOLATE(context, "IntegerValue");
     EXCEPTION_PREAMBLE(isolate);
     has_pending_exception =
         !i::Execution::ToInteger(isolate, obj).ToHandle(&num);
-    EXCEPTION_BAILOUT_CHECK(isolate, Maybe<int64_t>());
+    EXCEPTION_BAILOUT_CHECK(isolate, Nothing<int64_t>());
   }
-  if (num->IsSmi()) {
-    return maybe(static_cast<int64_t>(i::Smi::cast(*num)->value()));
-  } else {
-    return maybe(static_cast<int64_t>(num->Number()));
-  }
+  return Just(num->IsSmi() ? static_cast<int64_t>(i::Smi::cast(*num)->value())
+                           : static_cast<int64_t>(num->Number()));
 }
 
 
 int64_t Value::IntegerValue() const {
   auto obj = Utils::OpenHandle(this);
   if (obj->IsNumber()) {
     if (obj->IsSmi()) {
       return i::Smi::cast(*obj)->value();
     } else {
       return static_cast<int64_t>(obj->Number());
     }
   }
-  return IntegerValue(ContextFromHeapObject(obj)).From(0);
+  return IntegerValue(ContextFromHeapObject(obj)).FromMaybe(0);
 }
 
 
 Maybe<int32_t> Value::Int32Value(Local<Context> context) const {
   auto obj = Utils::OpenHandle(this);
-  if (obj->IsNumber()) return maybe(NumberToInt32(*obj));
+  if (obj->IsNumber()) return Just(NumberToInt32(*obj));
   CONTEXT_SCOPE_GET_ISOLATE(context, "Int32Value");
   EXCEPTION_PREAMBLE(isolate);
   i::Handle<i::Object> num;
   has_pending_exception = !i::Execution::ToInt32(isolate, obj).ToHandle(&num);
-  EXCEPTION_BAILOUT_CHECK(isolate, Maybe<int32_t>());
-  if (num->IsSmi()) {
-    return maybe(i::Smi::cast(*num)->value());
-  } else {
-    return maybe(static_cast<int32_t>(num->Number()));
-  }
+  EXCEPTION_BAILOUT_CHECK(isolate, Nothing<int32_t>());
+  return Just(num->IsSmi() ? i::Smi::cast(*num)->value()
+                           : static_cast<int32_t>(num->Number()));
 }
 
 
 int32_t Value::Int32Value() const {
   auto obj = Utils::OpenHandle(this);
   if (obj->IsNumber()) return NumberToInt32(*obj);
-  return Int32Value(ContextFromHeapObject(obj)).From(0);
+  return Int32Value(ContextFromHeapObject(obj)).FromMaybe(0);
 }
 
 
 Maybe<uint32_t> Value::Uint32Value(Local<Context> context) const {
   auto obj = Utils::OpenHandle(this);
-  if (obj->IsNumber()) return maybe(NumberToUint32(*obj));
+  if (obj->IsNumber()) return Just(NumberToUint32(*obj));
   CONTEXT_SCOPE_GET_ISOLATE(context, "Uint32Value");
   EXCEPTION_PREAMBLE(isolate);
   i::Handle<i::Object> num;
   has_pending_exception = !i::Execution::ToUint32(isolate, obj).ToHandle(&num);
-  EXCEPTION_BAILOUT_CHECK(isolate, Maybe<uint32_t>());
-  if (num->IsSmi()) {
-    return maybe(static_cast<uint32_t>(i::Smi::cast(*num)->value()));
-  } else {
-    return maybe(static_cast<uint32_t>(num->Number()));
-  }
+  EXCEPTION_BAILOUT_CHECK(isolate, Nothing<uint32_t>());
+  return Just(num->IsSmi() ? static_cast<uint32_t>(i::Smi::cast(*num)->value())
+                           : static_cast<uint32_t>(num->Number()));
 }
 
 
 uint32_t Value::Uint32Value() const {
   auto obj = Utils::OpenHandle(this);
   if (obj->IsNumber()) return NumberToUint32(*obj);
-  return Uint32Value(ContextFromHeapObject(obj)).From(0);
+  return Uint32Value(ContextFromHeapObject(obj)).FromMaybe(0);
 }
 
 
 Local<Uint32> Value::ToArrayIndex() const {
   i::Handle<i::Object> obj = Utils::OpenHandle(this);
   if (obj->IsSmi()) {
     if (i::Smi::cast(*obj)->value() >= 0) return Utils::Uint32ToLocal(obj);
     return Local<Uint32>();
   }
   i::Isolate* isolate = i::HeapObject::cast(*obj)->GetIsolate();
@@ skipping 468 matching lines @@
 }
 
 
 bool v8::Object::Has(v8::Handle<Value> key) {
   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
   ON_BAILOUT(isolate, "v8::Object::Has()", return false);
   ENTER_V8(isolate);
   i::Handle<i::JSReceiver> self = Utils::OpenHandle(this);
   i::Handle<i::Object> key_obj = Utils::OpenHandle(*key);
   EXCEPTION_PREAMBLE(isolate);
-  Maybe<bool> maybe;
+  Maybe<bool> maybe = Nothing<bool>();
   // Check if the given key is an array index.
   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);
     }
@@ skipping 193 matching lines @@
   EXCEPTION_BAILOUT_CHECK(it->isolate(), Local<Value>());
 
   if (it->IsFound()) return Utils::ToLocal(result);
   return Local<Value>();
 }
 
 
 static Maybe<PropertyAttribute> GetPropertyAttributesByLookup(
     i::LookupIterator* it) {
   Maybe<PropertyAttributes> attr = i::JSReceiver::GetPropertyAttributes(it);
-  if (!it->IsFound()) return Maybe<PropertyAttribute>();
-  return Maybe<PropertyAttribute>(static_cast<PropertyAttribute>(attr.value));
+  return it->IsFound() ? Just<PropertyAttribute>(
+                             static_cast<PropertyAttribute>(attr.value))
+                       : 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>());
   ENTER_V8(isolate);
   i::Handle<i::JSObject> self_obj = Utils::OpenHandle(this);
   i::Handle<i::String> key_obj = Utils::OpenHandle(*key);
   i::PrototypeIterator iter(isolate, self_obj);
   if (iter.IsAtEnd()) return Local<Value>();
   i::Handle<i::Object> proto = i::PrototypeIterator::GetCurrent(iter);
   i::LookupIterator it(self_obj, key_obj, i::Handle<i::JSReceiver>::cast(proto),
                        i::LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR);
   return GetPropertyByLookup(&it);
 }
 
 
 Maybe<PropertyAttribute>
 v8::Object::GetRealNamedPropertyAttributesInPrototypeChain(Handle<String> key) {
   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
   ON_BAILOUT(isolate,
              "v8::Object::GetRealNamedPropertyAttributesInPrototypeChain()",
-             return Maybe<PropertyAttribute>());
+             return Nothing<PropertyAttribute>());
   ENTER_V8(isolate);
   i::Handle<i::JSObject> self_obj = Utils::OpenHandle(this);
   i::Handle<i::String> key_obj = Utils::OpenHandle(*key);
   i::PrototypeIterator iter(isolate, self_obj);
-  if (iter.IsAtEnd()) return Maybe<PropertyAttribute>();
+  if (iter.IsAtEnd()) return Nothing<PropertyAttribute>();
   i::Handle<i::Object> proto = i::PrototypeIterator::GetCurrent(iter);
   i::LookupIterator it(self_obj, key_obj, i::Handle<i::JSReceiver>::cast(proto),
                        i::LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR);
   return GetPropertyAttributesByLookup(&it);
 }
 
 
 Local<Value> v8::Object::GetRealNamedProperty(Handle<String> key) {
   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
   ON_BAILOUT(isolate, "v8::Object::GetRealNamedProperty()",
              return Local<Value>());
   ENTER_V8(isolate);
   i::Handle<i::JSObject> self_obj = Utils::OpenHandle(this);
   i::Handle<i::String> key_obj = Utils::OpenHandle(*key);
   i::LookupIterator it(self_obj, key_obj,
                        i::LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR);
   return GetPropertyByLookup(&it);
 }
 
 
 Maybe<PropertyAttribute> v8::Object::GetRealNamedPropertyAttributes(
     Handle<String> key) {
   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
   ON_BAILOUT(isolate, "v8::Object::GetRealNamedPropertyAttributes()",
-             return Maybe<PropertyAttribute>());
+             return Nothing<PropertyAttribute>());
   ENTER_V8(isolate);
   i::Handle<i::JSObject> self_obj = Utils::OpenHandle(this);
   i::Handle<i::String> key_obj = Utils::OpenHandle(*key);
   i::LookupIterator it(self_obj, key_obj,
                        i::LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR);
   return GetPropertyAttributesByLookup(&it);
 }
 
 
 // Turns on access checks by copying the map and setting the check flag.
@@ skipping 3997 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