Move more parts of stack trace formatting to runtime.

src/messages.cc

 // Copyright 2011 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/v8.h"
 
 #include "src/api.h"
 #include "src/execution.h"
 #include "src/heap/spaces-inl.h"
 #include "src/messages.h"
@@ skipping 179 matching lines @@
   if (script_obj->IsScript()) {
     Handle<Script> script = Handle<Script>::cast(script_obj);
     Object* source_url = script->source_url();
     if (source_url->IsString()) return Handle<Object>(source_url, isolate);
     return Handle<Object>(script->name(), isolate);
   }
   return isolate->factory()->null_value();
 }
 
 
+bool CheckMethodName(Handle<JSObject> obj, Handle<Name> name,
+                     Handle<JSFunction> fun) {

[Igor Sheludko, 2015/05/05 10:30:49]

Maybe it's better to use LookupIterator here.

+  if (obj->IsAccessCheckNeeded()) return false;
+  if (JSObject::GetDataProperty(obj, name).is_identical_to(fun)) return true;
+  Handle<Object> getter =
+      JSObject::GetAccessor(obj, name, ACCESSOR_GETTER).ToHandleChecked();
+  if (getter.is_identical_to(fun)) return true;
+  Handle<Object> setter =
+      JSObject::GetAccessor(obj, name, ACCESSOR_SETTER).ToHandleChecked();
+  return setter.is_identical_to(fun);
+}
+
+
+Handle<Object> CallSite::GetMethodName(Isolate* isolate) {
+  MaybeHandle<JSReceiver> maybe = Object::ToObject(isolate, receiver_);
+  Handle<JSReceiver> receiver;
+  if (!maybe.ToHandle(&receiver) || !receiver->IsJSObject()) {
+    return isolate->factory()->null_value();
+  }
+
+  Handle<JSObject> obj = Handle<JSObject>::cast(receiver);
+  Handle<Object> function_name(fun_->shared()->name(), isolate);
+  if (function_name->IsName()) {
+    Handle<Name> name = Handle<Name>::cast(function_name);
+    if (CheckMethodName(obj, name, fun_)) return function_name;
+  }
+
+  HandleScope scope(isolate);
+  Handle<Object> name;
+  for (PrototypeIterator iter(isolate, obj,
+                              PrototypeIterator::START_AT_RECEIVER);
+       !iter.IsAtEnd(); iter.Advance()) {
+    Handle<JSObject> current =
+        Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter));
+    if (current->IsAccessCheckNeeded()) break;
+    Handle<Object> lookup(current->SlowReverseLookup(*fun_), isolate);

[Igor Sheludko, 2015/05/05 10:30:49]

SlowReverseLookup() does not look into accessor pairs and it does not handle
"multiple matches in the same object" case.

+    if (lookup->IsName()) {
+      if (!name.is_null()) break;

[Igor Sheludko, 2015/05/05 10:30:49]

You probably wanted to return null at this point to avoid "multiple matches"
confusion (in this case please add a comment here).

If not, then why do we need to perform another iteration before exiting the
loop? Why not just break after
  name = lookup;
?

+      name = lookup;
+    }
+  }
+
+  if (!name.is_null()) return scope.CloseAndEscape(name);
+  return isolate->factory()->null_value();
+}
+
+
 int CallSite::GetLineNumber(Isolate* isolate) {
   if (pos_ >= 0) {
     Handle<Object> script_obj(fun_->shared()->script(), isolate);
     if (script_obj->IsScript()) {
       Handle<Script> script = Handle<Script>::cast(script_obj);
       return Script::GetLineNumber(script, pos_) + 1;
     }
   }
   return -1;
 }
@@ skipping 25 matching lines @@
 
 
 bool CallSite::IsEval(Isolate* isolate) {
   Handle<Object> script(fun_->shared()->script(), isolate);
   return script->IsScript() &&
          Handle<Script>::cast(script)->compilation_type() ==
              Script::COMPILATION_TYPE_EVAL;
 }
 
 
+bool CallSite::IsConstructor(Isolate* isolate) {
+  if (!receiver_->IsJSObject()) return false;
+  Handle<Object> constructor =
+      JSObject::GetDataProperty(Handle<JSObject>::cast(receiver_),
+                                isolate->factory()->constructor_string());
+  return constructor.is_identical_to(fun_);
+}
+
+
 MaybeHandle<String> MessageTemplate::FormatMessage(int template_index,
                                                    Handle<String> arg0,
                                                    Handle<String> arg1,
                                                    Handle<String> arg2) {
   const char* template_string;
   switch (template_index) {
 #define CASE(NAME, STRING)    \
   case k##NAME:               \
     template_string = STRING; \
     break;
@@ skipping 16 matching lines @@
       DCHECK(i < arraysize(args));
       builder.AppendString(args[i++]);
     } else {
       builder.AppendCharacter(*c);
     }
   }
 
   return builder.Finish();
 }
 } }  // namespace v8::internal