typenative 0.1.3 → 0.2.0

package/bin/node/assert.js

@@ -0,0 +1,344 @@
+// node:assert (+ node:assert/strict): failures throw an AssertionError
+// (code 'ERR_ASSERTION', actual / expected / operator) that try/catch sees
+import { defineClass, defineHelper, defineModule, setResults, isFunctionNode, isObjectLiteral } from './registry.js';
+const assertHelper = `// node:assert
+func tnAssertionError(message interface{}, generated string, actual interface{}, expected interface{}, operator string) *TnError {
+	if e, ok := message.(*TnError); ok {
+		panic(e)
+	}
+	text, isGenerated := generated, true
+	if s, ok := message.(string); ok {
+		text, isGenerated = s, false
+	}
+	err := TnNodeError("AssertionError", "ERR_ASSERTION", text)
+	err.props["actual"] = actual
+	err.props["expected"] = expected
+	err.props["operator"] = operator
+	err.props["generatedMessage"] = isGenerated
+	return err
+}
+
+func tnAssertMessage(msg []interface{}) interface{} {
+	if len(msg) > 0 {
+		return msg[0]
+	}
+	return nil
+}
+
+func TnAssertOk(value interface{}, msg ...interface{}) {
+	if !TnTruthy(value) {
+		panic(tnAssertionError(tnAssertMessage(msg), "The expression evaluated to a falsy value", value, true, "=="))
+	}
+}
+
+// Object.is
+func tnObjectIs(a interface{}, b interface{}) bool {
+	if x, ok := a.(float64); ok {
+		if y, ok := b.(float64); ok {
+			if math.IsNaN(x) && math.IsNaN(y) {
+				return true
+			}
+			if x == 0 && y == 0 {
+				return math.Signbit(x) == math.Signbit(y)
+			}
+			return x == y
+		}
+		return false
+	}
+	return TnSame(a, b)
+}
+
+// ==, for assert.equal
+func tnLooseEqual(a interface{}, b interface{}) bool {
+	if a == nil || b == nil {
+		return a == nil && b == nil
+	}
+	if TnSame(a, b) {
+		x, isFloat := a.(float64)
+		return !isFloat || !math.IsNaN(x)
+	}
+	_, aStr := a.(string)
+	_, bStr := b.(string)
+	_, aNum := a.(float64)
+	_, bNum := b.(float64)
+	_, aBool := a.(bool)
+	_, bBool := b.(bool)
+	if (aStr || aNum || aBool) && (bStr || bNum || bBool) {
+		return TnNumber(a) == TnNumber(b)
+	}
+	return false
+}
+
+func TnAssertStrictEqual(actual interface{}, expected interface{}, msg ...interface{}) {
+	if !tnObjectIs(actual, expected) {
+		panic(tnAssertionError(tnAssertMessage(msg), "Expected values to be strictly equal:\\n\\n"+TnInspect(actual)+" !== "+TnInspect(expected)+"\\n", actual, expected, "strictEqual"))
+	}
+}
+
+func TnAssertNotStrictEqual(actual interface{}, expected interface{}, msg ...interface{}) {
+	if tnObjectIs(actual, expected) {
+		panic(tnAssertionError(tnAssertMessage(msg), "Expected \\"actual\\" to be strictly unequal to: "+TnInspect(expected), actual, expected, "notStrictEqual"))
+	}
+}
+
+func TnAssertEqual(actual interface{}, expected interface{}, msg ...interface{}) {
+	if !tnLooseEqual(actual, expected) {
+		panic(tnAssertionError(tnAssertMessage(msg), TnInspect(actual)+" == "+TnInspect(expected), actual, expected, "=="))
+	}
+}
+
+func TnAssertNotEqual(actual interface{}, expected interface{}, msg ...interface{}) {
+	if tnLooseEqual(actual, expected) {
+		panic(tnAssertionError(tnAssertMessage(msg), TnInspect(actual)+" != "+TnInspect(expected), actual, expected, "!="))
+	}
+}
+
+func TnAssertDeepEqual(actual interface{}, expected interface{}, strict bool, msg ...interface{}) {
+	if !TnDeepEqual(actual, expected, strict) {
+		operator, label := "deepEqual", "Expected values to be loosely deep-equal:"
+		if strict {
+			operator, label = "deepStrictEqual", "Expected values to be strictly deep-equal:"
+		}
+		panic(tnAssertionError(tnAssertMessage(msg), label+"\\n\\n"+TnInspect(actual)+"\\n\\nshould equal\\n\\n"+TnInspect(expected), actual, expected, operator))
+	}
+}
+
+func TnAssertNotDeepEqual(actual interface{}, expected interface{}, strict bool, msg ...interface{}) {
+	if TnDeepEqual(actual, expected, strict) {
+		operator := "notDeepEqual"
+		if strict {
+			operator = "notDeepStrictEqual"
+		}
+		panic(tnAssertionError(tnAssertMessage(msg), "Expected \\"actual\\" not to be deep-equal to: "+TnInspect(expected), actual, expected, operator))
+	}
+}
+
+// The text an error is matched against by a RegExp: "Name: message"
+func TnErrorText(e interface{}) string {
+	if err, ok := e.(*TnError); ok {
+		return err.Get_name() + ": " + err.message
+	}
+	if s, ok := e.(string); ok {
+		return s
+	}
+	if msg, ok := TnGet(e, "message").(string); ok {
+		return "Error: " + msg
+	}
+	return fmt.Sprint(e)
+}
+
+// { message, code, name } validation objects: every listed property must match
+func TnErrorMatches(e interface{}, expected map[string]interface{}) bool {
+	for key, want := range expected {
+		got := TnGet(e, key)
+		if key == "message" {
+			if _, ok := e.(*TnError); !ok {
+				if m, ok := TnGet(e, "message").(string); ok {
+					got = m
+				}
+			}
+		}
+		if re, ok := want.(*regexp.Regexp); ok {
+			s, _ := got.(string)
+			if !re.MatchString(s) {
+				return false
+			}
+			continue
+		}
+		if !TnDeepEqual(got, want, true) {
+			return false
+		}
+	}
+	return true
+}
+
+func tnAssertRun(fn func()) (thrown interface{}, didThrow bool) {
+	defer func() {
+		if r := recover(); r != nil {
+			thrown, didThrow = r, true
+		}
+	}()
+	fn()
+	return nil, false
+}
+
+func TnAssertThrows(fn func(), check func(interface{}) bool, msg ...interface{}) {
+	thrown, didThrow := tnAssertRun(fn)
+	if !didThrow {
+		generated := "Missing expected exception."
+		if s, ok := tnAssertMessage(msg).(string); ok {
+			generated = "Missing expected exception: " + s
+		}
+		panic(tnAssertionError(nil, generated, nil, nil, "throws"))
+	}
+	if check != nil && !check(thrown) {
+		panic(thrown)
+	}
+}
+
+func TnAssertDoesNotThrow(fn func(), msg ...interface{}) {
+	thrown, didThrow := tnAssertRun(fn)
+	if didThrow {
+		generated := "Got unwanted exception.\\nActual message: \\"" + TnErrorText(thrown) + "\\""
+		panic(tnAssertionError(tnAssertMessage(msg), generated, thrown, nil, "doesNotThrow"))
+	}
+}
+
+// assert.rejects / doesNotReject: promises settle on their own goroutine
+func TnAssertRejects[T any](p chan T, check func(interface{}) bool, msg ...interface{}) chan struct{} {
+	out := make(chan struct{}, 1)
+	go func() {
+		defer close(out)
+		defer TnRejectOnPanic(out)
+		_, reason, rejected := tnSettle(p)
+		if !rejected {
+			generated := "Missing expected rejection."
+			if s, ok := tnAssertMessage(msg).(string); ok {
+				generated = "Missing expected rejection: " + s
+			}
+			panic(tnAssertionError(nil, generated, nil, nil, "rejects"))
+		}
+		if check != nil && !check(reason) {
+			panic(reason)
+		}
+		out <- struct{}{}
+	}()
+	return out
+}
+
+func TnAssertDoesNotReject[T any](p chan T, msg ...interface{}) chan struct{} {
+	out := make(chan struct{}, 1)
+	go func() {
+		defer close(out)
+		defer TnRejectOnPanic(out)
+		_, reason, rejected := tnSettle(p)
+		if rejected {
+			panic(tnAssertionError(tnAssertMessage(msg), "Got unwanted rejection.\\nActual message: \\""+TnErrorText(reason)+"\\"", reason, nil, "doesNotReject"))
+		}
+		out <- struct{}{}
+	}()
+	return out
+}
+
+func TnAssertMatch(s string, re *regexp.Regexp, negate bool, msg ...interface{}) {
+	if re.MatchString(s) == negate {
+		generated := "The input did not match the regular expression /" + re.String() + "/. Input:\\n\\n" + TnInspect(s) + "\\n"
+		operator := "match"
+		if negate {
+			generated = "The input was expected to not match the regular expression /" + re.String() + "/. Input:\\n\\n" + TnInspect(s) + "\\n"
+			operator = "doesNotMatch"
+		}
+		panic(tnAssertionError(tnAssertMessage(msg), generated, s, re, operator))
+	}
+}
+
+func TnAssertFail(msg ...interface{}) {
+	panic(tnAssertionError(tnAssertMessage(msg), "Failed", nil, nil, "fail"))
+}
+
+func TnAssertIfError(v interface{}) {
+	if v != nil {
+		panic(tnAssertionError(nil, "ifError got unwanted exception: "+TnErrorText(v), v, nil, "ifError"))
+	}
+}`;
+// The error validator of throws / rejects: (e) => bool in Go, or 'nil'
+function errorCheck(r, node, arg, type) {
+    if (!node)
+        return 'nil';
+    if (type === '*regexp.Regexp')
+        return `func(e interface{}) bool { return ${arg}.MatchString(TnErrorText(e)) }`;
+    if (isFunctionNode(node))
+        return `func(e interface{}) bool { return TnTruthy((${arg})(e)) }`;
+    if (isObjectLiteral(node)) {
+        const fields = [];
+        for (const prop of node.properties ?? []) {
+            if (prop.kind !== 'PropertyAssignment' || !prop.name)
+                continue;
+            fields.push(`${JSON.stringify(String(prop.name.text))}: ${r.visit(prop.initializer)}`);
+        }
+        return `func(e interface{}) bool { return TnErrorMatches(e, map[string]interface{}{${fields.join(', ')}}) }`;
+    }
+    if (node.kind === 'Identifier') {
+        const name = String(node.text);
+        if (name === 'Error')
+            return 'func(e interface{}) bool { return TnIsNativeError(e) }';
+        if (['TypeError', 'RangeError', 'SyntaxError', 'ReferenceError', 'EvalError', 'URIError'].includes(name)) {
+            return `func(e interface{}) bool { err, ok := e.(*TnError); return ok && err.Get_name() == ${JSON.stringify(name)} }`;
+        }
+        return `func(e interface{}) bool { _, ok := e.(*${name}); return ok }`;
+    }
+    return 'nil';
+}
+// The message argument of throws(fn, [expected], [message]) when expected is a string
+function throwsArgs(r, call, from) {
+    const node = call.nodes[from];
+    if (node && call.types[from] === 'string') {
+        return `nil, ${call.args[from]}`;
+    }
+    const check = errorCheck(r, node, call.args[from] ?? '', call.types[from]);
+    const message = call.args[from + 1];
+    return message ? `${check}, ${message}` : check;
+}
+export function registerAssert(r) {
+    defineModule(r, 'assert');
+    defineModule(r, 'assert/strict');
+    defineHelper(r, 'nodeAssert', ['fmt', 'math', 'regexp'], ['error', 'dynamic', 'nodeUtil', 'promise'], assertHelper);
+    // AssertionError is a TnError (see NodeJS.ErrnoException); keep that the class of *TnError
+    const errnoKey = r.classByGoType['*TnError'];
+    defineClass(r, 'assert.AssertionError', '*TnError', 'class', '', 'message=string; code=string', 'name=string; actual=interface{}; expected=interface{}; operator=string; generatedMessage=bool', '');
+    if (errnoKey)
+        r.classByGoType['*TnError'] = errnoKey;
+    r.classes['assert/strict.AssertionError'] = r.classes['assert.AssertionError'];
+    r.namespaces['assert.strict'] = 'assert/strict';
+    r.namespaces['assert/strict.strict'] = 'assert/strict';
+    for (const mod of ['assert', 'assert/strict']) {
+        const strict = mod === 'assert/strict';
+        const fn = (name, emit) => {
+            r.functions[`${mod}.${name}`] = (call) => {
+                r.helper('nodeAssert');
+                return emit(call);
+            };
+            r.results[`${mod}.${name}`] = '';
+        };
+        const ok = (call) => `TnAssertOk(${call.args.join(', ')})`;
+        r.functions[mod] = (call) => {
+            r.helper('nodeAssert');
+            return ok(call);
+        };
+        fn('ok', ok);
+        fn('equal', (c) => (strict ? `TnAssertStrictEqual(${c.args.join(', ')})` : `TnAssertEqual(${c.args.join(', ')})`));
+        fn('notEqual', (c) => (strict ? `TnAssertNotStrictEqual(${c.args.join(', ')})` : `TnAssertNotEqual(${c.args.join(', ')})`));
+        fn('strictEqual', (c) => `TnAssertStrictEqual(${c.args.join(', ')})`);
+        fn('notStrictEqual', (c) => `TnAssertNotStrictEqual(${c.args.join(', ')})`);
+        const deep = (s, negate) => (c) => {
+            const rest = c.args.slice(2);
+            const tail = rest.length > 0 ? `, ${rest.join(', ')}` : '';
+            return `${negate ? 'TnAssertNotDeepEqual' : 'TnAssertDeepEqual'}(${c.args[0]}, ${c.args[1]}, ${s ? 'true' : 'false'}${tail})`;
+        };
+        fn('deepEqual', deep(strict, false));
+        fn('notDeepEqual', deep(strict, true));
+        fn('deepStrictEqual', deep(true, false));
+        fn('notDeepStrictEqual', deep(true, true));
+        fn('throws', (c) => `TnAssertThrows(func() { (${c.args[0]})() }, ${throwsArgs(r, c, 1)})`);
+        fn('doesNotThrow', (c) => {
+            const message = c.types[1] === 'string' ? `, ${c.args[1]}` : c.args[2] ? `, ${c.args[2]}` : '';
+            return `TnAssertDoesNotThrow(func() { (${c.args[0]})() }${message})`;
+        });
+        const promiseArg = (c) => (isFunctionNode(c.nodes[0]) || c.types[0].startsWith('func(') ? `(${c.args[0]})()` : c.args[0]);
+        fn('rejects', (c) => `TnAssertRejects(${promiseArg(c)}, ${throwsArgs(r, c, 1)})`);
+        fn('doesNotReject', (c) => {
+            const message = c.types[1] === 'string' ? `, ${c.args[1]}` : c.args[2] ? `, ${c.args[2]}` : '';
+            return `TnAssertDoesNotReject(${promiseArg(c)}${message})`;
+        });
+        r.results[`${mod}.rejects`] = 'chan struct{}';
+        r.results[`${mod}.doesNotReject`] = 'chan struct{}';
+        fn('match', (c) => `TnAssertMatch(${c.args[0]}, ${c.args[1]}, false${c.args[2] ? `, ${c.args[2]}` : ''})`);
+        fn('doesNotMatch', (c) => `TnAssertMatch(${c.args[0]}, ${c.args[1]}, true${c.args[2] ? `, ${c.args[2]}` : ''})`);
+        fn('fail', (c) => `TnAssertFail(${c.args.slice(0, 1).join(', ')})`);
+        fn('ifError', (c) => `TnAssertIfError(${c.args[0]})`);
+        for (const name of ['throws', 'rejects', 'doesNotThrow', 'doesNotReject']) {
+            r.paramTypers[`${mod}.${name}`] = (_n) => ['interface{}'];
+        }
+        setResults(r, mod, '');
+    }
+}

