timers: fix leak when interpreter shutsdown early

If something creates an unhandled rejection condition we'll end up with
timers being kept alive in C without a way to recover them.

Fix it by keeping the strong reference in JS, so it all goes away when
we destroy the runtime.

.gitignore

@@ -9,3 +9,4 @@ src/js/std.js
 src/version.h
 node_modules/
 docs/api/
+test_dir*/

src/cli.c

@@ -35,10 +35,7 @@ int main(int argc, char **argv) {
 
     int exit_code = TJS_Run(qrt);
 
-    if (exit_code == EXIT_SUCCESS) {
-        // TODO: maybe mark the runtime as aborted and skip some steps?
-        TJS_FreeRuntime(qrt);
-    }
+    TJS_FreeRuntime(qrt);
 
     return exit_code;
 }

src/js/polyfills/base.js

@@ -1,11 +1,7 @@
-const core = globalThis.__bootstrap;
+import './timers.js';
 
 import queueMicrotask from 'queue-microtask';
 
-globalThis.setTimeout = core.setTimeout;
-globalThis.clearTimeout = core.clearTimeout;
-globalThis.setInterval = core.setInterval;
-globalThis.clearInterval = core.clearInterval;
 globalThis.queueMicrotask = queueMicrotask;
 
 Object.defineProperty(globalThis, 'global', {

src/js/polyfills/timers.js

@@ -0,0 +1,29 @@
+const core = globalThis.__bootstrap;
+
+const timers = new Set();
+
+globalThis.setTimeout = (fn, ms) => {
+    const t = core.setTimeout(fn, ms);
+
+    timers.add(t);
+
+    return t;
+};
+
+globalThis.clearTimeout = t => {
+    core.clearTimeout(t);
+    timers.delete(t);
+};
+
+globalThis.setInterval = (fn, ms) => {
+    const t = core.setInterval(fn, ms);
+
+    timers.add(t);
+
+    return t;
+};
+
+globalThis.clearInterval = t => {
+    core.clearInterval(t);
+    timers.delete(t);
+};

src/timers.c

@@ -30,7 +30,6 @@ typedef struct {
     JSContext *ctx;
     uv_timer_t handle;
     int interval;
-    JSValue obj;
     JSValue func;
     int argc;
     JSValue argv[];
@@ -47,10 +46,6 @@ static void clear_timer(TJSTimer *th) {
         th->argv[i] = JS_UNDEFINED;
     }
     th->argc = 0;
-
-    JSValue obj = th->obj;
-    th->obj = JS_UNDEFINED;
-    JS_FreeValue(ctx, obj);
 }
 
 static void call_timer(TJSTimer *th) {
@@ -145,7 +140,6 @@ static JSValue tjs_setTimeout(JSContext *ctx, JSValueConst this_val, int argc, J
     CHECK_EQ(uv_timer_init(tjs_get_loop(ctx), &th->handle), 0);
     th->handle.data = th;
     th->interval = magic;
-    th->obj = JS_DupValue(ctx, obj);
     th->func = JS_DupValue(ctx, func);
     th->argc = nargs;
     for (int i = 0; i < nargs; i++)

tests/helpers/timers.js

@@ -0,0 +1,13 @@
+async function foo() {
+    throw new Error('oops!');
+}
+
+
+setTimeout(async () => {
+    await foo();
+}, 100);
+
+
+setTimeout(() => {
+    console.log('boooo!');
+}, 99999);

tests/test-timer-leak.js

@@ -0,0 +1,16 @@
+import assert from 'tjs:assert';
+import path from 'tjs:path';
+
+
+const args = [
+    tjs.exepath,
+    'run',
+    path.join(import.meta.dirname, 'helpers', 'timers.js')
+];
+const proc = tjs.spawn(args, { stdout: 'ignore', stderr: 'pipe' });
+const buf = new Uint8Array(4096);
+const nread = await proc.stderr.read(buf);
+const stderrStr = new TextDecoder().decode(buf.subarray(0, nread));
+const status = await proc.wait();
+assert.ok(stderrStr.match(/Error: oops!/) !== null, 'dumps to stderr');
+assert.ok(status.exit_status !== 0 && status.term_signal === null, 'succeeded');