take ownership of prepareStackTrace for upstream v8 changes

lib/internal/bootstrap/node.js

@@ -35,6 +35,8 @@
 // passed by node::RunBootstrapping()
 /* global process, require, internalBinding, isMainThread, ownsProcessState */
 
+setupPrepareStackTrace();
+
 const { JSON, Object, Symbol } = primordials;
 const config = internalBinding('config');
 const { deprecate } = require('internal/util');
@@ -290,6 +292,12 @@ process.emitWarning = emitWarning;
  // Note: only after this point are the timers effective
 }
 
+function setupPrepareStackTrace() {
+ const { setPrepareStackTraceCallback } = internalBinding('errors');
+ const { prepareStackTrace } = require('internal/errors');
+ setPrepareStackTraceCallback(prepareStackTrace);
+}
+
 function setupProcessObject() {
  const EventEmitter = require('events');
  const origProcProto = Object.getPrototypeOf(process);

lib/internal/errors.js

@@ -19,6 +19,31 @@ const codes = {};
 
 const { kMaxLength } = internalBinding('buffer');
 
+const MainContextError = Error;
+const ErrorToString = Error.prototype.toString;
+// Polyfill of V8's Error.prepareStackTrace API.
+// https://crbug.com/v8/7848
+const prepareStackTrace = (globalThis, error, trace) => {
+ // `globalThis` is the global that contains the constructor which
+ // created `error`.
+ if (typeof globalThis.Error.prepareStackTrace === 'function') {
+ return globalThis.Error.prepareStackTrace(error, trace);
+ }
+ // We still have legacy usage that depends on the main context's `Error`
+ // being used, even when the error is from a different context.
+ // TODO(devsnek): evaluate if this can be eventually deprecated/removed.
+ if (typeof MainContextError.prepareStackTrace === 'function') {
+ return MainContextError.prepareStackTrace(error, trace);
+ }
+
+ const errorString = ErrorToString.call(error);
+ if (trace.length === 0) {
+ return errorString;
+ }
+ return `${errorString}\n at ${trace.join('\n at ')}`;
+};
+
+
 let excludedStackFn;
 
 // Lazily loaded
@@ -598,7 +623,8 @@ module.exports = {
  uvExceptionWithHostPort,
  SystemError,
  // This is exported only to facilitate testing.
- E
+ E,
+ prepareStackTrace,
 };
 
 // To declare an error message, use the E(sym, val, def) function above. The sym

src/api/environment.cc

@@ -13,6 +13,8 @@
 #endif
 
 namespace node {
+using errors::TryCatchScope;
+using v8::Array;
 using v8::Context;
 using v8::EscapableHandleScope;
 using v8::Function;
@@ -45,6 +47,41 @@ static bool ShouldAbortOnUncaughtException(Isolate* isolate) {
  !env->inside_should_not_abort_on_uncaught_scope();
 }
 
+static MaybeLocal<Value> PrepareStackTraceCallback(Local<Context> context,
+ Local<Value> exception,
+ Local<Array> trace) {
+ Environment* env = Environment::GetCurrent(context);
+ if (env == nullptr) {
+ MaybeLocal<String> s = exception->ToString(context);
+ return s.IsEmpty() ?
+ MaybeLocal<Value>() :
+ MaybeLocal<Value>(s.ToLocalChecked());
+ }
+ Local<Function> prepare = env->prepare_stack_trace_callback();
+ if (prepare.IsEmpty()) {
+ MaybeLocal<String> s = exception->ToString(context);
+ return s.IsEmpty() ?
+ MaybeLocal<Value>() :
+ MaybeLocal<Value>(s.ToLocalChecked());
+ }
+ Local<Value> args[] = {
+ context->Global(),
+ exception,
+ trace,
+ };
+ // This TryCatch + Rethrow is required by V8 due to details around exception
+ // handling there. For C++ callbacks, V8 expects a scheduled exception (which
+ // is what ReThrow gives us). Just returning the empty MaybeLocal would leave
+ // us with a pending exception.
+ TryCatchScope try_catch(env);
+ MaybeLocal<Value> result = prepare->Call(
+ context, Undefined(env->isolate()), arraysize(args), args);
+ if (try_catch.HasCaught() && !try_catch.HasTerminated()) {
+ try_catch.ReThrow();
+ }
+ return result;
+}
+
 void* NodeArrayBufferAllocator::Allocate(size_t size) {
  if (zero_fill_field_ || per_process::cli_options->zero_fill_all_buffers)
  return UncheckedCalloc(size);
@@ -166,6 +203,7 @@ void SetIsolateUpForNode(v8::Isolate* isolate, IsolateSettingCategories cat) {
  isolate->SetAbortOnUncaughtExceptionCallback(
  ShouldAbortOnUncaughtException);
  isolate->SetFatalErrorHandler(OnFatalError);
+ isolate->SetPrepareStackTraceCallback(PrepareStackTraceCallback);
  break;
  case IsolateSettingCategories::kMisc:
  isolate->SetMicrotasksPolicy(MicrotasksPolicy::kExplicit);

src/env.h

@@ -402,6 +402,7 @@ constexpr size_t kFsStatsBufferLength = kFsStatsFieldsNumber * 2;
  V(native_module_require, v8::Function) \
  V(performance_entry_callback, v8::Function) \
  V(performance_entry_template, v8::Function) \
+ V(prepare_stack_trace_callback, v8::Function) \
  V(process_object, v8::Object) \
  V(primordials, v8::Object) \
  V(promise_reject_callback, v8::Function) \

src/node_binding.cc

@@ -48,6 +48,7 @@
  V(contextify) \
  V(credentials) \
  V(domain) \
+ V(errors) \
  V(fs) \
  V(fs_event_wrap) \
  V(heap_utils) \

src/node_errors.cc

@@ -17,6 +17,7 @@ using v8::Boolean;
 using v8::Context;
 using v8::Exception;
 using v8::Function;
+using v8::FunctionCallbackInfo;
 using v8::HandleScope;
 using v8::Int32;
 using v8::Isolate;
@@ -767,6 +768,21 @@ void PerIsolateMessageListener(Local<Message> message, Local<Value> error) {
  }
 }
 
+void SetPrepareStackTraceCallback(const FunctionCallbackInfo<Value>& args) {
+ Environment* env = Environment::GetCurrent(args);
+ CHECK(args[0]->IsFunction());
+ env->set_prepare_stack_trace_callback(args[0].As<Function>());
+}
+
+void Initialize(Local<Object> target,
+ Local<Value> unused,
+ Local<Context> context,
+ void* priv) {
+ Environment* env = Environment::GetCurrent(context);
+ env->SetMethod(
+ target, "setPrepareStackTraceCallback", SetPrepareStackTraceCallback);
+}
+
 } // namespace errors
 
 void DecorateErrorStack(Environment* env,
@@ -880,3 +896,5 @@ void FatalException(Isolate* isolate,
 }
 
 } // namespace node
+
+NODE_MODULE_CONTEXT_AWARE_INTERNAL(errors, node::errors::Initialize)

test/parallel/test-bootstrap-modules.js

@@ -9,6 +9,7 @@ const common = require('../common');
 const assert = require('assert');
 
 const expectedModules = new Set([
+ 'Internal Binding errors',
  'Internal Binding async_wrap',
  'Internal Binding buffer',
  'Internal Binding config',