Lines Matching full:handle
18 Handle<T> Factory::New(Handle<Map> map, AllocationSpace space) {
27 Handle<T> Factory::New(Handle<Map> map,
29 Handle<AllocationSite> allocation_site) {
37 Handle<HeapObject> Factory::NewFillerObject(int size,
47 Handle<Box> Factory::NewBox(Handle<Object> value) {
48 Handle<Box> result = Handle<Box>::cast(NewStruct(BOX_TYPE));
54 Handle<Oddball> Factory::NewOddball(Handle<Map> map,
56 Handle<Object> to_number,
58 Handle<Oddball> oddball = New<Oddball>(map, OLD_POINTER_SPACE);
64 Handle<FixedArray> Factory::NewFixedArray(int size, PretenureFlag pretenure) {
73 Handle<FixedArray> Factory::NewFixedArrayWithHoles(int size,
85 Handle<FixedArray> Factory::NewUninitializedFixedArray(int size) {
93 Handle<FixedArrayBase> Factory::NewFixedDoubleArray(int size,
103 Handle<FixedArrayBase> Factory::NewFixedDoubleArrayWithHoles(
107 Handle<FixedArrayBase> array = NewFixedDoubleArray(size, pretenure);
109 Handle<FixedDoubleArray> double_array =
110 Handle<FixedDoubleArray>::cast(array);
119 Handle<ConstantPoolArray> Factory::NewConstantPoolArray(
129 Handle<ConstantPoolArray> Factory::NewExtendedConstantPoolArray(
141 Handle<OrderedHashSet> Factory::NewOrderedHashSet() {
146 Handle<OrderedHashMap> Factory::NewOrderedHashMap() {
151 Handle<AccessorPair> Factory::NewAccessorPair() {
152 Handle<AccessorPair> accessors =
153 Handle<AccessorPair>::cast(NewStruct(ACCESSOR_PAIR_TYPE));
160 Handle<TypeFeedbackInfo> Factory::NewTypeFeedbackInfo() {
161 Handle<TypeFeedbackInfo> info =
162 Handle<TypeFeedbackInfo>::cast(NewStruct(TYPE_FEEDBACK_INFO_TYPE));
169 Handle<String> Factory::InternalizeUtf8String(Vector<const char> string) {
176 Handle<String> Factory::InternalizeString(Handle<String> string) {
182 Handle<String> Factory::InternalizeOneByteString(Vector<const uint8_t> string) {
188 Handle<String> Factory::InternalizeOneByteString(
189 Handle<SeqOneByteString> string, int from, int length) {
195 Handle<String> Factory::InternalizeTwoByteString(Vector<const uc16> string) {
202 Handle<String> Factory::InternalizeStringWithKey(StringTableKey* key) {
211 Handle<SeqOneByteString> result;
246 Handle<SeqTwoByteString> result;
269 Handle<SeqOneByteString> result;
278 Handle<SeqTwoByteString> result;
290 Handle<String> Factory::NewInternalizedStringFromUtf8(Vector<const char> str,
301 MUST_USE_RESULT Handle<String> Factory::NewOneByteInternalizedString(
311 MUST_USE_RESULT Handle<String> Factory::NewOneByteInternalizedSubString(
312 Handle<SeqOneByteString> string, int offset, int length,
322 MUST_USE_RESULT Handle<String> Factory::NewTwoByteInternalizedString(
332 Handle<String> Factory::NewInternalizedStringImpl(
333 Handle<String> string, int chars, uint32_t hash_field) {
343 Handle<String> string) {
392 Handle<String> Factory::LookupSingleCharacterStringFromCode(uint32_t code) {
398 return handle(String::cast(value), isolate());
403 Handle<String> result =
410 Handle<SeqTwoByteString> result = NewRawTwoByteString(1).ToHandleChecked();
423 static inline Handle<String> MakeOrFindTwoCharacterString(Isolate* isolate,
429 Handle<String> result;
442 Handle<SeqOneByteString> str =
449 Handle<SeqTwoByteString> str =
460 Handle<String> ConcatStringContent(Handle<StringType> result,
461 Handle<String> first,
462 Handle<String> second) {
471 MaybeHandle<String> Factory::NewConsString(Handle<String> left,
472 Handle<String> right) {
516 Handle<SeqOneByteString> result =
523 ? Handle<ExternalOneByteString>::cast(left)->GetChars()
524 : Handle<SeqOneByteString>::cast(left)->GetChars();
528 ? Handle<ExternalOneByteString>::cast(right)->GetChars()
529 : Handle<SeqOneByteString>::cast(right)->GetChars();
541 Handle<Map> map = (is_one_byte || is_one_byte_data_in_two_byte_string)
544 Handle<ConsString> result = New<ConsString>(map, NEW_SPACE);
557 Handle<String> Factory::NewProperSubString(Handle<String> str,
583 Handle<SeqOneByteString> result =
590 Handle<SeqTwoByteString> result =
602 Handle<SlicedString> slice = Handle<SlicedString>::cast(str);
603 str = Handle<String>(slice->parent(), isolate());
608 Handle<Map> map = str->IsOneByteRepresentation()
611 Handle<SlicedString> slice = New<SlicedString>(map, NEW_SPACE);
628 Handle<Map> map = external_one_byte_string_map();
629 Handle<ExternalOneByteString> external_string =
651 Handle<Map> map = is_one_byte ?
653 Handle<ExternalTwoByteString> external_string =
663 Handle<Symbol> Factory::NewSymbol() {
671 Handle<Symbol> Factory::NewPrivateSymbol() {
672 Handle<Symbol> symbol = NewSymbol();
678 Handle<Symbol> Factory::NewPrivateOwnSymbol() {
679 Handle<Symbol> symbol = NewSymbol();
686 Handle<Context> Factory::NewNativeContext() {
687 Handle<FixedArray> array = NewFixedArray(Context::NATIVE_CONTEXT_SLOTS);
689 Handle<Context> context = Handle<Context>::cast(array);
696 Handle<Context> Factory::NewGlobalContext(Handle<JSFunction> function,
697 Handle<ScopeInfo> scope_info) {
698 Handle<FixedArray> array =
701 Handle<Context> context = Handle<Context>::cast(array);
711 Handle<Context> Factory::NewModuleContext(Handle<ScopeInfo> scope_info) {
712 Handle<FixedArray> array =
716 Handle<Context> context = Handle<Context>::cast(array);
722 Handle<Context> Factory::NewFunctionContext(int length,
723 Handle<JSFunction> function) {
725 Handle<FixedArray> array = NewFixedArray(length);
727 Handle<Context> context = Handle<Context>::cast(array);
736 Handle<Context> Factory::NewCatchContext(Handle<JSFunction> function,
737 Handle<Context> previous,
738 Handle<String> name,
739 Handle<Object> thrown_object) {
741 Handle<FixedArray> array = NewFixedArray(Context::MIN_CONTEXT_SLOTS + 1);
743 Handle<Context> context = Handle<Context>::cast(array);
753 Handle<Context> Factory::NewWithContext(Handle<JSFunction> function,
754 Handle<Context> previous,
755 Handle<JSReceiver> extension) {
756 Handle<FixedArray> array = NewFixedArray(Context::MIN_CONTEXT_SLOTS);
758 Handle<Context> context = Handle<Context>::cast(array);
767 Handle<Context> Factory::NewBlockContext(Handle<JSFunction> function,
768 Handle<Context> previous,
769 Handle<ScopeInfo> scope_info) {
770 Handle<FixedArray> array =
773 Handle<Context> context = Handle<Context>::cast(array);
782 Handle<Struct> Factory::NewStruct(InstanceType type) {
790 Handle<CodeCache> Factory::NewCodeCache() {
791 Handle<CodeCache> code_cache =
792 Handle<CodeCache>::cast(NewStruct(CODE_CACHE_TYPE));
799 Handle<AliasedArgumentsEntry> Factory::NewAliasedArgumentsEntry(
801 Handle<AliasedArgumentsEntry> entry = Handle<AliasedArgumentsEntry>::cast(
808 Handle<DeclaredAccessorDescriptor> Factory::NewDeclaredAccessorDescriptor() {
809 return Handle<DeclaredAccessorDescriptor>::cast(
814 Handle<DeclaredAccessorInfo> Factory::NewDeclaredAccessorInfo() {
815 Handle<DeclaredAccessorInfo> info =
816 Handle<DeclaredAccessorInfo>::cast(
823 Handle<ExecutableAccessorInfo> Factory::NewExecutableAccessorInfo() {
824 Handle<ExecutableAccessorInfo> info =
825 Handle<ExecutableAccessorInfo>::cast(
832 Handle<Script> Factory::NewScript(Handle<String> source) {
840 Handle<Foreign> wrapper = NewForeign(0, TENURED);
841 Handle<Script> script = Handle<Script>::cast(NewStruct(SCRIPT_TYPE));
859 Handle<Foreign> Factory::NewForeign(Address addr, PretenureFlag pretenure) {
866 Handle<Foreign> Factory::NewForeign(const AccessorDescriptor* desc) {
871 Handle<ByteArray> Factory::NewByteArray(int length, PretenureFlag pretenure) {
880 Handle<ExternalArray> Factory::NewExternalArray(int length,
895 Handle<FixedTypedArrayBase> Factory::NewFixedTypedArray(
909 Handle<Cell> Factory::NewCell(Handle<Object> value) {
918 Handle<PropertyCell> Factory::NewPropertyCellWithHole() {
926 Handle<PropertyCell> Factory::NewPropertyCell(Handle<Object> value) {
928 Handle<PropertyCell> cell = NewPropertyCellWithHole();
934 Handle<AllocationSite> Factory::NewAllocationSite() {
935 Handle<Map> map = allocation_site_map();
936 Handle<AllocationSite> site = New<AllocationSite>(map, OLD_POINTER_SPACE);
946 Handle<Map> Factory::NewMap(InstanceType type,
956 Handle<JSObject> Factory::CopyJSObject(Handle<JSObject> object) {
963 Handle<JSObject> Factory::CopyJSObjectWithAllocationSite(
964 Handle<JSObject> object,
965 Handle<AllocationSite> site) {
974 Handle<FixedArray> Factory::CopyFixedArrayWithMap(Handle<FixedArray> array,
975 Handle<Map> map) {
982 Handle<FixedArray> Factory::CopyFixedArray(Handle<FixedArray> array) {
989 Handle<FixedArray> Factory::CopyAndTenureFixedCOWArray(
990 Handle<FixedArray> array) {
998 Handle<FixedDoubleArray> Factory::CopyFixedDoubleArray(
999 Handle<FixedDoubleArray> array) {
1006 Handle<ConstantPoolArray> Factory::CopyConstantPoolArray(
1007 Handle<ConstantPoolArray> array) {
1014 Handle<Object> Factory::NewNumber(double value,
1023 return handle(Smi::FromInt(int_value), isolate());
1031 Handle<Object> Factory::NewNumberFromInt(int32_t value,
1033 if (Smi::IsValid(value)) return handle(Smi::FromInt(value), isolate());
1039 Handle<Object> Factory::NewNumberFromUint(uint32_t value,
1043 return handle(Smi::FromInt(int32v), isolate());
1049 Handle<HeapNumber> Factory::NewHeapNumber(double value,
1060 Vector<Handle<Object> > args) {
1065 MaybeHandle<Object> Factory::NewTypeError(Handle<String> message) {
1071 Vector<Handle<Object> > args) {
1076 MaybeHandle<Object> Factory::NewRangeError(Handle<String> message) {
1082 Handle<JSArray> args) {
1087 MaybeHandle<Object> Factory::NewSyntaxError(Handle<String> message) {
1093 Vector<Handle<Object> > args) {
1099 Handle<JSArray> args) {
1104 MaybeHandle<Object> Factory::NewReferenceError(Handle<String> message) {
1110 Vector<Handle<Object> > args) {
1113 Handle<FixedArray> array = NewFixedArray(args.length());
1117 Handle<JSArray> object = NewJSArrayWithElements(array);
1118 Handle<Object> result;
1126 Vector<Handle<Object> > args) {
1132 Vector<Handle<Object> > args) {
1137 Handle<String> Factory::EmergencyNewError(const char* message,
1138 Handle<JSArray> args) {
1154 Handle<String> arg_str = Handle<String>::cast(
1174 Handle<JSArray> args) {
1175 Handle<String> make_str = InternalizeUtf8String(maker);
1176 Handle<Object> fun_obj = Object::GetProperty(
1183 Handle<JSFunction> fun = Handle<JSFunction>::cast(fun_obj);
1184 Handle<Object> message_obj = InternalizeUtf8String(message);
1185 Handle<Object> argv[] = { message_obj, args };
1189 Handle<Object> result;
1202 MaybeHandle<Object> Factory::NewError(Handle<String> message) {
1208 Handle<String> message) {
1209 Handle<String> constr = InternalizeUtf8String(constructor);
1210 Handle<JSFunction> fun = Handle<JSFunction>::cast(Object::GetProperty(
1212 Handle<Object> argv[] = { message };
1216 Handle<Object> result;
1229 void Factory::InitializeFunction(Handle<JSFunction> function,
1230 Handle<SharedFunctionInfo> info,
1231 Handle<Context> context) {
1243 Handle<JSFunction> Factory::NewFunction(Handle<Map> map,
1244 Handle<SharedFunctionInfo> info,
1245 Handle<Context> context,
1248 Handle<JSFunction> result = New<JSFunction>(map, space);
1254 Handle<JSFunction> Factory::NewFunction(Handle<Map> map,
1255 Handle<String> name,
1257 Handle<Context> context(isolate()->native_context());
1258 Handle<SharedFunctionInfo> info = NewSharedFunctionInfo(name, code);
1269 Handle<JSFunction> Factory::NewFunction(Handle<String> name) {
1275 Handle<JSFunction> Factory::NewFunctionWithoutPrototype(Handle<String> name,
1276 Handle<Code> code) {
1282 Handle<JSFunction> Factory::NewFunction(Handle<String> name,
1283 Handle<Code> code,
1284 Handle<Object> prototype,
1286 Handle<Map> map = read_only_prototype
1289 Handle<JSFunction> result = NewFunction(map, name, code);
1295 Handle<JSFunction> Factory::NewFunction(Handle<String> name,
1296 Handle<Code> code,
1297 Handle<Object> prototype,
1302 Handle<JSFunction> function = NewFunction(
1305 Handle<Map> initial_map = NewMap(
1312 Handle<JSReceiver>::cast(prototype));
1318 Handle<JSFunction> Factory::NewFunction(Handle<String> name,
1319 Handle<Code> code,
1326 Handle<JSObject> Factory::NewFunctionPrototype(Handle<JSFunction> function) {
1329 Handle<Context> native_context(function->context()->native_context());
1330 Handle<Map> new_map;
1334 new_map = handle(native_context->generator_object_prototype_map());
1338 Handle<JSFunction> object_function(native_context->object_function());
1340 new_map = handle(object_function->initial_map());
1344 Handle<JSObject> prototype = NewJSObjectFromMap(new_map);
1354 Handle<JSFunction> Factory::NewFunctionFromSharedFunctionInfo(
1355 Handle<SharedFunctionInfo> info,
1356 Handle<Context> context,
1359 Handle<Map> map(Map::cast(context->native_context()->get(map_index)));
1360 Handle<JSFunction> result = NewFunction(map, info, context, pretenure);
1370 Handle<FixedArray> literals = NewFixedArray(number_of_literals, pretenure);
1404 Handle<ScopeInfo> Factory::NewScopeInfo(int length) {
1405 Handle<FixedArray> array = NewFixedArray(length, TENURED);
1407 Handle<ScopeInfo> scope_info = Handle<ScopeInfo>::cast(array);
1412 Handle<JSObject> Factory::NewExternal(void* value) {
1413 Handle<Foreign> foreign = NewForeign(static_cast<Address>(value));
1414 Handle<JSObject> external = NewJSObjectFromMap(external_map());
1420 Handle<Code> Factory::NewCodeRaw(int object_size, bool immovable) {
1427 Handle<Code> Factory::NewCode(const CodeDesc& desc,
1429 Handle<Object> self_ref,
1434 Handle<ByteArray> reloc_info = NewByteArray(desc.reloc_size, TENURED);
1435 Handle<ConstantPoolArray> constant_pool =
1442 Handle<Code> code = NewCodeRaw(obj_size, immovable);
1475 // Allow self references to created code object by patching the handle to
1493 Handle<Code> Factory::CopyCode(Handle<Code> code) {
1500 Handle<Code> Factory::CopyCode(Handle<Code> code, Vector<byte> reloc_info) {
1507 Handle<JSObject> Factory::NewJSObject(Handle<JSFunction> constructor,
1516 Handle<JSObject> Factory::NewJSObjectWithMemento(
1517 Handle<JSFunction> constructor,
1518 Handle<AllocationSite> site) {
1527 Handle<JSModule> Factory::NewJSModule(Handle<Context> context,
1528 Handle<ScopeInfo> scope_info) {
1530 Handle<Map> map = NewMap(JS_MODULE_TYPE, JSModule::kSize);
1532 Handle<JSModule> module =
1533 Handle<JSModule>::cast(NewJSObjectFromMap(map, TENURED));
1540 Handle<GlobalObject> Factory::NewGlobalObject(Handle<JSFunction> constructor) {
1542 Handle<Map> map(constructor->initial_map());
1562 Handle<NameDictionary> dictionary =
1567 Handle<DescriptorArray> descs(map->instance_descriptors());
1572 Handle<Name> name(descs->GetKey(i));
1573 Handle<Object> value(descs->GetCallbacksObject(i), isolate());
1574 Handle<PropertyCell> cell = NewPropertyCell(value);
1580 Handle<GlobalObject> global = New<GlobalObject>(map, OLD_POINTER_SPACE);
1584 Handle<Map> new_map = Map::CopyDropDescriptors(map);
1597 Handle<JSObject> Factory::NewJSObjectFromMap(
1598 Handle<Map> map,
1601 Handle<AllocationSite> allocation_site) {
1613 Handle<JSArray> Factory::NewJSArray(ElementsKind elements_kind,
1620 return Handle<JSArray>::cast(NewJSObjectFromMap(handle(map), pretenure));
1624 Handle<JSArray> Factory::NewJSArray(ElementsKind elements_kind,
1629 Handle<JSArray> array = NewJSArray(elements_kind, pretenure);
1635 Handle<JSArray> Factory::NewJSArrayWithElements(Handle<FixedArrayBase> elements,
1640 Handle<JSArray> array = NewJSArray(elements_kind, pretenure);
1649 void Factory::NewJSArrayStorage(Handle<JSArray> array,
1661 Handle<FixedArrayBase> elms;
1685 Handle<JSGeneratorObject> Factory::NewJSGeneratorObject(
1686 Handle<JSFunction> function) {
1689 Handle<Map> map(function->initial_map());
1698 Handle<JSArrayBuffer> Factory::NewJSArrayBuffer() {
1699 Handle<JSFunction> array_buffer_fun(
1708 Handle<JSDataView> Factory::NewJSDataView() {
1709 Handle<JSFunction> data_view_fun(
1736 Handle<JSTypedArray> Factory::NewJSTypedArray(ExternalArrayType type) {
1737 Handle<JSFunction> typed_array_fun_handle(GetTypedArrayFun(type, isolate()));
1746 Handle<JSProxy> Factory::NewJSProxy(Handle<Object> handler,
1747 Handle<Object> prototype) {
1751 Handle<Map> map = NewMap(JS_PROXY_TYPE, JSProxy::kSize);
1755 Handle<JSProxy> result = New<JSProxy>(map, NEW_SPACE);
1763 Handle<JSProxy> Factory::NewJSFunctionProxy(Handle<Object> handler,
1764 Handle<Object> call_trap,
1765 Handle<Object> construct_trap,
1766 Handle<Object> prototype) {
1770 Handle<Map> map = NewMap(JS_FUNCTION_PROXY_TYPE, JSFunctionProxy::kSize);
1774 Handle<JSFunctionProxy> result = New<JSFunctionProxy>(map, NEW_SPACE);
1784 void Factory::ReinitializeJSProxy(Handle<JSProxy> proxy, InstanceType type,
1790 Handle<Map> map = NewMap(type, size);
1800 Handle<FixedArray> properties = NewFixedArray(prop_size, TENURED);
1807 Handle<String> name = InternalizeStringWithKey(&key);
1824 Handle<JSObject> jsobj = Handle<JSObject>::cast(proxy);
1832 Handle<Context> context(isolate()->native_context());
1837 Handle<JSFunction> js_function = Handle<JSFunction>::cast(proxy);
1846 void Factory::ReinitializeJSGlobalProxy(Handle<JSGlobalProxy> object,
1847 Handle<JSFunction> constructor) {
1849 Handle<Map> map(constructor->initial_map(), isolate());
1852 Handle<Object> hash(object->hash(), isolate());
1861 Handle<FixedArray> properties = NewFixedArray(prop_size, TENURED);
1879 void Factory::BecomeJSObject(Handle<JSProxy> proxy) {
1884 void Factory::BecomeJSFunction(Handle<JSProxy> proxy) {
1889 Handle
1895 return Handle<TypeFeedbackVector>::cast(empty_fixed_array());
1906 Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfo(
1907 Handle<String> name, int number_of_literals, FunctionKind kind,
1908 Handle<Code> code, Handle<ScopeInfo> scope_info,
1909 Handle<TypeFeedbackVector> feedback_vector) {
1911 Handle<SharedFunctionInfo> shared = NewSharedFunctionInfo(name, code);
1931 Handle<JSMessageObject> Factory::NewJSMessageObject(
1932 Handle<String> type,
1933 Handle<JSArray> arguments,
1936 Handle<Object> script,
1937 Handle<Object> stack_frames) {
1938 Handle<Map> map = message_object_map();
1939 Handle<JSMessageObject> message = New<JSMessageObject>(map, NEW_SPACE);
1953 Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfo(
1954 Handle<String> name,
1956 Handle<Map> map = shared_function_info_map();
1957 Handle<SharedFunctionInfo> share = New<SharedFunctionInfo>(map,
1962 Handle<Code> code;
1964 code = handle(isolate()->builtins()->builtin(Builtins::kIllegal));
1977 Handle<TypeFeedbackVector> feedback_vector = NewTypeFeedbackVector(0);
1999 static inline int NumberCacheHash(Handle<FixedArray> cache,
2000 Handle<Object> number) {
2003 return Handle<Smi>::cast(number)->value() & mask;
2012 Handle<Object> Factory::GetNumberStringCache(Handle<Object> number) {
2018 return Handle<String>(
2025 void Factory::SetNumberStringCache(Handle<Object> number,
2026 Handle<String> string) {
2037 Handle<FixedArray> new_cache = NewFixedArray(full_size, TENURED);
2047 Handle<String> Factory::NumberToString(Handle<Object> number,
2051 Handle<Object> cached = GetNumberStringCache(number);
2052 if (!cached->IsUndefined()) return Handle<String>::cast(cached);
2059 int num = Handle<Smi>::cast(number)->value();
2062 double num = Handle<HeapNumber>::cast(number)->value();
2068 Handle<String> js_string = NewStringFromAsciiChecked(str, TENURED);
2074 Handle<DebugInfo> Factory::NewDebugInfo(Handle<SharedFunctionInfo> shared) {
2076 Handle<Code> code(shared->code());
2080 Handle<Code> original_code(*Factory::CopyCode(code));
2085 Handle<FixedArray> break_points(
2091 Handle<DebugInfo> debug_info =
2092 Handle<DebugInfo>::cast(NewStruct(DEBUG_INFO_TYPE));
2105 Handle<JSObject> Factory::NewArgumentsObject(Handle<JSFunction> callee,
2108 Handle<Map> map = strict_mode_callee ? isolate()->strict_arguments_map()
2111 AllocationSiteUsageContext context(isolate(), Handle<AllocationSite>(),
2114 Handle<JSObject> result = NewJSObjectFromMap(map);
2115 Handle<Smi> value(Smi::FromInt(length), isolate());
2124 Handle<JSFunction> Factory::CreateApiFunction(
2125 Handle<FunctionTemplateInfo> obj,
2126 Handle<Object> prototype,
2128 Handle<Code> code = isolate()->builtins()->HandleApiCall();
2129 Handle<Code> construct_stub = isolate()->builtins()->JSConstructStubApi();
2131 Handle<JSFunction> result;
2137 Handle<ObjectTemplateInfo> instance_template =
2138 Handle<ObjectTemplateInfo>(
2172 Handle<Object> class_name(obj->class_name(), isolate());
2190 LookupIterator it(handle(JSObject::cast(result->prototype())),
2198 JSObject::AddProperty(handle(JSObject::cast(result->prototype())),
2205 Handle<Map> map(result->initial_map());
2246 Handle<Object> props_handle(props, isolate());
2254 Handle<Object> props_handle(props, isolate());
2268 Handle<FixedArray> array;
2276 Handle<ObjectTemplateInfo> instance =
2277 Handle<ObjectTemplateInfo>(
2279 Handle<Object> props = Handle<Object>(instance->property_accessors(),
2287 Handle<Object> props = Handle<Object>(obj->property_accessors(),
2293 Handle<Object> parent = Handle<Object>(obj->parent_template(), isolate());
2295 obj = Handle<FunctionTemplateInfo>::cast(parent);
2300 Handle<AccessorInfo> accessor(AccessorInfo::cast(array->get(i)));
2309 Handle<MapCache> Factory::AddToMapCache(Handle<Context> context,
2310 Handle<FixedArray> keys,
2311 Handle<Map> map) {
2312 Handle<MapCache> map_cache = handle(MapCache::cast(context->map_cache()));
2313 Handle<MapCache> result = MapCache::Put(map_cache, keys, map);
2319 Handle<Map> Factory::ObjectLiteralMapFromCache(Handle<Context> context,
2320 Handle<FixedArray> keys) {
2323 Handle<MapCache> new_cache = MapCache::New(isolate(), 24);
2327 Handle<MapCache> cache =
2328 Handle<MapCache>(MapCache::cast(context->map_cache()));
2329 Handle<Object> result = Handle<Object>(cache->Lookup(*keys), isolate());
2330 if (result->IsMap()) return Handle<Map>::cast(result);
2334 Handle<Map> map = length == 0
2335 ? handle(context->object_function()->initial_map())
2342 void Factory::SetRegExpAtomData(Handle<JSRegExp> regexp,
2344 Handle<String> source,
2346 Handle<Object> data) {
2347 Handle<FixedArray> store = NewFixedArray(JSRegExp::kAtomDataSize);
2356 void Factory::SetRegExpIrregexpData(Handle<JSRegExp> regexp,
2358 Handle<String> source,
2361 Handle<FixedArray> store = NewFixedArray(JSRegExp::kIrregexpDataSize);
2379 Handle<FunctionTemplateInfo> desc, Handle<JSObject> instance) {
2382 Handle<Object> instance_template(desc->instance_template(), isolate());
2393 Handle<Object> Factory::GlobalConstantFor(Handle<String> name) {
2397 return Handle<Object>::null();
2401 Handle<Object> Factory::ToBoolean(bool value) {
