Lines Matching refs:Handle
33 return Handle<TYPE>(TYPE::cast(__object__), ISOLATE); \
59 return Handle<TYPE>(); \
63 Handle<T> Factory::New(Handle<Map> map, AllocationSpace space) {
72 Handle<T> Factory::New(Handle<Map> map,
74 Handle<AllocationSite> allocation_site) {
82 Handle<HeapObject> Factory::NewFillerObject(int size,
92 Handle<PrototypeInfo> Factory::NewPrototypeInfo() {
93 Handle<PrototypeInfo> result =
94 Handle<PrototypeInfo>::cast(NewStruct(PROTOTYPE_INFO_TYPE));
102 Handle<Tuple2> Factory::NewTuple2(Handle<Object> value1,
103 Handle<Object> value2) {
104 Handle<Tuple2> result = Handle<Tuple2>::cast(NewStruct(TUPLE2_TYPE));
110 Handle<Tuple3> Factory::NewTuple3(Handle<Object> value1, Handle<Object> value2,
111 Handle<Object> value3) {
112 Handle<Tuple3> result = Handle<Tuple3>::cast(NewStruct(TUPLE3_TYPE));
119 Handle<ContextExtension> Factory::NewContextExtension(
120 Handle<ScopeInfo> scope_info, Handle<Object> extension) {
121 Handle<ContextExtension> result =
122 Handle<ContextExtension>::cast(NewStruct(CONTEXT_EXTENSION_TYPE));
128 Handle<ConstantElementsPair> Factory::NewConstantElementsPair(
129 ElementsKind elements_kind, Handle<FixedArrayBase> constant_values) {
130 Handle<ConstantElementsPair> result = Handle<ConstantElementsPair>::cast(
137 Handle<Oddball> Factory::NewOddball(Handle<Map> map, const char* to_string,
138 Handle<Object> to_number,
140 Handle<Oddball> oddball = New<Oddball>(map, OLD_SPACE);
146 Handle<FixedArray> Factory::NewFixedArray(int size, PretenureFlag pretenure) {
161 return Handle<FixedArray>(FixedArray::cast(array), isolate());
164 Handle<FixedArray> Factory::NewFixedArrayWithHoles(int size,
175 Handle<FixedArray> Factory::NewUninitializedFixedArray(int size) {
182 Handle<BoilerplateDescription> Factory::NewBoilerplateDescription(
201 Handle<BoilerplateDescription> description =
202 Handle<BoilerplateDescription>::cast(NewFixedArray(size, TENURED));
211 Handle<FixedArrayBase> Factory::NewFixedDoubleArray(int size,
221 Handle<FixedArrayBase> Factory::NewFixedDoubleArrayWithHoles(
225 Handle<FixedArrayBase> array = NewFixedDoubleArray(size, pretenure);
227 Handle<FixedDoubleArray>::cast(array)->FillWithHoles(0, size);
232 Handle<FrameArray> Factory::NewFrameArray(int number_of_frames,
235 Handle<FixedArray> result =
238 return Handle<FrameArray>::cast(result);
241 Handle<OrderedHashSet> Factory::NewOrderedHashSet() {
246 Handle<OrderedHashMap> Factory::NewOrderedHashMap() {
251 Handle<AccessorPair> Factory::NewAccessorPair() {
252 Handle<AccessorPair> accessors =
253 Handle<AccessorPair>::cast(NewStruct(ACCESSOR_PAIR_TYPE));
260 Handle<TypeFeedbackInfo> Factory::NewTypeFeedbackInfo() {
261 Handle<TypeFeedbackInfo> info =
262 Handle<TypeFeedbackInfo>::cast(NewStruct(TYPE_FEEDBACK_INFO_TYPE));
269 Handle<String> Factory::InternalizeUtf8String(Vector<const char> string) {
275 Handle<String> Factory::InternalizeOneByteString(Vector<const uint8_t> string) {
281 Handle<String> Factory::InternalizeOneByteString(
282 Handle<SeqOneByteString> string, int from, int length) {
288 Handle<String> Factory::InternalizeTwoByteString(Vector<const uc16> string) {
295 Handle<String> Factory::InternalizeStringWithKey(StringTableKey* key) {
305 Handle<SeqOneByteString> result;
340 Handle<SeqTwoByteString> result;
357 Handle<SeqOneByteString> str, int begin, int length,
375 Handle<SeqTwoByteString> result;
400 Handle<SeqOneByteString> result;
409 Handle<SeqTwoByteString> result;
431 Handle<String> Factory::NewInternalizedStringFromUtf8(Vector<const char> str,
442 MUST_USE_RESULT Handle<String> Factory::NewOneByteInternalizedString(
452 MUST_USE_RESULT Handle<String> Factory::NewOneByteInternalizedSubString(
453 Handle<SeqOneByteString> string, int offset, int length,
463 MUST_USE_RESULT Handle<String> Factory::NewTwoByteInternalizedString(
473 Handle<String> Factory::NewInternalizedStringImpl(
474 Handle<String> string, int chars, uint32_t hash_field) {
484 MaybeHandle<Map> GetInternalizedStringMap(Factory* f, Handle<String> string) {
509 Handle<String> string) {
517 Handle<StringClass> Factory::InternalizeExternalString(Handle<String> string) {
518 Handle<StringClass> cast_string = Handle<StringClass>::cast(string);
519 Handle<Map> map = GetInternalizedStringMap(this, string).ToHandleChecked();
520 Handle<StringClass> external_string = New<StringClass>(map, OLD_SPACE);
528 template Handle<ExternalOneByteString>
529 Factory::InternalizeExternalString<ExternalOneByteString>(Handle<String>);
530 template Handle<ExternalTwoByteString>
531 Factory::InternalizeExternalString<ExternalTwoByteString>(Handle<String>);
559 Handle<String> Factory::LookupSingleCharacterStringFromCode(uint32_t code) {
565 return handle(String::cast(value), isolate());
570 Handle<String> result =
577 Handle<SeqTwoByteString> result = NewRawTwoByteString(1).ToHandleChecked();
590 static inline Handle<String> MakeOrFindTwoCharacterString(Isolate* isolate,
596 Handle<String> result;
609 Handle<SeqOneByteString> str =
616 Handle<SeqTwoByteString> str =
627 Handle<String> ConcatStringContent(Handle<StringType> result,
628 Handle<String> first,
629 Handle<String> second) {
638 MaybeHandle<String> Factory::NewConsString(Handle<String> left,
639 Handle<String> right) {
641 left = handle(Handle<ThinString>::cast(left)->actual(), isolate());
644 right = handle(Handle<ThinString>::cast(right)->actual(), isolate());
689 Handle<SeqOneByteString> result =
696 ? Handle<ExternalOneByteString>::cast(left)->GetChars()
697 : Handle<SeqOneByteString>::cast(left)->GetChars();
701 ? Handle<ExternalOneByteString>::cast(right)->GetChars()
702 : Handle<SeqOneByteString>::cast(right)->GetChars();
714 Handle<ConsString> result =
729 Handle<String> Factory::NewSurrogatePairString(uint16_t lead, uint16_t trail) {
735 Handle<SeqTwoByteString> str =
743 Handle<String> Factory::NewProperSubString(Handle<String> str,
769 Handle<SeqOneByteString> result =
776 Handle<SeqTwoByteString> result =
788 Handle<SlicedString> slice = Handle<SlicedString>::cast(str);
789 str = Handle<String>(slice->parent(), isolate());
793 Handle<ThinString> thin = Handle<ThinString>::cast(str);
794 str = handle(thin->actual(), isolate());
798 Handle<Map> map = str->IsOneByteRepresentation()
801 Handle<SlicedString> slice = New<SlicedString>(map, NEW_SPACE);
819 Handle<Map> map;
826 Handle<ExternalOneByteString> external_string =
849 Handle<Map> map;
858 Handle<ExternalTwoByteString> external_string =
867 Handle<ExternalOneByteString> Factory::NewNativeSourceString(
872 Handle<Map> map = native_source_string_map();
873 Handle<ExternalOneByteString> external_string =
882 Handle<JSStringIterator> Factory::NewJSStringIterator(Handle<String> string) {
883 Handle<Map> map(isolate()->native_context()->string_iterator_map(),
885 Handle<String> flat_string = String::Flatten(string);
886 Handle<JSStringIterator> iterator =
887 Handle<JSStringIterator>::cast(NewJSObjectFromMap(map));
894 Handle<Symbol> Factory::NewSymbol() {
902 Handle<Symbol> Factory::NewPrivateSymbol() {
903 Handle<Symbol> symbol = NewSymbol();
909 Handle<Context> Factory::NewNativeContext() {
910 Handle<FixedArray> array =
913 Handle<Context> context = Handle<Context>::cast(array);
917 Handle<WeakCell> weak_cell = NewWeakCell(context);
924 Handle<Context> Factory::NewScriptContext(Handle<JSFunction> function,
925 Handle<ScopeInfo> scope_info) {
927 Handle<FixedArray> array =
930 Handle<Context> context = Handle<Context>::cast(array);
940 Handle<ScriptContextTable> Factory::NewScriptContextTable() {
941 Handle<FixedArray> array = NewFixedArray(1);
943 Handle<ScriptContextTable> context_table =
944 Handle<ScriptContextTable>::cast(array);
949 Handle<Context> Factory::NewModuleContext(Handle<Module> module,
950 Handle<JSFunction> function,
951 Handle<ScopeInfo> scope_info) {
953 Handle<FixedArray> array =
956 Handle<Context> context = Handle<Context>::cast(array);
965 Handle<Context> Factory::NewFunctionContext(int length,
966 Handle<JSFunction> function,
970 Handle<FixedArray> array = NewFixedArray(length);
971 Handle<Map> map;
983 Handle<Context> context = Handle<Context>::cast(array);
991 Handle<Context> Factory::NewCatchContext(Handle<JSFunction> function,
992 Handle<Context> previous,
993 Handle<ScopeInfo> scope_info,
994 Handle<String> name,
995 Handle<Object> thrown_object) {
997 Handle<ContextExtension> extension = NewContextExtension(scope_info, name);
998 Handle<FixedArray> array = NewFixedArray(Context::MIN_CONTEXT_SLOTS + 1);
1000 Handle<Context> context = Handle<Context>::cast(array);
1009 Handle<Context> Factory::NewDebugEvaluateContext(Handle<Context> previous,
1010 Handle<ScopeInfo> scope_info,
1011 Handle<JSReceiver> extension,
1012 Handle<Context> wrapped,
1013 Handle<StringSet> whitelist) {
1016 Handle<ContextExtension> context_extension = NewContextExtension(
1017 scope_info, extension.is_null() ? Handle<Object>::cast(undefined_value())
1018 : Handle<Object>::cast(extension));
1019 Handle<FixedArray> array = NewFixedArray(Context::MIN_CONTEXT_SLOTS + 2);
1021 Handle<Context> c = Handle<Context>::cast(array);
1031 Handle<Context> Factory::NewWithContext(Handle<JSFunction> function,
1032 Handle<Context> previous,
1033 Handle<ScopeInfo> scope_info,
1034 Handle<JSReceiver> extension) {
1035 Handle<ContextExtension> context_extension =
1037 Handle<FixedArray> array = NewFixedArray(Context::MIN_CONTEXT_SLOTS);
1039 Handle<Context> context = Handle<Context>::cast(array);
1048 Handle<Context> Factory::NewBlockContext(Handle<JSFunction> function,
1049 Handle<Context> previous,
1050 Handle<ScopeInfo> scope_info) {
1052 Handle<FixedArray> array = NewFixedArray(scope_info->ContextLength());
1054 Handle<Context> context = Handle<Context>::cast(array);
1062 Handle<Struct> Factory::NewStruct(InstanceType type) {
1069 Handle<AliasedArgumentsEntry> Factory::NewAliasedArgumentsEntry(
1071 Handle<AliasedArgumentsEntry> entry = Handle<AliasedArgumentsEntry>::cast(
1078 Handle<AccessorInfo> Factory::NewAccessorInfo() {
1079 Handle<AccessorInfo> info =
1080 Handle<AccessorInfo>::cast(NewStruct(ACCESSOR_INFO_TYPE));
1087 Handle<Script> Factory::NewScript(Handle<String> source) {
1090 Handle<Script> script = Handle<Script>::cast(NewStruct(SCRIPT_TYPE));
1110 Handle<Foreign> Factory::NewForeign(Address addr, PretenureFlag pretenure) {
1117 Handle<Foreign> Factory::NewForeign(const AccessorDescriptor* desc) {
1122 Handle<ByteArray> Factory::NewByteArray(int length, PretenureFlag pretenure) {
1131 Handle<BytecodeArray> Factory::NewBytecodeArray(
1133 Handle<FixedArray> constant_pool) {
1142 Handle<FixedTypedArrayBase> Factory::NewFixedTypedArrayWithExternalPointer(
1153 Handle<FixedTypedArrayBase> Factory::NewFixedTypedArray(
1162 Handle<Cell> Factory::NewCell(Handle<Object> value) {
1170 Handle<Cell> Factory::NewNoClosuresCell(Handle<Object> value) {
1171 Handle<Cell> cell = NewCell(value);
1176 Handle<Cell> Factory::NewOneClosureCell(Handle<Object> value) {
1177 Handle<Cell> cell = NewCell(value);
1182 Handle<Cell> Factory::NewManyClosuresCell(Handle<Object> value) {
1183 Handle<Cell> cell = NewCell(value);
1188 Handle<PropertyCell> Factory::NewPropertyCell() {
1196 Handle<WeakCell> Factory::NewWeakCell(Handle<HeapObject> value) {
1205 Handle<TransitionArray> Factory::NewTransitionArray(int capacity) {
1212 Handle<AllocationSite> Factory::NewAllocationSite() {
1213 Handle<Map> map = allocation_site_map();
1214 Handle<AllocationSite> site = New<AllocationSite>(map, OLD_SPACE);
1224 Handle<Map> Factory::NewMap(InstanceType type,
1234 Handle<JSObject> Factory::CopyJSObject(Handle<JSObject> object) {
1241 Handle<JSObject> Factory::CopyJSObjectWithAllocationSite(
1242 Handle<JSObject> object,
1243 Handle<AllocationSite> site) {
1252 Handle<FixedArray> Factory::CopyFixedArrayWithMap(Handle<FixedArray> array,
1253 Handle<Map> map) {
1260 Handle<FixedArray> Factory::CopyFixedArrayAndGrow(Handle<FixedArray> array,
1268 Handle<FixedArray> Factory::CopyFixedArrayUpTo(Handle<FixedArray> array,
1276 Handle<FixedArray> Factory::CopyFixedArray(Handle<FixedArray> array) {
1283 Handle<FixedArray> Factory::CopyAndTenureFixedCOWArray(
1284 Handle<FixedArray> array) {
1292 Handle<FixedDoubleArray> Factory::CopyFixedDoubleArray(
1293 Handle<FixedDoubleArray> array) {
1300 Handle<Object> Factory::NewNumber(double value,
1305 return handle(Smi::FromInt(int_value), isolate());
1313 Handle<Object> Factory::NewNumberFromInt(int32_t value,
1315 if (Smi::IsValid(value)) return handle(Smi::FromInt(value), isolate());
1321 Handle<Object> Factory::NewNumberFromUint(uint32_t value,
1325 return handle(Smi::FromInt(int32v), isolate());
1330 Handle<HeapNumber> Factory::NewHeapNumber(MutableMode mode,
1337 Handle<Object> Factory::NewError(Handle<JSFunction> constructor,
1339 Handle<Object> arg0, Handle<Object> arg1,
1340 Handle<Object> arg2) {
1352 Handle<Object> result;
1359 result = handle(isolate()->pending_exception(), isolate());
1367 Handle<Object> Factory::NewError(Handle<JSFunction> constructor,
1368 Handle<String> message) {
1372 Handle<Object> no_caller;
1378 maybe_error = handle(isolate()->pending_exception(), isolate());
1385 Handle<Object> Factory::NewInvalidStringLengthError() {
1394 Handle<Object> Factory::New##NAME(MessageTemplate::Template template_index, \
1395 Handle<Object> arg0, Handle<Object> arg1, \
1396 Handle<Object> arg2) { \
1411 Handle<JSFunction> Factory::NewFunction(Handle<Map> map,
1412 Handle<SharedFunctionInfo> info,
1413 Handle<Object> context_or_undefined,
1416 Handle<JSFunction> function = New<JSFunction>(map, space);
1433 Handle<JSFunction> Factory::NewFunction(Handle<Map> map,
1434 Handle<String> name,
1436 Handle<Context> context(isolate()->native_context());
1437 Handle<SharedFunctionInfo> info =
1456 Handle<JSFunction> Factory::NewFunction(Handle<String> name) {
1462 Handle<JSFunction> Factory::NewFunctionWithoutPrototype(Handle<String> name,
1463 Handle<Code> code,
1465 Handle<Map> map = is_strict
1472 Handle<JSFunction> Factory::NewFunction(Handle<String> name, Handle<Code> code,
1473 Handle<Object> prototype,
1475 Handle<Map> map = is_strict ? isolate()->strict_function_map()
1477 Handle<JSFunction> result = NewFunction(map, name, code);
1483 Handle<JSFunction> Factory::NewFunction(Handle<String> name, Handle<Code> code,
1484 Handle<Object> prototype,
1488 Handle<JSFunction> function = NewFunction(name, code, prototype, is_strict);
1492 Handle<Map> initial_map = NewMap(type, instance_size, elements_kind);
1503 Handle<JSReceiver>::cast(prototype));
1509 Handle<JSFunction> Factory::NewFunction(Handle<String> name,
1510 Handle<Code> code,
1517 Handle<JSObject> Factory::NewFunctionPrototype(Handle<JSFunction> function) {
1520 Handle<Context> native_context(function->context()->native_context());
1521 Handle<Map> new_map;
1525 new_map = handle(native_context->generator_object_prototype_map());
1529 Handle<JSFunction> object_function(native_context->object_function());
1531 new_map = handle(object_function->initial_map());
1535 Handle<JSObject> prototype = NewJSObjectFromMap(new_map);
1545 Handle<JSFunction> Factory::NewFunctionFromSharedFunctionInfo(
1546 Handle<SharedFunctionInfo> info,
1547 Handle<Context> context,
1551 Handle<Map> initial_map(Map::cast(context->native_context()->get(map_index)));
1557 Handle<JSFunction> Factory::NewFunctionFromSharedFunctionInfo(
1558 Handle<SharedFunctionInfo> info, Handle<Context> context,
1559 Handle<Cell> vector, PretenureFlag pretenure) {
1562 Handle<Map> initial_map(Map::cast(context->native_context()->get(map_index)));
1568 Handle<JSFunction> Factory::NewFunctionFromSharedFunctionInfo(
1569 Handle<Map> initial_map, Handle<SharedFunctionInfo> info,
1570 Handle<Object> context_or_undefined, PretenureFlag pretenure) {
1572 Handle<JSFunction> result =
1587 Handle<JSFunction> Factory::NewFunctionFromSharedFunctionInfo(
1588 Handle<Map> initial_map, Handle<SharedFunctionInfo> info,
1589 Handle<Object> context_or_undefined, Handle<Cell> vector,
1592 Handle<JSFunction> result =
1617 Handle<ScopeInfo> Factory::NewScopeInfo(int length) {
1618 Handle<FixedArray> array = NewFixedArray(length, TENURED);
1620 Handle<ScopeInfo> scope_info = Handle<ScopeInfo>::cast(array);
1624 Handle<ModuleInfo> Factory::NewModuleInfo() {
1625 Handle<FixedArray> array = NewFixedArray(ModuleInfo::kLength, TENURED);
1627 return Handle<ModuleInfo>::cast(array);
1630 Handle<JSObject> Factory::NewExternal(void* value) {
1631 Handle<Foreign> foreign = NewForeign(static_cast<Address>(value));
1632 Handle<JSObject> external = NewJSObjectFromMap(external_map());
1638 Handle<Code> Factory::NewCodeRaw(int object_size, bool immovable) {
1645 Handle<Code> Factory::NewCode(const CodeDesc& desc,
1647 Handle<Object> self_ref,
1652 Handle<ByteArray> reloc_info = NewByteArray(desc.reloc_size, TENURED);
1667 Handle<Code> code = NewCodeRaw(obj_size, immovable);
1703 // Allow self references to created code object by patching the handle to
1721 Handle<Code> Factory::CopyCode(Handle<Code> code) {
1728 Handle<BytecodeArray> Factory::CopyBytecodeArray(
1729 Handle<BytecodeArray> bytecode_array) {
1735 Handle<JSObject> Factory::NewJSObject(Handle<JSFunction> constructor,
1743 Handle<JSObject> Factory::NewJSObjectWithNullProto(PretenureFlag pretenure) {
1744 Handle<JSObject> result =
1746 Handle<Map> new_map =
1747 Map::Copy(Handle<Map>(result->map()), "ObjectWithNullProto");
1753 Handle<JSGlobalObject> Factory::NewJSGlobalObject(
1754 Handle<JSFunction> constructor) {
1756 Handle<Map> map(constructor->initial_map());
1776 Handle<GlobalDictionary> dictionary =
1781 Handle<DescriptorArray> descs(map->instance_descriptors());
1788 Handle<Name> name(descs->GetKey(i));
1789 Handle<PropertyCell> cell = NewPropertyCell();
1796 Handle<JSGlobalObject> global = New<JSGlobalObject>(map, OLD_SPACE);
1800 Handle<Map> new_map = Map::CopyDropDescriptors(map);
1813 Handle<JSObject> Factory::NewJSObjectFromMap(
1814 Handle<Map> map,
1816 Handle<AllocationSite> allocation_site) {
1827 Handle<JSArray> Factory::NewJSArray(ElementsKind elements_kind,
1835 return Handle<JSArray>::cast(NewJSObjectFromMap(handle(map), pretenure));
1838 Handle<JSArray> Factory::NewJSArray(ElementsKind elements_kind, int length,
1842 Handle<JSArray> array = NewJSArray(elements_kind, pretenure);
1847 Handle<JSArray> Factory::NewJSArrayWithElements(Handle<FixedArrayBase> elements,
1852 Handle<JSArray> array = NewJSArray(elements_kind, pretenure);
1861 void Factory::NewJSArrayStorage(Handle<JSArray> array,
1874 Handle<FixedArrayBase> elms;
1897 Handle<JSModuleNamespace> Factory::NewJSModuleNamespace() {
1898 Handle<Map> map = isolate()->js_module_namespace_map();
1899 Handle<JSModuleNamespace> module_namespace(
1900 Handle<JSModuleNamespace>::cast(NewJSObjectFromMap(map)));
1908 Handle<JSGeneratorObject> Factory::NewJSGeneratorObject(
1909 Handle<JSFunction> function) {
1912 Handle<Map> map(function->initial_map());
1920 Handle<Module> Factory::NewModule(Handle<SharedFunctionInfo> code) {
1921 Handle<ModuleInfo> module_info(code->scope_info()->ModuleDescriptorInfo(),
1923 Handle<ObjectHashTable> exports =
1925 Handle<FixedArray> regular_exports =
1927 Handle<FixedArray> regular_imports =
1930 Handle<FixedArray> requested_modules =
1934 Handle<Module> module = Handle<Module>::cast(NewStruct(MODULE_TYPE));
1947 Handle<JSArrayBuffer> Factory::NewJSArrayBuffer(SharedFlag shared,
1949 Handle<JSFunction> array_buffer_fun(
1959 Handle<JSDataView> Factory::NewJSDataView() {
1960 Handle<JSFunction> data_view_fun(
1968 Handle<JSIteratorResult> Factory::NewJSIteratorResult(Handle<Object> value,
1970 Handle<Map> map(isolate()->native_context()->iterator_result_map());
1971 Handle<JSIteratorResult> js_iter_result =
1972 Handle<JSIteratorResult>::cast(NewJSObjectFromMap(map));
1978 Handle<JSAsyncFromSyncIterator> Factory::NewJSAsyncFromSyncIterator(
1979 Handle<JSReceiver> sync_iterator) {
1980 Handle<Map> map(isolate()->native_context()->async_from_sync_iterator_map());
1981 Handle<JSAsyncFromSyncIterator> iterator =
1982 Handle<JSAsyncFromSyncIterator>::cast(NewJSObjectFromMap(map));
1988 Handle<JSMap> Factory::NewJSMap() {
1989 Handle<Map> map(isolate()->native_context()->js_map_map());
1990 Handle<JSMap> js_map = Handle<JSMap>::cast(NewJSObjectFromMap(map));
1996 Handle<JSSet> Factory::NewJSSet() {
1997 Handle<Map> map(isolate()->native_context()->js_set_map());
1998 Handle<JSSet> js_set = Handle<JSSet>::cast(NewJSObjectFromMap(map));
2004 Handle<JSMapIterator> Factory::NewJSMapIterator() {
2005 Handle<Map> map(isolate()->native_context()->map_iterator_map());
2012 Handle<JSSetIterator> Factory::NewJSSetIterator() {
2013 Handle<Map> map(isolate()->native_context()->set_iterator_map());
2112 i::Handle<i::JSArrayBufferView> obj,
2113 i::Handle<i::JSArrayBuffer> buffer,
2127 i::Handle<i::Object> byte_offset_object =
2131 i::Handle<i::Object> byte_length_object =
2140 Handle<JSTypedArray> Factory::NewJSTypedArray(ExternalArrayType type,
2142 Handle<JSFunction> typed_array_fun_handle(GetTypedArrayFun(type, isolate()));
2150 Handle<JSTypedArray> Factory::NewJSTypedArray(ElementsKind elements_kind,
2152 Handle<JSFunction> typed_array_fun_handle(
2161 Handle<JSTypedArray> Factory::NewJSTypedArray(ExternalArrayType type,
2162 Handle<JSArrayBuffer> buffer,
2165 Handle<JSTypedArray> obj = NewJSTypedArray(type, pretenure);
2178 Handle<Object> length_object = NewNumberFromSize(length, pretenure);
2181 Handle<FixedTypedArrayBase> elements = NewFixedTypedArrayWithExternalPointer(
2184 Handle<Map> map = JSObject::GetElementsTransitionMap(obj, elements_kind);
2190 Handle<JSTypedArray> Factory::NewJSTypedArray(ElementsKind elements_kind,
2193 Handle<JSTypedArray> obj = NewJSTypedArray(elements_kind, pretenure);
2209 i::Handle<i::Object> byte_length_object =
2212 Handle<Object> length_object =
2216 Handle<JSArrayBuffer> buffer =
2221 Handle<FixedTypedArrayBase> elements = NewFixedTypedArray(
2228 Handle<JSDataView> Factory::NewJSDataView(Handle<JSArrayBuffer> buffer,
2231 Handle<JSDataView> obj = NewJSDataView();
2238 Handle<JSReceiver> target_function, Handle<Object> bound_this,
2239 Vector<Handle<Object>> bound_args) {
2249 Handle<Object> prototype;
2255 Handle<FixedArray> bound_arguments;
2266 Handle<Map> map = target_function->IsConstructor()
2275 Handle<JSBoundFunction> result =
2276 Handle<JSBoundFunction>::cast(NewJSObjectFromMap(map));
2285 Handle<JSProxy> Factory::NewJSProxy(Handle<JSReceiver> target,
2286 Handle<JSReceiver> handler) {
2288 Handle<Map> map;
2291 map = Handle<Map>(isolate()->proxy_constructor_map());
2293 map = Handle<Map>(isolate()->proxy_callable_map());
2296 map = Handle<Map>(isolate()->proxy_map());
2299 Handle<JSProxy> result = New<JSProxy>(map, NEW_SPACE);
2307 Handle<JSGlobalProxy> Factory::NewUninitializedJSGlobalProxy(int size) {
2310 Handle<Map> map = NewMap(JS_GLOBAL_PROXY_TYPE, size);
2319 void Factory::ReinitializeJSGlobalProxy(Handle<JSGlobalProxy> object,
2320 Handle<JSFunction> constructor) {
2322 Handle<Map> map(constructor->initial_map(), isolate());
2323 Handle<Map> old_map(object->map(), isolate());
2326 Handle<Object> hash(object->hash(), isolate());
2341 Handle<FixedArray> properties = empty_fixed_array();
2358 Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfo(
2359 Handle<String> name, FunctionKind kind, Handle<Code> code,
2360 Handle<ScopeInfo> scope_info) {
2362 Handle<SharedFunctionInfo> shared = NewSharedFunctionInfo(
2373 Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfoForLiteral(
2374 FunctionLiteral* literal, Handle<Script> script) {
2375 Handle<Code> code = isolate()->builtins()->CompileLazy();
2376 Handle<ScopeInfo> scope_info(ScopeInfo::Empty(isolate()));
2377 Handle<SharedFunctionInfo> result =
2384 Handle<JSMessageObject> Factory::NewJSMessageObject(
2385 MessageTemplate::Template message, Handle<Object> argument,
2386 int start_position, int end_position, Handle<Object> script,
2387 Handle<Object> stack_frames) {
2388 Handle<Map> map = message_object_map();
2389 Handle<JSMessageObject> message_obj = New<JSMessageObject>(map, NEW_SPACE);
2404 Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfo(
2405 Handle<String> name, MaybeHandle<Code> maybe_code, bool is_constructor) {
2410 Handle<Map> map = shared_function_info_map();
2411 Handle<SharedFunctionInfo> share = New<SharedFunctionInfo>(map, OLD_SPACE);
2416 Handle<Code> code;
2424 Handle<Code> construct_stub =
2433 Handle<FeedbackMetadata> feedback_metadata =
2456 Handle<Object> new_noscript_list =
2464 static inline int NumberCacheHash(Handle<FixedArray> cache,
2465 Handle<Object> number) {
2468 return Handle<Smi>::cast(number)->value() & mask;
2476 Handle<Object> Factory::GetNumberStringCache(Handle<Object> number) {
2482 return Handle<String>(
2489 void Factory::SetNumberStringCache(Handle<Object> number,
2490 Handle<String> string) {
2495 Handle<FixedArray> new_cache = NewFixedArray(full_size, TENURED);
2505 Handle<String> Factory::NumberToString(Handle<Object> number,
2509 Handle<Object> cached = GetNumberStringCache(number);
2510 if (!cached->IsUndefined(isolate())) return Handle<String>::cast(cached);
2517 int num = Handle<Smi>::cast(number)->value();
2520 double num = Handle<HeapNumber>::cast(number)->value();
2526 Handle<String> js_string = NewStringFromAsciiChecked(str, TENURED);
2532 Handle<DebugInfo> Factory::NewDebugInfo(Handle<SharedFunctionInfo> shared) {
2537 Handle<FixedArray> break_points(
2541 Handle<Object> maybe_debug_bytecode_array = undefined_value();
2543 Handle<BytecodeArray> original(shared->bytecode_array());
2550 Handle<DebugInfo> debug_info =
2551 Handle<DebugInfo>::cast(NewStruct(DEBUG_INFO_TYPE));
2563 Handle<BreakPointInfo> Factory::NewBreakPointInfo(int source_position) {
2564 Handle<BreakPointInfo> new_break_point_info =
2565 Handle<BreakPointInfo>::cast(NewStruct(BREAK_POINT_INFO_TYPE));
2571 Handle<JSObject> Factory::NewArgumentsObject(Handle<JSFunction> callee,
2575 Handle<Map> map = strict_mode_callee ? isolate()->strict_arguments_map()
2577 AllocationSiteUsageContext context(isolate(), Handle<AllocationSite>(),
2580 Handle<JSObject> result = NewJSObjectFromMap(map);
2581 Handle<Smi> value(Smi::FromInt(length), isolate());
2590 Handle<JSWeakMap> Factory::NewJSWeakMap() {
2594 Handle<Map> map = NewMap(JS_WEAK_MAP_TYPE, JSWeakMap::kSize);
2595 return Handle<JSWeakMap>::cast(NewJSObjectFromMap(map));
2599 Handle<Map> Factory::ObjectLiteralMapFromCache(Handle<Context> context,
2608 Handle<Map> map = Map::Create(isolate(), number_of_properties);
2615 return handle(context->object_function()->initial_map(), isolate());
2619 Handle<Object> maybe_cache(context->map_cache(), isolate());
2626 Handle<FixedArray> cache = Handle<FixedArray>::cast(maybe_cache);
2631 return handle(Map::cast(cell->value()), isolate());
2636 Handle<FixedArray> cache = Handle<FixedArray>::cast(maybe_cache);
2637 Handle<Map> map = Map::Create(isolate(), number_of_properties);
2638 Handle<WeakCell> cell = NewWeakCell(map);
2644 void Factory::SetRegExpAtomData(Handle<JSRegExp> regexp,
2646 Handle<String> source,
2648 Handle<Object> data) {
2649 Handle<FixedArray> store = NewFixedArray(JSRegExp::kAtomDataSize);
2659 void Factory::SetRegExpIrregexpData(Handle<JSRegExp> regexp,
2661 Handle<String> source,
2664 Handle<FixedArray> store = NewFixedArray(JSRegExp::kIrregexpDataSize);
2680 Handle<RegExpMatchInfo> Factory::NewRegExpMatchInfo() {
2686 Handle<FixedArray> elems = NewFixedArray(kInitialSize);
2687 Handle<RegExpMatchInfo> result = Handle<RegExpMatchInfo>::cast(elems);
2698 Handle<Object> Factory::GlobalConstantFor(Handle<Name> name) {
2702 return Handle<Object>::null();
2706 Handle<Object> Factory::ToBoolean(bool value) {
2710 Handle<String> Factory::ToPrimitiveHintString(ToPrimitiveHint hint) {
2720 return Handle<String>::null();
2723 Handle<Map> Factory::CreateSloppyFunctionMap(FunctionMode function_mode) {
2724 Handle<Map> map = NewMap(JS_FUNCTION_TYPE, JSFunction::kSize);
2731 void Factory::SetFunctionInstanceDescriptor(Handle<Map> map,
2742 Handle<AccessorInfo> length =
2746 Handle<Name>(Name::cast(length->name())), length, roc_attribs);
2751 Handle<AccessorInfo> name =
2755 Handle<Name>(Name::cast(name->name())), name, roc_attribs);
2758 Handle<AccessorInfo> args =
2762 Handle<Name>(Name::cast(args->name())), args, ro_attribs);
2765 Handle<AccessorInfo> caller =
2769 Handle<Name>(Name::cast(caller->name())), caller, ro_attribs);
2776 Handle<AccessorInfo> prototype =
2779 Handle<Name>(Name::cast(prototype->name())), prototype, ro_attribs);
2784 Handle<Map> Factory::CreateStrictFunctionMap(
2785 FunctionMode function_mode, Handle<JSFunction> empty_function) {
2786 Handle<Map> map = NewMap(JS_FUNCTION_TYPE, JSFunction::kSize);
2794 void Factory::SetStrictFunctionInstanceDescriptor(Handle<Map> map,
2811 Handle<AccessorInfo> length =
2814 handle(Name::cast(length->name())), length, roc_attribs);
2820 Handle<AccessorInfo> name =
2823 handle(Name::cast(name->name())), name, roc_attribs);
2831 Handle<AccessorInfo> prototype =
2834 Handle<Name>(Name::cast(prototype->name())), prototype, attribs);
2839 Handle<Map> Factory::CreateClassFunctionMap(Handle<JSFunction> empty_function) {
2840 Handle<Map> map = NewMap(JS_FUNCTION_TYPE, JSFunction::kSize);
2848 void Factory::SetClassFunctionInstanceDescriptor(Handle<Map> map) {
2858 Handle<AccessorInfo> length =
2861 handle(Name::cast(length->name())), length, roc_attribs);
2867 Handle<AccessorInfo> prototype =
2870 Handle<Name>(Name::cast(prototype->name())), prototype, rw_attribs);
