Move FormatStackTrace to C++

src/messages.cc

Index: src/messages.cc
diff --git a/src/messages.cc b/src/messages.cc
index ae99df29ddaa6ad912fb3367080a395d7ffe1b2c..759395f65d0b68e75be7f815b6b9e19f8275683e 100644
--- a/src/messages.cc
+++ b/src/messages.cc
@@ -7,7 +7,6 @@
 #include <memory>
 
 #include "src/api.h"
-#include "src/bootstrapper.h"
 #include "src/execution.h"
 #include "src/isolate-inl.h"
 #include "src/keys.h"
@@ -304,6 +303,129 @@ Handle<Object> CallSite::GetMethodName() {
   return isolate_->factory()->null_value();
 }
 
+Handle<Object> CallSite::GetTypeName() {
+  // TODO(jgruber): Check for strict/constructor here as in
+  // CallSitePrototypeGetThis.
+
+  if (receiver_->IsNull(isolate_) || receiver_->IsUndefined(isolate_))
+    return isolate_->factory()->null_value();
+
+  if (receiver_->IsJSProxy()) return isolate_->factory()->Proxy_string();
+
+  Handle<JSReceiver> receiver_object =
+      Object::ToObject(isolate_, receiver_).ToHandleChecked();
+  return JSReceiver::GetConstructorName(receiver_object);
+}
+
+namespace {
+
+Object* EvalFromFunctionName(Isolate* isolate, Handle<Script> script) {
+  if (script->eval_from_shared()->IsUndefined(isolate))
+    return *isolate->factory()->undefined_value();
+
+  Handle<SharedFunctionInfo> shared(
+      SharedFunctionInfo::cast(script->eval_from_shared()));
+  // Find the name of the function calling eval.
+  if (shared->name()->BooleanValue()) {
+    return shared->name();
+  }
+
+  return shared->inferred_name();
+}
+
+Object* EvalFromScript(Isolate* isolate, Handle<Script> script) {
+  if (script->eval_from_shared()->IsUndefined(isolate))
+    return *isolate->factory()->undefined_value();
+
+  Handle<SharedFunctionInfo> eval_from_shared(
+      SharedFunctionInfo::cast(script->eval_from_shared()));
+  return eval_from_shared->script()->IsScript()
+             ? eval_from_shared->script()
+             : *isolate->factory()->undefined_value();
+}
+
+MaybeHandle<String> FormatEvalOrigin(Isolate* isolate, Handle<Script> script) {
+  Handle<Object> sourceURL = Script::GetNameOrSourceURL(script);
+  if (!sourceURL->IsUndefined(isolate)) {
+    DCHECK(sourceURL->IsString());
+    return Handle<String>::cast(sourceURL);
+  }
+
+  IncrementalStringBuilder builder(isolate);
+  builder.AppendCString("eval at ");
+
+  Handle<Object> eval_from_function_name =
+      handle(EvalFromFunctionName(isolate, script), isolate);
+  if (eval_from_function_name->BooleanValue()) {
+    Handle<String> str;
+    ASSIGN_RETURN_ON_EXCEPTION(
+        isolate, str, Object::ToString(isolate, eval_from_function_name),
+        String);
+    builder.AppendString(str);
+  } else {
+    builder.AppendCString("<anonymous>");
+  }
+
+  Handle<Object> eval_from_script_obj =
+      handle(EvalFromScript(isolate, script), isolate);
+  if (eval_from_script_obj->IsScript()) {
+    Handle<Script> eval_from_script =
+        Handle<Script>::cast(eval_from_script_obj);
+    builder.AppendCString(" (");
+    if (eval_from_script->compilation_type() == Script::COMPILATION_TYPE_EVAL) {
+      // Eval script originated from another eval.
+      Handle<String> str;
+      ASSIGN_RETURN_ON_EXCEPTION(
+          isolate, str, FormatEvalOrigin(isolate, eval_from_script), String);
+      builder.AppendString(str);
+    } else {
+      DCHECK(eval_from_script->compilation_type() !=
+             Script::COMPILATION_TYPE_EVAL);
+      // eval script originated from "real" source.
+      Handle<Object> name_obj = handle(eval_from_script->name(), isolate);
+      if (eval_from_script->name()->IsString()) {
+        builder.AppendString(Handle<String>::cast(name_obj));
+
+        Script::PositionInfo info;
+        if (eval_from_script->GetPositionInfo(script->GetEvalPosition(), &info,
+                                              Script::NO_OFFSET)) {
+          builder.AppendCString(":");
+
+          Handle<String> str = isolate->factory()->NumberToString(
+              handle(Smi::FromInt(info.line + 1), isolate));
+          builder.AppendString(str);
+
+          builder.AppendCString(":");
+
+          str = isolate->factory()->NumberToString(
+              handle(Smi::FromInt(info.column + 1), isolate));
+          builder.AppendString(str);
+        }
+      } else {
+        DCHECK(!eval_from_script->name()->IsString());
+        builder.AppendCString("unknown source");
+      }
+    }
+    builder.AppendCString(")");
+  }
+
+  Handle<String> result;
+  ASSIGN_RETURN_ON_EXCEPTION(isolate, result, builder.Finish(), String);
+  return result;
+}
+
+}  // namespace
+
+Handle<Object> CallSite::GetEvalOrigin() {
+  if (IsWasm()) return isolate_->factory()->undefined_value();
+  DCHECK(IsJavaScript());
+
+  Handle<Object> script = handle(fun_->shared()->script(), isolate_);
+  if (!script->IsScript()) return isolate_->factory()->undefined_value();
+
+  return FormatEvalOrigin(isolate_, Handle<Script>::cast(script))
+      .ToHandleChecked();
+}
 
 int CallSite::GetLineNumber() {
   if (pos_ >= 0 && IsJavaScript()) {
@@ -365,22 +487,187 @@ bool CallSite::IsConstructor() {
   return constructor.is_identical_to(fun_);
 }
 
+namespace {
+
+// Convert the raw frames as written by Isolate::CaptureSimpleStackTrace into
+// a vector of JS CallSite objects.
+MaybeHandle<FixedArray> GetStackFrames(Isolate* isolate,
+                                       Handle<Object> raw_stack) {
+  DCHECK(raw_stack->IsJSArray());
+  Handle<JSArray> raw_stack_array = Handle<JSArray>::cast(raw_stack);
+
+  DCHECK(raw_stack_array->elements()->IsFixedArray());
+  Handle<FixedArray> raw_stack_elements =
+      handle(FixedArray::cast(raw_stack_array->elements()), isolate);
+
+  const int raw_stack_len = raw_stack_elements->length();
+  DCHECK(raw_stack_len % 4 == 1);  // Multiples of 4 plus sloppy frames count.
+  const int frame_count = (raw_stack_len - 1) / 4;
+
+  Handle<Object> sloppy_frames_obj =
+      FixedArray::get(*raw_stack_elements, 0, isolate);
+  int sloppy_frames = Handle<Smi>::cast(sloppy_frames_obj)->value();
+
+  Handle<JSFunction> callsite_ctor =
+      handle(isolate->native_context()->callsite_function(), isolate);
+
+  int dst_ix = 0;
+  Handle<FixedArray> frames = isolate->factory()->NewFixedArray(frame_count);
+  for (int i = 1; i < raw_stack_len; i += 4) {
+    Handle<Object> recv = FixedArray::get(*raw_stack_elements, i, isolate);
+    Handle<Object> fun = FixedArray::get(*raw_stack_elements, i + 1, isolate);
+    Handle<AbstractCode> code = Handle<AbstractCode>::cast(
+        FixedArray::get(*raw_stack_elements, i + 2, isolate));
+    Handle<Smi> pc =
+        Handle<Smi>::cast(FixedArray::get(*raw_stack_elements, i + 3, isolate));
+
+    Handle<Object> pos =
+        (fun->IsSmi() && pc->value() < 0)
+            ? handle(Smi::FromInt(-1 - pc->value()), isolate)
+            : handle(Smi::FromInt(code->SourcePosition(pc->value())), isolate);
+
+    sloppy_frames--;
+    Handle<Object> strict = isolate->factory()->ToBoolean(sloppy_frames < 0);
+
+    Handle<Object> callsite;
+    ASSIGN_RETURN_ON_EXCEPTION(
+        isolate, callsite,
+        CallSiteUtils::Construct(isolate, callsite_ctor, callsite_ctor, recv,
+                                 fun, pos, strict),
+        FixedArray);
+
+    frames->set(dst_ix++, *callsite);
+  }
+
+  DCHECK_EQ(frame_count, dst_ix);
+  return frames;
+}
+
+MaybeHandle<Object> AppendErrorString(Isolate* isolate, Handle<Object> error,
+                                      IncrementalStringBuilder* builder) {
+  MaybeHandle<String> err_str =
+      ErrorUtils::ToString(isolate, Handle<Object>::cast(error));
+  if (err_str.is_null()) {
+    // Error.toString threw. Try to return a string representation of the thrown
+    // exception instead.
+
+    DCHECK(isolate->has_pending_exception());
+    Handle<Object> pending_exception =
+        handle(isolate->pending_exception(), isolate);
+    isolate->clear_pending_exception();
+
+    err_str = ErrorUtils::ToString(isolate, pending_exception);
+    if (err_str.is_null()) {
+      // Formatting the thrown exception threw again, give up.
+      DCHECK(isolate->has_pending_exception());
+      isolate->clear_pending_exception();
+
+      builder->AppendCString("<error>");
+    } else {
+      // Formatted thrown exception successfully, append it.
+      builder->AppendCString("<error: ");
+      builder->AppendString(err_str.ToHandleChecked());
+      builder->AppendCharacter('>');
+    }
+  } else {
+    builder->AppendString(err_str.ToHandleChecked());
+  }
+
+  return error;
+}
+
+class PrepareStackTraceScope {
+ public:
+  explicit PrepareStackTraceScope(Isolate* isolate) : isolate_(isolate) {
+    DCHECK(!isolate_->formatting_stack_trace());
+    isolate_->set_formatting_stack_trace(true);
+  }
+
+  ~PrepareStackTraceScope() { isolate_->set_formatting_stack_trace(false); }
+
+ private:
+  Isolate* isolate_;
+
+  DISALLOW_COPY_AND_ASSIGN(PrepareStackTraceScope);
+};
+
+}  // namespace
+
 MaybeHandle<Object> FormatStackTrace(Isolate* isolate, Handle<JSObject> error,
-                                     Handle<Object> stack_trace) {
-  // TODO(jgruber): Port FormatStackTrace from JS.
-  Handle<JSFunction> fun = isolate->error_format_stack_trace();
+                                     Handle<Object> raw_stack) {
+  // Create JS CallSite objects from the raw stack frame array.
+
+  Handle<FixedArray> frames;
+  ASSIGN_RETURN_ON_EXCEPTION(isolate, frames,
+                             GetStackFrames(isolate, raw_stack), Object);
 
-  int argc = 2;
-  ScopedVector<Handle<Object>> argv(argc);
-  argv[0] = error;
-  argv[1] = stack_trace;
+  // If there's a user-specified "prepareStackFrames" function, call it on the
+  // frames and use its result.
 
-  Handle<Object> formatted_stack_trace;
+  Handle<JSFunction> global_error = isolate->error_function();
+  Handle<Object> prepare_stack_trace;
   ASSIGN_RETURN_ON_EXCEPTION(
-      isolate, formatted_stack_trace,
-      Execution::Call(isolate, fun, error, argc, argv.start()), Object);
+      isolate, prepare_stack_trace,
+      JSFunction::GetProperty(isolate, global_error, "prepareStackTrace"),
+      Object);
+
+  const bool in_recursion = isolate->formatting_stack_trace();
+  if (prepare_stack_trace->IsJSFunction() && !in_recursion) {
+    PrepareStackTraceScope scope(isolate);
+    Handle<JSArray> array = isolate->factory()->NewJSArrayWithElements(frames);
+
+    const int argc = 2;
+    ScopedVector<Handle<Object>> argv(argc);
+    argv[0] = error;
+    argv[1] = array;
+
+    Handle<Object> result;
+    ASSIGN_RETURN_ON_EXCEPTION(
+        isolate, result, Execution::Call(isolate, prepare_stack_trace,
+                                         global_error, argc, argv.start()),
+        Object);
+
+    return result;
+  }
+
+  IncrementalStringBuilder builder(isolate);
+
+  RETURN_ON_EXCEPTION(isolate, AppendErrorString(isolate, error, &builder),
+                      Object);
+
+  for (int i = 0; i < frames->length(); i++) {
+    builder.AppendCString("\n    at ");
+
+    Handle<Object> frame = FixedArray::get(*frames, i, isolate);
+    MaybeHandle<String> maybe_frame_string =
+        CallSiteUtils::ToString(isolate, frame);
+    if (maybe_frame_string.is_null()) {
+      // CallSite.toString threw. Try to return a string representation of the
+      // thrown exception instead.
 
-  return formatted_stack_trace;
+      DCHECK(isolate->has_pending_exception());
+      Handle<Object> pending_exception =
+          handle(isolate->pending_exception(), isolate);
+      isolate->clear_pending_exception();
+
+      maybe_frame_string = ErrorUtils::ToString(isolate, pending_exception);
+      if (maybe_frame_string.is_null()) {
+        // Formatting the thrown exception threw again, give up.
+
+        builder.AppendCString("<error>");
+      } else {
+        // Formatted thrown exception successfully, append it.
+        builder.AppendCString("<error: ");
+        builder.AppendString(maybe_frame_string.ToHandleChecked());
+        builder.AppendCString("<error>");
+      }
+    } else {
+      // CallSite.toString completed without throwing.
+      builder.AppendString(maybe_frame_string.ToHandleChecked());
+    }
+  }
+
+  RETURN_RESULT(isolate, builder.Finish(), Object);
 }
 
 Handle<String> MessageTemplate::FormatMessage(Isolate* isolate,
@@ -464,10 +751,9 @@ MaybeHandle<String> MessageTemplate::FormatMessage(int template_index,
   return builder.Finish();
 }
 
-MaybeHandle<Object> ConstructError(Isolate* isolate, Handle<JSFunction> target,
-                                   Handle<Object> new_target,
-                                   Handle<Object> message, FrameSkipMode mode,
-                                   bool suppress_detailed_trace) {
+MaybeHandle<Object> ErrorUtils::Construct(
+    Isolate* isolate, Handle<JSFunction> target, Handle<Object> new_target,
+    Handle<Object> message, FrameSkipMode mode, bool suppress_detailed_trace) {
   // 1. If NewTarget is undefined, let newTarget be the active function object,
   // else let newTarget be NewTarget.
 
@@ -521,5 +807,365 @@ MaybeHandle<Object> ConstructError(Isolate* isolate, Handle<JSFunction> target,
   return err;
 }
 
+namespace {
+
+MaybeHandle<String> GetStringPropertyOrDefault(Isolate* isolate,
+                                               Handle<JSReceiver> recv,
+                                               Handle<String> key,
+                                               Handle<String> default_str) {
+  Handle<Object> obj;
+  ASSIGN_RETURN_ON_EXCEPTION(isolate, obj, JSObject::GetProperty(recv, key),
+                             String);
+
+  Handle<String> str;
+  if (obj->IsUndefined(isolate)) {
+    str = default_str;
+  } else {
+    ASSIGN_RETURN_ON_EXCEPTION(isolate, str, Object::ToString(isolate, obj),
+                               String);
+  }
+
+  return str;
+}
+
+}  // namespace
+
+// ES6 section 19.5.3.4 Error.prototype.toString ( )
+MaybeHandle<String> ErrorUtils::ToString(Isolate* isolate,
+                                         Handle<Object> receiver) {
+  // 1. Let O be the this value.
+  // 2. If Type(O) is not Object, throw a TypeError exception.
+  if (!receiver->IsJSReceiver()) {
+    return isolate->Throw<String>(isolate->factory()->NewTypeError(
+        MessageTemplate::kIncompatibleMethodReceiver,
+        isolate->factory()->NewStringFromAsciiChecked(
+            "Error.prototype.toString"),
+        receiver));
+  }
+  Handle<JSReceiver> recv = Handle<JSReceiver>::cast(receiver);
+
+  // 3. Let name be ? Get(O, "name").
+  // 4. If name is undefined, let name be "Error"; otherwise let name be
+  // ? ToString(name).
+  Handle<String> name_key = isolate->factory()->name_string();
+  Handle<String> name_default = isolate->factory()->Error_string();
+  Handle<String> name;
+  ASSIGN_RETURN_ON_EXCEPTION(
+      isolate, name,
+      GetStringPropertyOrDefault(isolate, recv, name_key, name_default),
+      String);
+
+  // 5. Let msg be ? Get(O, "message").
+  // 6. If msg is undefined, let msg be the empty String; otherwise let msg be
+  // ? ToString(msg).
+  Handle<String> msg_key = isolate->factory()->message_string();
+  Handle<String> msg_default = isolate->factory()->empty_string();
+  Handle<String> msg;
+  ASSIGN_RETURN_ON_EXCEPTION(
+      isolate, msg,
+      GetStringPropertyOrDefault(isolate, recv, msg_key, msg_default), String);
+
+  // 7. If name is the empty String, return msg.
+  // 8. If msg is the empty String, return name.
+  if (name->length() == 0) return msg;
+  if (msg->length() == 0) return name;
+
+  // 9. Return the result of concatenating name, the code unit 0x003A (COLON),
+  // the code unit 0x0020 (SPACE), and msg.
+  IncrementalStringBuilder builder(isolate);
+  builder.AppendString(name);
+  builder.AppendCString(": ");
+  builder.AppendString(msg);
+
+  Handle<String> result;
+  ASSIGN_RETURN_ON_EXCEPTION(isolate, result, builder.Finish(), String);
+  return result;
+}
+
+#define SET_CALLSITE_PROPERTY(target, key, value)                        \
+  RETURN_ON_EXCEPTION(                                                   \
+      isolate, JSObject::SetOwnPropertyIgnoreAttributes(                 \
+                   target, isolate->factory()->key(), value, DONT_ENUM), \
+      Object)
+
+MaybeHandle<Object> CallSiteUtils::Construct(
+    Isolate* isolate, Handle<JSFunction> target, Handle<Object> new_target,
+    Handle<Object> receiver, Handle<Object> fun, Handle<Object> pos,
+    Handle<Object> strict_mode) {
+  // Create the JS object.
+
+  Handle<JSReceiver> new_target_recv =
+      new_target->IsJSReceiver() ? Handle<JSReceiver>::cast(new_target)
+                                 : Handle<JSReceiver>::cast(target);
+
+  Handle<JSObject> obj;
+  ASSIGN_RETURN_ON_EXCEPTION(isolate, obj,
+                             JSObject::New(target, new_target_recv), Object);
+
+  // For wasm frames, receiver is the wasm object and fun is the function index
+  // instead of an actual function.
+  const bool is_wasm_object =
+      receiver->IsJSObject() && wasm::IsWasmObject(JSObject::cast(*receiver));
+  if (!fun->IsJSFunction() && !is_wasm_object) {
+    THROW_NEW_ERROR(isolate,
+                    NewTypeError(MessageTemplate::kCallSiteExpectsFunction,
+                                 Object::TypeOf(isolate, receiver),
+                                 Object::TypeOf(isolate, fun)),
+                    Object);
+  }
+
+  if (is_wasm_object) {
+    DCHECK(fun->IsSmi());
+    DCHECK(wasm::GetNumberOfFunctions(JSObject::cast(*receiver)) >
+           Smi::cast(*fun)->value());
+
+    SET_CALLSITE_PROPERTY(obj, call_site_wasm_obj_symbol, receiver);
+    SET_CALLSITE_PROPERTY(obj, call_site_wasm_func_index_symbol, fun);
+  } else {
+    DCHECK(fun->IsJSFunction());
+    SET_CALLSITE_PROPERTY(obj, call_site_receiver_symbol, receiver);
+    SET_CALLSITE_PROPERTY(obj, call_site_function_symbol, fun);
+  }
+
+  DCHECK(pos->IsSmi());
+  SET_CALLSITE_PROPERTY(obj, call_site_position_symbol, pos);
+  SET_CALLSITE_PROPERTY(
+      obj, call_site_strict_symbol,
+      isolate->factory()->ToBoolean(strict_mode->BooleanValue()));
+
+  return obj;
+}
+
+#undef SET_CALLSITE_PROPERTY
+
+namespace {
+
+bool IsNonEmptyString(Handle<Object> object) {
+  return (object->IsString() && String::cast(*object)->length() > 0);
+}
+
+MaybeHandle<JSObject> AppendWasmToString(Isolate* isolate,
+                                         Handle<JSObject> recv,
+                                         CallSite* call_site,
+                                         IncrementalStringBuilder* builder) {
+  Handle<Object> name = call_site->GetFunctionName();
+  if (name->IsNull(isolate)) {
+    builder->AppendCString("<WASM UNNAMED>");
+  } else {
+    DCHECK(name->IsString());
+    builder->AppendString(Handle<String>::cast(name));
+  }
+
+  builder->AppendCString(" (<WASM>[");
+
+  Handle<String> ix = isolate->factory()->NumberToString(
+      handle(Smi::FromInt(call_site->wasm_func_index()), isolate));
+  builder->AppendString(ix);
+
+  builder->AppendCString("]+");
+
+  Handle<Object> pos;
+  ASSIGN_RETURN_ON_EXCEPTION(
+      isolate, pos, JSObject::GetProperty(
+                        recv, isolate->factory()->call_site_position_symbol()),
+      JSObject);
+  DCHECK(pos->IsNumber());
+  builder->AppendString(isolate->factory()->NumberToString(pos));
+  builder->AppendCString(")");
+
+  return recv;
+}
+
+MaybeHandle<JSObject> AppendFileLocation(Isolate* isolate,
+                                         Handle<JSObject> recv,
+                                         CallSite* call_site,
+                                         IncrementalStringBuilder* builder) {
+  if (call_site->IsNative()) {
+    builder->AppendCString("native");
+    return recv;
+  }
+
+  Handle<Object> file_name = call_site->GetScriptNameOrSourceUrl();
+  if (!file_name->IsString() && call_site->IsEval()) {
+    Handle<Object> eval_origin = call_site->GetEvalOrigin();
+    DCHECK(eval_origin->IsString());
+    builder->AppendString(Handle<String>::cast(eval_origin));
+    builder->AppendCString(", ");  // Expecting source position to follow.
+  }
+
+  if (IsNonEmptyString(file_name)) {
+    builder->AppendString(Handle<String>::cast(file_name));
+  } else {
+    // Source code does not originate from a file and is not native, but we
+    // can still get the source position inside the source string, e.g. in
+    // an eval string.
+    builder->AppendCString("<anonymous>");
+  }
+
+  int line_number = call_site->GetLineNumber();
+  if (line_number != -1) {
+    builder->AppendCharacter(':');
+    Handle<String> line_string = isolate->factory()->NumberToString(
+        handle(Smi::FromInt(line_number), isolate), isolate);
+    builder->AppendString(line_string);
+
+    int column_number = call_site->GetColumnNumber();
+    if (column_number != -1) {
+      builder->AppendCharacter(':');
+      Handle<String> column_string = isolate->factory()->NumberToString(
+          handle(Smi::FromInt(column_number), isolate), isolate);
+      builder->AppendString(column_string);
+    }
+  }
+
+  return recv;
+}
+
+int StringIndexOf(Isolate* isolate, Handle<String> subject,
+                  Handle<String> pattern) {
+  if (pattern->length() > subject->length()) return -1;
+  return String::IndexOf(isolate, subject, pattern, 0);
+}
+
+// Returns true iff
+// 1. the subject ends with '.' + pattern, or
+// 2. subject == pattern.
+bool StringEndsWithMethodName(Isolate* isolate, Handle<String> subject,
+                              Handle<String> pattern) {
+  if (String::Equals(subject, pattern)) return true;
+
+  FlatStringReader subject_reader(isolate, String::Flatten(subject));
+  FlatStringReader pattern_reader(isolate, String::Flatten(pattern));
+
+  int pattern_index = pattern_reader.length() - 1;
+  int subject_index = subject_reader.length() - 1;
+  for (int i = 0; i <= pattern_reader.length(); i++) {  // Iterate over len + 1.
+    if (subject_index < 0) {
+      return false;
+    }
+
+    const uc32 subject_char = subject_reader.Get(subject_index);
+    if (i == pattern_reader.length()) {
+      if (subject_char != '.') return false;
+    } else if (subject_char != pattern_reader.Get(pattern_index)) {
+      return false;
+    }
+
+    pattern_index--;
+    subject_index--;
+  }
+
+  return true;
+}
+
+MaybeHandle<JSObject> AppendMethodCall(Isolate* isolate, Handle<JSObject> recv,
+                                       CallSite* call_site,
+                                       IncrementalStringBuilder* builder) {
+  Handle<Object> type_name = call_site->GetTypeName();
+  Handle<Object> method_name = call_site->GetMethodName();
+  Handle<Object> function_name = call_site->GetFunctionName();
+
+  if (IsNonEmptyString(function_name)) {
+    Handle<String> function_string = Handle<String>::cast(function_name);
+    if (IsNonEmptyString(type_name)) {
+      Handle<String> type_string = Handle<String>::cast(type_name);
+      bool starts_with_type_name =
+          (StringIndexOf(isolate, function_string, type_string) == 0);
+      if (!starts_with_type_name) {
+        builder->AppendString(type_string);
+        builder->AppendCharacter('.');
+      }
+    }
+    builder->AppendString(function_string);
+
+    if (IsNonEmptyString(method_name)) {
+      Handle<String> method_string = Handle<String>::cast(method_name);
+      if (!StringEndsWithMethodName(isolate, function_string, method_string)) {
+        builder->AppendCString(" [as ");
+        builder->AppendString(method_string);
+        builder->AppendCharacter(']');
+      }
+    }
+  } else {
+    builder->AppendString(Handle<String>::cast(type_name));
+    builder->AppendCharacter('.');
+    if (IsNonEmptyString(method_name)) {
+      builder->AppendString(Handle<String>::cast(method_name));
+    } else {
+      builder->AppendCString("<anonymous>");
+    }
+  }
+
+  return recv;
+}
+
+}  // namespace
+
+MaybeHandle<String> CallSiteUtils::ToString(Isolate* isolate,
+                                            Handle<Object> receiver) {
+  if (!receiver->IsJSObject()) {
+    THROW_NEW_ERROR(
+        isolate,
+        NewTypeError(MessageTemplate::kIncompatibleMethodReceiver,
+                     isolate->factory()->NewStringFromAsciiChecked("toString"),
+                     receiver),
+        String);
+  }
+  Handle<JSObject> recv = Handle<JSObject>::cast(receiver);
+
+  if (!JSReceiver::HasOwnProperty(
+           recv, isolate->factory()->call_site_position_symbol())
+           .FromMaybe(false)) {
+    THROW_NEW_ERROR(
+        isolate,
+        NewTypeError(MessageTemplate::kCallSiteMethod,
+                     isolate->factory()->NewStringFromAsciiChecked("toString")),
+        String);
+  }
+
+  IncrementalStringBuilder builder(isolate);
+
+  CallSite call_site(isolate, recv);
+  if (call_site.IsWasm()) {
+    RETURN_ON_EXCEPTION(isolate,
+                        AppendWasmToString(isolate, recv, &call_site, &builder),
+                        String);
+    RETURN_RESULT(isolate, builder.Finish(), String);
+  }
+
+  DCHECK(!call_site.IsWasm());
+  Handle<Object> function_name = call_site.GetFunctionName();
+
+  const bool is_toplevel = call_site.IsToplevel();
+  const bool is_constructor = call_site.IsConstructor();
+  const bool is_method_call = !(is_toplevel || is_constructor);
+
+  if (is_method_call) {
+    RETURN_ON_EXCEPTION(
+        isolate, AppendMethodCall(isolate, recv, &call_site, &builder), String);
+  } else if (is_constructor) {
+    builder.AppendCString("new ");
+    if (IsNonEmptyString(function_name)) {
+      builder.AppendString(Handle<String>::cast(function_name));
+    } else {
+      builder.AppendCString("<anonymous>");
+    }
+  } else if (IsNonEmptyString(function_name)) {
+    builder.AppendString(Handle<String>::cast(function_name));
+  } else {
+    RETURN_ON_EXCEPTION(isolate,
+                        AppendFileLocation(isolate, recv, &call_site, &builder),
+                        String);
+    RETURN_RESULT(isolate, builder.Finish(), String);
+  }
+
+  builder.AppendCString(" (");
+  RETURN_ON_EXCEPTION(
+      isolate, AppendFileLocation(isolate, recv, &call_site, &builder), String);
+  builder.AppendCString(")");
+
+  RETURN_RESULT(isolate, builder.Finish(), String);
+}
+
 }  // namespace internal
 }  // namespace v8