AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

Removed funky Maybe constructor and made fields private.

Browse Source 
BUG=v8:3929
LOG=y
R=dcarney@chromium.org

Review URL: https://codereview.chromium.org/958053003

Cr-Commit-Position: refs/heads/master@{#26937}
This commit is contained in:
Sven Panne 2015-03-02 13:22:27 +01:00
parent 30637108dd
commit 602d0dab93
19 changed files with 185 additions and 223 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
include/v8.h
View File

@ -5726,14 +5726,11 @@ class V8_EXPORT V8 {
/** /**
* A simple Maybe type, representing an object which may or may not have a * A simple Maybe type, representing an object which may or may not have a
* value. * value, see https://hackage.haskell.org/package/base/docs/Data-Maybe.html.
*/ */
template <class T> template <class T>
class Maybe { class Maybe {
public: public:
// TODO(dcarney): remove this constructor, it makes no sense.
Maybe(bool has, const T& t) : has_value(has), value(t) {}
V8_INLINE bool IsJust() const { return has_value; } V8_INLINE bool IsJust() const { return has_value; }
V8_INLINE T FromJust() const { V8_INLINE T FromJust() const {
@ -5747,18 +5744,26 @@ class Maybe {
return has_value ? value : default_value; return has_value ? value : default_value;
} }
// TODO(dcarney): make private. V8_INLINE bool operator==(const Maybe& other) const {
return (IsJust() == other.IsJust()) &&
(!IsJust() || FromJust() == other.FromJust());
}
V8_INLINE bool operator!=(const Maybe& other) const {
return !operator==(other);
}
private:
Maybe() : has_value(false) {}
explicit Maybe(const T& t) : has_value(true), value(t) {}
bool has_value; bool has_value;
T value; T value;
private:
template <class U> template <class U>
friend Maybe<U> Nothing(); friend Maybe<U> Nothing();
template <class U> template <class U>
friend Maybe<U> Just(const U& u); friend Maybe<U> Just(const U& u);
Maybe() : has_value(false) {}
explicit Maybe(const T& t) : has_value(true), value(t) {}
}; };

6
src/api-natives.cc
View File

@ -81,14 +81,14 @@ MaybeHandle<Object> DefineDataProperty(Isolate* isolate,
LookupIterator it(object, Handle<Name>::cast(key), LookupIterator it(object, Handle<Name>::cast(key),
LookupIterator::OWN_SKIP_INTERCEPTOR); LookupIterator::OWN_SKIP_INTERCEPTOR);
Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it); Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it);
DCHECK(maybe.has_value); DCHECK(maybe.IsJust());
duplicate = it.IsFound(); duplicate = it.IsFound();
} else { } else {
uint32_t index = 0; uint32_t index = 0;
key->ToArrayIndex(&index); key->ToArrayIndex(&index);
Maybe<bool> maybe = JSReceiver::HasOwnElement(object, index); Maybe<bool> maybe = JSReceiver::HasOwnElement(object, index);
if (!maybe.has_value) return MaybeHandle<Object>(); if (!maybe.IsJust()) return MaybeHandle<Object>();
duplicate = maybe.value; duplicate = maybe.FromJust();
} }
if (duplicate) { if (duplicate) {
Handle<Object> args[1] = {key}; Handle<Object> args[1] = {key};

38
src/api.cc
View File

@ -1943,9 +1943,9 @@ v8::Local<Value> v8::TryCatch::StackTrace() const {
{ {
EXCEPTION_PREAMBLE(isolate_); EXCEPTION_PREAMBLE(isolate_);
Maybe<bool> maybe = i::JSReceiver::HasProperty(obj, name); 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>()); 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; i::Handle<i::Object> value;
EXCEPTION_PREAMBLE(isolate_); EXCEPTION_PREAMBLE(isolate_);
@ -3358,10 +3358,10 @@ PropertyAttribute v8::Object::GetPropertyAttributes(v8::Handle<Value> key) {
EXCEPTION_PREAMBLE(isolate); EXCEPTION_PREAMBLE(isolate);
Maybe<PropertyAttributes> result = Maybe<PropertyAttributes> result =
i::JSReceiver::GetPropertyAttributes(self, key_name); 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)); EXCEPTION_BAILOUT_CHECK(isolate, static_cast<PropertyAttribute>(NONE));
if (result.value == ABSENT) return static_cast<PropertyAttribute>(NONE); if (result.FromJust() == ABSENT) return static_cast<PropertyAttribute>(NONE);
return static_cast<PropertyAttribute>(result.value); return static_cast<PropertyAttribute>(result.FromJust());
} }
@ -3597,10 +3597,10 @@ bool v8::Object::Has(v8::Handle<Value> key) {
maybe = i::JSReceiver::HasProperty(self, 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); EXCEPTION_BAILOUT_CHECK(isolate, false);
DCHECK(maybe.has_value); DCHECK(maybe.IsJust());
return maybe.value; return maybe.FromJust();
} }
@ -3634,9 +3634,9 @@ bool v8::Object::Has(uint32_t index) {
i::Handle<i::JSObject> self = Utils::OpenHandle(this); i::Handle<i::JSObject> self = Utils::OpenHandle(this);
EXCEPTION_PREAMBLE(isolate); EXCEPTION_PREAMBLE(isolate);
Maybe<bool> maybe = i::JSReceiver::HasElement(self, index); Maybe<bool> maybe = i::JSReceiver::HasElement(self, index);
has_pending_exception = !maybe.has_value; has_pending_exception = !maybe.IsJust();
EXCEPTION_BAILOUT_CHECK(isolate, false); EXCEPTION_BAILOUT_CHECK(isolate, false);
return maybe.value; return maybe.FromJust();
} }
@ -3721,9 +3721,9 @@ bool v8::Object::HasOwnProperty(Handle<String> key) {
EXCEPTION_PREAMBLE(isolate); EXCEPTION_PREAMBLE(isolate);
Maybe<bool> maybe = i::JSReceiver::HasOwnProperty(Utils::OpenHandle(this), Maybe<bool> maybe = i::JSReceiver::HasOwnProperty(Utils::OpenHandle(this),
Utils::OpenHandle(*key)); Utils::OpenHandle(*key));
has_pending_exception = !maybe.has_value; has_pending_exception = !maybe.IsJust();
EXCEPTION_BAILOUT_CHECK(isolate, false); EXCEPTION_BAILOUT_CHECK(isolate, false);
return maybe.value; return maybe.FromJust();
} }
@ -3734,9 +3734,9 @@ bool v8::Object::HasRealNamedProperty(Handle<String> key) {
EXCEPTION_PREAMBLE(isolate); EXCEPTION_PREAMBLE(isolate);
Maybe<bool> maybe = i::JSObject::HasRealNamedProperty( Maybe<bool> maybe = i::JSObject::HasRealNamedProperty(
Utils::OpenHandle(this), Utils::OpenHandle(*key)); Utils::OpenHandle(this), Utils::OpenHandle(*key));
has_pending_exception = !maybe.has_value; has_pending_exception = !maybe.IsJust();
EXCEPTION_BAILOUT_CHECK(isolate, false); EXCEPTION_BAILOUT_CHECK(isolate, false);
return maybe.value; return maybe.FromJust();
} }
@ -3747,9 +3747,9 @@ bool v8::Object::HasRealIndexedProperty(uint32_t index) {
EXCEPTION_PREAMBLE(isolate); EXCEPTION_PREAMBLE(isolate);
Maybe<bool> maybe = Maybe<bool> maybe =
i::JSObject::HasRealElementProperty(Utils::OpenHandle(this), index); i::JSObject::HasRealElementProperty(Utils::OpenHandle(this), index);
has_pending_exception = !maybe.has_value; has_pending_exception = !maybe.IsJust();
EXCEPTION_BAILOUT_CHECK(isolate, false); EXCEPTION_BAILOUT_CHECK(isolate, false);
return maybe.value; return maybe.FromJust();
} }
@ -3762,9 +3762,9 @@ bool v8::Object::HasRealNamedCallbackProperty(Handle<String> key) {
EXCEPTION_PREAMBLE(isolate); EXCEPTION_PREAMBLE(isolate);
Maybe<bool> maybe = i::JSObject::HasRealNamedCallbackProperty( Maybe<bool> maybe = i::JSObject::HasRealNamedCallbackProperty(
Utils::OpenHandle(this), Utils::OpenHandle(*key)); Utils::OpenHandle(this), Utils::OpenHandle(*key));
has_pending_exception = !maybe.has_value; has_pending_exception = !maybe.IsJust();
EXCEPTION_BAILOUT_CHECK(isolate, false); EXCEPTION_BAILOUT_CHECK(isolate, false);
return maybe.value; return maybe.FromJust();
} }
@ -3800,7 +3800,7 @@ static Maybe<PropertyAttribute> GetPropertyAttributesByLookup(
i::LookupIterator* it) { i::LookupIterator* it) {
Maybe<PropertyAttributes> attr = i::JSReceiver::GetPropertyAttributes(it); Maybe<PropertyAttributes> attr = i::JSReceiver::GetPropertyAttributes(it);
return it->IsFound() ? Just<PropertyAttribute>( return it->IsFound() ? Just<PropertyAttribute>(
static_cast<PropertyAttribute>(attr.value)) static_cast<PropertyAttribute>(attr.FromJust()))
: Nothing<PropertyAttribute>(); : Nothing<PropertyAttribute>();
} }

