[V8] Use Function.name for stack frames in v8::StackTrace

src/isolate.cc

 // Copyright 2012 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 <stdlib.h>
 
 #include <fstream>  // NOLINT(readability/streams)
 #include <sstream>
 
 #include "src/v8.h"
@@ skipping 473 matching lines @@
     }
     if (options & StackTrace::kScriptName) {
       script_name_key_ =
           factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("scriptName"));
     }
     if (options & StackTrace::kScriptNameOrSourceURL) {
       script_name_or_source_url_key_ = factory()->InternalizeOneByteString(
           STATIC_CHAR_VECTOR("scriptNameOrSourceURL"));
     }
     if (options & StackTrace::kFunctionName) {
+      display_name_ = factory()->InternalizeOneByteString(
+          STATIC_CHAR_VECTOR("displayName"));
       function_key_ = factory()->InternalizeOneByteString(
           STATIC_CHAR_VECTOR("functionName"));
     }
     if (options & StackTrace::kIsEval) {
       eval_key_ =
           factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("isEval"));
     }
     if (options & StackTrace::kIsConstructor) {
       constructor_key_ = factory()->InternalizeOneByteString(
           STATIC_CHAR_VECTOR("isConstructor"));
@@ skipping 43 matching lines @@
                             handle(script->name(), isolate_), NONE);
     }
 
     if (!script_name_or_source_url_key_.is_null()) {
       Handle<Object> result = Script::GetNameOrSourceURL(script);
       JSObject::AddProperty(stack_frame, script_name_or_source_url_key_, result,
                             NONE);
     }
 
     if (!function_key_.is_null()) {
-      Handle<Object> fun_name(fun->shared()->DebugName(), isolate_);
-      JSObject::AddProperty(stack_frame, function_key_, fun_name, NONE);
+      Handle<Object> display_name =
+          JSObject::GetDataProperty(fun, display_name_);
+      if (display_name->IsString()) {
+        JSObject::AddProperty(stack_frame, function_key_, display_name, NONE);

[Yang, 2015/02/12 14:25:36]

Why are we storing this in a separate property, and not under the same
"functionName"? Do we need to preserve the information about where the name
string originates?

[kozy, 2015/02/12 14:46:13]

In output stack frame we store display name or function name in the same
"functionName" property. In function we try receiving display name from current
JS function instance and if there is no this property then we get DebugName from
SharedFunctionInfo. As I understand it, we can have a lot of JS function objects
with different display names from one shared function info with its name.

+      } else {
+        Handle<Object> fun_name(fun->shared()->DebugName(), isolate_);
+        JSObject::AddProperty(stack_frame, function_key_, fun_name, NONE);
+      }
     }
 
     if (!eval_key_.is_null()) {
       Handle<Object> is_eval = factory()->ToBoolean(
           script->compilation_type() == Script::COMPILATION_TYPE_EVAL);
       JSObject::AddProperty(stack_frame, eval_key_, is_eval, NONE);
     }
 
     if (!constructor_key_.is_null()) {
       Handle<Object> is_constructor_obj = factory()->ToBoolean(is_constructor);
       JSObject::AddProperty(stack_frame, constructor_key_, is_constructor_obj,
                             NONE);
     }
 
     return stack_frame;
   }
 
  private:
   inline Factory* factory() { return isolate_->factory(); }
 
   Isolate* isolate_;
   Handle<String> column_key_;
   Handle<String> line_key_;
   Handle<String> script_id_key_;
   Handle<String> script_name_key_;
   Handle<String> script_name_or_source_url_key_;
   Handle<String> function_key_;
   Handle<String> eval_key_;
   Handle<String> constructor_key_;
+  Handle<String> display_name_;
 };
 
 
 Handle<JSArray> Isolate::GetDetailedFromSimpleStackTrace(
     Handle<JSObject> error_object) {
   Handle<Name> key = factory()->stack_trace_symbol();
   Handle<Object> property = JSObject::GetDataProperty(error_object, key);
   if (!property->IsJSArray()) return Handle<JSArray>();
   Handle<JSArray> simple_stack_trace = Handle<JSArray>::cast(property);
 
@@ skipping 2035 matching lines @@
   if (prev_ && prev_->Intercept(flag)) return true;
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 } }  // namespace v8::internal