Expose v8::Function::GetDisplayName to public API.

src/api.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 4094 matching lines @@
 }
 
 
 Handle<Value> Function::GetInferredName() const {
   i::Handle<i::JSFunction> func = Utils::OpenHandle(this);
   return Utils::ToLocal(i::Handle<i::Object>(func->shared()->inferred_name(),
                                              func->GetIsolate()));
 }
 
 
+Handle<Value> Function::GetDisplayName() const {

[yurys, 2013/10/16 14:57:52]

If you anyways return either empty handle or String, can we change return type
to Handle<String>?

[aandrey, 2013/10/16 15:25:19]

I guess we can, but there are 2 similar methods defined already:

Handle<Value> GetName() const;
Handle<Value> GetInferredName() const;

I think all these should be consistent in return value. Should we change all of
them? I guess it could be painful to change the public API?

[yurys, 2013/10/17 07:40:19]

That's because they will return Undefined when there is no {inferred}name while
you return an empty handle in that case. So to be consistent with them you
should also return Undefined in case there is no displayName.

+  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
+  ON_BAILOUT(isolate, "v8::Function::GetDisplayName()",
+             return Local<v8::Value>());
+  ENTER_V8(isolate);
+  i::HandleScope scope(isolate);
+  i::Handle<i::JSFunction> func = Utils::OpenHandle(this);
+  i::Handle<i::String> property_name =
+      isolate->factory()->InternalizeOneByteString(
+          STATIC_ASCII_VECTOR("displayName"));
+  i::LookupResult lookup(isolate);
+  func->LookupRealNamedProperty(*property_name, &lookup);

[yurys, 2013/10/16 14:57:52]

Should we count displayName property declared on prototype?

[aandrey, 2013/10/16 15:19:45]

I think we should. And this code does look up on prototypes.

FYI, quick reference:

void JSObject::LookupRealNamedProperty(Name* name, LookupResult* result) {
  LocalLookupRealNamedProperty(name, result);
  if (result->IsFound()) return;

  LookupRealNamedPropertyInPrototypes(name, result);
}

+  if (!lookup.IsFound()) return Local<v8::Value>();
+  i::Object* value = lookup.GetLazyValue();
+  if (value && value->IsString()) {
+    i::String* name = i::String::cast(value);
+    if (name->length() > 0) return Utils::ToLocal(i::Handle<i::String>(name));
+  }
+  return Local<v8::Value>();
+}
+
+
 ScriptOrigin Function::GetScriptOrigin() const {
   i::Handle<i::JSFunction> func = Utils::OpenHandle(this);
   if (func->shared()->script()->IsScript()) {
     i::Handle<i::Script> script(i::Script::cast(func->shared()->script()));
     i::Handle<i::Object> scriptName = GetScriptNameOrSourceURL(script);
     v8::ScriptOrigin origin(
       Utils::ToLocal(scriptName),
       v8::Integer::New(script->line_offset()->value()),
       v8::Integer::New(script->column_offset()->value()));
     return origin;
@@ skipping 3419 matching lines @@
   Isolate* isolate = reinterpret_cast<Isolate*>(info.GetIsolate());
   Address callback_address =
       reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
   VMState<EXTERNAL> state(isolate);
   ExternalCallbackScope call_scope(isolate, callback_address);
   callback(info);
 }
 
 
 } }  // namespace v8::internal