For non-prototype objects constructed using base==new.target, use the cached constructor to render …

src/objects.cc

 // Copyright 2013 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/objects.h"
 
 #include <cmath>
 #include <iomanip>
 #include <sstream>
 
@@ skipping 2262 matching lines @@
     return String::cast(constructor->shared()->instance_class_name());
   }
   // If the constructor is not present, return "Object".
   return GetHeap()->Object_string();
 }
 
 
 // static
 Handle<String> JSReceiver::GetConstructorName(Handle<JSReceiver> receiver) {
   Isolate* isolate = receiver->GetIsolate();
+
+  // If the object was instantiated simply with base == new.target, the
+  // constructor on the map provides the most accurate name.
+  // Don't provide the info for prototypes, since their constructors are
+  // reclaimed and replaced by Object in OptimizeAsPrototype.
+  if (!receiver->IsJSProxy() && receiver->map()->new_target_is_base() &&
+      !receiver->map()->is_prototype_map()) {
+    Object* maybe_constructor = receiver->map()->GetConstructor();
+    if (maybe_constructor->IsJSFunction()) {
+      JSFunction* constructor = JSFunction::cast(maybe_constructor);
+      String* name = String::cast(constructor->shared()->name());
+      if (name->length() == 0) name = constructor->shared()->inferred_name();
+      if (name->length() != 0 &&
+          !name->Equals(isolate->heap()->Object_string())) {
+        return handle(name, isolate);
+      }
+    }
+  }
+
   if (FLAG_harmony_tostring) {
     Handle<Object> maybe_tag = JSReceiver::GetDataProperty(
         receiver, isolate->factory()->to_string_tag_symbol());
     if (maybe_tag->IsString()) return Handle<String>::cast(maybe_tag);
   }
 
   PrototypeIterator iter(isolate, receiver);
   if (iter.IsAtEnd()) return handle(receiver->class_name());
   Handle<JSReceiver> start = PrototypeIterator::GetCurrent<JSReceiver>(iter);
   LookupIterator it(receiver, isolate->factory()->constructor_string(), start,
                     LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR);
   Handle<Object> maybe_constructor = JSReceiver::GetDataProperty(&it);
   Handle<String> result = isolate->factory()->Object_string();
   if (maybe_constructor->IsJSFunction()) {
     JSFunction* constructor = JSFunction::cast(*maybe_constructor);
     String* name = String::cast(constructor->shared()->name());
-    if (name->length() > 0) {
-      result = handle(name, isolate);
-    } else {
-      String* inferred_name = constructor->shared()->inferred_name();
-      if (inferred_name->length() > 0) {
-        result = handle(inferred_name, isolate);
-      }
-    }
+    if (name->length() == 0) name = constructor->shared()->inferred_name();
+    if (name->length() > 0) result = handle(name, isolate);
   }
 
   return result.is_identical_to(isolate->factory()->Object_string())
              ? handle(receiver->class_name())
              : result;
 }
 
 
 Context* JSReceiver::GetCreationContext() {
   Object* constructor = map()->GetConstructor();
@@ skipping 10251 matching lines @@
   if (*new_target == *constructor) return constructor_initial_map;
 
   if (new_target->IsJSProxy()) {
     Handle<JSProxy> new_target_proxy = Handle<JSProxy>::cast(new_target);
     Handle<Object> prototype;
     Handle<String> prototype_string = isolate->factory()->prototype_string();
     ASSIGN_RETURN_ON_EXCEPTION(
         isolate, prototype,
         JSReceiver::GetProperty(new_target_proxy, prototype_string), Map);
     Handle<Map> map = Map::CopyInitialMap(constructor_initial_map);
+    map->set_new_target_is_base(false);
 
     if (!prototype->IsJSReceiver()) {
       Handle<Context> context;
       ASSIGN_RETURN_ON_EXCEPTION(
           isolate, context, JSProxy::GetFunctionRealm(new_target_proxy), Map);
       DCHECK(context->IsNativeContext());
       // TODO(verwaest): Use the intrinsicDefaultProto instead.
       prototype = handle(context->initial_object_prototype(), isolate);
     }
 
@@ skipping 31 matching lines @@
                         constructor_initial_map->unused_property_fields();
     int instance_size;
     int in_object_properties;
     new_target_function->CalculateInstanceSizeForDerivedClass(
         instance_type, internal_fields, &instance_size, &in_object_properties);
 
     int unused_property_fields = in_object_properties - pre_allocated;
     Handle<Map> map =
         Map::CopyInitialMap(constructor_initial_map, instance_size,
                             in_object_properties, unused_property_fields);
+    map->set_new_target_is_base(false);
 
     JSFunction::SetInitialMap(new_target_function, map, prototype);
     map->SetConstructor(*constructor);
     new_target_function->StartInobjectSlackTracking();
     return map;
   }
 
   // Fetch the prototype.
   Handle<Object> prototype;
   if (new_target_function->map()->has_non_instance_prototype()) {
     // TODO(verwaest): In case of non-instance prototype, use the
     // intrinsicDefaultProto instead.
     prototype = handle(new_target_function->context()
                            ->native_context()
                            ->initial_object_prototype());
   } else {
     // Make sure the prototype is cached on new_target_function.
     EnsureHasInitialMap(new_target_function);
     prototype = handle(new_target_function->instance_prototype(), isolate);
   }
 
   Handle<Map> map = Map::CopyInitialMap(constructor_initial_map);
+  map->set_new_target_is_base(false);
   DCHECK(prototype->IsJSReceiver());
   if (map->prototype() != *prototype) {
     Map::SetPrototype(map, prototype, FAST_PROTOTYPE);
   }
   map->SetConstructor(*constructor);
   return map;
 }
 
 
 void JSFunction::PrintName(FILE* out) {
@@ skipping 6394 matching lines @@
   if (cell->value() != *new_value) {
     cell->set_value(*new_value);
     Isolate* isolate = cell->GetIsolate();
     cell->dependent_code()->DeoptimizeDependentCodeGroup(
         isolate, DependentCode::kPropertyCellChangedGroup);
   }
 }
 
 }  // namespace internal
 }  // namespace v8