test: cover huge Error.stackTraceLimit values

With --trace-uncaught, large Error.stackTraceLimit values overflowed
when V8 converted the limit into raw CallSiteInfo slots, either
aborting with `Check failed: new_capacity > 0.` or silently dropping
frames from error.stack. The V8 cctest for the fix does not run in the
regular Node.js CI, so cover the behavior from JavaScript as well.

Refs: #66074
Assisted-by: a closed-source coding agent
Signed-off-by: Eliau Elkouby <145869377+eliau2005@users.noreply.github.com>

Author: eliau2005

test/parallel/test-error-stack-trace-limit-overflow.js

@@ -0,0 +1,59 @@
+// Flags: --trace-uncaught
+'use strict';
+
+// Regression test for https://github.com/nodejs/node/issues/66074.
+// When the isolate captures stack traces for uncaught exceptions (as it does
+// with --trace-uncaught or an attached inspector), a large
+// Error.stackTraceLimit used to overflow when converted into a number of raw
+// CallSiteInfo slots. Depending on the value, this either aborted the process
+// with `Check failed: new_capacity > 0.` or silently dropped frames from
+// error.stack.
+
+require('../common');
+const assert = require('assert');
+const { spawnSyncAndExit } = require('../common/child_process');
+
+function recurse(n) {
+  if (n === 0) return new Error('boom');
+  return recurse(n - 1);
+}
+
+function countFrames(limit) {
+  Error.stackTraceLimit = limit;
+  const { stack } = recurse(50);
+  return stack.split('\n').filter((line) => line.startsWith('    at ')).length;
+}
+
+const expected = countFrames(1000);
+assert.ok(expected > 50, `expected more than 50 frames, got ${expected}`);
+
+for (const limit of [
+  // Limit * 6 no longer fits in an int32 (6 raw slots per frame).
+  357913942,
+  // Limit * 5 no longer fits in an int32 (5 raw slots per frame).
+  429496730,
+  // Limit * 6 wraps around to a small positive value.
+  715827883,
+  715827884,
+  // Limit * 5 wraps around to a small positive value.
+  858993460,
+  1073741824,
+  1431655766,
+  2 ** 31 - 1,
+  2 ** 32,
+  Number.MAX_SAFE_INTEGER,
+  Infinity,
+]) {
+  assert.strictEqual(countFrames(limit), expected, `Error.stackTraceLimit = ${limit}`);
+}
+
+// The original reproduction: an uncaught error thrown with an unbounded limit.
+spawnSyncAndExit(process.execPath, [
+  '--trace-uncaught',
+  '--eval',
+  'Error.stackTraceLimit = Infinity; throw new Error("boom");',
+], {
+  status: 1,
+  signal: null,
+  stderr: /^Thrown at:$/m,
+});