Lines Matching defs:isolate
33 #include "src/execution/isolate-inl.h"
34 #include "src/execution/isolate-utils-inl.h"
35 #include "src/execution/isolate-utils.h"
137 ShouldThrow GetShouldThrow(Isolate* isolate, Maybe<ShouldThrow> should_throw) {
140 LanguageMode mode = isolate->context().scope_info().language_mode();
143 for (StackFrameIterator it(isolate); !it.done(); it.Advance()) {
206 Handle<FieldType> Object::OptimalType(Isolate* isolate,
208 if (representation.IsNone()) return FieldType::None(isolate);
212 Handle<Map> map(HeapObject::cast(*this).map(), isolate);
214 return FieldType::Class(map, isolate);
218 return FieldType::Any(isolate);
221 Handle<Object> Object::NewStorageFor(Isolate* isolate, Handle<Object> object,
224 auto result = isolate->factory()->NewHeapNumberWithHoleNaN();
225 if (object->IsUninitialized(isolate)) {
238 Handle<Object> Object::WrapForRead(IsolateT* isolate, Handle<Object> object,
240 DCHECK(!object->IsUninitialized(isolate));
245 return isolate->factory()->template NewHeapNumberFromBits<allocation_type>(
250 Isolate* isolate, Handle<Object> object, Representation representation);
252 LocalIsolate* isolate, Handle<Object> object,
255 MaybeHandle<JSReceiver> Object::ToObjectImpl(Isolate* isolate,
259 Handle<Context> native_context = isolate->native_context();
262 constructor = handle(native_context->number_function(), isolate);
269 isolate,
272 isolate->factory()->NewStringFromAsciiChecked(method_name)),
275 THROW_NEW_ERROR(isolate,
281 isolate);
283 Handle<JSObject> result = isolate->factory()->NewJSObject(constructor);
290 MaybeHandle<JSReceiver> Object::ConvertReceiver(Isolate* isolate,
293 if (object->IsNullOrUndefined(isolate)) {
294 return isolate->global_proxy();
296 return Object::ToObject(isolate, object);
300 MaybeHandle<Object> Object::ConvertToNumberOrNumeric(Isolate* isolate,
308 return String::ToNumber(isolate, Handle<String>::cast(input));
311 return Oddball::ToNumber(isolate, Handle<Oddball>::cast(input));
314 THROW_NEW_ERROR(isolate, NewTypeError(MessageTemplate::kSymbolToNumber),
320 THROW_NEW_ERROR(isolate, NewTypeError(MessageTemplate::kBigIntToNumber),
324 isolate, input,
325 JSReceiver::ToPrimitive(isolate, Handle<JSReceiver>::cast(input),
332 MaybeHandle<Object> Object::ConvertToInteger(Isolate* isolate,
335 isolate, input,
336 ConvertToNumberOrNumeric(isolate, input, Conversion::kToNumber), Object);
338 return isolate->factory()->NewNumber(DoubleToInteger(input->Number()));
342 MaybeHandle<Object> Object::ConvertToInt32(Isolate* isolate,
345 isolate, input,
346 ConvertToNumberOrNumeric(isolate, input, Conversion::kToNumber), Object);
348 return isolate->factory()->NewNumberFromInt(DoubleToInt32(input->Number()));
352 MaybeHandle<Object> Object::ConvertToUint32(Isolate* isolate,
355 isolate, input,
356 ConvertToNumberOrNumeric(isolate, input, Conversion::kToNumber), Object);
357 if (input->IsSmi()) return handle(Smi::cast(*input).ToUint32Smi(), isolate);
358 return isolate->factory()->NewNumberFromUint(DoubleToUint32(input->Number()));
362 MaybeHandle<Name> Object::ConvertToName(Isolate* isolate,
365 isolate, input,
366 Object::ToPrimitive(isolate, input, ToPrimitiveHint::kString), Name);
368 return ToString(isolate, input);
373 MaybeHandle<Object> Object::ConvertToPropertyKey(Isolate* isolate,
377 Object::ToPrimitive(isolate, value, ToPrimitiveHint::kString);
390 return handle(Smi::FromInt(static_cast<int>(uint_value)), isolate);
393 return Object::ToString(isolate, key);
397 MaybeHandle<String> Object::ConvertToString(Isolate* isolate,
401 return handle(Handle<Oddball>::cast(input)->to_string(), isolate);
404 return isolate->factory()->NumberToString(input);
407 THROW_NEW_ERROR(isolate, NewTypeError(MessageTemplate::kSymbolToString),
411 return BigInt::ToString(isolate, Handle<BigInt>::cast(input));
414 isolate, input,
415 JSReceiver::ToPrimitive(isolate, Handle<JSReceiver>::cast(input),
428 bool IsErrorObject(Isolate* isolate, Handle<Object> object) {
430 Handle<Symbol> symbol = isolate->factory()->error_stack_symbol();
431 return JSReceiver::HasOwnProperty(isolate, Handle<JSReceiver>::cast(object),
436 Handle<String> AsStringOrEmpty(Isolate* isolate, Handle<Object> object) {
438 : isolate->factory()->empty_string();
441 Handle<String> NoSideEffectsErrorToString(Isolate* isolate,
443 Handle<Name> name_key = isolate->factory()->name_string();
444 Handle<Object> name = JSReceiver::GetDataProperty(isolate, error, name_key);
445 Handle<String> name_str = AsStringOrEmpty(isolate, name);
447 Handle<Name> msg_key = isolate->factory()->message_string();
448 Handle<Object> msg = JSReceiver::GetDataProperty(isolate, error, msg_key);
449 Handle<String> msg_str = AsStringOrEmpty(isolate, msg);
454 IncrementalStringBuilder builder(isolate);
470 MaybeHandle<String> Object::NoSideEffectsToMaybeString(Isolate* isolate,
472 DisallowJavascriptExecution no_js(isolate);
475 return Object::ToString(isolate, input).ToHandleChecked();
479 HeapObject target = Handle<JSProxy>::cast(currInput)->target(isolate);
480 currInput = Handle<Object>(target, isolate);
482 return NoSideEffectsToString(isolate, currInput);
485 BigInt::ToString(isolate, Handle<BigInt>::cast(input), 10, kDontThrow);
490 return isolate->factory()->NewStringFromStaticChars(
506 IncrementalStringBuilder builder(isolate);
507 builder.AppendString(isolate->factory()->NewSubString(fun_str, 0, 111));
509 builder.AppendString(isolate->factory()->NewSubString(
520 return Handle<String>(String::cast(symbol->description()), isolate);
523 IncrementalStringBuilder builder(isolate);
527 handle(String::cast(symbol->description()), isolate));
536 isolate, receiver, isolate->factory()->toString_string());
538 if (IsErrorObject(isolate, input) ||
539 *to_string == *isolate->error_to_string()) {
543 return NoSideEffectsErrorToString(isolate,
545 } else if (*to_string == *isolate->object_to_string()) {
547 isolate, receiver, isolate->factory()->constructor_string());
552 isolate, Handle<JSBoundFunction>::cast(ctor))
556 JSFunction::GetName(isolate, Handle<JSFunction>::cast(ctor));
560 IncrementalStringBuilder builder(isolate);
574 Handle<String> Object::NoSideEffectsToString(Isolate* isolate,
576 DisallowJavascriptExecution no_js(isolate);
579 MaybeHandle<String> maybe_string = NoSideEffectsToMaybeString(isolate, input);
596 return isolate->factory()->NewStringFromAsciiChecked("[object Unknown]");
599 receiver = Object::ToObjectImpl(isolate, input).ToHandleChecked();
602 Handle<String> builtin_tag = handle(receiver->class_name(), isolate);
604 isolate, receiver, isolate->factory()->to_string_tag_symbol());
608 IncrementalStringBuilder builder(isolate);
617 MaybeHandle<Object> Object::ConvertToLength(Isolate* isolate,
619 ASSIGN_RETURN_ON_EXCEPTION(isolate, input, ToNumber(isolate, input), Object);
622 return handle(Smi::FromInt(value), isolate);
626 return handle(Smi::zero(), isolate);
630 return isolate->factory()->NewNumber(len);
634 MaybeHandle<Object> Object::ConvertToIndex(Isolate* isolate,
637 if (input->IsUndefined(isolate)) return handle(Smi::zero(), isolate);
638 ASSIGN_RETURN_ON_EXCEPTION(isolate, input, ToNumber(isolate, input), Object);
641 auto js_len = isolate->factory()->NewNumber(len);
643 THROW_NEW_ERROR(isolate, NewRangeError(error_index, js_len), Object);
648 bool Object::BooleanValue(Isolate* isolate) {
651 if (IsBoolean()) return IsTrue(isolate);
652 if (IsNullOrUndefined(isolate)) return false;
660 Object Object::ToBoolean(Isolate* isolate) {
662 return isolate->heap()->ToBoolean(BooleanValue(isolate));
710 Maybe<ComparisonResult> Object::Compare(Isolate* isolate, Handle<Object> x,
713 if (!Object::ToPrimitive(isolate, x, ToPrimitiveHint::kNumber).ToHandle(&x) ||
714 !Object::ToPrimitive(isolate, y, ToPrimitiveHint::kNumber).ToHandle(&y)) {
719 return Just(String::Compare(isolate, Handle<String>::cast(x),
723 return BigInt::CompareToString(isolate, Handle<BigInt>::cast(x),
728 isolate, Handle<BigInt>::cast(y), Handle<String>::cast(x));
737 if (!Object::ToNumeric(isolate, x).ToHandle(&x) ||
738 !Object::ToNumeric(isolate, y).ToHandle(&y)) {
757 Maybe<bool> Object::Equals(Isolate* isolate, Handle<Object> x,
770 x, String::ToNumber(isolate, Handle<String>::cast(y))));
774 if (!JSReceiver::ToPrimitive(isolate, Handle<JSReceiver>::cast(y))
783 return Just(String::Equals(isolate, Handle<String>::cast(x),
786 x = String::ToNumber(isolate, Handle<String>::cast(x));
789 x = String::ToNumber(isolate, Handle<String>::cast(x));
793 return BigInt::EqualToString(isolate, Handle<BigInt>::cast(y),
796 if (!JSReceiver::ToPrimitive(isolate, Handle<JSReceiver>::cast(y))
810 y = String::ToNumber(isolate, Handle<String>::cast(y));
814 x = Oddball::ToNumber(isolate, Handle<Oddball>::cast(x));
817 if (!JSReceiver::ToPrimitive(isolate, Handle<JSReceiver>::cast(y))
821 x = Oddball::ToNumber(isolate, Handle<Oddball>::cast(x));
829 if (!JSReceiver::ToPrimitive(isolate, Handle<JSReceiver>::cast(y))
840 return Equals(isolate, y, x);
847 y = Oddball::ToNumber(isolate, Handle<Oddball>::cast(y));
848 } else if (!JSReceiver::ToPrimitive(isolate, Handle<JSReceiver>::cast(x))
873 Handle<String> Object::TypeOf(Isolate* isolate, Handle<Object> object) {
874 if (object->IsNumber()) return isolate->factory()->number_string();
876 return handle(Oddball::cast(*object).type_of(), isolate);
878 return isolate->factory()->undefined_string();
880 if (object->IsString()) return isolate->factory()->string_string();
881 if (object->IsSymbol()) return isolate->factory()->symbol_string();
882 if (object->IsBigInt()) return isolate->factory()->bigint_string();
883 if (object->IsCallable()) return isolate->factory()->function_string();
884 return isolate->factory()->object_string();
888 MaybeHandle<Object> Object::Add(Isolate* isolate, Handle<Object> lhs,
891 return isolate->factory()->NewNumber(lhs->Number() + rhs->Number());
893 return isolate->factory()->NewConsString(Handle<String>::cast(lhs),
896 ASSIGN_RETURN_ON_EXCEPTION(isolate, lhs, Object::ToPrimitive(isolate, lhs),
898 ASSIGN_RETURN_ON_EXCEPTION(isolate, rhs, Object::ToPrimitive(isolate, rhs),
901 ASSIGN_RETURN_ON_EXCEPTION(isolate, rhs, Object::ToString(isolate, rhs),
903 ASSIGN_RETURN_ON_EXCEPTION(isolate, lhs, Object::ToString(isolate, lhs),
905 return isolate->factory()->NewConsString(Handle<String>::cast(lhs),
908 ASSIGN_RETURN_ON_EXCEPTION(isolate, rhs, Object::ToNumber(isolate, rhs),
910 ASSIGN_RETURN_ON_EXCEPTION(isolate, lhs, Object::ToNumber(isolate, lhs),
912 return isolate->factory()->NewNumber(lhs->Number() + rhs->Number());
916 MaybeHandle<Object> Object::OrdinaryHasInstance(Isolate* isolate,
920 if (!callable->IsCallable()) return isolate->factory()->false_value();
927 STACK_CHECK(isolate, MaybeHandle<Object>());
930 isolate);
931 return Object::InstanceOf(isolate, object, bound_callable);
935 if (!object->IsJSReceiver()) return isolate->factory()->false_value();
940 isolate, prototype,
941 Object::GetProperty(isolate, callable,
942 isolate->factory()->prototype_string()),
946 isolate,
953 isolate, Handle<JSReceiver>::cast(object), prototype);
955 return isolate->factory()->ToBoolean(result.FromJust());
959 MaybeHandle<Object> Object::InstanceOf(Isolate* isolate, Handle<Object> object,
963 THROW_NEW_ERROR(isolate,
971 isolate, inst_of_handler,
973 isolate->factory()->has_instance_symbol()),
975 if (!inst_of_handler->IsUndefined(isolate)) {
979 isolate, result,
980 Execution::Call(isolate, inst_of_handler, callable, 1, &object),
982 return isolate->factory()->ToBoolean(result->BooleanValue(isolate));
988 isolate, NewTypeError(MessageTemplate::kNonCallableInInstanceOfCheck),
995 isolate, result, Object::OrdinaryHasInstance(isolate, callable, object),
1004 Isolate* isolate = receiver->GetIsolate();
1006 isolate, func, JSReceiver::GetProperty(isolate, receiver, name), Object);
1007 if (func->IsNullOrUndefined(isolate)) {
1008 return isolate->factory()->undefined_value();
1011 THROW_NEW_ERROR(isolate,
1022 Isolate* isolate, Handle<Object> object, ElementTypes element_types) {
1027 if (!array->HasArrayPrototype(isolate) ||
1029 !JSObject::PrototypeHasNoElements(isolate, *array)) {
1033 isolate, array, length);
1044 isolate, array, static_cast<uint32_t>(length));
1054 Isolate* isolate, Handle<Object> object, ElementTypes element_types) {
1057 CreateListFromArrayLikeFastPath(isolate, object, element_types);
1063 THROW_NEW_ERROR(isolate,
1065 isolate->factory()->NewStringFromAsciiChecked(
1073 ASSIGN_RETURN_ON_EXCEPTION(isolate, raw_length_number,
1074 Object::GetLengthFromArrayLike(isolate, receiver),
1079 THROW_NEW_ERROR(isolate,
1084 Handle<FixedArray> list = isolate->factory()->NewFixedArray(len);
1091 ASSIGN_RETURN_ON_EXCEPTION(isolate, next,
1092 JSReceiver::GetElement(isolate, receiver, index),
1102 THROW_NEW_ERROR(isolate,
1108 next = isolate->factory()->InternalizeName(Handle<Name>::cast(next));
1120 MaybeHandle<Object> Object::GetLengthFromArrayLike(Isolate* isolate,
1123 Handle<Name> key = isolate->factory()->length_string();
1125 isolate, val, JSReceiver::GetProperty(isolate, object, key), Object);
1126 return Object::ToLength(isolate, val);
1144 it->isolate());
1148 it->isolate(), it->GetHolder<JSProxy>(), it->GetName());
1152 return it->isolate()->factory()->undefined_value();
1156 JSProxy::GetProperty(it->isolate(), it->GetHolder<JSProxy>(),
1165 it->isolate(), result,
1176 return it->isolate()->factory()->undefined_value();
1182 return it->isolate()->factory()->undefined_value();
1186 MaybeHandle<Object> JSProxy::GetProperty(Isolate* isolate,
1194 STACK_CHECK(isolate, MaybeHandle<Object>());
1195 Handle<Name> trap_name = isolate->factory()->get_string();
1198 Handle<Object> handler(proxy->handler(), isolate);
1202 THROW_NEW_ERROR(isolate,
1207 Handle<JSReceiver> target(JSReceiver::cast(proxy->target()), isolate);
1211 isolate, trap,
1214 if (trap->IsUndefined(isolate)) {
1216 PropertyKey key(isolate, name);
1217 LookupIterator it(isolate, receiver, key, target);
1226 isolate, trap_result,
1227 Execution::Call(isolate, trap, handler, arraysize(args), args), Object);
1230 JSProxy::CheckGetSetTrapResult(isolate, name, target, trap_result, kGet);
1240 MaybeHandle<Object> JSProxy::CheckGetSetTrapResult(Isolate* isolate,
1248 JSReceiver::GetOwnPropertyDescriptor(isolate, target, name, &target_desc);
1263 isolate,
1268 isolate->Throw(*isolate->factory()->NewTypeError(
1279 target_desc.get()->IsUndefined(isolate) &&
1280 !trap_result->IsUndefined(isolate);
1284 target_desc.set()->IsUndefined(isolate);
1289 isolate,
1294 isolate->Throw(*isolate->factory()->NewTypeError(
1300 return isolate->factory()->undefined_value();
1320 Handle<TemplateList> TemplateList::New(Isolate* isolate, int size) {
1322 isolate->factory()->NewFixedArray(kLengthIndex + size);
1328 Handle<TemplateList> TemplateList::Add(Isolate* isolate,
1334 fixed_array = FixedArray::SetAndGrow(isolate, fixed_array, index, value);
1342 Isolate* isolate = proxy->GetIsolate();
1343 Handle<String> trap_name = isolate->factory()->getPrototypeOf_string();
1345 STACK_CHECK(isolate, MaybeHandle<HeapObject>());
1352 THROW_NEW_ERROR(isolate,
1356 Handle<JSReceiver> target(JSReceiver::cast(proxy->target()), isolate);
1357 Handle<JSReceiver> handler(JSReceiver::cast(proxy->handler()), isolate);
1361 ASSIGN_RETURN_ON_EXCEPTION(isolate, trap,
1364 if (trap->IsUndefined(isolate)) {
1365 return JSReceiver::GetPrototype(isolate, target);
1371 isolate, handler_proto,
1372 Execution::Call(isolate, trap, handler, arraysize(argv), argv),
1375 if (!(handler_proto->IsJSReceiver() || handler_proto->IsNull(isolate))) {
1376 THROW_NEW_ERROR(isolate,
1387 ASSIGN_RETURN_ON_EXCEPTION(isolate, target_proto,
1388 JSReceiver::GetPrototype(isolate, target),
1393 isolate,
1402 Isolate* isolate = it->isolate();
1408 receiver = handle(JSGlobalObject::cast(*receiver).global_proxy(), isolate);
1421 THROW_NEW_ERROR(isolate,
1427 if (!info->has_getter()) return isolate->factory()->undefined_value();
1430 ASSIGN_RETURN_ON_EXCEPTION(isolate, receiver,
1431 Object::ConvertReceiver(isolate, receiver),
1435 PropertyCallbackArguments args(isolate, info->data(), *receiver, *holder,
1438 RETURN_EXCEPTION_IF_SCHEDULED_EXCEPTION(isolate, Object);
1439 if (result.is_null()) return isolate->factory()->undefined_value();
1440 Handle<Object> reboxed_result = handle(*result, isolate);
1442 RETURN_ON_EXCEPTION(isolate,
1444 isolate, receiver, holder, name, result),
1457 Handle<Object> getter(accessor_pair->getter(), isolate);
1459 SaveAndSwitchContext save(isolate,
1462 isolate, false, Handle<FunctionTemplateInfo>::cast(getter), receiver, 0,
1463 nullptr, isolate->factory()->undefined_value());
1470 return isolate->factory()->undefined_value();
1505 Isolate* isolate = it->isolate();
1511 receiver = handle(JSGlobalObject::cast(*receiver).global_proxy(), isolate);
1524 isolate->Throw(*isolate->factory()->NewTypeError(
1538 isolate, receiver, Object::ConvertReceiver(isolate, receiver),
1548 PropertyCallbackArguments args(isolate, info->data(), *receiver, *holder,
1555 RETURN_VALUE_IF_SCHEDULED_EXCEPTION(isolate, Nothing<bool>());
1557 DCHECK(result->BooleanValue(isolate) ||
1558 GetShouldThrow(isolate, maybe_should_throw) == kDontThrow);
1559 return Just(result->BooleanValue(isolate));
1563 Handle<Object> setter(AccessorPair::cast(*structure).setter(), isolate);
1565 SaveAndSwitchContext save(isolate,
1569 isolate,
1570 Builtins::InvokeApiFunction(isolate, false,
1573 isolate->factory()->undefined_value()),
1582 RETURN_FAILURE(isolate, GetShouldThrow(isolate, maybe_should_throw),
1589 Isolate* isolate = getter->GetIsolate();
1599 StackLimitCheck check(isolate);
1601 isolate->StackOverflow();
1605 return Execution::Call(isolate, getter, receiver, 0, nullptr);
1611 Isolate* isolate = setter->GetIsolate();
1615 isolate,
1616 Execution::Call(isolate, setter, receiver, arraysize(argv), argv),
1621 Map Object::GetPrototypeChainRootMap(Isolate* isolate) const {
1624 Context native_context = isolate->context().native_context();
1629 return heap_object.map().GetPrototypeChainRootMap(isolate);
1632 Smi Object::GetOrCreateHash(Isolate* isolate) {
1638 return JSReceiver::cast(*this).GetOrCreateIdentityHash(isolate);
1676 Isolate* isolate, Handle<Object> original_array) {
1677 Handle<Object> default_species = isolate->array_function();
1680 Handle<JSArray>::cast(original_array)->HasArrayPrototype(isolate) &&
1681 Protectors::IsArraySpeciesLookupChainIntact(isolate)) {
1684 Handle<Object> constructor = isolate->factory()->undefined_value();
1689 isolate, constructor,
1690 Object::GetProperty(isolate, original_array,
1691 isolate->factory()->constructor_string()),
1696 isolate, constructor_context,
1699 if (*constructor_context != *isolate->native_context() &&
1701 constructor = isolate->factory()->undefined_value();
1706 isolate, constructor,
1707 JSReceiver::GetProperty(isolate,
1709 isolate->factory()->species_symbol()),
1711 if (constructor->IsNull(isolate)) {
1712 constructor = isolate->factory()->undefined_value();
1716 if (constructor->IsUndefined(isolate)) {
1720 THROW_NEW_ERROR(isolate,
1730 Isolate* isolate, Handle<JSReceiver> recv,
1734 isolate, ctor_obj,
1735 JSObject::GetProperty(isolate, recv,
1736 isolate->factory()->constructor_string()),
1739 if (ctor_obj->IsUndefined(isolate)) return default_ctor;
1742 THROW_NEW_ERROR(isolate,
1751 isolate, species,
1752 JSObject::GetProperty(isolate, ctor,
1753 isolate->factory()->species_symbol()),
1756 if (species->IsNullOrUndefined(isolate)) {
1763 isolate, NewTypeError(MessageTemplate::kSpeciesNotConstructor), Object);
1770 Isolate* isolate = array.GetIsolate();
1773 i::HandleScope handle_scope(isolate);
1784 if (!Protectors::IsArrayIteratorLookupChainIntact(isolate)) return true;
1795 Protectors::IsNoElementsIntact(isolate)) {
1801 bool Object::IsCodeLike(Isolate* isolate) const {
1803 return IsJSReceiver() && JSReceiver::cast(*this).IsCodeLike(isolate);
2388 void HeapObject::RehashBasedOnMap(IsolateT* isolate) {
2389 switch (map(isolate).instance_type()) {
2393 NameDictionary::cast(*this).Rehash(isolate);
2396 NameToIndexHashTable::cast(*this).Rehash(isolate);
2399 RegisteredSymbolTable::cast(*this).Rehash(isolate);
2402 SwissNameDictionary::cast(*this).Rehash(isolate);
2405 GlobalDictionary::cast(*this).Rehash(isolate);
2408 NumberDictionary::cast(*this).Rehash(isolate);
2411 SimpleNumberDictionary::cast(*this).Rehash(isolate);
2430 JSMap::cast(*this).Rehash(isolate->AsIsolate());
2434 JSSet::cast(*this).Rehash(isolate->AsIsolate());
2450 template void HeapObject::RehashBasedOnMap(Isolate* isolate);
2451 template void HeapObject::RehashBasedOnMap(LocalIsolate* isolate);
2467 MaybeHandle<Object> Object::SetProperty(Isolate* isolate, Handle<Object> object,
2471 LookupIterator it(isolate, object, name);
2485 AssertNoContextChange ncc(it->isolate());
2505 it->isolate());
2569 it->isolate(), throwaway_value,
2570 BigInt::FromObject(it->isolate(), value), Nothing<bool>());
2573 it->isolate(), throwaway_value,
2574 Object::ToNumber(it->isolate(), value), Nothing<bool>());
2608 Isolate* isolate = it->isolate();
2610 if (it->GetReceiver()->IsJSGlobalObject(isolate) &&
2611 (GetShouldThrow(isolate, should_throw) == ShouldThrow::kThrowOnError)) {
2617 it->transition_cell()->ClearAndInvalidate(ReadOnlyRoots(isolate));
2619 isolate->Throw(*isolate->factory()->NewReferenceError(
2645 Isolate* isolate = it->isolate();
2668 it->IsElement() ? LookupIterator(isolate, receiver, it->index(), c)
2669 : LookupIterator(isolate, receiver, it->name(), c);
2690 return RedefineIncompatibleProperty(isolate, it->GetName(), value,
2716 return RedefineIncompatibleProperty(isolate, it->GetName(), value,
2722 return JSReceiver::DefineOwnProperty(isolate, receiver, it->GetName(),
2738 Maybe<bool> Object::CannotCreateProperty(Isolate* isolate,
2744 isolate, GetShouldThrow(isolate, should_throw),
2746 Object::TypeOf(isolate, receiver), receiver));
2752 ShouldThrow should_throw = GetShouldThrow(it->isolate(), maybe_should_throw);
2760 it->isolate()->CountUsage(feature);
2762 return WriteToReadOnlyProperty(it->isolate(), it->GetReceiver(),
2766 Maybe<bool> Object::WriteToReadOnlyProperty(Isolate* isolate,
2771 RETURN_FAILURE(isolate, should_throw,
2773 Object::TypeOf(isolate, receiver), receiver));
2777 Isolate* isolate, Handle<Object> name, Handle<Object> value,
2779 RETURN_FAILURE(isolate, GetShouldThrow(isolate, should_throw),
2784 Isolate* isolate = it->isolate();
2785 DCHECK_IMPLIES(it->GetReceiver()->IsJSProxy(isolate),
2786 it->GetName()->IsPrivateName(isolate));
2787 DCHECK_IMPLIES(!it->IsElement() && it->GetName()->IsPrivateName(isolate),
2796 if (it->IsElement() && receiver->IsJSObject(isolate) &&
2798 isolate)) {
2801 ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate, to_assign,
2802 BigInt::FromObject(isolate, value),
2810 } else if (!value->IsNumber() && !value->IsUndefined(isolate)) {
2811 ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate, to_assign,
2812 Object::ToNumber(isolate, value),
2824 if (receiver->IsWasmObject(isolate)) {
2828 isolate, to_assign,
2829 WasmObject::ToWasmValue(isolate, it->wasm_value_type(), to_assign),
2838 if (V8_UNLIKELY(receiver->IsJSSharedStruct(isolate))) {
2843 isolate, to_assign, Object::Share(isolate, to_assign, kThrowOnError),
2857 receiver->HeapObjectVerify(isolate);
2869 return CannotCreateProperty(it->isolate(), it->GetReceiver(), it->GetName(),
2877 RETURN_FAILURE(it->isolate(), GetShouldThrow(it->isolate(), should_throw),
2892 Isolate* isolate = it->isolate();
2895 RETURN_FAILURE(isolate, GetShouldThrow(it->isolate(), should_throw),
2906 RETURN_FAILURE(isolate, GetShouldThrow(it->isolate(), should_throw),
2908 isolate->factory()->length_string(),
2909 Object::TypeOf(isolate, array), array));
2943 receiver->HeapObjectVerify(it->isolate());
2950 MaybeHandle<Object> Object::ShareSlow(Isolate* isolate,
2957 return String::Share(isolate, Handle<String>::cast(value));
2962 return isolate->factory()
2968 isolate, NewTypeError(MessageTemplate::kCannotBeShared, value), Object);
2974 static int AppendUniqueCallbacks(Isolate* isolate,
2984 Handle<AccessorInfo> entry(AccessorInfo::cast(callbacks->get(i)), isolate);
2985 Handle<Name> key(Name::cast(entry->name()), isolate);
3013 int AccessorInfo::AppendUnique(Isolate* isolate, Handle<Object> descriptors,
3018 return AppendUniqueCallbacks<FixedArrayAppender>(isolate, callbacks, array,
3023 Isolate* isolate = proxy->GetIsolate();
3027 proxy->set_target(ReadOnlyRoots(isolate).null_value());
3029 proxy->set_handler(ReadOnlyRoots(isolate).null_value());
3036 Isolate* isolate = proxy->GetIsolate();
3041 isolate->Throw(*isolate->factory()->NewTypeError(
3043 isolate->factory()->NewStringFromAsciiChecked("IsArray")));
3046 object = handle(JSReceiver::cast(proxy->target()), isolate);
3052 isolate->StackOverflow();
3056 Maybe<bool> JSProxy::HasProperty(Isolate* isolate, Handle<JSProxy> proxy,
3059 STACK_CHECK(isolate, Nothing<bool>());
3062 Handle<Object> handler(proxy->handler(), isolate);
3066 isolate->Throw(*isolate->factory()->NewTypeError(
3067 MessageTemplate::kProxyRevoked, isolate->factory()->has_string()));
3071 Handle<JSReceiver> target(JSReceiver::cast(proxy->target()), isolate);
3075 isolate, trap,
3077 isolate->factory()->has_string()),
3080 if (trap->IsUndefined(isolate)) {
3082 return JSReceiver::HasProperty(isolate, target, name);
3088 isolate, trap_result_obj,
3089 Execution::Call(isolate, trap, handler, arraysize(args), args),
3091 bool boolean_trap_result = trap_result_obj->BooleanValue(isolate);
3094 MAYBE_RETURN(JSProxy::CheckHasTrap(isolate, name, target), Nothing<bool>());
3100 Maybe<bool> JSProxy::CheckHasTrap(Isolate* isolate, Handle<Name> name,
3105 JSReceiver::GetOwnPropertyDescriptor(isolate, target, name, &target_desc);
3112 isolate->Throw(*isolate->factory()->NewTypeError(
3121 isolate->Throw(*isolate->factory()->NewTypeError(
3133 Isolate* isolate = proxy->GetIsolate();
3134 STACK_CHECK(isolate, Nothing<bool>());
3135 Factory* factory = isolate->factory();
3139 isolate->Throw(
3143 Handle<JSReceiver> target(JSReceiver::cast(proxy->target()), isolate);
3144 Handle<JSReceiver> handler(JSReceiver::cast(proxy->handler()), isolate);
3148 isolate, trap, Object::GetMethod(handler, trap_name), Nothing<bool>());
3149 if (trap->IsUndefined(isolate)) {
3150 PropertyKey key(isolate, name);
3151 LookupIterator it(isolate, receiver, key, target);
3160 isolate, trap_result,
3161 Execution::Call(isolate, trap, handler, arraysize(args), args),
3163 if (!trap_result->BooleanValue(isolate)) {
3164 RETURN_FAILURE(isolate, GetShouldThrow(isolate, should_throw),
3170 JSProxy::CheckGetSetTrapResult(isolate, name, target, value, kSet);
3184 Isolate* isolate = proxy->GetIsolate();
3185 STACK_CHECK(isolate, Nothing<bool>());
3186 Factory* factory = isolate->factory();
3190 isolate->Throw(
3194 Handle<JSReceiver> target(JSReceiver::cast(proxy->target()), isolate);
3195 Handle<JSReceiver> handler(JSReceiver::cast(proxy->handler()), isolate);
3199 isolate, trap, Object::GetMethod(handler, trap_name), Nothing<bool>());
3200 if (trap->IsUndefined(isolate)) {
3207 isolate, trap_result,
3208 Execution::Call(isolate, trap, handler, arraysize(args), args),
3210 if (!trap_result->BooleanValue(isolate)) {
3211 RETURN_FAILURE(isolate, should_throw,
3217 return JSProxy::CheckDeleteTrap(isolate, name, target);
3220 Maybe<bool> JSProxy::CheckDeleteTrap(Isolate* isolate, Handle<Name> name,
3225 JSReceiver::GetOwnPropertyDescriptor(isolate, target, name, &target_desc);
3231 isolate->Throw(*isolate->factory()->NewTypeError(
3240 isolate->Throw(*isolate->factory()->NewTypeError(
3249 MaybeHandle<JSProxy> JSProxy::New(Isolate* isolate, Handle<Object> target,
3252 THROW_NEW_ERROR(isolate, NewTypeError(MessageTemplate::kProxyNonObject),
3256 THROW_NEW_ERROR(isolate, NewTypeError(MessageTemplate::kProxyNonObject),
3259 return isolate->factory()->NewJSProxy(Handle<JSReceiver>::cast(target),
3266 it->isolate(), it->GetHolder<JSProxy>(), it->GetName(), &desc);
3287 Maybe<bool> JSArray::DefineOwnProperty(Isolate* isolate, Handle<JSArray> o,
3294 if (*name == ReadOnlyRoots(isolate).length_string()) {
3296 return ArraySetLength(isolate, o, desc, should_throw);
3304 isolate, o, isolate->factory()->length_string(), &old_len_desc);
3318 RETURN_FAILURE(isolate, GetShouldThrow(isolate, should_throw),
3323 OrdinaryDefineOwnProperty(isolate, o, name, desc, should_throw);
3331 old_len_desc.set_value(isolate->factory()->NewNumberFromUint(index + 1));
3334 succeeded = OrdinaryDefineOwnProperty(isolate, o,
3335 isolate->factory()->length_string(),
3346 return OrdinaryDefineOwnProperty(isolate, o, name, desc, should_throw);
3351 bool JSArray::AnythingToArrayLength(Isolate* isolate,
3364 if (!Object::ToUint32(isolate, length_object).ToHandle(&uint32_v)) {
3370 if (!Object::ToNumber(isolate, length_object).ToHandle(&number_v)) {
3377 isolate->factory()->NewRangeError(MessageTemplate::kInvalidArrayLength);
3378 isolate->Throw(*exception);
3387 Maybe<bool> JSArray::ArraySetLength(Isolate* isolate, Handle<JSArray> a,
3394 isolate, a, isolate->factory()->length_string(), desc, should_throw);
3401 if (!AnythingToArrayLength(isolate, desc->value(), &new_len)) {
3402 DCHECK(isolate->has_pending_exception());
3410 isolate, a, isolate->factory()->length_string(), &old_len_desc);
3421 new_len_desc->set_value(isolate->factory()->NewNumberFromUint(new_len));
3422 return OrdinaryDefineOwnProperty(isolate, a,
3423 isolate->factory()->length_string(),
3435 RETURN_FAILURE(isolate, GetShouldThrow(isolate, should_throw),
3437 isolate->factory()->length_string()));
3458 success = OrdinaryDefineOwnProperty(isolate, a,
3459 isolate->factory()->length_string(),
3470 isolate, GetShouldThrow(isolate, should_throw),
3472 isolate->factory()->NewNumberFromUint(actual_new_len - 1),
3480 Maybe<bool> JSProxy::DefineOwnProperty(Isolate* isolate, Handle<JSProxy> proxy,
3484 STACK_CHECK(isolate, Nothing<bool>());
3487 return JSProxy::SetPrivateSymbol(isolate, proxy, Handle<Symbol>::cast(key),
3490 Handle<String> trap_name = isolate->factory()->defineProperty_string();
3494 Handle<Object> handler(proxy->handler(), isolate);
3498 isolate->Throw(*isolate->factory()->NewTypeError(
3503 Handle<JSReceiver> target(JSReceiver::cast(proxy->target()), isolate);
3507 isolate, trap,
3511 if (trap->IsUndefined(isolate)) {
3513 return JSReceiver::DefineOwnProperty(isolate, target, key, desc,
3517 Handle<Object> desc_obj = desc->ToObject(isolate);
3523 : Handle<Name>::cast(isolate->factory()->NumberToString(key));
3529 isolate, trap_result_obj,
3530 Execution::Call(isolate, trap, handler, arraysize(args), args),
3533 if (!trap_result_obj->BooleanValue(isolate)) {
3534 RETURN_FAILURE(isolate, GetShouldThrow(isolate, should_throw),
3541 JSReceiver::GetOwnPropertyDescriptor(isolate, target, key, &target_desc);
3556 isolate->Throw(*isolate->factory()->NewTypeError(
3562 isolate->Throw(*isolate->factory()->NewTypeError(
3571 isolate, extensible_target, desc, &target_desc, property_name,
3575 isolate->Throw(*isolate->factory()->NewTypeError(
3582 isolate->Throw(*isolate->factory()->NewTypeError(
3594 isolate->Throw(*isolate->factory()->NewTypeError(
3606 Maybe<bool> JSProxy::SetPrivateSymbol(Isolate* isolate, Handle<JSProxy> proxy,
3613 RETURN_FAILURE(isolate, GetShouldThrow(isolate, should_throw),
3620 : Handle<Object>::cast(isolate->factory()->undefined_value());
3622 LookupIterator it(isolate, proxy, private_name, proxy);
3638 isolate);
3640 SwissNameDictionary::Add(isolate, dict, private_name, value, details);
3643 Handle<NameDictionary> dict(proxy->property_dictionary(), isolate);
3645 NameDictionary::Add(isolate, dict, private_name, value, details);
3653 Maybe<bool> JSProxy::GetOwnPropertyDescriptor(Isolate* isolate,
3658 STACK_CHECK(isolate, Nothing<bool>());
3661 isolate->factory()->getOwnPropertyDescriptor_string();
3664 Handle<Object> handler(proxy->handler(), isolate);
3668 isolate->Throw(*isolate->factory()->NewTypeError(
3673 Handle<JSReceiver> target(JSReceiver::cast(proxy->target()), isolate);
3677 isolate, trap,
3681 if (trap->IsUndefined(isolate)) {
3683 return JSReceiver::GetOwnPropertyDescriptor(isolate, target, name, desc);
3689 isolate, trap_result_obj,
3690 Execution::Call(isolate, trap, handler, arraysize(args), args),
3695 !trap_result_obj->IsUndefined(isolate)) {
3696 isolate->Throw(*isolate->factory()->NewTypeError(
3703 JSReceiver::GetOwnPropertyDescriptor(isolate, target, name, &target_desc);
3706 if (trap_result_obj->IsUndefined(isolate)) {
3712 isolate->Throw(*isolate->factory()->NewTypeError(
3722 isolate->Throw(*isolate->factory()->NewTypeError(
3733 if (!PropertyDescriptor::ToPropertyDescriptor(isolate, trap_result_obj,
3735 DCHECK(isolate->has_pending_exception());
3739 PropertyDescriptor::CompletePropertyDescriptor(isolate, desc);
3743 isolate, extensible_target.FromJust(), desc, &target_desc, name,
3748 isolate->Throw(*isolate->factory()->NewTypeError(
3757 isolate->Throw(*isolate->factory()->NewTypeError(
3767 isolate->Throw(*isolate->factory()->NewTypeError(
3781 Isolate* isolate = proxy->GetIsolate();
3782 STACK_CHECK(isolate, Nothing<bool>());
3783 Factory* factory = isolate->factory();
3787 isolate->Throw(
3791 Handle<JSReceiver> target(JSReceiver::cast(proxy->target()), isolate);
3792 Handle<JSReceiver> handler(JSReceiver::cast(proxy->handler()), isolate);
3796 isolate, trap, Object::GetMethod(handler, trap_name), Nothing<bool>());
3797 if (trap->IsUndefined(isolate)) {
3804 isolate, trap_result,
3805 Execution::Call(isolate, trap, handler, arraysize(args), args),
3807 if (!trap_result->BooleanValue(isolate)) {
3809 isolate, should_throw,
3817 isolate->Throw(*factory->NewTypeError(
3825 Isolate* isolate = proxy->GetIsolate();
3826 STACK_CHECK(isolate, Nothing<bool>());
3827 Factory* factory = isolate->factory();
3831 isolate->Throw(
3835 Handle<JSReceiver> target(JSReceiver::cast(proxy->target()), isolate);
3836 Handle<JSReceiver> handler(JSReceiver::cast(proxy->handler()), isolate);
3840 isolate, trap, Object::GetMethod(handler, trap_name), Nothing<bool>());
3841 if (trap->IsUndefined(isolate)) {
3848 isolate, trap_result,
3849 Execution::Call(isolate, trap, handler, arraysize(args), args),
3855 if (target_result.FromJust() != trap_result->BooleanValue(isolate)) {
3856 isolate->Throw(
3864 Handle<DescriptorArray> DescriptorArray::CopyUpTo(Isolate* isolate,
3868 return DescriptorArray::CopyUpToAddAttributes(isolate, desc,
3873 Isolate* isolate, Handle<DescriptorArray> source_handle,
3876 return isolate->factory()->empty_descriptor_array();
3881 DescriptorArray::Allocate(isolate, size, slack);
3921 Isolate* isolate, Handle<DescriptorArray> src_handle, int enumeration_index,
3924 return isolate->factory()->empty_descriptor_array();
3929 DescriptorArray::Allocate(isolate, size, slack);
3987 Handle<FixedArray> FixedArray::SetAndGrow(Isolate* isolate,
3998 Handle<FixedArray> new_array = isolate->factory()->NewFixedArray(capacity);
4005 Handle<FixedArray> FixedArray::ShrinkOrEmpty(Isolate* isolate,
4011 array->Shrink(isolate, new_length);
4016 void FixedArray::Shrink(Isolate* isolate, int new_length) {
4019 isolate->heap()->RightTrimFixedArray(*this, length() - new_length);
4035 Handle<ArrayList> ArrayList::Add(Isolate* isolate, Handle<ArrayList> array,
4038 array = EnsureSpace(isolate, array, length + 1);
4051 Handle<ArrayList> ArrayList::Add(Isolate* isolate, Handle<ArrayList> array,
4054 array = EnsureSpace(isolate, array, length + 2);
4067 Handle<ArrayList> ArrayList::Add(Isolate* isolate, Handle<ArrayList> array,
4071 array = EnsureSpace(isolate, array, length + 4);
4087 Handle<ArrayList> ArrayList::New(Isolate* isolate, int size) {
4088 return isolate->factory()->NewArrayList(size);
4091 Handle<FixedArray> ArrayList::Elements(Isolate* isolate,
4094 Handle<FixedArray> result = isolate->factory()->NewFixedArray(length);
4102 Handle<FixedArray> EnsureSpaceInFixedArray(Isolate* isolate,
4110 array = isolate->factory()->CopyFixedArrayAndGrow(array, grow_by);
4118 Handle<ArrayList> ArrayList::EnsureSpace(Isolate* isolate,
4122 EnsureSpaceInFixedArray(isolate, array, kFirstIndex + length));
4128 Handle<WeakArrayList> WeakArrayList::AddToEnd(Isolate* isolate,
4132 array = EnsureSpace(isolate, array, length + 1);
4144 Handle<WeakArrayList> WeakArrayList::AddToEnd(Isolate* isolate,
4149 array = EnsureSpace(isolate, array, length + 2);
4163 Handle<WeakArrayList> WeakArrayList::Append(Isolate* isolate,
4191 array = isolate->factory()->CompactWeakArrayList(array, new_capacity,
4196 array->Compact(isolate);
4213 void WeakArrayList::Compact(Isolate* isolate) {
4219 MaybeObject value = Get(isolate, i);
4235 Handle<WeakArrayList> WeakArrayList::EnsureSpace(Isolate* isolate,
4242 array = isolate->factory()->CopyWeakArrayListAndGrow(array, grow_by,
4288 Handle<WeakArrayList> PrototypeUsers::Add(Isolate* isolate,
4295 array = WeakArrayList::EnsureSpace(isolate, array, kFirstIndex + 1);
4335 array = WeakArrayList::EnsureSpace(isolate, array, length + 1);
4363 heap->isolate(),
4364 handle(ReadOnlyRoots(heap).empty_weak_array_list(), heap->isolate()),
4384 Handle<RegExpMatchInfo> RegExpMatchInfo::New(Isolate* isolate,
4386 Handle<RegExpMatchInfo> match_info = isolate->factory()->NewRegExpMatchInfo();
4387 return ReserveCaptures(isolate, match_info, capture_count);
4391 Isolate* isolate, Handle<RegExpMatchInfo> match_info, int capture_count) {
4398 EnsureSpaceInFixedArray(isolate, match_info, required_length));
4404 Handle<DescriptorArray> DescriptorArray::Allocate(IsolateT* isolate,
4409 ? isolate->factory()->empty_descriptor_array()
4410 : isolate->factory()->NewDescriptorArray(nof_descriptors, slack,
4414 Isolate* isolate, int nof_descriptors, int slack,
4417 LocalIsolate* isolate, int nof_descriptors, int slack,
4446 Handle<DescriptorArray> descriptors, Isolate* isolate,
4449 if (enum_cache == ReadOnlyRoots(isolate).empty_enum_cache()) {
4450 enum_cache = *isolate->factory()->NewEnumCache(keys, indices);
4539 Handle<AccessorPair> AccessorPair::Copy(Isolate* isolate,
4541 Handle<AccessorPair> copy = isolate->factory()->NewAccessorPair();
4547 Handle<Object> AccessorPair::GetComponent(Isolate* isolate,
4551 Handle<Object> accessor(accessor_pair->get(component), isolate);
4554 isolate, native_context,
4560 if (accessor->IsNull(isolate)) {
4561 return isolate->factory()->undefined_value();
4581 MaybeHandle<String> Name::ToFunctionName(Isolate* isolate, Handle<Name> name) {
4585 isolate);
4586 if (description->IsUndefined(isolate)) {
4587 return isolate->factory()->empty_string();
4589 IncrementalStringBuilder builder(isolate);
4597 MaybeHandle<String> Name::ToFunctionName(Isolate* isolate, Handle<Name> name,
4600 ASSIGN_RETURN_ON_EXCEPTION(isolate, name_string,
4601 ToFunctionName(isolate, name), String);
4602 IncrementalStringBuilder builder(isolate);
4609 void Relocatable::PostGarbageCollectionProcessing(Isolate* isolate) {
4610 Relocatable* current = isolate->relocatable_top();
4621 char* Relocatable::ArchiveState(Isolate* isolate, char* to) {
4622 *reinterpret_cast<Relocatable**>(to) = isolate->relocatable_top();
4623 isolate->set_relocatable_top(nullptr);
4628 char* Relocatable::RestoreState(Isolate* isolate, char* from) {
4629 isolate->set_relocatable_top(*reinterpret_cast<Relocatable**>(from));
4639 void Relocatable::Iterate(Isolate* isolate, RootVisitor* v) {
4640 Iterate(v, isolate->relocatable_top());
4733 Address JSArray::ArrayJoinConcatToSequentialString(Isolate* isolate,
4739 DisallowJavascriptExecution no_js(isolate);
4780 void Oddball::Initialize(Isolate* isolate, Handle<Oddball> oddball,
4784 isolate->factory()->InternalizeUtf8String(to_string);
4786 isolate->factory()->InternalizeUtf8String(type_of);
4800 int Script::GetEvalPosition(Isolate* isolate, Handle<Script> script) {
4811 handle(script->eval_from_shared(), isolate);
4812 SharedFunctionInfo::EnsureSourcePositionsAvailable(isolate, shared);
4813 position = shared->abstract_code(isolate).SourcePosition(-position);
4823 void Script::InitLineEnds(IsolateT* isolate, Handle<Script> script) {
4824 if (!script->line_ends().IsUndefined(isolate)) return;
4832 DCHECK(src_obj.IsUndefined(isolate));
4833 script->set_line_ends(ReadOnlyRoots(isolate).empty_fixed_array());
4836 Handle<String> src(String::cast(src_obj), isolate);
4837 Handle<FixedArray> array = String::CalculateLineEnds(isolate, src, true);
4845 Isolate* isolate, Handle<Script> script);
4847 LocalIsolate* isolate, Handle<Script> script);
5047 Handle<Script> script, IsolateT* isolate,
5052 return FindWebSnapshotSharedFunctionInfo(script, isolate, function_literal);
5064 heap_object.IsUndefined(isolate)) {
5067 return handle(SharedFunctionInfo::cast(heap_object), isolate);
5070 Handle<Script> script, Isolate* isolate, FunctionLiteral* function_literal);
5072 Handle<Script> script, LocalIsolate* isolate,
5076 Handle<Script> script, Isolate* isolate,
5083 ObjectHashTable::cast(script->shared_function_info_table()), isolate);
5087 handle(Smi::FromInt(function_literal->start_position()), isolate));
5105 return handle(shared, isolate);
5119 handle(Smi::FromInt(function_literal->start_position()), isolate),
5120 handle(Smi::FromInt(function_literal_id), isolate));
5127 handle(script->shared_function_infos(), isolate);
5131 isolate->factory()->NewWeakFixedArray(capacity, AllocationType::kOld));
5132 new_infos->CopyElements(isolate, 0, *old_infos, 0, old_length,
5140 Handle<Script> script, LocalIsolate* isolate,
5146 Script::Iterator::Iterator(Isolate* isolate)
5147 : iterator_(isolate->heap()->script_list()) {}
5173 Maybe<bool> JSProxy::SetPrototype(Isolate* isolate, Handle<JSProxy> proxy,
5176 STACK_CHECK(isolate, Nothing<bool>());
5177 Handle<Name> trap_name = isolate->factory()->setPrototypeOf_string();
5179 DCHECK(value->IsJSReceiver() || value->IsNull(isolate));
5181 Handle<Object> handler(proxy->handler(), isolate);
5185 isolate->Throw(*isolate->factory()->NewTypeError(
5190 Handle<JSReceiver> target(JSReceiver::cast(proxy->target()), isolate);
5194 isolate, trap,
5198 if (trap->IsUndefined(isolate)) {
5199 return JSReceiver::SetPrototype(isolate, target, value, from_javascript,
5206 isolate, trap_result,
5207 Execution::Call(isolate, trap, handler, arraysize(argv), argv),
5209 bool bool_trap_result = trap_result->BooleanValue(isolate);
5213 isolate, should_throw,
5223 isolate, should_throw,
5228 ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate, target_proto,
5229 JSReceiver::GetPrototype(isolate, target),
5233 isolate->Throw(*isolate->factory()->NewTypeError(
5320 Isolate* isolate = array->GetIsolate();
5321 LookupIterator it(isolate, array, isolate->factory()->length_string(), array,
5399 Isolate* const isolate = promise->GetIsolate();
5402 if (isolate->HasContextPromiseHooks()) {
5403 isolate->raw_native_context().RunPromiseHook(
5405 isolate->factory()->undefined_value());
5413 Handle<Object> reactions(promise->reactions(), isolate);
5424 return TriggerPromiseReactions(isolate, reactions, value,
5428 static void MoveMessageToPromise(Isolate* isolate, Handle<JSPromise> promise) {
5429 if (!isolate->has_pending_message()) return;
5431 Handle<Object> message = handle(isolate->pending_message(), isolate);
5432 Handle<Symbol> key = isolate->factory()->promise_debug_message_symbol();
5433 Object::SetProperty(isolate, promise, key, message, StoreOrigin::kMaybeKeyed,
5439 isolate->clear_pending_message();
5445 Isolate* const isolate = promise->GetIsolate();
5447 !reinterpret_cast<v8::Isolate*>(isolate)->GetCurrentContext().IsEmpty());
5449 if (isolate->debug()->is_active()) MoveMessageToPromise(isolate, promise);
5451 if (debug_event) isolate->debug()->OnPromiseReject(promise, reason);
5452 isolate->RunAllPromiseHooks(PromiseHookType::kResolve, promise,
5453 isolate->factory()->undefined_value());
5459 Handle<Object> reactions(promise->reactions(), isolate);
5472 isolate->ReportPromiseReject(promise, reason, kPromiseRejectWithNoHandler);
5476 return TriggerPromiseReactions(isolate, reactions, reason,
5484 Isolate* const isolate = promise->GetIsolate();
5486 !reinterpret_cast<v8::Isolate*>(isolate)->GetCurrentContext().IsEmpty());
5488 isolate->RunPromiseHook(PromiseHookType::kResolve, promise,
5489 isolate->factory()->undefined_value());
5494 Handle<Object> self_resolution_error = isolate->factory()->NewTypeError(
5516 isolate->IsInAnyContext(receiver->map().prototype(),
5518 Protectors::IsPromiseThenLookupChainIntact(isolate)) {
5523 then = isolate->promise_then();
5525 then = JSReceiver::GetProperty(isolate, receiver,
5526 isolate->factory()->then_string());
5533 if (!isolate->is_catchable_by_javascript(isolate->pending_exception())) {
5538 Handle<Object> reason(isolate->pending_exception(), isolate);
5539 isolate->clear_pending_exception();
5555 then_context = isolate->native_context();
5559 isolate->factory()->NewPromiseResolveThenableJobTask(
5562 if (isolate->debug()->is_active() && resolution->IsJSPromise()) {
5564 Object::SetProperty(isolate, resolution,
5565 isolate->factory()->promise_handled_by_symbol(),
5573 return isolate->factory()->undefined_value();
5577 Handle<Object> JSPromise::TriggerPromiseReactions(Isolate* isolate,
5595 reactions = handle(reversed, isolate);
5603 reactions = handle(reaction->next(), isolate);
5613 primary_handler = handle(reaction->fulfill_handler(), isolate);
5614 secondary_handler = handle(reaction->reject_handler(), isolate);
5616 primary_handler = handle(reaction->reject_handler(), isolate);
5617 secondary_handler = handle(reaction->fulfill_handler(), isolate);
5631 if (!has_handler_context) handler_context = isolate->native_context();
5639 ReadOnlyRoots(isolate).promise_fulfill_reaction_job_task_map(),
5660 ReadOnlyRoots(isolate).promise_reject_reaction_job_task_map(),
5685 return isolate->factory()->undefined_value();
5702 IsolateT* isolate, int at_least_space_for, AllocationType allocation,
5712 isolate->FatalProcessOutOfHeapMemory("invalid table size");
5714 return NewInternal(isolate, capacity, allocation);
5720 IsolateT* isolate, int capacity, AllocationType allocation) {
5721 auto* factory = isolate->factory();
5724 Derived::GetMap(ReadOnlyRoots(isolate)), length, allocation);
5852 IsolateT* isolate, Handle<Derived> table, int n,
5863 isolate, new_nof,
5866 table->Rehash(isolate, *new_table);
5912 Handle<Derived> HashTable<Derived, Shape>::Shrink(Isolate* isolate,
5923 HashTable::New(isolate, new_capacity,
5927 table->Rehash(isolate, *new_table);
5945 Isolate* isolate, Handle<Name> name, RelaxedLoadTag tag) {
5953 PtrComprCageBase cage_base{isolate};
5954 ReadOnlyRoots roots(isolate);
5964 if (isolate->heap()->IsPendingAllocation(element)) return {};
5973 Handle<StringSet> StringSet::New(Isolate* isolate) {
5974 return HashTable::New(isolate, 0);
5977 Handle<StringSet> StringSet::Add(Isolate* isolate, Handle<StringSet> stringset,
5979 if (!stringset->Has(isolate, name)) {
5980 stringset = EnsureCapacity(isolate, stringset);
5981 uint32_t hash = ShapeT::Hash(ReadOnlyRoots(isolate), *name);
5982 InternalIndex entry = stringset->FindInsertionEntry(isolate, hash);
5989 bool StringSet::Has(Isolate* isolate, Handle<String> name) {
5990 return FindEntry(isolate, *name).is_found();
5994 Isolate* isolate, Handle<RegisteredSymbolTable> table, Handle<String> key,
5997 SLOW_DCHECK(table->FindEntry(isolate, key).is_not_found());
5999 table = EnsureCapacity(isolate, table);
6000 uint32_t hash = ShapeT::Hash(ReadOnlyRoots(isolate), key);
6001 InternalIndex entry = table->FindInsertionEntry(isolate, hash);
6008 Handle<ObjectHashSet> ObjectHashSet::Add(Isolate* isolate,
6011 int32_t hash = key->GetOrCreateHash(isolate).value();
6012 if (!set->Has(isolate, key, hash)) {
6013 set = EnsureCapacity(isolate, set);
6014 InternalIndex entry = set->FindInsertionEntry(isolate, hash);
6024 IsolateT* isolate, int at_least_space_for, AllocationType allocation,
6028 isolate, at_least_space_for, allocation, capacity_option);
6036 Isolate* isolate, Handle<Derived> dictionary) {
6041 Handle<FixedArray> iteration_order = IterationIndices(isolate, dictionary);
6050 dictionary->KeyAt(isolate, internal_index)));
6069 Isolate* isolate, Handle<Derived> dictionary, InternalIndex entry) {
6074 return Shrink(isolate, dictionary);
6078 Handle<Derived> Dictionary<Derived, Shape>::AtPut(Isolate* isolate,
6082 InternalIndex entry = dictionary->FindEntry(isolate, key);
6086 return Derived::Add(isolate, dictionary, key, value, details);
6099 IsolateT* isolate, Handle<Derived> dictionary, Key key,
6102 return Dictionary<Derived, Shape>::Add(isolate, dictionary, key, value,
6108 Isolate* isolate, Handle<Derived> dictionary, Key key, Handle<Object> value,
6114 int index = Derived::NextEnumerationIndex(isolate, dictionary);
6116 dictionary = AddNoUpdateNextEnumerationIndex(isolate, dictionary, key, value,
6126 Handle<Derived> Dictionary<Derived, Shape>::Add(IsolateT* isolate,
6131 ReadOnlyRoots roots(isolate);
6134 SLOW_DCHECK(dictionary->FindEntry(isolate, key).is_not_found());
6136 dictionary = Derived::EnsureCapacity(isolate, dictionary);
6139 Handle<Object> k = Shape::AsHandle(isolate, key);
6141 InternalIndex entry = dictionary->FindInsertionEntry(isolate, roots, hash);
6143 DCHECK(dictionary->KeyAt(isolate, entry).IsNumber() ||
6144 Shape::Unwrap(dictionary->KeyAt(isolate, entry)).IsUniqueName());
6152 Isolate* isolate, Handle<Derived> dictionary) {
6153 return Handle<Derived>::cast(isolate->factory()->CopyFixedArrayWithMap(
6154 dictionary, Derived::GetMap(ReadOnlyRoots(isolate))));
6159 Isolate* isolate, Handle<SimpleNumberDictionary> dictionary, uint32_t key,
6161 return AtPut(isolate, dictionary, key, value, PropertyDetails::Empty());
6188 Isolate* isolate, Handle<NumberDictionary> dictionary, uint32_t key,
6195 AtPut(isolate, dictionary, key, value, details);
6231 Isolate* isolate, Handle<Derived> dictionary) {
6233 isolate->factory()->NewFixedArray(dictionary->NumberOfElements());
6234 ReadOnlyRoots roots(isolate);
6259 return FixedArray::ShrinkOrEmpty(isolate, array, array_size);
6359 Isolate* isolate = Heap::FromWritableHeapObject(*table)->isolate();
6360 DCHECK(table->IsKey(ReadOnlyRoots(isolate), *key));
6361 DCHECK(!value->IsTheHole(ReadOnlyRoots(isolate)));
6364 int32_t hash = key->GetOrCreateHash(isolate).value();
6366 return ObjectHashTableBase<Derived, Shape>::Put(isolate, table, key, value,
6371 Handle<Derived> ObjectHashTableBase<Derived, Shape>::Put(Isolate* isolate,
6376 ReadOnlyRoots roots(isolate);
6380 InternalIndex entry = table->FindEntry(isolate, roots, key, hash);
6391 table->Rehash(isolate);
6400 isolate->heap()->CollectAllGarbage(
6403 table->Rehash(isolate);
6408 table = Derived::EnsureCapacity(isolate, table);
6409 table->AddEntry(table->FindInsertionEntry(isolate, hash), *key, *value);
6415 Isolate* isolate, Handle<Derived> table, Handle<Object> key,
6425 return Remove(isolate, table, key, was_present, Smi::ToInt(hash));
6430 Isolate* isolate, Handle<Derived> table, Handle<Object> key,
6435 InternalIndex entry = table->FindEntry(isolate, roots, key, hash);
6443 return Derived::Shrink(isolate, table);
6462 void JSSet::Initialize(Handle<JSSet> set, Isolate* isolate) {
6463 Handle<OrderedHashSet> table = isolate->factory()->NewOrderedHashSet();
6467 void JSSet::Clear(Isolate* isolate, Handle<JSSet> set) {
6468 Handle<OrderedHashSet> table(OrderedHashSet::cast(set->table()), isolate);
6469 table = OrderedHashSet::Clear(isolate, table);
6473 void JSSet::Rehash(Isolate* isolate) {
6474 Handle<OrderedHashSet> table_handle(OrderedHashSet::cast(table()), isolate);
6476 OrderedHashSet::Rehash(isolate, table_handle).ToHandleChecked();
6480 void JSMap::Initialize(Handle<JSMap> map, Isolate* isolate) {
6481 Handle<OrderedHashMap> table = isolate->factory()->NewOrderedHashMap();
6485 void JSMap::Clear(Isolate* isolate, Handle<JSMap> map) {
6486 Handle<OrderedHashMap> table(OrderedHashMap::cast(map->table()), isolate);
6487 table = OrderedHashMap::Clear(isolate, table);
6491 void JSMap::Rehash(Isolate* isolate) {
6492 Handle<OrderedHashMap> table_handle(OrderedHashMap::cast(table()), isolate);
6494 OrderedHashMap::Rehash(isolate, table_handle).ToHandleChecked();
6499 Isolate* isolate) {
6500 Handle<EphemeronHashTable> table = EphemeronHashTable::New(isolate, 0);
6541 Isolate* isolate = holder->GetIsolate();
6543 isolate);
6549 isolate->factory()->NewFixedArray(max_entries * values_per_entry);
6557 ReadOnlyRoots roots = ReadOnlyRoots(isolate);
6565 Object value = table->Lookup(handle(key, isolate));
6572 return isolate->factory()->NewJSArrayWithElements(entries);
6581 Isolate* isolate = GetIsolateFromWritableObject(*this);
6583 isolate, DependentCode::kPropertyCellChangedGroup);
6588 Isolate* isolate, Handle<GlobalDictionary> dictionary, InternalIndex entry,
6590 Handle<PropertyCell> cell(dictionary->CellAt(entry), isolate);
6591 Handle<Name> name(cell->name(), isolate);
6593 DCHECK(!cell->value().IsTheHole(isolate));
6597 isolate->factory()->NewPropertyCell(name, new_details, new_value);
6600 cell->ClearAndInvalidate(ReadOnlyRoots(isolate));
6617 PropertyCellType PropertyCell::InitialType(Isolate* isolate, Object value) {
6618 return value.IsUndefined(isolate) ? PropertyCellType::kUndefined
6623 PropertyCellType PropertyCell::UpdatedType(Isolate* isolate, PropertyCell cell,
6627 DCHECK(!value.IsTheHole(isolate));
6628 DCHECK(!cell.value().IsTheHole(isolate));
6648 Isolate* isolate, Handle<GlobalDictionary> dictionary, InternalIndex entry,
6650 DCHECK(!value->IsTheHole(isolate));
6652 CHECK(!raw_cell.value().IsTheHole(isolate));
6662 UpdatedType(isolate, raw_cell, *value, original_details);
6665 Handle<PropertyCell> cell(raw_cell, isolate);
6668 cell = PropertyCell::InvalidateAndReplaceEntry(isolate, dictionary, entry,
6680 isolate, DependentCode::kPropertyCellChangedGroup);
6692 Isolate* isolate = GetIsolateFromWritableObject(*this);
6694 isolate, DependentCode::kPropertyCellChangedGroup);
6746 Isolate* isolate = GetIsolate();
6748 function().shared().GetBytecodeArray(isolate).HasSourcePositionTable());
6756 AbstractCode::cast(function().shared().GetBytecodeArray(isolate));
6761 AccessCheckInfo AccessCheckInfo::Get(Isolate* isolate,
6769 if (data_obj.IsUndefined(isolate)) return AccessCheckInfo();
6780 if (data_obj.IsUndefined(isolate)) return AccessCheckInfo();
6785 Address Smi::LexicographicCompare(Isolate* isolate, Smi x, Smi y) {
6787 DisallowJavascriptExecution no_js(isolate);
6899 Isolate* isolate, Handle<DERIVED>, Key, Handle<Object>, PropertyDetails, \
6902 LocalIsolate* isolate, Handle<DERIVED>, Key, Handle<Object>, \
6919 Isolate* isolate, Handle<DERIVED>, Key, Handle<Object>, PropertyDetails, \
6923 LocalIsolate* isolate, Handle<DERIVED>, Key, Handle<Object>, \
6947 Isolate* isolate, Address raw_finalization_registry,
6953 DCHECK(!weak_cell.unregister_token().IsUndefined(isolate));
6954 HeapObject undefined = ReadOnlyRoots(isolate).undefined_value();
6960 if (weak_cell.key_list_prev().IsUndefined(isolate)) {
6965 InternalIndex entry = key_map.FindEntry(isolate, key);
6968 if (weak_cell.key_list_next().IsUndefined(isolate)) {