LCOV - code coverage report
Current view: top level - src/builtins - builtins-object.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 175 177 98.9 %
Date: 2017-04-26 Functions: 54 80 67.5 %

          Line data    Source code
       1             : // Copyright 2016 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #include "src/builtins/builtins-utils.h"
       6             : #include "src/builtins/builtins.h"
       7             : #include "src/code-factory.h"
       8             : #include "src/code-stub-assembler.h"
       9             : #include "src/counters.h"
      10             : #include "src/keys.h"
      11             : #include "src/lookup.h"
      12             : #include "src/objects-inl.h"
      13             : #include "src/property-descriptor.h"
      14             : 
      15             : namespace v8 {
      16             : namespace internal {
      17             : 
      18             : // -----------------------------------------------------------------------------
      19             : // ES6 section 19.1 Object Objects
      20             : 
      21             : // ES6 19.1.2.1 Object.assign
      22        1143 : BUILTIN(ObjectAssign) {
      23             :   HandleScope scope(isolate);
      24             :   Handle<Object> target = args.atOrUndefined(isolate, 1);
      25             : 
      26             :   // 1. Let to be ? ToObject(target).
      27         762 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, target,
      28             :                                      Object::ToObject(isolate, target));
      29             :   Handle<JSReceiver> to = Handle<JSReceiver>::cast(target);
      30             :   // 2. If only one argument was passed, return to.
      31         325 :   if (args.length() == 2) return *to;
      32             :   // 3. Let sources be the List of argument values starting with the
      33             :   //    second argument.
      34             :   // 4. For each element nextSource of sources, in ascending index order,
      35         921 :   for (int i = 2; i < args.length(); ++i) {
      36         354 :     Handle<Object> next_source = args.at(i);
      37         354 :     MAYBE_RETURN(JSReceiver::SetOrCopyDataProperties(isolate, to, next_source),
      38             :                  isolate->heap()->exception());
      39             :   }
      40             :   // 5. Return to.
      41         269 :   return *to;
      42             : }
      43             : 
      44             : // ES6 section 19.1.3.4 Object.prototype.propertyIsEnumerable ( V )
      45       26166 : BUILTIN(ObjectPrototypePropertyIsEnumerable) {
      46             :   HandleScope scope(isolate);
      47             :   Handle<JSReceiver> object;
      48             :   Handle<Name> name;
      49       17444 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
      50             :       isolate, name, Object::ToName(isolate, args.atOrUndefined(isolate, 1)));
      51       17432 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
      52             :       isolate, object, JSReceiver::ToObject(isolate, args.receiver()));
      53             :   Maybe<PropertyAttributes> maybe =
      54        8432 :       JSReceiver::GetOwnPropertyAttributes(object, name);
      55        8432 :   if (!maybe.IsJust()) return isolate->heap()->exception();
      56        8133 :   if (maybe.FromJust() == ABSENT) return isolate->heap()->false_value();
      57       15546 :   return isolate->heap()->ToBoolean((maybe.FromJust() & DONT_ENUM) == 0);
      58             : }
      59             : 
      60             : // ES6 section 19.1.2.3 Object.defineProperties
      61       54858 : BUILTIN(ObjectDefineProperties) {
      62             :   HandleScope scope(isolate);
      63             :   DCHECK_EQ(3, args.length());
      64       18286 :   Handle<Object> target = args.at(1);
      65       18286 :   Handle<Object> properties = args.at(2);
      66             : 
      67       54589 :   RETURN_RESULT_OR_FAILURE(
      68             :       isolate, JSReceiver::DefineProperties(isolate, target, properties));
      69             : }
      70             : 
      71             : // ES6 section 19.1.2.4 Object.defineProperty
      72      857862 : BUILTIN(ObjectDefineProperty) {
      73             :   HandleScope scope(isolate);
      74             :   DCHECK_EQ(4, args.length());
      75      285954 :   Handle<Object> target = args.at(1);
      76      285954 :   Handle<Object> key = args.at(2);
      77      285954 :   Handle<Object> attributes = args.at(3);
      78             : 
      79      571908 :   return JSReceiver::DefineProperty(isolate, target, key, attributes);
      80             : }
      81             : 
      82             : namespace {
      83             : 
      84             : template <AccessorComponent which_accessor>
      85       50566 : Object* ObjectDefineAccessor(Isolate* isolate, Handle<Object> object,
      86             :                              Handle<Object> name, Handle<Object> accessor) {
      87             :   // 1. Let O be ? ToObject(this value).
      88             :   Handle<JSReceiver> receiver;
      89      101132 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
      90             :       isolate, receiver,
      91             :       FLAG_harmony_strict_legacy_accessor_builtins
      92             :           ? Object::ToObject(isolate, object)
      93             :           : Object::ConvertReceiver(isolate, object));
      94             :   // 2. If IsCallable(getter) is false, throw a TypeError exception.
      95       50566 :   if (!accessor->IsCallable()) {
      96             :     MessageTemplate::Template message =
      97             :         which_accessor == ACCESSOR_GETTER
      98             :             ? MessageTemplate::kObjectGetterExpectingFunction
      99             :             : MessageTemplate::kObjectSetterExpectingFunction;
     100         172 :     THROW_NEW_ERROR_RETURN_FAILURE(isolate, NewTypeError(message));
     101             :   }
     102             :   // 3. Let desc be PropertyDescriptor{[[Get]]: getter, [[Enumerable]]: true,
     103             :   //                                   [[Configurable]]: true}.
     104             :   PropertyDescriptor desc;
     105             :   if (which_accessor == ACCESSOR_GETTER) {
     106             :     desc.set_get(accessor);
     107             :   } else {
     108             :     DCHECK(which_accessor == ACCESSOR_SETTER);
     109             :     desc.set_set(accessor);
     110             :   }
     111             :   desc.set_enumerable(true);
     112             :   desc.set_configurable(true);
     113             :   // 4. Let key be ? ToPropertyKey(P).
     114      100960 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, name,
     115             :                                      Object::ToPropertyKey(isolate, name));
     116             :   // 5. Perform ? DefinePropertyOrThrow(O, key, desc).
     117             :   // To preserve legacy behavior, we ignore errors silently rather than
     118             :   // throwing an exception.
     119             :   Maybe<bool> success = JSReceiver::DefineOwnProperty(
     120             :       isolate, receiver, name, &desc,
     121             :       FLAG_harmony_strict_legacy_accessor_builtins ? Object::THROW_ON_ERROR
     122       50480 :                                                    : Object::DONT_THROW);
     123       50480 :   MAYBE_RETURN(success, isolate->heap()->exception());
     124       50460 :   if (!success.FromJust()) {
     125         218 :     isolate->CountUsage(v8::Isolate::kDefineGetterOrSetterWouldThrow);
     126             :   }
     127             :   // 6. Return undefined.
     128       50460 :   return isolate->heap()->undefined_value();
     129             : }
     130             : 
     131        1009 : Object* ObjectLookupAccessor(Isolate* isolate, Handle<Object> object,
     132             :                              Handle<Object> key, AccessorComponent component) {
     133        2018 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
     134             :       isolate, object,
     135             :       FLAG_harmony_strict_legacy_accessor_builtins
     136             :           ? Object::ToObject(isolate, object)
     137             :           : Object::ConvertReceiver(isolate, object));
     138        2018 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, key,
     139             :                                      Object::ToPropertyKey(isolate, key));
     140        1009 :   bool success = false;
     141             :   LookupIterator it = LookupIterator::PropertyOrElement(
     142             :       isolate, object, key, &success,
     143        1009 :       LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR);
     144             :   DCHECK(success);
     145             : 
     146        1009 :   for (; it.IsFound(); it.Next()) {
     147         897 :     switch (it.state()) {
     148             :       case LookupIterator::INTERCEPTOR:
     149             :       case LookupIterator::NOT_FOUND:
     150             :       case LookupIterator::TRANSITION:
     151           0 :         UNREACHABLE();
     152             : 
     153             :       case LookupIterator::ACCESS_CHECK:
     154           6 :         if (it.HasAccess()) continue;
     155           6 :         isolate->ReportFailedAccessCheck(it.GetHolder<JSObject>());
     156           6 :         RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
     157           0 :         return isolate->heap()->undefined_value();
     158             : 
     159             :       case LookupIterator::JSPROXY: {
     160             :         PropertyDescriptor desc;
     161             :         Maybe<bool> found = JSProxy::GetOwnPropertyDescriptor(
     162         448 :             isolate, it.GetHolder<JSProxy>(), it.GetName(), &desc);
     163         448 :         MAYBE_RETURN(found, isolate->heap()->exception());
     164         448 :         if (found.FromJust()) {
     165         378 :           if (component == ACCESSOR_GETTER && desc.has_get()) {
     166             :             return *desc.get();
     167             :           }
     168         294 :           if (component == ACCESSOR_SETTER && desc.has_set()) {
     169             :             return *desc.set();
     170             :           }
     171          84 :           return isolate->heap()->undefined_value();
     172             :         }
     173             :         Handle<Object> prototype;
     174         392 :         ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
     175             :             isolate, prototype, JSProxy::GetPrototype(it.GetHolder<JSProxy>()));
     176         196 :         if (prototype->IsNull(isolate)) {
     177          28 :           return isolate->heap()->undefined_value();
     178             :         }
     179         168 :         return ObjectLookupAccessor(isolate, prototype, key, component);
     180             :       }
     181             : 
     182             :       case LookupIterator::INTEGER_INDEXED_EXOTIC:
     183             :       case LookupIterator::DATA:
     184         112 :         return isolate->heap()->undefined_value();
     185             : 
     186             :       case LookupIterator::ACCESSOR: {
     187         331 :         Handle<Object> maybe_pair = it.GetAccessors();
     188         331 :         if (maybe_pair->IsAccessorPair()) {
     189             :           return *AccessorPair::GetComponent(
     190         662 :               Handle<AccessorPair>::cast(maybe_pair), component);
     191             :         }
     192             :       }
     193             :     }
     194             :   }
     195             : 
     196         112 :   return isolate->heap()->undefined_value();
     197             : }
     198             : 
     199             : }  // namespace
     200             : 
     201             : // ES6 B.2.2.2 a.k.a.
     202             : // https://tc39.github.io/ecma262/#sec-object.prototype.__defineGetter__
     203       99648 : BUILTIN(ObjectDefineGetter) {
     204             :   HandleScope scope(isolate);
     205       33216 :   Handle<Object> object = args.at(0);  // Receiver.
     206       33216 :   Handle<Object> name = args.at(1);
     207       33216 :   Handle<Object> getter = args.at(2);
     208       66432 :   return ObjectDefineAccessor<ACCESSOR_GETTER>(isolate, object, name, getter);
     209             : }
     210             : 
     211             : // ES6 B.2.2.3 a.k.a.
     212             : // https://tc39.github.io/ecma262/#sec-object.prototype.__defineSetter__
     213       52050 : BUILTIN(ObjectDefineSetter) {
     214             :   HandleScope scope(isolate);
     215       17350 :   Handle<Object> object = args.at(0);  // Receiver.
     216       17350 :   Handle<Object> name = args.at(1);
     217       17350 :   Handle<Object> setter = args.at(2);
     218       34700 :   return ObjectDefineAccessor<ACCESSOR_SETTER>(isolate, object, name, setter);
     219             : }
     220             : 
     221             : // ES6 B.2.2.4 a.k.a.
     222             : // https://tc39.github.io/ecma262/#sec-object.prototype.__lookupGetter__
     223        1311 : BUILTIN(ObjectLookupGetter) {
     224             :   HandleScope scope(isolate);
     225         437 :   Handle<Object> object = args.at(0);
     226         437 :   Handle<Object> name = args.at(1);
     227         874 :   return ObjectLookupAccessor(isolate, object, name, ACCESSOR_GETTER);
     228             : }
     229             : 
     230             : // ES6 B.2.2.5 a.k.a.
     231             : // https://tc39.github.io/ecma262/#sec-object.prototype.__lookupSetter__
     232        1212 : BUILTIN(ObjectLookupSetter) {
     233             :   HandleScope scope(isolate);
     234         404 :   Handle<Object> object = args.at(0);
     235         404 :   Handle<Object> name = args.at(1);
     236         808 :   return ObjectLookupAccessor(isolate, object, name, ACCESSOR_SETTER);
     237             : }
     238             : 
     239             : // ES6 section 19.1.2.5 Object.freeze ( O )
     240      494871 : BUILTIN(ObjectFreeze) {
     241             :   HandleScope scope(isolate);
     242             :   Handle<Object> object = args.atOrUndefined(isolate, 1);
     243      164957 :   if (object->IsJSReceiver()) {
     244      164845 :     MAYBE_RETURN(JSReceiver::SetIntegrityLevel(Handle<JSReceiver>::cast(object),
     245             :                                                FROZEN, Object::THROW_ON_ERROR),
     246             :                  isolate->heap()->exception());
     247             :   }
     248      164907 :   return *object;
     249             : }
     250             : 
     251             : // ES section 19.1.2.9 Object.getPrototypeOf ( O )
     252     1921068 : BUILTIN(ObjectGetPrototypeOf) {
     253             :   HandleScope scope(isolate);
     254      640356 :   Handle<Object> object = args.atOrUndefined(isolate, 1);
     255             : 
     256             :   Handle<JSReceiver> receiver;
     257     1280712 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, receiver,
     258             :                                      Object::ToObject(isolate, object));
     259             : 
     260     1920964 :   RETURN_RESULT_OR_FAILURE(isolate,
     261             :                            JSReceiver::GetPrototype(isolate, receiver));
     262             : }
     263             : 
     264             : // ES6 section 19.1.2.21 Object.setPrototypeOf ( O, proto )
     265      273444 : BUILTIN(ObjectSetPrototypeOf) {
     266             :   HandleScope scope(isolate);
     267             : 
     268             :   // 1. Let O be ? RequireObjectCoercible(O).
     269             :   Handle<Object> object = args.atOrUndefined(isolate, 1);
     270       91148 :   if (object->IsNullOrUndefined(isolate)) {
     271          84 :     THROW_NEW_ERROR_RETURN_FAILURE(
     272             :         isolate, NewTypeError(MessageTemplate::kCalledOnNullOrUndefined,
     273             :                               isolate->factory()->NewStringFromAsciiChecked(
     274             :                                   "Object.setPrototypeOf")));
     275             :   }
     276             : 
     277             :   // 2. If Type(proto) is neither Object nor Null, throw a TypeError exception.
     278             :   Handle<Object> proto = args.atOrUndefined(isolate, 2);
     279      182028 :   if (!proto->IsNull(isolate) && !proto->IsJSReceiver()) {
     280        1486 :     THROW_NEW_ERROR_RETURN_FAILURE(
     281             :         isolate, NewTypeError(MessageTemplate::kProtoObjectOrNull, proto));
     282             :   }
     283             : 
     284             :   // 3. If Type(O) is not Object, return O.
     285       90433 :   if (!object->IsJSReceiver()) return *object;
     286             :   Handle<JSReceiver> receiver = Handle<JSReceiver>::cast(object);
     287             : 
     288             :   // 4. Let status be ? O.[[SetPrototypeOf]](proto).
     289             :   // 5. If status is false, throw a TypeError exception.
     290       90321 :   MAYBE_RETURN(
     291             :       JSReceiver::SetPrototype(receiver, proto, true, Object::THROW_ON_ERROR),
     292             :       isolate->heap()->exception());
     293             : 
     294             :   // 6. Return O.
     295       90040 :   return *receiver;
     296             : }
     297             : 
     298             : // ES6 section B.2.2.1.1 get Object.prototype.__proto__
     299      587844 : BUILTIN(ObjectPrototypeGetProto) {
     300             :   HandleScope scope(isolate);
     301             :   // 1. Let O be ? ToObject(this value).
     302             :   Handle<JSReceiver> receiver;
     303      391896 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
     304             :       isolate, receiver, Object::ToObject(isolate, args.receiver()));
     305             : 
     306             :   // 2. Return ? O.[[GetPrototypeOf]]().
     307      587754 :   RETURN_RESULT_OR_FAILURE(isolate,
     308             :                            JSReceiver::GetPrototype(isolate, receiver));
     309             : }
     310             : 
     311             : // ES6 section B.2.2.1.2 set Object.prototype.__proto__
     312      205332 : BUILTIN(ObjectPrototypeSetProto) {
     313             :   HandleScope scope(isolate);
     314             :   // 1. Let O be ? RequireObjectCoercible(this value).
     315             :   Handle<Object> object = args.receiver();
     316       68444 :   if (object->IsNullOrUndefined(isolate)) {
     317          90 :     THROW_NEW_ERROR_RETURN_FAILURE(
     318             :         isolate, NewTypeError(MessageTemplate::kCalledOnNullOrUndefined,
     319             :                               isolate->factory()->NewStringFromAsciiChecked(
     320             :                                   "set Object.prototype.__proto__")));
     321             :   }
     322             : 
     323             :   // 2. If Type(proto) is neither Object nor Null, return undefined.
     324             :   Handle<Object> proto = args.at(1);
     325      136390 :   if (!proto->IsNull(isolate) && !proto->IsJSReceiver()) {
     326       44502 :     return isolate->heap()->undefined_value();
     327             :   }
     328             : 
     329             :   // 3. If Type(O) is not Object, return undefined.
     330       23912 :   if (!object->IsJSReceiver()) return isolate->heap()->undefined_value();
     331       23837 :   Handle<JSReceiver> receiver = Handle<JSReceiver>::cast(object);
     332             : 
     333             :   // 4. Let status be ? O.[[SetPrototypeOf]](proto).
     334             :   // 5. If status is false, throw a TypeError exception.
     335       23837 :   MAYBE_RETURN(
     336             :       JSReceiver::SetPrototype(receiver, proto, true, Object::THROW_ON_ERROR),
     337             :       isolate->heap()->exception());
     338             : 
     339             :   // Return undefined.
     340       23683 :   return isolate->heap()->undefined_value();
     341             : }
     342             : 
     343             : // ES6 section 19.1.2.6 Object.getOwnPropertyDescriptor ( O, P )
     344    10455657 : BUILTIN(ObjectGetOwnPropertyDescriptor) {
     345             :   HandleScope scope(isolate);
     346             :   // 1. Let obj be ? ToObject(O).
     347     3485219 :   Handle<Object> object = args.atOrUndefined(isolate, 1);
     348             :   Handle<JSReceiver> receiver;
     349     6970438 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, receiver,
     350             :                                      Object::ToObject(isolate, object));
     351             :   // 2. Let key be ? ToPropertyKey(P).
     352     3485189 :   Handle<Object> property = args.atOrUndefined(isolate, 2);
     353             :   Handle<Name> key;
     354     6970378 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, key,
     355             :                                      Object::ToName(isolate, property));
     356             :   // 3. Let desc be ? obj.[[GetOwnProperty]](key).
     357             :   PropertyDescriptor desc;
     358             :   Maybe<bool> found =
     359     3485189 :       JSReceiver::GetOwnPropertyDescriptor(isolate, receiver, key, &desc);
     360     3485189 :   MAYBE_RETURN(found, isolate->heap()->exception());
     361             :   // 4. Return FromPropertyDescriptor(desc).
     362     3484687 :   if (!found.FromJust()) return isolate->heap()->undefined_value();
     363     6951832 :   return *desc.ToObject(isolate);
     364             : }
     365             : 
     366             : namespace {
     367             : 
     368      245040 : Object* GetOwnPropertyKeys(Isolate* isolate, BuiltinArguments args,
     369             :                            PropertyFilter filter) {
     370             :   HandleScope scope(isolate);
     371      245040 :   Handle<Object> object = args.atOrUndefined(isolate, 1);
     372             :   Handle<JSReceiver> receiver;
     373      490080 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, receiver,
     374             :                                      Object::ToObject(isolate, object));
     375             :   Handle<FixedArray> keys;
     376      490020 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
     377             :       isolate, keys,
     378             :       KeyAccumulator::GetKeys(receiver, KeyCollectionMode::kOwnOnly, filter,
     379             :                               GetKeysConversion::kConvertToString));
     380             :   return *isolate->factory()->NewJSArrayWithElements(keys);
     381             : }
     382             : 
     383             : }  // namespace
     384             : 
     385             : // ES6 section 19.1.2.7 Object.getOwnPropertyNames ( O )
     386      273324 : BUILTIN(ObjectGetOwnPropertyNames) {
     387      136662 :   return GetOwnPropertyKeys(isolate, args, SKIP_SYMBOLS);
     388             : }
     389             : 
     390             : // ES6 section 19.1.2.8 Object.getOwnPropertySymbols ( O )
     391      216756 : BUILTIN(ObjectGetOwnPropertySymbols) {
     392      108378 :   return GetOwnPropertyKeys(isolate, args, SKIP_STRINGS);
     393             : }
     394             : 
     395             : // ES#sec-object.is Object.is ( value1, value2 )
     396      105252 : BUILTIN(ObjectIs) {
     397             :   SealHandleScope shs(isolate);
     398             :   DCHECK_EQ(3, args.length());
     399             :   Handle<Object> value1 = args.at(1);
     400             :   Handle<Object> value2 = args.at(2);
     401       70168 :   return isolate->heap()->ToBoolean(value1->SameValue(*value2));
     402             : }
     403             : 
     404             : // ES6 section 19.1.2.11 Object.isExtensible ( O )
     405        1944 : BUILTIN(ObjectIsExtensible) {
     406             :   HandleScope scope(isolate);
     407             :   Handle<Object> object = args.atOrUndefined(isolate, 1);
     408             :   Maybe<bool> result =
     409             :       object->IsJSReceiver()
     410             :           ? JSReceiver::IsExtensible(Handle<JSReceiver>::cast(object))
     411         648 :           : Just(false);
     412         648 :   MAYBE_RETURN(result, isolate->heap()->exception());
     413         648 :   return isolate->heap()->ToBoolean(result.FromJust());
     414             : }
     415             : 
     416             : // ES6 section 19.1.2.12 Object.isFrozen ( O )
     417       13395 : BUILTIN(ObjectIsFrozen) {
     418             :   HandleScope scope(isolate);
     419             :   Handle<Object> object = args.atOrUndefined(isolate, 1);
     420             :   Maybe<bool> result = object->IsJSReceiver()
     421             :                            ? JSReceiver::TestIntegrityLevel(
     422             :                                  Handle<JSReceiver>::cast(object), FROZEN)
     423        4465 :                            : Just(true);
     424        4465 :   MAYBE_RETURN(result, isolate->heap()->exception());
     425        4465 :   return isolate->heap()->ToBoolean(result.FromJust());
     426             : }
     427             : 
     428             : // ES6 section 19.1.2.13 Object.isSealed ( O )
     429       10290 : BUILTIN(ObjectIsSealed) {
     430             :   HandleScope scope(isolate);
     431             :   Handle<Object> object = args.atOrUndefined(isolate, 1);
     432             :   Maybe<bool> result = object->IsJSReceiver()
     433             :                            ? JSReceiver::TestIntegrityLevel(
     434             :                                  Handle<JSReceiver>::cast(object), SEALED)
     435        3430 :                            : Just(true);
     436        3430 :   MAYBE_RETURN(result, isolate->heap()->exception());
     437        3430 :   return isolate->heap()->ToBoolean(result.FromJust());
     438             : }
     439             : 
     440             : // ES6 section 19.1.2.14 Object.keys ( O )
     441      695184 : BUILTIN(ObjectKeys) {
     442             :   HandleScope scope(isolate);
     443      231728 :   Handle<Object> object = args.atOrUndefined(isolate, 1);
     444             :   Handle<JSReceiver> receiver;
     445      463456 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, receiver,
     446             :                                      Object::ToObject(isolate, object));
     447             : 
     448             :   Handle<FixedArray> keys;
     449             :   int enum_length = receiver->map()->EnumLength();
     450      409046 :   if (enum_length != kInvalidEnumCacheSentinel &&
     451             :       JSObject::cast(*receiver)->elements() ==
     452      177361 :           isolate->heap()->empty_fixed_array()) {
     453             :     DCHECK(receiver->IsJSObject());
     454             :     DCHECK(!JSObject::cast(*receiver)->HasNamedInterceptor());
     455             :     DCHECK(!JSObject::cast(*receiver)->IsAccessCheckNeeded());
     456             :     DCHECK(!receiver->map()->has_hidden_prototype());
     457             :     DCHECK(JSObject::cast(*receiver)->HasFastProperties());
     458      165450 :     if (enum_length == 0) {
     459             :       keys = isolate->factory()->empty_fixed_array();
     460             :     } else {
     461             :       Handle<FixedArray> cache(
     462      150792 :           receiver->map()->instance_descriptors()->GetEnumCache());
     463      150792 :       keys = isolate->factory()->CopyFixedArrayUpTo(cache, enum_length);
     464             :     }
     465             :   } else {
     466      132470 :     ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
     467             :         isolate, keys,
     468             :         KeyAccumulator::GetKeys(receiver, KeyCollectionMode::kOwnOnly,
     469             :                                 ENUMERABLE_STRINGS,
     470             :                                 GetKeysConversion::kConvertToString));
     471             :   }
     472             :   return *isolate->factory()->NewJSArrayWithElements(keys, FAST_ELEMENTS);
     473             : }
     474             : 
     475        1680 : BUILTIN(ObjectValues) {
     476             :   HandleScope scope(isolate);
     477         560 :   Handle<Object> object = args.atOrUndefined(isolate, 1);
     478             :   Handle<JSReceiver> receiver;
     479        1120 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, receiver,
     480             :                                      Object::ToObject(isolate, object));
     481             :   Handle<FixedArray> values;
     482        1036 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
     483             :       isolate, values, JSReceiver::GetOwnValues(receiver, ENUMERABLE_STRINGS));
     484             :   return *isolate->factory()->NewJSArrayWithElements(values);
     485             : }
     486             : 
     487        1764 : BUILTIN(ObjectEntries) {
     488             :   HandleScope scope(isolate);
     489         588 :   Handle<Object> object = args.atOrUndefined(isolate, 1);
     490             :   Handle<JSReceiver> receiver;
     491        1176 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, receiver,
     492             :                                      Object::ToObject(isolate, object));
     493             :   Handle<FixedArray> entries;
     494        1092 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
     495             :       isolate, entries,
     496             :       JSReceiver::GetOwnEntries(receiver, ENUMERABLE_STRINGS));
     497             :   return *isolate->factory()->NewJSArrayWithElements(entries);
     498             : }
     499             : 
     500         420 : BUILTIN(ObjectGetOwnPropertyDescriptors) {
     501             :   HandleScope scope(isolate);
     502         140 :   Handle<Object> object = args.atOrUndefined(isolate, 1);
     503             : 
     504             :   Handle<JSReceiver> receiver;
     505         280 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, receiver,
     506             :                                      Object::ToObject(isolate, object));
     507             : 
     508             :   Handle<FixedArray> keys;
     509         196 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
     510             :       isolate, keys, KeyAccumulator::GetKeys(
     511             :                          receiver, KeyCollectionMode::kOwnOnly, ALL_PROPERTIES,
     512             :                          GetKeysConversion::kConvertToString));
     513             : 
     514             :   Handle<JSObject> descriptors =
     515          98 :       isolate->factory()->NewJSObject(isolate->object_function());
     516             : 
     517         644 :   for (int i = 0; i < keys->length(); ++i) {
     518         224 :     Handle<Name> key = Handle<Name>::cast(FixedArray::get(*keys, i, isolate));
     519             :     PropertyDescriptor descriptor;
     520             :     Maybe<bool> did_get_descriptor = JSReceiver::GetOwnPropertyDescriptor(
     521         224 :         isolate, receiver, key, &descriptor);
     522         224 :     MAYBE_RETURN(did_get_descriptor, isolate->heap()->exception());
     523             : 
     524         252 :     if (!did_get_descriptor.FromJust()) continue;
     525         196 :     Handle<Object> from_descriptor = descriptor.ToObject(isolate);
     526             : 
     527             :     LookupIterator it = LookupIterator::PropertyOrElement(
     528         196 :         isolate, descriptors, key, descriptors, LookupIterator::OWN);
     529             :     Maybe<bool> success = JSReceiver::CreateDataProperty(&it, from_descriptor,
     530         196 :                                                          Object::DONT_THROW);
     531         196 :     CHECK(success.FromJust());
     532             :   }
     533             : 
     534          98 :   return *descriptors;
     535             : }
     536             : 
     537             : // ES6 section 19.1.2.15 Object.preventExtensions ( O )
     538       15399 : BUILTIN(ObjectPreventExtensions) {
     539             :   HandleScope scope(isolate);
     540             :   Handle<Object> object = args.atOrUndefined(isolate, 1);
     541        5133 :   if (object->IsJSReceiver()) {
     542        5133 :     MAYBE_RETURN(JSReceiver::PreventExtensions(Handle<JSReceiver>::cast(object),
     543             :                                                Object::THROW_ON_ERROR),
     544             :                  isolate->heap()->exception());
     545             :   }
     546        5121 :   return *object;
     547             : }
     548             : 
     549             : // ES6 section 19.1.2.17 Object.seal ( O )
     550        1836 : BUILTIN(ObjectSeal) {
     551             :   HandleScope scope(isolate);
     552             :   Handle<Object> object = args.atOrUndefined(isolate, 1);
     553         612 :   if (object->IsJSReceiver()) {
     554         563 :     MAYBE_RETURN(JSReceiver::SetIntegrityLevel(Handle<JSReceiver>::cast(object),
     555             :                                                SEALED, Object::THROW_ON_ERROR),
     556             :                  isolate->heap()->exception());
     557             :   }
     558         606 :   return *object;
     559             : }
     560             : 
     561             : }  // namespace internal
     562             : }  // namespace v8

Generated by: LCOV version 1.10