package/bin/node/async_hooks.js

@@ -0,0 +1,273 @@
+// node:async_hooks — AsyncLocalStorage and AsyncResource on the event loop's
+// async context (TnAsyncContext): the stores active when a callback is
+// scheduled (timers, immediates, nextTick, microtasks, promise callbacks,
+// async function bodies, fs / dns callbacks, streams, sockets and servers)
+// are active again when it runs, and an await resumes with its own stores.
+// createHook is accepted but its callbacks are never called; executionAsyncId
+// is always 1 (ids are not tracked).
+import { defineClass, defineHelper, defineModule, setResults } from './registry.js';
+const asyncHooksHelper = `// node:async_hooks
+type TnAsyncLocalStorage struct {
+	name string
+}
+
+func TnNewAsyncLocalStorage(options ...interface{}) *TnAsyncLocalStorage {
+	als := &TnAsyncLocalStorage{}
+	if len(options) > 0 && options[0] != nil {
+		if n, ok := TnGet(options[0], "name").(string); ok {
+			als.name = n
+		}
+	}
+	return als
+}
+
+func (als *TnAsyncLocalStorage) Get_name() string { return als.name }
+
+// A copy of the current context with key set to store (nil removes it)
+func tnAsyncWith(key interface{}, store interface{}, remove bool) TnAsyncContext {
+	ctx := TnAsyncContext{}
+	for k, v := range tnAsyncCtx {
+		ctx[k] = v
+	}
+	if remove {
+		delete(ctx, key)
+	} else {
+		ctx[key] = store
+	}
+	if len(ctx) == 0 {
+		return nil
+	}
+	return ctx
+}
+
+func (als *TnAsyncLocalStorage) getStore() interface{} {
+	if tnAsyncCtx == nil {
+		return nil
+	}
+	return tnAsyncCtx[als]
+}
+
+func (als *TnAsyncLocalStorage) enterWith(store interface{}) {
+	tnAsyncCtx = tnAsyncWith(als, store, false)
+}
+
+func (als *TnAsyncLocalStorage) disable() {
+	tnAsyncCtx = tnAsyncWith(als, nil, true)
+}
+
+// run(store, fn): fn's result; fn (and everything it schedules) sees store
+func TnAlsRun[R any](als *TnAsyncLocalStorage, store interface{}, fn func() R) R {
+	var out R
+	TnAsyncRun(tnAsyncWith(als, store, false), func() { out = fn() })
+	return out
+}
+
+func TnAlsRunVoid(als *TnAsyncLocalStorage, store interface{}, fn func()) {
+	TnAsyncRun(tnAsyncWith(als, store, false), fn)
+}
+
+func TnAlsRunAny(als *TnAsyncLocalStorage, store interface{}, fn interface{}, args ...interface{}) interface{} {
+	var out interface{}
+	TnAsyncRun(tnAsyncWith(als, store, false), func() { out = TnInvoke(fn, args...) })
+	return out
+}
+
+func TnAlsExit[R any](als *TnAsyncLocalStorage, fn func() R) R {
+	var out R
+	TnAsyncRun(tnAsyncWith(als, nil, true), func() { out = fn() })
+	return out
+}
+
+func TnAlsExitVoid(als *TnAsyncLocalStorage, fn func()) {
+	TnAsyncRun(tnAsyncWith(als, nil, true), fn)
+}
+
+// A function of any type that runs in ctx
+func tnAsyncBindTo[F any](ctx TnAsyncContext, fn F) F {
+	fv := reflect.ValueOf(fn)
+	if !fv.IsValid() || fv.Kind() != reflect.Func || fv.IsNil() {
+		return fn
+	}
+	bound := reflect.MakeFunc(fv.Type(), func(in []reflect.Value) []reflect.Value {
+		var out []reflect.Value
+		TnAsyncRun(ctx, func() {
+			if fv.Type().IsVariadic() {
+				out = fv.CallSlice(in)
+			} else {
+				out = fv.Call(in)
+			}
+		})
+		return out
+	})
+	return bound.Interface().(F)
+}
+
+// AsyncLocalStorage.bind(fn) / AsyncResource.bind(fn): fn bound to the current context
+func TnAsyncBind[F any](fn F) F { return tnAsyncBindTo(tnAsyncCtx, fn) }
+
+// AsyncLocalStorage.snapshot(): runs functions in the current context
+func TnAsyncSnapshotRunner() func(fn interface{}, args ...interface{}) interface{} {
+	ctx := tnAsyncCtx
+	return func(fn interface{}, args ...interface{}) interface{} {
+		var out interface{}
+		TnAsyncRun(ctx, func() { out = TnInvoke(fn, args...) })
+		return out
+	}
+}
+
+var tnAsyncIDs float64 = 1
+
+// AsyncResource: a context captured at construction
+type TnAsyncResource struct {
+	type_     string
+	id        float64
+	triggerID float64
+	ctx       TnAsyncContext
+}
+
+func TnNewAsyncResource(kind string, options ...interface{}) *TnAsyncResource {
+	tnAsyncIDs++
+	res := &TnAsyncResource{type_: kind, id: tnAsyncIDs, triggerID: 1, ctx: tnAsyncCtx}
+	if len(options) > 0 && options[0] != nil {
+		if n, ok := tnNetNumberAsync(TnGet(options[0], "triggerAsyncId")); ok {
+			res.triggerID = n
+		}
+	}
+	return res
+}
+
+func tnNetNumberAsync(v interface{}) (float64, bool) {
+	switch n := v.(type) {
+	case float64:
+		return n, true
+	case int:
+		return float64(n), true
+	}
+	return 0, false
+}
+
+func (res *TnAsyncResource) asyncId() float64        { return res.id }
+func (res *TnAsyncResource) triggerAsyncId() float64 { return res.triggerID }
+func (res *TnAsyncResource) emitDestroy() *TnAsyncResource { return res }
+
+func TnAsyncResourceRun[R any](res *TnAsyncResource, fn func() R) R {
+	var out R
+	TnAsyncRun(res.ctx, func() { out = fn() })
+	return out
+}
+
+func TnAsyncResourceRunVoid(res *TnAsyncResource, fn func()) {
+	TnAsyncRun(res.ctx, fn)
+}
+
+func TnAsyncResourceBind[F any](res *TnAsyncResource, fn F) F { return tnAsyncBindTo(res.ctx, fn) }
+
+// createHook: accepted, its callbacks are not called
+type TnAsyncHook struct {
+	enabled bool
+}
+
+func (h *TnAsyncHook) enable() *TnAsyncHook {
+	h.enabled = true
+	return h
+}
+
+func (h *TnAsyncHook) disable() *TnAsyncHook {
+	h.enabled = false
+	return h
+}`;
+// The result type of a Go func type ('func(a string) float64' → 'float64', '' for none)
+export function goFuncResult(goType) {
+    if (!goType || !goType.startsWith('func('))
+        return '';
+    let depth = 0;
+    for (let i = 4; i < goType.length; i++) {
+        const ch = goType[i];
+        if (ch === '(')
+            depth++;
+        else if (ch === ')') {
+            depth--;
+            if (depth === 0)
+                return goType.substring(i + 1).trim();
+        }
+    }
+    return '';
+}
+// Calls fn with the extra arguments inside a zero-argument closure
+export function closure(fn, fnType, extra) {
+    if (extra.length === 0 && fnType.startsWith('func()'))
+        return fn;
+    const result = goFuncResult(fnType);
+    const call = `(${fn})(${extra.join(', ')})`;
+    return result ? `func() ${result} { return ${call} }` : `func() { ${call} }`;
+}
+export function registerAsyncHooks(r) {
+    defineModule(r, 'async_hooks');
+    defineHelper(r, 'nodeAsyncHooks', ['reflect'], ['eventLoop', 'dynamic', 'nodeInvoke'], asyncHooksHelper);
+    const use = () => r.helper('nodeAsyncHooks');
+    defineClass(r, 'async_hooks.AsyncLocalStorage', '*TnAsyncLocalStorage', 'class', 'getStore=interface{}; enterWith=; disable=', '', 'name=string', '');
+    defineClass(r, 'async_hooks.AsyncResource', '*TnAsyncResource', 'class', 'asyncId=float64; triggerAsyncId=float64; emitDestroy=*TnAsyncResource', '', '', '');
+    defineClass(r, 'async_hooks.AsyncHook', '*TnAsyncHook', 'class', 'enable=*TnAsyncHook; disable=*TnAsyncHook', '', '', '');
+    r.constructors['async_hooks.AsyncLocalStorage'] = (c) => {
+        use();
+        return `TnNewAsyncLocalStorage(${c.args.join(', ')})`;
+    };
+    r.constructors['async_hooks.AsyncResource'] = (c) => {
+        use();
+        return `TnNewAsyncResource(${c.args.join(', ')})`;
+    };
+    // run(store, fn, ...args) / exit(fn, ...args): typed by the callback's result
+    r.methods['async_hooks.AsyncLocalStorage#run'] = (c) => {
+        use();
+        const fnType = c.types[1] || '';
+        if (!fnType.startsWith('func('))
+            return `TnAlsRunAny(${c.recv}, ${c.args.join(', ')})`;
+        const fn = closure(c.args[1], fnType, c.args.slice(2));
+        return goFuncResult(fnType) ? `TnAlsRun(${c.recv}, ${c.args[0]}, ${fn})` : `TnAlsRunVoid(${c.recv}, ${c.args[0]}, ${fn})`;
+    };
+    r.typers['async_hooks.AsyncLocalStorage#run'] = (c) => {
+        const fnType = c.types[1] || '';
+        return fnType.startsWith('func(') ? goFuncResult(fnType) : 'interface{}';
+    };
+    r.methods['async_hooks.AsyncLocalStorage#exit'] = (c) => {
+        use();
+        const fnType = c.types[0] || 'func()';
+        const fn = closure(c.args[0], fnType, c.args.slice(1));
+        return goFuncResult(fnType) ? `TnAlsExit(${c.recv}, ${fn})` : `TnAlsExitVoid(${c.recv}, ${fn})`;
+    };
+    r.typers['async_hooks.AsyncLocalStorage#exit'] = (c) => goFuncResult(c.types[0] || '');
+    r.methods['async_hooks.AsyncResource#runInAsyncScope'] = (c) => {
+        use();
+        const fnType = c.types[0] || 'func()';
+        // runInAsyncScope(fn, thisArg, ...args): thisArg is ignored
+        const fn = closure(c.args[0], fnType, c.args.slice(2));
+        return goFuncResult(fnType) ? `TnAsyncResourceRun(${c.recv}, ${fn})` : `TnAsyncResourceRunVoid(${c.recv}, ${fn})`;
+    };
+    r.typers['async_hooks.AsyncResource#runInAsyncScope'] = (c) => goFuncResult(c.types[0] || '');
+    r.methods['async_hooks.AsyncResource#bind'] = (c) => {
+        use();
+        return `TnAsyncResourceBind(${c.recv}, ${c.args[0]})`;
+    };
+    r.typers['async_hooks.AsyncResource#bind'] = (c) => c.types[0] || 'interface{}';
+    for (const cls of ['AsyncLocalStorage', 'AsyncResource']) {
+        r.functions[`async_hooks.${cls}.bind`] = (c) => {
+            use();
+            return `TnAsyncBind(${c.args[0]})`;
+        };
+        r.typers[`async_hooks.${cls}.bind`] = (c) => c.types[0] || 'interface{}';
+    }
+    r.functions['async_hooks.AsyncLocalStorage.snapshot'] = (_c) => {
+        use();
+        return 'TnAsyncSnapshotRunner()';
+    };
+    r.results['async_hooks.AsyncLocalStorage.snapshot'] = 'func(interface{}, ...interface{}) interface{}';
+    // Execution ids are not tracked: the top-level id (1) everywhere
+    r.functions['async_hooks.executionAsyncId'] = (_c) => '1.0';
+    r.functions['async_hooks.triggerAsyncId'] = (_c) => '0.0';
+    r.functions['async_hooks.executionAsyncResource'] = (_c) => 'interface{}(map[string]interface{}{})';
+    r.functions['async_hooks.createHook'] = (_c) => {
+        use();
+        return '&TnAsyncHook{}';
+    };
+    setResults(r, 'async_hooks', 'executionAsyncId=float64; triggerAsyncId=float64; executionAsyncResource=interface{}; createHook=*TnAsyncHook');
+}