4
src/ast.h
View File

@ -2076,8 +2076,8 @@ class BinaryOperation FINAL : public Expression {
return has_fixed_right_arg_ ? Just(fixed_right_arg_value_) : Nothing<int>(); return has_fixed_right_arg_ ? Just(fixed_right_arg_value_) : Nothing<int>();
} }
void set_fixed_right_arg(Maybe<int> arg) { void set_fixed_right_arg(Maybe<int> arg) {
has_fixed_right_arg_ = arg.has_value; has_fixed_right_arg_ = arg.IsJust();
if (arg.has_value) fixed_right_arg_value_ = arg.value; if (arg.IsJust()) fixed_right_arg_value_ = arg.FromJust();
} }
virtual void RecordToBooleanTypeFeedback( virtual void RecordToBooleanTypeFeedback(

10
src/contexts.cc
View File

@ -122,8 +122,8 @@ static Maybe<PropertyAttributes> UnscopableLookup(LookupIterator* it) {
Isolate* isolate = it->isolate(); Isolate* isolate = it->isolate();
Maybe<PropertyAttributes> attrs = JSReceiver::GetPropertyAttributes(it); Maybe<PropertyAttributes> attrs = JSReceiver::GetPropertyAttributes(it);
DCHECK(attrs.has_value || isolate->has_pending_exception()); DCHECK(attrs.IsJust() || isolate->has_pending_exception());
if (!attrs.has_value || attrs.value == ABSENT) return attrs; if (!attrs.IsJust() || attrs.FromJust() == ABSENT) return attrs;
Handle<Symbol> unscopables_symbol = isolate->factory()->unscopables_symbol(); Handle<Symbol> unscopables_symbol = isolate->factory()->unscopables_symbol();
Handle<Object> receiver = it->GetReceiver(); Handle<Object> receiver = it->GetReceiver();
@ -264,11 +264,11 @@ Handle<Object> Context::Lookup(Handle<String> name,
maybe = JSReceiver::GetPropertyAttributes(object, name); maybe = JSReceiver::GetPropertyAttributes(object, name);
} }
if (!maybe.has_value) return Handle<Object>(); if (!maybe.IsJust()) return Handle<Object>();
DCHECK(!isolate->has_pending_exception()); DCHECK(!isolate->has_pending_exception());
*attributes = maybe.value; *attributes = maybe.FromJust();
if (maybe.value != ABSENT) { if (maybe.FromJust() != ABSENT) {
if (FLAG_trace_contexts) { if (FLAG_trace_contexts) {
PrintF("=> found property in context object %p\n", PrintF("=> found property in context object %p\n",
reinterpret_cast<void*>(*object)); reinterpret_cast<void*>(*object));

4
src/hydrogen-instructions.cc
View File

@ -2946,7 +2946,7 @@ Maybe<HConstant*> HConstant::CopyToTruncatedInt32(Zone* zone) {
HConstant(DoubleToInt32(double_value_), Representation::Integer32(), HConstant(DoubleToInt32(double_value_), Representation::Integer32(),
NotInNewSpace(), object_); NotInNewSpace(), object_);
} }
return Maybe<HConstant*>(res != NULL, res); return res != NULL ? Just(res) : Nothing<HConstant*>();
} }
@ -2962,7 +2962,7 @@ Maybe<HConstant*> HConstant::CopyToTruncatedNumber(Isolate* isolate,
} else if (handle->IsNull()) { } else if (handle->IsNull()) {
res = new(zone) HConstant(0); res = new(zone) HConstant(0);
} }
return Maybe<HConstant*>(res != NULL, res); return res != NULL ? Just(res) : Nothing<HConstant*>();
} }

2
src/hydrogen-representation-changes.cc
View File

