Move NoSideEffectToString to C++

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/messages.h"
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/execution.h"
@@ skipping 83 matching lines @@
 
   // Turn the exception on the message into a string if it is an object.
   if (message->argument()->IsJSObject()) {
     HandleScope scope(isolate);
     Handle<Object> argument(message->argument(), isolate);
 
     MaybeHandle<Object> maybe_stringified;
     Handle<Object> stringified;
     // Make sure we don't leak uncaught internally generated Error objects.
     if (argument->IsJSError()) {
-      Handle<Object> args[] = {argument};
-      maybe_stringified = Execution::TryCall(
-          isolate, isolate->no_side_effects_to_string_fun(),
-          isolate->factory()->undefined_value(), arraysize(args), args);
+      maybe_stringified = Object::NoSideEffectsToString(isolate, argument);
     } else {
       v8::TryCatch catcher(reinterpret_cast<v8::Isolate*>(isolate));
       catcher.SetVerbose(false);
       catcher.SetCaptureMessage(false);
 
       maybe_stringified = Object::ToString(isolate, argument);
     }
 
     if (!maybe_stringified.ToHandle(&stringified)) {
       stringified = isolate->factory()->NewStringFromAsciiChecked("exception");
@@ skipping 545 matching lines @@
     }
   }
 
   RETURN_RESULT(isolate, builder.Finish(), Object);
 }
 
 Handle<String> MessageTemplate::FormatMessage(Isolate* isolate,
                                               int template_index,
                                               Handle<Object> arg) {
   Factory* factory = isolate->factory();
-  Handle<String> result_string;
-  if (arg->IsString()) {
-    result_string = Handle<String>::cast(arg);
-  } else {
-    Handle<JSFunction> fun = isolate->no_side_effects_to_string_fun();
-
-    MaybeHandle<Object> maybe_result =
-        Execution::TryCall(isolate, fun, factory->undefined_value(), 1, &arg);
-    Handle<Object> result;
-    if (!maybe_result.ToHandle(&result) || !result->IsString()) {
-      return factory->InternalizeOneByteString(STATIC_CHAR_VECTOR("<error>"));
-    }
-    result_string = Handle<String>::cast(result);
-  }
+  Handle<String> result_string = Object::NoSideEffectsToString(isolate, arg);
   MaybeHandle<String> maybe_result_string = MessageTemplate::FormatMessage(
       template_index, result_string, factory->empty_string(),
       factory->empty_string());
   if (!maybe_result_string.ToHandle(&result_string)) {
     return factory->InternalizeOneByteString(STATIC_CHAR_VECTOR("<error>"));
   }
   // A string that has been obtained from JS code in this way is
   // likely to be a complicated ConsString of some sort.  We flatten it
   // here to improve the efficiency of converting it to a C string and
   // other operations that are likely to take place (see GetLocalizedMessage
@@ skipping 45 matching lines @@
     } else {
       builder.AppendCharacter(*c);
     }
   }
 
   return builder.Finish();
 }
 
 MaybeHandle<Object> ErrorUtils::Construct(
     Isolate* isolate, Handle<JSFunction> target, Handle<Object> new_target,
-    Handle<Object> message, FrameSkipMode mode, bool suppress_detailed_trace) {
+    Handle<Object> message, FrameSkipMode mode, Handle<Object> caller,
+    bool suppress_detailed_trace) {
   // 1. If NewTarget is undefined, let newTarget be the active function object,
   // else let newTarget be NewTarget.
 
   Handle<JSReceiver> new_target_recv =
       new_target->IsJSReceiver() ? Handle<JSReceiver>::cast(new_target)
                                  : Handle<JSReceiver>::cast(target);
 
   // 2. Let O be ? OrdinaryCreateFromConstructor(newTarget, "%ErrorPrototype%",
   //    « [[ErrorData]] »).
   Handle<JSObject> err;
@@ skipping 16 matching lines @@
                                      msg_string, DONT_ENUM),
                         Object);
   }
 
   // Optionally capture a more detailed stack trace for the message.
   if (!suppress_detailed_trace) {
     RETURN_ON_EXCEPTION(isolate, isolate->CaptureAndSetDetailedStackTrace(err),
                         Object);
   }
 
-  // When we're passed a JSFunction as new target, we can skip frames until that
-  // specific function is seen instead of unconditionally skipping the first
-  // frame.
-  Handle<Object> caller;
-  if (mode == SKIP_FIRST && new_target->IsJSFunction()) {
-    mode = SKIP_UNTIL_SEEN;
-    caller = new_target;
-  }
-
   // Capture a simple stack trace for the stack property.
   RETURN_ON_EXCEPTION(isolate,
                       isolate->CaptureAndSetSimpleStackTrace(err, mode, caller),
                       Object);
 
   return err;
 }
 
 namespace {
 
@@ skipping 63 matching lines @@
   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;
 }
 
+namespace {
+
+Handle<String> FormatMessage(Isolate* isolate, int template_index,
+                             Handle<Object> arg0, Handle<Object> arg1,
+                             Handle<Object> arg2) {
+  Handle<String> arg0_str = Object::NoSideEffectsToString(isolate, arg0);
+  Handle<String> arg1_str = Object::NoSideEffectsToString(isolate, arg1);
+  Handle<String> arg2_str = Object::NoSideEffectsToString(isolate, arg2);
+
+  isolate->native_context()->IncrementErrorsThrown();
+
+  Handle<String> msg;
+  if (!MessageTemplate::FormatMessage(template_index, arg0_str, arg1_str,
+                                      arg2_str)
+           .ToHandle(&msg)) {
+    DCHECK(isolate->has_pending_exception());
+    isolate->clear_pending_exception();
+    return isolate->factory()->NewStringFromAsciiChecked("<error>");
+  }
+
+  return msg;
+}
+
+}  // namespace
+
+// static
+MaybeHandle<Object> ErrorUtils::MakeGenericError(
+    Isolate* isolate, Handle<JSFunction> constructor, int template_index,
+    Handle<Object> arg0, Handle<Object> arg1, Handle<Object> arg2,
+    FrameSkipMode mode) {
+  // This function used to be implemented in JavaScript, and JSEntryStub clears
+  // any pending exceptions - so whenever we'd call this from C++, pending
+  // exceptions would be cleared. Preserve this behavior.
+  isolate->clear_pending_exception();
+
+  DCHECK(mode != SKIP_UNTIL_SEEN);
+
+  Handle<Object> no_caller;
+  Handle<String> msg = FormatMessage(isolate, template_index, arg0, arg1, arg2);
+  return ErrorUtils::Construct(isolate, constructor, constructor, msg, mode,
+                               no_caller, false);
+}
+
 #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<Object> receiver,
                                              Handle<Object> fun,
                                              Handle<Object> pos,
@@ skipping 267 matching lines @@
   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