Introduce IsUndefined(Isolate*) and IsTheHole(Isolate*)

src/api-natives.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/api-natives.h"
 
 #include "src/api.h"
 #include "src/isolate-inl.h"
 #include "src/lookup.h"
 #include "src/messages.h"
@@ skipping 138 matching lines @@
     return native_context->iname();
     V8_INTRINSICS_LIST(GET_INTRINSIC_VALUE)
 #undef GET_INTRINSIC_VALUE
   }
   return nullptr;
 }
 
 // Returns parent function template or null.
 FunctionTemplateInfo* GetParent(FunctionTemplateInfo* data) {
   Object* parent = data->parent_template();
-  return parent->IsUndefined() ? nullptr : FunctionTemplateInfo::cast(parent);
+  return parent->IsUndefined(data->GetIsolate())
+             ? nullptr
+             : FunctionTemplateInfo::cast(parent);
 }
 
 // Starting from given object template's constructor walk up the inheritance
 // chain till a function template that has an instance template is found.
 ObjectTemplateInfo* GetParent(ObjectTemplateInfo* data) {
   Object* maybe_ctor = data->constructor();
-  if (maybe_ctor->IsUndefined()) return nullptr;
+  Isolate* isolate = data->GetIsolate();
+  if (maybe_ctor->IsUndefined(isolate)) return nullptr;
   FunctionTemplateInfo* ctor = FunctionTemplateInfo::cast(maybe_ctor);
   while (true) {
     ctor = GetParent(ctor);
     if (ctor == nullptr) return nullptr;
     Object* maybe_obj = ctor->instance_template();
-    if (!maybe_obj->IsUndefined()) return ObjectTemplateInfo::cast(maybe_obj);
+    if (!maybe_obj->IsUndefined(isolate)) {
+      return ObjectTemplateInfo::cast(maybe_obj);
+    }
   }
 }
 
 template <typename TemplateInfoT>
 MaybeHandle<JSObject> ConfigureInstance(Isolate* isolate, Handle<JSObject> obj,
                                         Handle<TemplateInfoT> data,
                                         bool is_hidden_prototype) {
   HandleScope scope(isolate);
   // Disable access checks while instantiating the object.
   AccessCheckDisableScope access_check_scope(isolate, obj);
 
   // Walk the inheritance chain and copy all accessors to current object.
   int max_number_of_properties = 0;
   TemplateInfoT* info = *data;
   while (info != nullptr) {
-    if (!info->property_accessors()->IsUndefined()) {
+    if (!info->property_accessors()->IsUndefined(isolate)) {
       Object* props = info->property_accessors();
-      if (!props->IsUndefined()) {
+      if (!props->IsUndefined(isolate)) {
         Handle<Object> props_handle(props, isolate);
         NeanderArray props_array(props_handle);
         max_number_of_properties += props_array.length();
       }
     }
     info = GetParent(info);
   }
 
   if (max_number_of_properties > 0) {
     int valid_descriptors = 0;
     // Use a temporary FixedArray to accumulate unique accessors.
     Handle<FixedArray> array =
         isolate->factory()->NewFixedArray(max_number_of_properties);
 
     info = *data;
     while (info != nullptr) {
       // Accumulate accessors.
-      if (!info->property_accessors()->IsUndefined()) {
+      if (!info->property_accessors()->IsUndefined(isolate)) {
         Handle<Object> props(info->property_accessors(), isolate);
         valid_descriptors =
             AccessorInfo::AppendUnique(props, array, valid_descriptors);
       }
       info = GetParent(info);
     }
 
     // Install accumulated accessors.
     for (int i = 0; i < valid_descriptors; i++) {
       Handle<AccessorInfo> accessor(AccessorInfo::cast(array->get(i)));
       JSObject::SetAccessor(obj, accessor).Assert();
     }
   }
 
   auto property_list = handle(data->property_list(), isolate);
-  if (property_list->IsUndefined()) return obj;
+  if (property_list->IsUndefined(isolate)) return obj;
   // TODO(dcarney): just use a FixedArray here.
   NeanderArray properties(property_list);
   if (properties.length() == 0) return obj;
 
   int i = 0;
   for (int c = 0; c < data->number_of_properties(); c++) {
     auto name = handle(Name::cast(properties.get(i++)), isolate);
     auto bit = handle(properties.get(i++), isolate);
     if (bit->IsSmi()) {
       PropertyDetails details(Smi::cast(*bit));
@@ skipping 81 matching lines @@
       Object* boilerplate = cache->ValueAt(entry);
       result = handle(JSObject::cast(boilerplate), isolate);
       return isolate->factory()->CopyJSObject(result);
     }
   }
   // Enter a new scope.  Recursion could otherwise create a lot of handles.
   HandleScope scope(isolate);
 
   if (constructor.is_null()) {
     Handle<Object> cons(info->constructor(), isolate);
-    if (cons->IsUndefined()) {
+    if (cons->IsUndefined(isolate)) {
       constructor = isolate->object_function();
     } else {
       auto cons_templ = Handle<FunctionTemplateInfo>::cast(cons);
       ASSIGN_RETURN_ON_EXCEPTION(isolate, constructor,
                                  InstantiateFunction(isolate, cons_templ),
                                  JSObject);
     }
 
     if (new_target.is_null()) new_target = constructor;
   }
@@ skipping 27 matching lines @@
     if (entry != UnseededNumberDictionary::kNotFound) {
       Object* element = cache->ValueAt(entry);
       return handle(JSFunction::cast(element), isolate);
     }
   }
   // Enter a new scope.  Recursion could otherwise create a lot of handles.
   HandleScope scope(isolate);
   Handle<JSObject> prototype;
   if (!data->remove_prototype()) {
     auto prototype_templ = handle(data->prototype_template(), isolate);
-    if (prototype_templ->IsUndefined()) {
+    if (prototype_templ->IsUndefined(isolate)) {
       prototype = isolate->factory()->NewJSObject(isolate->object_function());
     } else {
       ASSIGN_RETURN_ON_EXCEPTION(
           isolate, prototype,
           InstantiateObject(isolate,
                             Handle<ObjectTemplateInfo>::cast(prototype_templ),
                             Handle<JSReceiver>(), data->hidden_prototype()),
           JSFunction);
     }
     auto parent = handle(data->parent_template(), isolate);
-    if (!parent->IsUndefined()) {
+    if (!parent->IsUndefined(isolate)) {
       Handle<JSFunction> parent_instance;
       ASSIGN_RETURN_ON_EXCEPTION(
           isolate, parent_instance,
           InstantiateFunction(isolate,
                               Handle<FunctionTemplateInfo>::cast(parent)),
           JSFunction);
       // TODO(dcarney): decide what to do here.
       Handle<Object> parent_prototype;
       ASSIGN_RETURN_ON_EXCEPTION(
           isolate, parent_prototype,
@@ skipping 42 matching lines @@
 
  private:
   Isolate* isolate_;
   SaveContext save_context_;
 };
 
 
 void AddPropertyToPropertyList(Isolate* isolate, Handle<TemplateInfo> templ,
                                int length, Handle<Object>* data) {
   auto list = handle(templ->property_list(), isolate);
-  if (list->IsUndefined()) {
+  if (list->IsUndefined(isolate)) {
     list = NeanderArray(isolate).value();
     templ->set_property_list(*list);
   }
   templ->set_number_of_properties(templ->number_of_properties() + 1);
   NeanderArray array(list);
   for (int i = 0; i < length; i++) {
     Handle<Object> value =
         data[i].is_null()
             ? Handle<Object>::cast(isolate->factory()->undefined_value())
             : data[i];
@@ skipping 54 matching lines @@
   auto details_handle = handle(details.AsSmi(), isolate);
   Handle<Object> data[kSize] = {name, details_handle, getter, setter};
   AddPropertyToPropertyList(isolate, info, kSize, data);
 }
 
 
 void ApiNatives::AddNativeDataProperty(Isolate* isolate,
                                        Handle<TemplateInfo> info,
                                        Handle<AccessorInfo> property) {
   auto list = handle(info->property_accessors(), isolate);
-  if (list->IsUndefined()) {
+  if (list->IsUndefined(isolate)) {
     list = NeanderArray(isolate).value();
     info->set_property_accessors(*list);
   }
   NeanderArray array(list);
   array.add(isolate, property);
 }
 
 
 Handle<JSFunction> ApiNatives::CreateApiFunction(
     Isolate* isolate, Handle<FunctionTemplateInfo> obj,
     Handle<Object> prototype, ApiInstanceType instance_type) {
   Handle<Code> code;
   if (obj->call_code()->IsCallHandlerInfo() &&
       CallHandlerInfo::cast(obj->call_code())->fast_handler()->IsCode()) {
     code = isolate->builtins()->HandleFastApiCall();
   } else {
     code = isolate->builtins()->HandleApiCall();
   }
   Handle<Code> construct_stub =
       prototype.is_null() ? isolate->builtins()->ConstructedNonConstructable()
                           : isolate->builtins()->JSConstructStubApi();
 
   obj->set_instantiated(true);
   Handle<JSFunction> result;
   if (obj->remove_prototype()) {
     result = isolate->factory()->NewFunctionWithoutPrototype(
         isolate->factory()->empty_string(), code);
   } else {
     int internal_field_count = 0;
-    if (!obj->instance_template()->IsUndefined()) {
+    if (!obj->instance_template()->IsUndefined(isolate)) {
       Handle<ObjectTemplateInfo> instance_template = Handle<ObjectTemplateInfo>(
           ObjectTemplateInfo::cast(obj->instance_template()));
       internal_field_count =
           Smi::cast(instance_template->internal_field_count())->value();
     }
 
     // TODO(svenpanne) Kill ApiInstanceType and refactor things by generalizing
     // JSObject::GetHeaderSize.
     int instance_size = kPointerSize * internal_field_count;
     InstanceType type;
     switch (instance_type) {
       case JavaScriptObjectType:
         if (!obj->needs_access_check() &&
-            obj->named_property_handler()->IsUndefined() &&
-            obj->indexed_property_handler()->IsUndefined()) {
+            obj->named_property_handler()->IsUndefined(isolate) &&
+            obj->indexed_property_handler()->IsUndefined(isolate)) {
           type = JS_API_OBJECT_TYPE;
         } else {
           type = JS_SPECIAL_API_OBJECT_TYPE;
         }
         instance_size += JSObject::kHeaderSize;
         break;
       case GlobalObjectType:
         type = JS_GLOBAL_OBJECT_TYPE;
         instance_size += JSGlobalObject::kSize;
         break;
@@ skipping 47 matching lines @@
   if (obj->undetectable()) {
     map->set_is_undetectable();
   }
 
   // Mark as needs_access_check if needed.
   if (obj->needs_access_check()) {
     map->set_is_access_check_needed(true);
   }
 
   // Set interceptor information in the map.
-  if (!obj->named_property_handler()->IsUndefined()) {
+  if (!obj->named_property_handler()->IsUndefined(isolate)) {
     map->set_has_named_interceptor();
   }
-  if (!obj->indexed_property_handler()->IsUndefined()) {
+  if (!obj->indexed_property_handler()->IsUndefined(isolate)) {
     map->set_has_indexed_interceptor();
   }
 
   // Mark instance as callable in the map.
-  if (!obj->instance_call_handler()->IsUndefined()) {
+  if (!obj->instance_call_handler()->IsUndefined(isolate)) {
     map->set_is_callable();
     map->set_is_constructor(true);
   }
 
   DCHECK(result->shared()->IsApiFunction());
   return result;
 }
 
 }  // namespace internal
 }  // namespace v8