@ -29,7 +29,7 @@ void HRepresentationChangesPhase::InsertRepresentationChangeForUse(
// Try to create a new copy of the constant with the new representation. // Try to create a new copy of the constant with the new representation.
if (is_truncating_to_int && to.IsInteger32()) { if (is_truncating_to_int && to.IsInteger32()) {
Maybe<HConstant*> res = constant->CopyToTruncatedInt32(graph()->zone()); Maybe<HConstant*> res = constant->CopyToTruncatedInt32(graph()->zone());
if (res.has_value) new_value = res.value; if (res.IsJust()) new_value = res.FromJust();
} else { } else {
new_value = constant->CopyToRepresentation(to, graph()->zone()); new_value = constant->CopyToRepresentation(to, graph()->zone());
} }

12
src/hydrogen.cc
View File

@ -10341,9 +10341,9 @@ HValue* HGraphBuilder::TruncateToNumber(HValue* value, Type** expected) {
HConstant* constant = HConstant::cast(value); HConstant* constant = HConstant::cast(value);
Maybe<HConstant*> number = Maybe<HConstant*> number =
constant->CopyToTruncatedNumber(isolate(), zone()); constant->CopyToTruncatedNumber(isolate(), zone());
if (number.has_value) { if (number.IsJust()) {
*expected = Type::Number(zone()); *expected = Type::Number(zone());
return AddInstruction(number.value); return AddInstruction(number.FromJust());
} }
} }
@ -10564,10 +10564,10 @@ HValue* HGraphBuilder::BuildBinaryOperation(
instr = AddUncasted<HMul>(left, right); instr = AddUncasted<HMul>(left, right);
break; break;
case Token::MOD: { case Token::MOD: {
if (fixed_right_arg.has_value && if (fixed_right_arg.IsJust() &&
!right->EqualsInteger32Constant(fixed_right_arg.value)) { !right->EqualsInteger32Constant(fixed_right_arg.FromJust())) {
HConstant* fixed_right = Add<HConstant>( HConstant* fixed_right =
static_cast<int>(fixed_right_arg.value)); Add<HConstant>(static_cast<int>(fixed_right_arg.FromJust()));
IfBuilder if_same(this); IfBuilder if_same(this);
if_same.If<HCompareNumericAndBranch>(right, fixed_right, Token::EQ); if_same.If<HCompareNumericAndBranch>(right, fixed_right, Token::EQ);
if_same.Then(); if_same.Then();

24
src/i18n.cc
View File

@ -395,8 +395,8 @@ void SetResolvedNumberSettings(Isolate* isolate,
Handle<String> key = Handle<String> key =
factory->NewStringFromStaticChars("minimumSignificantDigits"); factory->NewStringFromStaticChars("minimumSignificantDigits");
Maybe<bool> maybe = JSReceiver::HasOwnProperty(resolved, key); Maybe<bool> maybe = JSReceiver::HasOwnProperty(resolved, key);
CHECK(maybe.has_value); CHECK(maybe.IsJust());
if (maybe.value) { if (maybe.FromJust()) {
JSObject::SetProperty( JSObject::SetProperty(
resolved, factory->NewStringFromStaticChars("minimumSignificantDigits"), resolved, factory->NewStringFromStaticChars("minimumSignificantDigits"),
factory->NewNumberFromInt(number_format->getMinimumSignificantDigits()), factory->NewNumberFromInt(number_format->getMinimumSignificantDigits()),
@ -405,8 +405,8 @@ void SetResolvedNumberSettings(Isolate* isolate,
key = factory->NewStringFromStaticChars("maximumSignificantDigits"); key = factory->NewStringFromStaticChars("maximumSignificantDigits");
maybe = JSReceiver::HasOwnProperty(resolved, key); maybe = JSReceiver::HasOwnProperty(resolved, key);
CHECK(maybe.has_value); CHECK(maybe.IsJust());
if (maybe.value) { if (maybe.FromJust()) {
JSObject::SetProperty( JSObject::SetProperty(
resolved, factory->NewStringFromStaticChars("maximumSignificantDigits"), resolved, factory->NewStringFromStaticChars("maximumSignificantDigits"),
factory->NewNumberFromInt(number_format->getMaximumSignificantDigits()), factory->NewNumberFromInt(number_format->getMaximumSignificantDigits()),
@ -725,8 +725,8 @@ icu::SimpleDateFormat* DateFormat::UnpackDateFormat(
Handle<String> key = Handle<String> key =
isolate->factory()->NewStringFromStaticChars("dateFormat"); isolate->factory()->NewStringFromStaticChars("dateFormat");
Maybe<bool> maybe = JSReceiver::HasOwnProperty(obj, key); Maybe<bool> maybe = JSReceiver::HasOwnProperty(obj, key);
CHECK(maybe.has_value); CHECK(maybe.IsJust());
if (maybe.value) { if (maybe.FromJust()) {
return reinterpret_cast<icu::SimpleDateFormat*>( return reinterpret_cast<icu::SimpleDateFormat*>(
obj->GetInternalField(0)); obj->GetInternalField(0));
} }
@ -805,8 +805,8 @@ icu::DecimalFormat* NumberFormat::UnpackNumberFormat(
Handle<String> key = Handle<String> key =
isolate->factory()->NewStringFromStaticChars("numberFormat"); isolate->factory()->NewStringFromStaticChars("numberFormat");
Maybe<bool> maybe = JSReceiver::HasOwnProperty(obj, key); Maybe<bool> maybe = JSReceiver::HasOwnProperty(obj, key);
CHECK(maybe.has_value); CHECK(maybe.IsJust());
if (maybe.value) { if (maybe.FromJust()) {
return reinterpret_cast<icu::DecimalFormat*>(obj->GetInternalField(0)); return reinterpret_cast<icu::DecimalFormat*>(obj->GetInternalField(0));
} }
@ -866,8 +866,8 @@ icu::Collator* Collator::UnpackCollator(Isolate* isolate,
Handle<JSObject> obj) { Handle<JSObject> obj) {
Handle<String> key = isolate->factory()->NewStringFromStaticChars("collator"); Handle<String> key = isolate->factory()->NewStringFromStaticChars("collator");
Maybe<bool> maybe = JSReceiver::HasOwnProperty(obj, key); Maybe<bool> maybe = JSReceiver::HasOwnProperty(obj, key);
CHECK(maybe.has_value); CHECK(maybe.IsJust());
if (maybe.value) { if (maybe.FromJust()) {
return reinterpret_cast<icu::Collator*>(obj->GetInternalField(0)); return reinterpret_cast<icu::Collator*>(obj->GetInternalField(0));
} }
@ -931,8 +931,8 @@ icu::BreakIterator* BreakIterator::UnpackBreakIterator(Isolate* isolate,
Handle<String> key = Handle<String> key =
isolate->factory()->NewStringFromStaticChars("breakIterator"); isolate->factory()->NewStringFromStaticChars("breakIterator");
Maybe<bool> maybe = JSReceiver::HasOwnProperty(obj, key); Maybe<bool> maybe = JSReceiver::HasOwnProperty(obj, key);
CHECK(maybe.has_value); CHECK(maybe.IsJust());
if (maybe.value) { if (maybe.FromJust()) {
return reinterpret_cast<icu::BreakIterator*>(obj->GetInternalField(0)); return reinterpret_cast<icu::BreakIterator*>(obj->GetInternalField(0));
} }

38
src/ic/ic-state.cc
View File

@ -45,18 +45,17 @@ STATIC_CONST_MEMBER_DEFINITION const int BinaryOpICState::LAST_TOKEN;
BinaryOpICState::BinaryOpICState(Isolate* isolate, ExtraICState extra_ic_state) BinaryOpICState::BinaryOpICState(Isolate* isolate, ExtraICState extra_ic_state)
: fixed_right_arg_(Nothing<int>()), isolate_(isolate) { : fixed_right_arg_(
HasFixedRightArgField::decode(extra_ic_state)
? Just(1 << FixedRightArgValueField::decode(extra_ic_state))
: Nothing<int>()),
isolate_(isolate) {
op_ = op_ =
static_cast<Token::Value>(FIRST_TOKEN + OpField::decode(extra_ic_state)); static_cast<Token::Value>(FIRST_TOKEN + OpField::decode(extra_ic_state));
fixed_right_arg_ =
Maybe<int>(HasFixedRightArgField::decode(extra_ic_state),
1 << FixedRightArgValueField::decode(extra_ic_state));
left_kind_ = LeftKindField::decode(extra_ic_state); left_kind_ = LeftKindField::decode(extra_ic_state);
if (fixed_right_arg_.has_value) { right_kind_ = fixed_right_arg_.IsJust()
right_kind_ = Smi::IsValid(fixed_right_arg_.value) ? SMI : INT32; ? (Smi::IsValid(fixed_right_arg_.FromJust()) ? SMI : INT32)
} else { : RightKindField::decode(extra_ic_state);
right_kind_ = RightKindField::decode(extra_ic_state);
}
result_kind_ = ResultKindField::decode(extra_ic_state); result_kind_ = ResultKindField::decode(extra_ic_state);
DCHECK_LE(FIRST_TOKEN, op_); DCHECK_LE(FIRST_TOKEN, op_);
DCHECK_LE(op_, LAST_TOKEN); DCHECK_LE(op_, LAST_TOKEN);
@ -67,10 +66,10 @@ ExtraICState BinaryOpICState::GetExtraICState() const {
ExtraICState extra_ic_state = ExtraICState extra_ic_state =
OpField::encode(op_ - FIRST_TOKEN) | LeftKindField::encode(left_kind_) | OpField::encode(op_ - FIRST_TOKEN) | LeftKindField::encode(left_kind_) |
ResultKindField::encode(result_kind_) | ResultKindField::encode(result_kind_) |
HasFixedRightArgField::encode(fixed_right_arg_.has_value); HasFixedRightArgField::encode(fixed_right_arg_.IsJust());
if (fixed_right_arg_.has_value) { if (fixed_right_arg_.IsJust()) {
extra_ic_state = FixedRightArgValueField::update( extra_ic_state = FixedRightArgValueField::update(
extra_ic_state, WhichPowerOf2(fixed_right_arg_.value)); extra_ic_state, WhichPowerOf2(fixed_right_arg_.FromJust()));
} else { } else {
extra_ic_state = RightKindField::update(extra_ic_state, right_kind_); extra_ic_state = RightKindField::update(extra_ic_state, right_kind_);
} }
@ -89,7 +88,7 @@ void BinaryOpICState::GenerateAheadOfTime(
do { \ do { \
BinaryOpICState state(isolate, op); \ BinaryOpICState state(isolate, op); \
state.left_kind_ = left_kind; \ state.left_kind_ = left_kind; \
state.fixed_right_arg_.has_value = false; \ state.fixed_right_arg_ = Nothing<int>(); \
state.right_kind_ = right_kind; \ state.right_kind_ = right_kind; \
state.result_kind_ = result_kind; \ state.result_kind_ = result_kind; \
Generate(isolate, state); \ Generate(isolate, state); \
@ -191,8 +190,7 @@ void BinaryOpICState::GenerateAheadOfTime(
do { \ do { \
BinaryOpICState state(isolate, op); \ BinaryOpICState state(isolate, op); \
state.left_kind_ = left_kind; \ state.left_kind_ = left_kind; \
state.fixed_right_arg_.has_value = true; \ state.fixed_right_arg_ = Just(fixed_right_arg_value); \
state.fixed_right_arg_.value = fixed_right_arg_value; \
state.right_kind_ = SMI; \ state.right_kind_ = SMI; \
state.result_kind_ = result_kind; \ state.result_kind_ = result_kind; \
Generate(isolate, state); \ Generate(isolate, state); \
@ -225,8 +223,8 @@ std::ostream& operator<<(std::ostream& os, const BinaryOpICState& s) {
os << "(" << Token::Name(s.op_); os << "(" << Token::Name(s.op_);
if (s.CouldCreateAllocationMementos()) os << "_CreateAllocationMementos"; if (s.CouldCreateAllocationMementos()) os << "_CreateAllocationMementos";
os << ":" << BinaryOpICState::KindToString(s.left_kind_) << "*"; os << ":" << BinaryOpICState::KindToString(s.left_kind_) << "*";
if (s.fixed_right_arg_.has_value) { if (s.fixed_right_arg_.IsJust()) {
os << s.fixed_right_arg_.value; os << s.fixed_right_arg_.FromJust();
} else { } else {
os << BinaryOpICState::KindToString(s.right_kind_); os << BinaryOpICState::KindToString(s.right_kind_);
} }
@ -248,9 +246,9 @@ void BinaryOpICState::Update(Handle<Object> left, Handle<Object> right,
base::bits::IsPowerOfTwo32(fixed_right_arg_value) && base::bits::IsPowerOfTwo32(fixed_right_arg_value) &&
FixedRightArgValueField::is_valid(WhichPowerOf2(fixed_right_arg_value)) && FixedRightArgValueField::is_valid(WhichPowerOf2(fixed_right_arg_value)) &&
(left_kind_ == SMI || left_kind_ == INT32) && (left_kind_ == SMI || left_kind_ == INT32) &&
(result_kind_ == NONE || !fixed_right_arg_.has_value); (result_kind_ == NONE || !fixed_right_arg_.IsJust());
fixed_right_arg_ = Maybe<int32_t>(has_fixed_right_arg, fixed_right_arg_value); fixed_right_arg_ =
has_fixed_right_arg ? Just(fixed_right_arg_value) : Nothing<int32_t>();
result_kind_ = UpdateKind(result, result_kind_); result_kind_ = UpdateKind(result, result_kind_);
if (!Token::IsTruncatingBinaryOp(op_)) { if (!Token::IsTruncatingBinaryOp(op_)) {

8
src/objects-inl.h
View File

@ -6961,7 +6961,7 @@ Maybe<bool> JSReceiver::HasProperty(Handle<JSReceiver> object,
return JSProxy::HasPropertyWithHandler(proxy, name); return JSProxy::HasPropertyWithHandler(proxy, name);
} }
Maybe<PropertyAttributes> result = GetPropertyAttributes(object, name); Maybe<PropertyAttributes> result = GetPropertyAttributes(object, name);
return result.has_value ? Just(result.value != ABSENT) : Nothing<bool>(); return result.IsJust() ? Just(result.FromJust() != ABSENT) : Nothing<bool>();
} }
@ -6972,7 +6972,7 @@ Maybe<bool> JSReceiver::HasOwnProperty(Handle<JSReceiver> object,
return JSProxy::HasPropertyWithHandler(proxy, name); return JSProxy::HasPropertyWithHandler(proxy, name);
} }
Maybe<PropertyAttributes> result = GetOwnPropertyAttributes(object, name); Maybe<PropertyAttributes> result = GetOwnPropertyAttributes(object, name);
return result.has_value ? Just(result.value != ABSENT) : Nothing<bool>(); return result.IsJust() ? Just(result.FromJust() != ABSENT) : Nothing<bool>();
} }
@ -7031,7 +7031,7 @@ Maybe<bool> JSReceiver::HasElement(Handle<JSReceiver> object, uint32_t index) {
} }
Maybe<PropertyAttributes> result = JSObject::GetElementAttributeWithReceiver( Maybe<PropertyAttributes> result = JSObject::GetElementAttributeWithReceiver(
Handle<JSObject>::cast(object), object, index, true); Handle<JSObject>::cast(object), object, index, true);
return result.has_value ? Just(result.value != ABSENT) : Nothing<bool>(); return result.IsJust() ? Just(result.FromJust() != ABSENT) : Nothing<bool>();
} }
@ -7043,7 +7043,7 @@ Maybe<bool> JSReceiver::HasOwnElement(Handle<JSReceiver> object,
} }
Maybe<PropertyAttributes> result = JSObject::GetElementAttributeWithReceiver( Maybe<PropertyAttributes> result = JSObject::GetElementAttributeWithReceiver(
Handle<JSObject>::cast(object), object, index, false); Handle<JSObject>::cast(object), object, index, false);
return result.has_value ? Just(result.value != ABSENT) : Nothing<bool>(); return result.IsJust() ? Just(result.FromJust() != ABSENT) : Nothing<bool>();
} }

73
src/objects.cc
View File

@ -487,7 +487,7 @@ Maybe<PropertyAttributes> JSObject::GetPropertyAttributesWithFailedAccessCheck(
auto result = GetPropertyAttributesWithInterceptor( auto result = GetPropertyAttributesWithInterceptor(
it->GetHolder<JSObject>(), it->GetReceiver(), it->name()); it->GetHolder<JSObject>(), it->GetReceiver(), it->name());
if (it->isolate()->has_scheduled_exception()) break; if (it->isolate()->has_scheduled_exception()) break;
if (result.has_value && result.value != ABSENT) return result; if (result.IsJust() && result.FromJust() != ABSENT) return result;
} }
it->isolate()->ReportFailedAccessCheck(checked); it->isolate()->ReportFailedAccessCheck(checked);
RETURN_VALUE_IF_SCHEDULED_EXCEPTION(it->isolate(), RETURN_VALUE_IF_SCHEDULED_EXCEPTION(it->isolate(),
@ -625,7 +625,7 @@ Maybe<PropertyAttributes> JSObject::GetElementAttributesWithFailedAccessCheck(
auto result = auto result =
JSObject::GetElementAttributeFromInterceptor(object, receiver, index); JSObject::GetElementAttributeFromInterceptor(object, receiver, index);
if (isolate->has_scheduled_exception()) break; if (isolate->has_scheduled_exception()) break;
if (result.has_value && result.value != ABSENT) return result; if (result.IsJust() && result.FromJust() != ABSENT) return result;
where_to_start = PrototypeIterator::START_AT_PROTOTYPE; where_to_start = PrototypeIterator::START_AT_PROTOTYPE;
} }
isolate->ReportFailedAccessCheck(object); isolate->ReportFailedAccessCheck(object);
@ -723,12 +723,12 @@ MaybeHandle<Object> Object::SetElementWithReceiver(
Maybe<PropertyAttributes> from_interceptor = Maybe<PropertyAttributes> from_interceptor =
JSObject::GetElementAttributeFromInterceptor(js_object, receiver, JSObject::GetElementAttributeFromInterceptor(js_object, receiver,
index); index);
if (!from_interceptor.has_value) return MaybeHandle<Object>(); if (!from_interceptor.IsJust()) return MaybeHandle<Object>();
if ((from_interceptor.value & READ_ONLY) != 0) { if ((from_interceptor.FromJust() & READ_ONLY) != 0) {
return WriteToReadOnlyElement(isolate, receiver, index, value, return WriteToReadOnlyElement(isolate, receiver, index, value,
language_mode); language_mode);
} }
done = from_interceptor.value != ABSENT; done = from_interceptor.FromJust() != ABSENT;
} }
if (!done && if (!done &&
@ -3118,9 +3118,9 @@ MaybeHandle<Object> Object::SetPropertyInternal(LookupIterator* it,
Maybe<PropertyAttributes> maybe_attributes = Maybe<PropertyAttributes> maybe_attributes =
JSObject::GetPropertyAttributesWithInterceptor( JSObject::GetPropertyAttributesWithInterceptor(
it->GetHolder<JSObject>(), it->GetReceiver(), it->name()); it->GetHolder<JSObject>(), it->GetReceiver(), it->name());
if (!maybe_attributes.has_value) return MaybeHandle<Object>(); if (!maybe_attributes.IsJust()) return MaybeHandle<Object>();
done = maybe_attributes.value != ABSENT; done = maybe_attributes.FromJust() != ABSENT;
if (done && (maybe_attributes.value & READ_ONLY) != 0) { if (done && (maybe_attributes.FromJust() & READ_ONLY) != 0) {
return WriteToReadOnlyProperty(it, value, language_mode); return WriteToReadOnlyProperty(it, value, language_mode);
} }
} }
@ -4162,7 +4162,7 @@ void JSObject::AddProperty(Handle<JSObject> object, Handle<Name> name,
DCHECK(!object->IsJSProxy()); DCHECK(!object->IsJSProxy());
DCHECK(!name->AsArrayIndex(&index)); DCHECK(!name->AsArrayIndex(&index));
Maybe<PropertyAttributes> maybe = GetPropertyAttributes(&it); Maybe<PropertyAttributes> maybe = GetPropertyAttributes(&it);
DCHECK(maybe.has_value); DCHECK(maybe.IsJust());
DCHECK(!it.IsFound()); DCHECK(!it.IsFound());
DCHECK(object->map()->is_extensible() || DCHECK(object->map()->is_extensible() ||
it.isolate()->IsInternallyUsedPropertyName(name)); it.isolate()->IsInternallyUsedPropertyName(name));
@ -4357,8 +4357,8 @@ Maybe<PropertyAttributes> JSReceiver::GetPropertyAttributes(
Maybe<PropertyAttributes> result = Maybe<PropertyAttributes> result =
JSObject::GetPropertyAttributesWithInterceptor( JSObject::GetPropertyAttributesWithInterceptor(
it->GetHolder<JSObject>(), it->GetReceiver(), it->name()); it->GetHolder<JSObject>(), it->GetReceiver(), it->name());
if (!result.has_value) return result; if (!result.IsJust()) return result;
if (result.value != ABSENT) return result; if (result.FromJust() != ABSENT) return result;
break; break;
} }
case LookupIterator::ACCESS_CHECK: case LookupIterator::ACCESS_CHECK:
@ -4418,8 +4418,9 @@ Maybe<PropertyAttributes> JSObject::GetElementAttributeWithInterceptor(
Maybe<PropertyAttributes> from_interceptor = Maybe<PropertyAttributes> from_interceptor =
GetElementAttributeFromInterceptor(object, receiver, index); GetElementAttributeFromInterceptor(object, receiver, index);
if (!from_interceptor.has_value) return Nothing<PropertyAttributes>(); if (!from_interceptor.IsJust()) return Nothing<PropertyAttributes>();
if (from_interceptor.value != ABSENT) return Just(from_interceptor.value); if (from_interceptor.FromJust() != ABSENT)
return Just(from_interceptor.FromJust());
return GetElementAttributeWithoutInterceptor(object, receiver, index, return GetElementAttributeWithoutInterceptor(object, receiver, index,
check_prototype); check_prototype);
@ -5086,8 +5087,8 @@ bool JSObject::HasHiddenProperties(Handle<JSObject> object) {
LookupIterator it(object, hidden, LookupIterator::OWN_SKIP_INTERCEPTOR); LookupIterator it(object, hidden, LookupIterator::OWN_SKIP_INTERCEPTOR);
Maybe<PropertyAttributes> maybe = GetPropertyAttributes(&it); Maybe<PropertyAttributes> maybe = GetPropertyAttributes(&it);
// Cannot get an exception since the hidden_string isn't accessible to JS. // Cannot get an exception since the hidden_string isn't accessible to JS.
DCHECK(maybe.has_value); DCHECK(maybe.IsJust());
return maybe.value != ABSENT; return maybe.FromJust() != ABSENT;
} }
@ -5262,8 +5263,8 @@ MaybeHandle<Object> JSObject::DeleteElement(Handle<JSObject> object,
bool should_enqueue_change_record = false; bool should_enqueue_change_record = false;
if (object->map()->is_observed()) { if (object->map()->is_observed()) {
Maybe<bool> maybe = HasOwnElement(object, index); Maybe<bool> maybe = HasOwnElement(object, index);
if (!maybe.has_value) return MaybeHandle<Object>(); if (!maybe.IsJust()) return MaybeHandle<Object>();
should_enqueue_change_record = maybe.value; should_enqueue_change_record = maybe.FromJust();
if (should_enqueue_change_record) { if (should_enqueue_change_record) {
if (!GetOwnElementAccessorPair(object, index).is_null()) { if (!GetOwnElementAccessorPair(object, index).is_null()) {
old_value = Handle<Object>::cast(factory->the_hole_value()); old_value = Handle<Object>::cast(factory->the_hole_value());
@ -5287,8 +5288,8 @@ MaybeHandle<Object> JSObject::DeleteElement(Handle<JSObject> object,
if (should_enqueue_change_record) { if (should_enqueue_change_record) {
Maybe<bool> maybe = HasOwnElement(object, index); Maybe<bool> maybe = HasOwnElement(object, index);
if (!maybe.has_value) return MaybeHandle<Object>(); if (!maybe.IsJust()) return MaybeHandle<Object>();
if (!maybe.value) { if (!maybe.FromJust()) {
Handle<String> name = factory->Uint32ToString(index); Handle<String> name = factory->Uint32ToString(index);
RETURN_ON_EXCEPTION( RETURN_ON_EXCEPTION(
isolate, EnqueueChangeRecord(object, "delete", name, old_value), isolate, EnqueueChangeRecord(object, "delete", name, old_value),
@ -5939,8 +5940,8 @@ MaybeHandle<JSObject> JSObjectWalkVisitor<ContextObject>::StructureWalk(
Handle<String> key_string(String::cast(names->get(i))); Handle<String> key_string(String::cast(names->get(i)));
Maybe<PropertyAttributes> maybe = Maybe<PropertyAttributes> maybe =
JSReceiver::GetOwnPropertyAttributes(copy, key_string); JSReceiver::GetOwnPropertyAttributes(copy, key_string);
DCHECK(maybe.has_value); DCHECK(maybe.IsJust());
PropertyAttributes attributes = maybe.value; PropertyAttributes attributes = maybe.FromJust();
// Only deep copy fields from the object literal expression. // Only deep copy fields from the object literal expression.
// In particular, don't try to copy the length attribute of // In particular, don't try to copy the length attribute of
// an array. // an array.
@ -6599,18 +6600,18 @@ MaybeHandle<Object> JSObject::DefineAccessor(Handle<JSObject> object,
Maybe<bool> maybe = HasOwnElement(object, index); Maybe<bool> maybe = HasOwnElement(object, index);
// Workaround for a GCC 4.4.3 bug which leads to "‘preexists’ may be used // Workaround for a GCC 4.4.3 bug which leads to "‘preexists’ may be used
// uninitialized in this function". // uninitialized in this function".
if (!maybe.has_value) { if (!maybe.IsJust()) {
DCHECK(false); DCHECK(false);
return isolate->factory()->undefined_value(); return isolate->factory()->undefined_value();
} }
preexists = maybe.value; preexists = maybe.FromJust();
if (preexists && GetOwnElementAccessorPair(object, index).is_null()) { if (preexists && GetOwnElementAccessorPair(object, index).is_null()) {
old_value = old_value =
Object::GetElement(isolate, object, index).ToHandleChecked(); Object::GetElement(isolate, object, index).ToHandleChecked();
} }
} else { } else {
LookupIterator it(object, name, LookupIterator::HIDDEN_SKIP_INTERCEPTOR); LookupIterator it(object, name, LookupIterator::HIDDEN_SKIP_INTERCEPTOR);
CHECK(GetPropertyAttributes(&it).has_value); CHECK(GetPropertyAttributes(&it).IsJust());
preexists = it.IsFound(); preexists = it.IsFound();
if (preexists && (it.state() == LookupIterator::DATA || if (preexists && (it.state() == LookupIterator::DATA ||
it.GetAccessors()->IsAccessorInfo())) { it.GetAccessors()->IsAccessorInfo())) {
@ -6716,7 +6717,7 @@ MaybeHandle<Object> JSObject::SetAccessor(Handle<JSObject> object,
} else { } else {
// Lookup the name. // Lookup the name.
LookupIterator it(object, name, LookupIterator::HIDDEN_SKIP_INTERCEPTOR); LookupIterator it(object, name, LookupIterator::HIDDEN_SKIP_INTERCEPTOR);
CHECK(GetPropertyAttributes(&it).has_value); CHECK(GetPropertyAttributes(&it).IsJust());
// ES5 forbids turning a property into an accessor if it's not // ES5 forbids turning a property into an accessor if it's not
// configurable. See 8.6.1 (Table 5). // configurable. See 8.6.1 (Table 5).
if (it.IsFound() && (it.IsReadOnly() || !it.IsConfigurable())) { if (it.IsFound() && (it.IsReadOnly() || !it.IsConfigurable())) {
@ -11804,9 +11805,9 @@ static bool GetOldValue(Isolate* isolate,
List<uint32_t>* indices) { List<uint32_t>* indices) {
Maybe<PropertyAttributes> maybe = Maybe<PropertyAttributes> maybe =
JSReceiver::GetOwnElementAttribute(object, index); JSReceiver::GetOwnElementAttribute(object, index);
DCHECK(maybe.has_value); DCHECK(maybe.IsJust());
DCHECK(maybe.value != ABSENT); DCHECK(maybe.FromJust() != ABSENT);
if (maybe.value == DONT_DELETE) return false; if (maybe.FromJust() == DONT_DELETE) return false;
Handle<Object> value; Handle<Object> value;
if (!JSObject::GetOwnElementAccessorPair(object, index).is_null()) { if (!JSObject::GetOwnElementAccessorPair(object, index).is_null()) {
value = Handle<Object>::cast(isolate->factory()->the_hole_value()); value = Handle<Object>::cast(isolate->factory()->the_hole_value());
@ -13086,8 +13087,8 @@ MaybeHandle<Object> JSObject::SetElement(Handle<JSObject> object,
Maybe<PropertyAttributes> maybe = Maybe<PropertyAttributes> maybe =
JSReceiver::GetOwnElementAttribute(object, index); JSReceiver::GetOwnElementAttribute(object, index);
if (!maybe.has_value) return MaybeHandle<Object>(); if (!maybe.IsJust()) return MaybeHandle<Object>();
PropertyAttributes old_attributes = maybe.value; PropertyAttributes old_attributes = maybe.FromJust();
Handle<Object> old_value = isolate->factory()->the_hole_value(); Handle<Object> old_value = isolate->factory()->the_hole_value();
Handle<Object> old_length_handle; Handle<Object> old_length_handle;
@ -13117,8 +13118,8 @@ MaybeHandle<Object> JSObject::SetElement(Handle<JSObject> object,
Handle<String> name = isolate->factory()->Uint32ToString(index); Handle<String> name = isolate->factory()->Uint32ToString(index);
maybe = GetOwnElementAttribute(object, index); maybe = GetOwnElementAttribute(object, index);
if (!maybe.has_value) return MaybeHandle<Object>(); if (!maybe.IsJust()) return MaybeHandle<Object>();
PropertyAttributes new_attributes = maybe.value; PropertyAttributes new_attributes = maybe.FromJust();
if (old_attributes == ABSENT) { if (old_attributes == ABSENT) {
if (object->IsJSArray() && if (object->IsJSArray() &&
@ -13915,7 +13916,7 @@ Maybe<bool> JSObject::HasRealNamedProperty(Handle<JSObject> object,
Handle<Name> key) { Handle<Name> key) {
LookupIterator it(object, key, LookupIterator::OWN_SKIP_INTERCEPTOR); LookupIterator it(object, key, LookupIterator::OWN_SKIP_INTERCEPTOR);
Maybe<PropertyAttributes> maybe_result = GetPropertyAttributes(&it); Maybe<PropertyAttributes> maybe_result = GetPropertyAttributes(&it);
if (!maybe_result.has_value) return Nothing<bool>(); if (!maybe_result.IsJust()) return Nothing<bool>();
return Just(it.IsFound()); return Just(it.IsFound());
} }
@ -13944,7 +13945,7 @@ Maybe<bool> JSObject::HasRealElementProperty(Handle<JSObject> object,
Maybe<PropertyAttributes> result = Maybe<PropertyAttributes> result =
GetElementAttributeWithoutInterceptor(object, object, index, false); GetElementAttributeWithoutInterceptor(object, object, index, false);
return result.has_value ? Just(result.value != ABSENT) : Nothing<bool>(); return result.IsJust() ? Just(result.FromJust() != ABSENT) : Nothing<bool>();
} }
@ -13952,8 +13953,8 @@ Maybe<bool> JSObject::HasRealNamedCallbackProperty(Handle<JSObject> object,
Handle<Name> key) { Handle<Name> key) {
LookupIterator it(object, key, LookupIterator::OWN_SKIP_INTERCEPTOR); LookupIterator it(object, key, LookupIterator::OWN_SKIP_INTERCEPTOR);
Maybe<PropertyAttributes> maybe_result = GetPropertyAttributes(&it); Maybe<PropertyAttributes> maybe_result = GetPropertyAttributes(&it);
return maybe_result.has_value ? Just(it.state() == LookupIterator::ACCESSOR) return maybe_result.IsJust() ? Just(it.state() == LookupIterator::ACCESSOR)
: Nothing<bool>(); : Nothing<bool>();
} }

12
src/runtime/runtime-array.cc
View File

@ -444,8 +444,8 @@ static bool IterateElementsSlow(Isolate* isolate, Handle<JSObject> receiver,
for (uint32_t i = 0; i < length; ++i) { for (uint32_t i = 0; i < length; ++i) {
HandleScope loop_scope(isolate); HandleScope loop_scope(isolate);
Maybe<bool> maybe = JSReceiver::HasElement(receiver, i); Maybe<bool> maybe = JSReceiver::HasElement(receiver, i);
if (!maybe.has_value) return false; if (!maybe.IsJust()) return false;
if (maybe.value) { if (maybe.FromJust()) {
Handle<Object> element_value; Handle<Object> element_value;
ASSIGN_RETURN_ON_EXCEPTION_VALUE( ASSIGN_RETURN_ON_EXCEPTION_VALUE(
isolate, element_value, isolate, element_value,
@ -511,8 +511,8 @@ static bool IterateElements(Isolate* isolate, Handle<JSObject> receiver,
visitor->visit(j, element_value); visitor->visit(j, element_value);
} else { } else {
Maybe<bool> maybe = JSReceiver::HasElement(receiver, j); Maybe<bool> maybe = JSReceiver::HasElement(receiver, j);
if (!maybe.has_value) return false; if (!maybe.IsJust()) return false;
if (maybe.value) { if (maybe.FromJust()) {
// Call GetElement on receiver, not its prototype, or getters won't // Call GetElement on receiver, not its prototype, or getters won't
// have the correct receiver. // have the correct receiver.
ASSIGN_RETURN_ON_EXCEPTION_VALUE( ASSIGN_RETURN_ON_EXCEPTION_VALUE(
@ -547,8 +547,8 @@ static bool IterateElements(Isolate* isolate, Handle<JSObject> receiver,
visitor->visit(j, element_value); visitor->visit(j, element_value);
} else { } else {
Maybe<bool> maybe = JSReceiver::HasElement(receiver, j); Maybe<bool> maybe = JSReceiver::HasElement(receiver, j);
if (!maybe.has_value) return false; if (!maybe.IsJust()) return false;
if (maybe.value) { if (maybe.FromJust()) {
// Call GetElement on receiver, not its prototype, or getters won't // Call GetElement on receiver, not its prototype, or getters won't
// have the correct receiver. // have the correct receiver.
Handle<Object> element_value; Handle<Object> element_value;

12
src/runtime/runtime-debug.cc
View File

@ -913,8 +913,8 @@ static bool SetLocalVariableValue(Isolate* isolate, JavaScriptFrame* frame,
Handle<JSObject> ext(JSObject::cast(function_context->extension())); Handle<JSObject> ext(JSObject::cast(function_context->extension()));
Maybe<bool> maybe = JSReceiver::HasProperty(ext, variable_name); Maybe<bool> maybe = JSReceiver::HasProperty(ext, variable_name);
DCHECK(maybe.has_value); DCHECK(maybe.IsJust());
if (maybe.value) { if (maybe.FromJust()) {
// We don't expect this to do anything except replacing // We don't expect this to do anything except replacing
// property value. // property value.
Runtime::SetObjectProperty(isolate, ext, variable_name, new_value, Runtime::SetObjectProperty(isolate, ext, variable_name, new_value,
@ -996,8 +996,8 @@ static bool SetClosureVariableValue(Isolate* isolate, Handle<Context> context,
if (context->has_extension()) { if (context->has_extension()) {
Handle<JSObject> ext(JSObject::cast(context->extension())); Handle<JSObject> ext(JSObject::cast(context->extension()));
Maybe<bool> maybe = JSReceiver::HasProperty(ext, variable_name); Maybe<bool> maybe = JSReceiver::HasProperty(ext, variable_name);
DCHECK(maybe.has_value); DCHECK(maybe.IsJust());
if (maybe.value) { if (maybe.FromJust()) {
// We don't expect this to do anything except replacing property value. // We don't expect this to do anything except replacing property value.
Runtime::DefineObjectProperty(ext, variable_name, new_value, NONE) Runtime::DefineObjectProperty(ext, variable_name, new_value, NONE)
.Assert(); .Assert();
@ -2113,8 +2113,8 @@ MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeArgumentsObject(
if (!function->shared()->is_function()) return target; if (!function->shared()->is_function()) return target;
Maybe<bool> maybe = JSReceiver::HasOwnProperty( Maybe<bool> maybe = JSReceiver::HasOwnProperty(
target, isolate->factory()->arguments_string()); target, isolate->factory()->arguments_string());
if (!maybe.has_value) return MaybeHandle<JSObject>(); if (!maybe.IsJust()) return MaybeHandle<JSObject>();
if (maybe.value) return target; if (maybe.FromJust()) return target;
// FunctionGetArguments can't throw an exception. // FunctionGetArguments can't throw an exception.
Handle<JSObject> arguments = Handle<JSObject> arguments =

32
src/runtime/runtime-object.cc
View File

@ -368,8 +368,8 @@ MUST_USE_RESULT static MaybeHandle<Object> GetOwnProperty(Isolate* isolate,
// Get attributes. // Get attributes.
Maybe<PropertyAttributes> maybe = Maybe<PropertyAttributes> maybe =
JSReceiver::GetOwnElementAttribute(obj, index); JSReceiver::GetOwnElementAttribute(obj, index);
if (!maybe.has_value) return MaybeHandle<Object>(); if (!maybe.IsJust()) return MaybeHandle<Object>();
attrs = maybe.value; attrs = maybe.FromJust();
if (attrs == ABSENT) return factory->undefined_value(); if (attrs == ABSENT) return factory->undefined_value();
// Get AccessorPair if present. // Get AccessorPair if present.
@ -385,8 +385,8 @@ MUST_USE_RESULT static MaybeHandle<Object> GetOwnProperty(Isolate* isolate,
// Get attributes. // Get attributes.
LookupIterator it(obj, name, LookupIterator::HIDDEN); LookupIterator it(obj, name, LookupIterator::HIDDEN);
Maybe<PropertyAttributes> maybe = JSObject::GetPropertyAttributes(&it); Maybe<PropertyAttributes> maybe = JSObject::GetPropertyAttributes(&it);
if (!maybe.has_value) return MaybeHandle<Object>(); if (!maybe.IsJust()) return MaybeHandle<Object>();
attrs = maybe.value; attrs = maybe.FromJust();
if (attrs == ABSENT) return factory->undefined_value(); if (attrs == ABSENT) return factory->undefined_value();
// Get AccessorPair if present. // Get AccessorPair if present.
@ -667,7 +667,7 @@ RUNTIME_FUNCTION(Runtime_AddNamedProperty) {
DCHECK(!key->ToArrayIndex(&index)); DCHECK(!key->ToArrayIndex(&index));
LookupIterator it(object, key, LookupIterator::OWN_SKIP_INTERCEPTOR); LookupIterator it(object, key, LookupIterator::OWN_SKIP_INTERCEPTOR);
Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it); Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it);
if (!maybe.has_value) return isolate->heap()->exception(); if (!maybe.IsJust()) return isolate->heap()->exception();
RUNTIME_ASSERT(!it.IsFound()); RUNTIME_ASSERT(!it.IsFound());
#endif #endif
@ -736,8 +736,8 @@ static Object* HasOwnPropertyImplementation(Isolate* isolate,
Handle<JSObject> object, Handle<JSObject> object,
Handle<Name> key) { Handle<Name> key) {
Maybe<bool> maybe = JSReceiver::HasOwnProperty(object, key); Maybe<bool> maybe = JSReceiver::HasOwnProperty(object, key);
if (!maybe.has_value) return isolate->heap()->exception(); if (!maybe.IsJust()) return isolate->heap()->exception();
if (maybe.value) return isolate->heap()->true_value(); if (maybe.FromJust()) return isolate->heap()->true_value();
// Handle hidden prototypes. If there's a hidden prototype above this thing // Handle hidden prototypes. If there's a hidden prototype above this thing
// then we have to check it for properties, because they are supposed to // then we have to check it for properties, because they are supposed to
// look like they are on this object. // look like they are on this object.
@ -778,9 +778,9 @@ RUNTIME_FUNCTION(Runtime_HasOwnProperty) {
} else { } else {
maybe = JSObject::HasRealNamedProperty(js_obj, key); maybe = JSObject::HasRealNamedProperty(js_obj, key);
} }
if (!maybe.has_value) return isolate->heap()->exception(); if (!maybe.IsJust()) return isolate->heap()->exception();
DCHECK(!isolate->has_pending_exception()); DCHECK(!isolate->has_pending_exception());
if (maybe.value) { if (maybe.FromJust()) {
return isolate->heap()->true_value(); return isolate->heap()->true_value();
} }
Map* map = js_obj->map(); Map* map = js_obj->map();
@ -809,8 +809,8 @@ RUNTIME_FUNCTION(Runtime_HasProperty) {
CONVERT_ARG_HANDLE_CHECKED(Name, key, 1); CONVERT_ARG_HANDLE_CHECKED(Name, key, 1);
Maybe<bool> maybe = JSReceiver::HasProperty(receiver, key); Maybe<bool> maybe = JSReceiver::HasProperty(receiver, key);
if (!maybe.has_value) return isolate->heap()->exception(); if (!maybe.IsJust()) return isolate->heap()->exception();
return isolate->heap()->ToBoolean(maybe.value); return isolate->heap()->ToBoolean(maybe.FromJust());
} }
@ -821,8 +821,8 @@ RUNTIME_FUNCTION(Runtime_HasElement) {
CONVERT_SMI_ARG_CHECKED(index, 1); CONVERT_SMI_ARG_CHECKED(index, 1);
Maybe<bool> maybe = JSReceiver::HasElement(receiver, index); Maybe<bool> maybe = JSReceiver::HasElement(receiver, index);
if (!maybe.has_value) return isolate->heap()->exception(); if (!maybe.IsJust()) return isolate->heap()->exception();
return isolate->heap()->ToBoolean(maybe.value); return isolate->heap()->ToBoolean(maybe.FromJust());
} }
@ -835,9 +835,9 @@ RUNTIME_FUNCTION(Runtime_IsPropertyEnumerable) {
Maybe<PropertyAttributes> maybe = Maybe<PropertyAttributes> maybe =
JSReceiver::GetOwnPropertyAttributes(object, key); JSReceiver::GetOwnPropertyAttributes(object, key);
if (!maybe.has_value) return isolate->heap()->exception(); if (!maybe.IsJust()) return isolate->heap()->exception();
if (maybe.value == ABSENT) maybe.value = DONT_ENUM; if (maybe.FromJust() == ABSENT) maybe = Just(DONT_ENUM);
return isolate->heap()->ToBoolean((maybe.value & DONT_ENUM) == 0); return isolate->heap()->ToBoolean((maybe.FromJust() & DONT_ENUM) == 0);
} }

16
src/runtime/runtime-scopes.cc
View File

@ -46,10 +46,10 @@ static Object* DeclareGlobals(Isolate* isolate, Handle<GlobalObject> global,
// Do the lookup own properties only, see ES5 erratum. // Do the lookup own properties only, see ES5 erratum.
LookupIterator it(global, name, LookupIterator::HIDDEN_SKIP_INTERCEPTOR); LookupIterator it(global, name, LookupIterator::HIDDEN_SKIP_INTERCEPTOR);
Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it); Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it);
if (!maybe.has_value) return isolate->heap()->exception(); if (!maybe.IsJust()) return isolate->heap()->exception();
if (it.IsFound()) { if (it.IsFound()) {
PropertyAttributes old_attributes = maybe.value; PropertyAttributes old_attributes = maybe.FromJust();
// The name was declared before; check for conflicting re-declarations. // The name was declared before; check for conflicting re-declarations.
if (is_const) return ThrowRedeclarationError(isolate, name); if (is_const) return ThrowRedeclarationError(isolate, name);
@ -178,8 +178,8 @@ RUNTIME_FUNCTION(Runtime_InitializeConstGlobal) {
// Lookup the property as own on the global object. // Lookup the property as own on the global object.
LookupIterator it(global, name, LookupIterator::HIDDEN_SKIP_INTERCEPTOR); LookupIterator it(global, name, LookupIterator::HIDDEN_SKIP_INTERCEPTOR);
Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it); Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it);
DCHECK(maybe.has_value); DCHECK(maybe.IsJust());
PropertyAttributes old_attributes = maybe.value; PropertyAttributes old_attributes = maybe.FromJust();
PropertyAttributes attr = PropertyAttributes attr =
static_cast<PropertyAttributes>(DONT_DELETE | READ_ONLY); static_cast<PropertyAttributes>(DONT_DELETE | READ_ONLY);
@ -331,8 +331,8 @@ RUNTIME_FUNCTION(Runtime_InitializeLegacyConstLookupSlot) {
LookupIterator it(holder, name, LookupIterator::HIDDEN_SKIP_INTERCEPTOR); LookupIterator it(holder, name, LookupIterator::HIDDEN_SKIP_INTERCEPTOR);
Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it); Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it);
if (!maybe.has_value) return isolate->heap()->exception(); if (!maybe.IsJust()) return isolate->heap()->exception();
PropertyAttributes old_attributes = maybe.value; PropertyAttributes old_attributes = maybe.FromJust();
// Ignore if we can't reconfigure the value. // Ignore if we can't reconfigure the value.
if ((old_attributes & DONT_DELETE) != 0) { if ((old_attributes & DONT_DELETE) != 0) {
@ -596,8 +596,8 @@ static Object* FindNameClash(Handle<ScopeInfo> scope_info,
LookupIterator it(global_object, name, LookupIterator it(global_object, name,
LookupIterator::HIDDEN_SKIP_INTERCEPTOR); LookupIterator::HIDDEN_SKIP_INTERCEPTOR);
Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it); Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it);
if (!maybe.has_value) return isolate->heap()->exception(); if (!maybe.IsJust()) return isolate->heap()->exception();
if ((maybe.value & DONT_DELETE) != 0) { if ((maybe.FromJust() & DONT_DELETE) != 0) {
return ThrowRedeclarationError(isolate, name); return ThrowRedeclarationError(isolate, name);
} }

12
test/cctest/test-api.cc
View File

@ -10716,8 +10716,7 @@ THREADED_TEST(VariousGetPropertiesAndThrowingCallbacks) {
Maybe<PropertyAttribute> attr = Maybe<PropertyAttribute> attr =
instance->GetRealNamedPropertyAttributes(v8_str("f")); instance->GetRealNamedPropertyAttributes(v8_str("f"));
CHECK(!try_catch.HasCaught()); CHECK(!try_catch.HasCaught());
CHECK(attr.has_value); CHECK(Just(None) == attr);
CHECK_EQ(attr.value, None);
result = another->GetRealNamedProperty(v8_str("f")); result = another->GetRealNamedProperty(v8_str("f"));
CHECK(try_catch.HasCaught()); CHECK(try_catch.HasCaught());
@ -10726,8 +10725,7 @@ THREADED_TEST(VariousGetPropertiesAndThrowingCallbacks) {
attr = another->GetRealNamedPropertyAttributes(v8_str("f")); attr = another->GetRealNamedPropertyAttributes(v8_str("f"));
CHECK(!try_catch.HasCaught()); CHECK(!try_catch.HasCaught());
CHECK(attr.has_value); CHECK(Just(None) == attr);
CHECK_EQ(attr.value, None);
result = another->GetRealNamedPropertyInPrototypeChain(v8_str("f")); result = another->GetRealNamedPropertyInPrototypeChain(v8_str("f"));
CHECK(try_catch.HasCaught()); CHECK(try_catch.HasCaught());
@ -10736,8 +10734,7 @@ THREADED_TEST(VariousGetPropertiesAndThrowingCallbacks) {
attr = another->GetRealNamedPropertyAttributesInPrototypeChain(v8_str("f")); attr = another->GetRealNamedPropertyAttributesInPrototypeChain(v8_str("f"));
CHECK(!try_catch.HasCaught()); CHECK(!try_catch.HasCaught());
CHECK(attr.has_value); CHECK(Just(None) == attr);
CHECK_EQ(attr.value, None);
result = another->Get(v8_str("f")); result = another->Get(v8_str("f"));
CHECK(try_catch.HasCaught()); CHECK(try_catch.HasCaught());
@ -10751,8 +10748,7 @@ THREADED_TEST(VariousGetPropertiesAndThrowingCallbacks) {
attr = with_js_getter->GetRealNamedPropertyAttributes(v8_str("f")); attr = with_js_getter->GetRealNamedPropertyAttributes(v8_str("f"));
CHECK(!try_catch.HasCaught()); CHECK(!try_catch.HasCaught());
CHECK(attr.has_value); CHECK(Just(None) == attr);
CHECK_EQ(attr.value, None);
result = with_js_getter->Get(v8_str("f")); result = with_js_getter->Get(v8_str("f"));
CHECK(try_catch.HasCaught()); CHECK(try_catch.HasCaught());

73
test/cctest/test-heap.cc
View File

@ -40,6 +40,7 @@
#include "test/cctest/cctest.h" #include "test/cctest/cctest.h"
using namespace v8::internal; using namespace v8::internal;
using v8::Just;
static void CheckMap(Map* map, int type, int instance_size) { static void CheckMap(Map* map, int type, int instance_size) {
CHECK(map->IsHeapObject()); CHECK(map->IsHeapObject());
@ -191,9 +192,7 @@ TEST(HeapObjects) {
Handle<String> object_string = Handle<String>::cast(factory->Object_string()); Handle<String> object_string = Handle<String>::cast(factory->Object_string());
Handle<GlobalObject> global(CcTest::i_isolate()->context()->global_object()); Handle<GlobalObject> global(CcTest::i_isolate()->context()->global_object());
v8::Maybe<bool> maybe = JSReceiver::HasOwnProperty(global, object_string); CHECK(Just(true) == JSReceiver::HasOwnProperty(global, object_string));
CHECK(maybe.has_value);
CHECK(maybe.value);
// Check ToString for oddballs // Check ToString for oddballs
CheckOddball(isolate, heap->true_value(), "true"); CheckOddball(isolate, heap->true_value(), "true");
@ -260,9 +259,7 @@ TEST(GarbageCollection) {
heap->CollectGarbage(NEW_SPACE); heap->CollectGarbage(NEW_SPACE);
// Function should be alive. // Function should be alive.
v8::Maybe<bool> maybe = JSReceiver::HasOwnProperty(global, name); CHECK(Just(true) == JSReceiver::HasOwnProperty(global, name));
CHECK(maybe.has_value);
CHECK(maybe.value);
// Check function is retained. // Check function is retained.
Handle<Object> func_value = Handle<Object> func_value =
Object::GetProperty(global, name).ToHandleChecked(); Object::GetProperty(global, name).ToHandleChecked();
@ -280,9 +277,7 @@ TEST(GarbageCollection) {
// After gc, it should survive. // After gc, it should survive.
heap->CollectGarbage(NEW_SPACE); heap->CollectGarbage(NEW_SPACE);
maybe = JSReceiver::HasOwnProperty(global, obj_name); CHECK(Just(true) == JSReceiver::HasOwnProperty(global, obj_name));
CHECK(maybe.has_value);
CHECK(maybe.value);
Handle<Object> obj = Handle<Object> obj =
Object::GetProperty(global, obj_name).ToHandleChecked(); Object::GetProperty(global, obj_name).ToHandleChecked();
CHECK(obj->IsJSObject()); CHECK(obj->IsJSObject());
@ -639,85 +634,55 @@ TEST(ObjectProperties) {
Handle<Smi> two(Smi::FromInt(2), isolate); Handle<Smi> two(Smi::FromInt(2), isolate);
// check for empty // check for empty
v8::Maybe<bool> maybe = JSReceiver::HasOwnProperty(obj, first); CHECK(Just(false) == JSReceiver::HasOwnProperty(obj, first));
CHECK(maybe.has_value);
CHECK(!maybe.value);
// add first // add first
JSReceiver::SetProperty(obj, first, one, SLOPPY).Check(); JSReceiver::SetProperty(obj, first, one, SLOPPY).Check();
maybe = JSReceiver::HasOwnProperty(obj, first); CHECK(Just(true) == JSReceiver::HasOwnProperty(obj, first));
CHECK(maybe.has_value);
CHECK(maybe.value);
// delete first // delete first
JSReceiver::DeleteProperty(obj, first, SLOPPY).Check(); JSReceiver::DeleteProperty(obj, first, SLOPPY).Check();
maybe = JSReceiver::HasOwnProperty(obj, first); CHECK(Just(false) == JSReceiver::HasOwnProperty(obj, first));
CHECK(maybe.has_value);
CHECK(!maybe.value);
// add first and then second // add first and then second
JSReceiver::SetProperty(obj, first, one, SLOPPY).Check(); JSReceiver::SetProperty(obj, first, one, SLOPPY).Check();
JSReceiver::SetProperty(obj, second, two, SLOPPY).Check(); JSReceiver::SetProperty(obj, second, two, SLOPPY).Check();
maybe = JSReceiver::HasOwnProperty(obj, first); CHECK(Just(true) == JSReceiver::HasOwnProperty(obj, first));
CHECK(maybe.has_value); CHECK(Just(true) == JSReceiver::HasOwnProperty(obj, second));
CHECK(maybe.value);
maybe = JSReceiver::HasOwnProperty(obj, second);
CHECK(maybe.has_value);
CHECK(maybe.value);
// delete first and then second // delete first and then second
JSReceiver::DeleteProperty(obj, first, SLOPPY).Check(); JSReceiver::DeleteProperty(obj, first, SLOPPY).Check();
maybe = JSReceiver::HasOwnProperty(obj, second); CHECK(Just(true) == JSReceiver::HasOwnProperty(obj, second));
CHECK(maybe.has_value);
CHECK(maybe.value);
JSReceiver::DeleteProperty(obj, second, SLOPPY).Check(); JSReceiver::DeleteProperty(obj, second, SLOPPY).Check();
maybe = JSReceiver::HasOwnProperty(obj, first); CHECK(Just(false) == JSReceiver::HasOwnProperty(obj, first));
CHECK(maybe.has_value); CHECK(Just(false) == JSReceiver::HasOwnProperty(obj, second));
CHECK(!maybe.value);
maybe = JSReceiver::HasOwnProperty(obj, second);
CHECK(maybe.has_value);
CHECK(!maybe.value);
// add first and then second // add first and then second
JSReceiver::SetProperty(obj, first, one, SLOPPY).Check(); JSReceiver::SetProperty(obj, first, one, SLOPPY).Check();
JSReceiver::SetProperty(obj, second, two, SLOPPY).Check(); JSReceiver::SetProperty(obj, second, two, SLOPPY).Check();
maybe = JSReceiver::HasOwnProperty(obj, first); CHECK(Just(true) == JSReceiver::HasOwnProperty(obj, first));
CHECK(maybe.has_value); CHECK(Just(true) == JSReceiver::HasOwnProperty(obj, second));
CHECK(maybe.value);
maybe = JSReceiver::HasOwnProperty(obj, second);
CHECK(maybe.has_value);
CHECK(maybe.value);
// delete second and then first // delete second and then first
JSReceiver::DeleteProperty(obj, second, SLOPPY).Check(); JSReceiver::DeleteProperty(obj, second, SLOPPY).Check();
maybe = JSReceiver::HasOwnProperty(obj, first); CHECK(Just(true) == JSReceiver::HasOwnProperty(obj, first));
CHECK(maybe.has_value);
CHECK(maybe.value);
JSReceiver::DeleteProperty(obj, first, SLOPPY).Check(); JSReceiver::DeleteProperty(obj, first, SLOPPY).Check();
maybe = JSReceiver::HasOwnProperty(obj, first); CHECK(Just(false) == JSReceiver::HasOwnProperty(obj, first));
CHECK(maybe.has_value); CHECK(Just(false) == JSReceiver::HasOwnProperty(obj, second));
CHECK(!maybe.value);
maybe = JSReceiver::HasOwnProperty(obj, second);
CHECK(maybe.has_value);
CHECK(!maybe.value);
// check string and internalized string match // check string and internalized string match
const char* string1 = "fisk"; const char* string1 = "fisk";
Handle<String> s1 = factory->NewStringFromAsciiChecked(string1); Handle<String> s1 = factory->NewStringFromAsciiChecked(string1);
JSReceiver::SetProperty(obj, s1, one, SLOPPY).Check(); JSReceiver::SetProperty(obj, s1, one, SLOPPY).Check();
Handle<String> s1_string = factory->InternalizeUtf8String(string1); Handle<String> s1_string = factory->InternalizeUtf8String(string1);
maybe = JSReceiver::HasOwnProperty(obj, s1_string); CHECK(Just(true) == JSReceiver::HasOwnProperty(obj, s1_string));
CHECK(maybe.has_value);
CHECK(maybe.value);
// check internalized string and string match // check internalized string and string match
const char* string2 = "fugl"; const char* string2 = "fugl";
Handle<String> s2_string = factory->InternalizeUtf8String(string2); Handle<String> s2_string = factory->InternalizeUtf8String(string2);
JSReceiver::SetProperty(obj, s2_string, one, SLOPPY).Check(); JSReceiver::SetProperty(obj, s2_string, one, SLOPPY).Check();
Handle<String> s2 = factory->NewStringFromAsciiChecked(string2); Handle<String> s2 = factory->NewStringFromAsciiChecked(string2);
maybe = JSReceiver::HasOwnProperty(obj, s2); CHECK(Just(true) == JSReceiver::HasOwnProperty(obj, s2));
CHECK(maybe.has_value);
CHECK(maybe.value);
} }

9
test/cctest/test-mark-compact.cc
View File

@ -45,6 +45,7 @@
#include "test/cctest/cctest.h" #include "test/cctest/cctest.h"
using namespace v8::internal; using namespace v8::internal;
using v8::Just;
TEST(MarkingDeque) { TEST(MarkingDeque) {
@ -167,9 +168,7 @@ TEST(MarkCompactCollector) {
{ HandleScope scope(isolate); { HandleScope scope(isolate);
Handle<String> func_name = factory->InternalizeUtf8String("theFunction"); Handle<String> func_name = factory->InternalizeUtf8String("theFunction");
v8::Maybe<bool> maybe = JSReceiver::HasOwnProperty(global, func_name); CHECK(Just(true) == JSReceiver::HasOwnProperty(global, func_name));
CHECK(maybe.has_value);
CHECK(maybe.value);
Handle<Object> func_value = Handle<Object> func_value =
Object::GetProperty(global, func_name).ToHandleChecked(); Object::GetProperty(global, func_name).ToHandleChecked();
CHECK(func_value->IsJSFunction()); CHECK(func_value->IsJSFunction());
@ -187,9 +186,7 @@ TEST(MarkCompactCollector) {
{ HandleScope scope(isolate); { HandleScope scope(isolate);
Handle<String> obj_name = factory->InternalizeUtf8String("theObject"); Handle<String> obj_name = factory->InternalizeUtf8String("theObject");
v8::Maybe<bool> maybe = JSReceiver::HasOwnProperty(global, obj_name); CHECK(Just(true) == JSReceiver::HasOwnProperty(global, obj_name));
CHECK(maybe.has_value);
CHECK(maybe.value);
Handle<Object> object = Handle<Object> object =
Object::GetProperty(global, obj_name).ToHandleChecked(); Object::GetProperty(global, obj_name).ToHandleChecked();
CHECK(object->IsJSObject()); CHECK(object->IsJSObject());