@scriptc/compiler 0.3.5 → 0.4.0

package/dist/frontend/lowering/lower-mock.js

@@ -1,5 +1,6 @@
 /* node:test's mock functions (Node 24.22, lib/internal/test_runner/mock):
- * mock.fn and t.mock.fn, and the fn.mock context's calls, callCount,
+ * mock.fn, mock.method and their t.mock twins, the trackers' restoreAll
+ * and reset, and the fn.mock context's calls, callCount,
  * mockImplementation, mockImplementationOnce, resetCalls and restore.
  *
  * mock.fn(original, implementation?) lowers to the hybrid record
@@ -8,11 +9,21 @@
  * one-time implementation registered for this call index, or the current
  * one, calls it, and appends { arguments, error, result, this } to the
  * calls log before returning or rethrowing. The context's mutating
- * methods are lifted helpers of the same type. */
+ * methods are lifted helpers of the same type.
+ *
+ * mock.method(object, name, implementation?) mocks a function-valued field
+ * of a record: the field gets a second wrapper over the same context, one
+ * that records the object as `this`, and the context's %unmock closure
+ * writes the original back on restore(). Each mock registers a closure
+ * that calls its restore() with its tracker (scr_test.c): the module's
+ * `mock`, or the test's t.mock, which is reset when the test ends. */
 import * as ts from "../ts7/adapter.js";
 import { BOOL, CAUGHT, DYN, F64, UNDEFINED_T, VOID, typeKey, } from "../../ir/ir.js";
-import { countedFor, dynUndefinedExpr, numLit, varRef } from "../../ir/build.js";
+import { countedFor, dynUndefinedExpr, numLit, strLit, varRef } from "../../ir/build.js";
+import { mockType as mockHybridType } from "../mock-shapes.js";
 import { locOf } from "../program.js";
+import { resultIsDiscarded } from "./call-position.js";
+const RESTORE_FN = { kind: "func", params: [], ret: VOID };
 /** The context record's parts, or null when `type` is not a mock context
  * (mock-shapes.ts). */
 function mockContextFields(lowerer, type) {
@@ -23,9 +34,11 @@ function mockContextFields(lowerer, type) {
     const impl = field("%impl");
     const once = field("%once");
     const calls = field("calls");
+    const unmock = field("%unmock");
     if (impl?.kind !== "func" ||
         once?.kind !== "array" ||
         calls?.kind !== "array" ||
+        unmock?.kind !== "array" ||
         field("%original") === undefined)
         return null;
     const call = calls.elem;
@@ -34,7 +47,7 @@ function mockContextFields(lowerer, type) {
     const args = callShape?.fields.find((f) => f.name === "arguments")?.type;
     if (!result || !args)
         return null;
-    return { fn: impl, call, calls, once, onceEntry: once.elem, result, args };
+    return { fn: impl, call, calls, once, onceEntry: once.elem, unmock, result, args };
 }
 export function isMockContextType(lowerer, type) {
     return mockContextFields(lowerer, type) !== null;
@@ -69,9 +82,15 @@ const local = (id, name, type, mutable = false) => ({
     type,
     mutable,
 });
-/** Lifts one function per (context type, role), cached on the lowerer. */
-function liftOnce(lowerer, ctxType, role, build) {
-    const key = `mock.${role}:${ctxType.shapeId}`;
+/** A captured local of a lifted closure. */
+const boxedLocal = (id, name, type) => ({
+    ...local(id, name, type),
+    boxed: true,
+});
+/** Lifts one function per (context type, role), cached on the lowerer.
+ * `owner` overrides the context type's shape as the cache key. */
+function liftOnce(lowerer, ctxType, role, build, owner = ctxType.shapeId) {
+    const key = `mock.${role}:${owner}`;
     const existing = lowerer.assertHelpers.get(key);
     if (existing)
         return existing;
@@ -80,22 +99,31 @@ function liftOnce(lowerer, ctxType, role, build) {
     build(name);
     return name;
 }
-/** `%mock.wrap.N(ctx)`: the closure that records each call into ctx. */
-function mockWrapperFactory(lowerer, ctxType, loc) {
-    return liftOnce(lowerer, ctxType, "wrap", (name) => {
+/** `%mock.wrap.N(ctx)`: the closure that records each call into ctx, with
+ * `this` undefined. `%mock.wrapMethod.N(ctx, this)` records `this`. */
+function mockWrapperFactory(lowerer, ctxType, loc, withThis = false) {
+    return liftOnce(lowerer, ctxType, withThis ? "wrapMethod" : "wrap", (name) => {
         const { fn, call, calls, once, onceEntry, result, args } = mockContextFields(lowerer, ctxType);
         const impl = `${name}.impl`;
         const ctx = () => varRef("ctx.0", ctxType, loc);
+        // A checked-dynamic rest function (mock.fn()'s default type) takes its
+        // arguments as one trailing dyn array, recorded as the call's arguments
+        // and spread into the implementation.
+        const dynRest = fn.rest === true && fn.restAbi === undefined;
         const params = fn.params.map((type, i) => ({ localId: `p${i}.0`, name: `p${i}`, type }));
+        if (dynRest)
+            params.push({ localId: "rest.0", name: "args", type: DYN });
         const paramRefs = () => params.map((p) => varRef(p.localId, p.type, loc));
         const argumentsValue = () => fn.rest
             ? paramRefs()[0]
-            : {
-                kind: "recordLit",
-                fields: paramRefs().map((value, i) => ({ name: String(i), value })),
-                type: args,
-                loc,
-            };
+            : args.kind === "array"
+                ? { kind: "arrayLit", elems: [], type: args, loc }
+                : {
+                    kind: "recordLit",
+                    fields: paramRefs().map((value, i) => ({ name: String(i), value })),
+                    type: args,
+                    loc,
+                };
         const record = (resultValue, error) => ({
             kind: "exprStmt",
             expr: {
@@ -109,7 +137,10 @@ function mockWrapperFactory(lowerer, ctxType, loc) {
                             { name: "arguments", value: argumentsValue() },
                             { name: "error", value: error },
                             { name: "result", value: resultValue },
-                            { name: "this", value: dynUndefinedExpr(loc) },
+                            {
+                                name: "this",
+                                value: withThis ? varRef("this.0", DYN, loc) : dynUndefinedExpr(loc),
+                            },
                         ],
                         type: call,
                         loc,
@@ -147,13 +178,23 @@ function mockWrapperFactory(lowerer, ctxType, loc) {
                 loc,
             };
         };
-        const invoke = {
-            kind: "callValue",
-            callee: varRef("f.0", fn, loc),
-            args: paramRefs(),
-            type: fn.ret,
-            loc,
-        };
+        const invoke = dynRest
+            ? {
+                kind: "dynCall",
+                callee: { kind: "dynFrom", value: varRef("f.0", fn, loc), type: DYN, loc },
+                calleeName: "implementation",
+                args: paramRefs(),
+                spreads: [{ arg: 0, what: "args" }],
+                type: DYN,
+                loc,
+            }
+            : {
+                kind: "callValue",
+                callee: varRef("f.0", fn, loc),
+                args: paramRefs(),
+                type: fn.ret,
+                loc,
+            };
         const tryBody = voidReturn
             ? [
                 { kind: "exprStmt", expr: invoke, loc },
@@ -217,10 +258,14 @@ function mockWrapperFactory(lowerer, ctxType, loc) {
             name: impl,
             params,
             returnType: fn.ret,
-            captures: [{ localId: "ctx.0", name: "ctx", type: ctxType }],
+            captures: [
+                { localId: "ctx.0", name: "ctx", type: ctxType },
+                ...(withThis ? [{ localId: "this.0", name: "this", type: DYN }] : []),
+            ],
             locals: [
                 ...params.map((p) => local(p.localId, p.name, p.type)),
-                { ...local("ctx.0", "ctx", ctxType), boxed: true },
+                boxedLocal("ctx.0", "ctx", ctxType),
+                ...(withThis ? [boxedLocal("this.0", "this", DYN)] : []),
                 local("n.0", "index", F64),
                 local("f.0", "implementation", fn, true),
                 local("i.0", "entry", F64, true),
@@ -242,13 +287,25 @@ function mockWrapperFactory(lowerer, ctxType, loc) {
         });
         lowerer.liftedFns.push({
             name,
-            params: [{ localId: "ctx.0", name: "ctx", type: ctxType }],
+            params: [
+                { localId: "ctx.0", name: "ctx", type: ctxType },
+                ...(withThis ? [{ localId: "this.0", name: "this", type: DYN }] : []),
+            ],
             returnType: fn,
-            locals: [{ ...local("ctx.0", "ctx", ctxType), boxed: true }],
+            locals: [
+                boxedLocal("ctx.0", "ctx", ctxType),
+                ...(withThis ? [boxedLocal("this.0", "this", DYN)] : []),
+            ],
             body: [
                 {
                     kind: "return",
-                    value: { kind: "closure", fnName: impl, captures: ["ctx.0"], type: fn, loc },
+                    value: {
+                        kind: "closure",
+                        fnName: impl,
+                        captures: withThis ? ["ctx.0", "this.0"] : ["ctx.0"],
+                        type: fn,
+                        loc,
+                    },
                     loc,
                 },
             ],
@@ -256,6 +313,138 @@ function mockWrapperFactory(lowerer, ctxType, loc) {
         });
     });
 }
+/** `%mock.restore.N(ctx)`: fn.mock.restore(). A method mock writes the
+ * original back to its object and keeps its implementation; a mock.fn mock
+ * goes back to its original implementation. */
+function mockRestoreHelper(lowerer, ctxType, loc) {
+    const { fn, unmock } = mockContextFields(lowerer, ctxType);
+    return mockHelper(lowerer, ctxType, "restore", [], (ctx) => {
+        const unmockArray = () => recordGet(ctx(), "%unmock", unmock, loc);
+        return [
+            {
+                kind: "if",
+                cond: {
+                    kind: "bin",
+                    op: "===",
+                    left: length(unmockArray(), loc),
+                    right: numLit(0, loc),
+                    type: BOOL,
+                    loc,
+                },
+                then: [recordSet(ctx(), "%impl", recordGet(ctx(), "%original", fn, loc), loc)],
+                else_: [
+                    {
+                        kind: "exprStmt",
+                        expr: {
+                            kind: "callValue",
+                            callee: {
+                                kind: "arrayGet",
+                                arr: unmockArray(),
+                                index: numLit(0, loc),
+                                type: RESTORE_FN,
+                                loc,
+                            },
+                            args: [],
+                            type: VOID,
+                            loc,
+                        },
+                        loc,
+                    },
+                ],
+                loc,
+            },
+        ];
+    }, loc);
+}
+/** `%mock.tracked.N(ctx)`: the closure a tracker keeps, which calls the
+ * mock's restore(). */
+function mockTrackedFactory(lowerer, ctxType, loc) {
+    const restore = mockRestoreHelper(lowerer, ctxType, loc);
+    return liftOnce(lowerer, ctxType, "tracked", (name) => {
+        const impl = `${name}.impl`;
+        lowerer.liftedFns.push({
+            name: impl,
+            params: [],
+            returnType: VOID,
+            captures: [{ localId: "ctx.0", name: "ctx", type: ctxType }],
+            locals: [boxedLocal("ctx.0", "ctx", ctxType)],
+            body: [
+                {
+                    kind: "exprStmt",
+                    expr: {
+                        kind: "call",
+                        callee: restore,
+                        args: [varRef("ctx.0", ctxType, loc)],
+                        type: VOID,
+                        loc,
+                    },
+                    loc,
+                },
+                { kind: "return", value: null, loc },
+            ],
+            loc,
+        });
+        lowerer.liftedFns.push({
+            name,
+            params: [{ localId: "ctx.0", name: "ctx", type: ctxType }],
+            returnType: RESTORE_FN,
+            locals: [boxedLocal("ctx.0", "ctx", ctxType)],
+            body: [
+                {
+                    kind: "return",
+                    value: { kind: "closure", fnName: impl, captures: ["ctx.0"], type: RESTORE_FN, loc },
+                    loc,
+                },
+            ],
+            loc,
+        });
+    });
+}
+/** `%mock.unmock.N(object, original)`: the closure that writes `original`
+ * back to the object's field. */
+function mockUnmockFactory(lowerer, ctxType, objType, field, loc) {
+    const { fn } = mockContextFields(lowerer, ctxType);
+    return liftOnce(lowerer, ctxType, "unmock", (name) => {
+        const impl = `${name}.impl`;
+        const captures = [
+            { localId: "obj.0", name: "object", type: objType },
+            { localId: "orig.0", name: "original", type: fn },
+        ];
+        const boxedLocals = captures.map((c) => boxedLocal(c.localId, c.name, c.type));
+        lowerer.liftedFns.push({
+            name: impl,
+            params: [],
+            returnType: VOID,
+            captures,
+            locals: boxedLocals,
+            body: [
+                recordSet(varRef("obj.0", objType, loc), field, varRef("orig.0", fn, loc), loc),
+                { kind: "return", value: null, loc },
+            ],
+            loc,
+        });
+        lowerer.liftedFns.push({
+            name,
+            params: captures,
+            returnType: RESTORE_FN,
+            locals: boxedLocals,
+            body: [
+                {
+                    kind: "return",
+                    value: {
+                        kind: "closure",
+                        fnName: impl,
+                        captures: ["obj.0", "orig.0"],
+                        type: RESTORE_FN,
+                        loc,
+                    },
+                    loc,
+                },
+            ],
+            loc,
+        });
+    }, `${objType.shapeId}.${JSON.stringify(field)}`);
+}
 /** A VOID helper over the context: `%mock.<role>.N(ctx, ...extra)`. */
 function mockHelper(lowerer, ctxType, role, extra, body, loc) {
     return liftOnce(lowerer, ctxType, role, (name) => {
@@ -277,8 +466,98 @@ function mockHelper(lowerer, ctxType, role, extra, body, loc) {
         });
     });
 }
-/** mock.fn(original, implementation?) and t.mock.fn(...). */
-export function lowerMockFn(lowerer, call, what) {
+/** Registers a mock's restore with its tracker. */
+function trackMock(lowerer, tracker, ctxType, ctx, loc) {
+    const restore = {
+        kind: "call",
+        callee: mockTrackedFactory(lowerer, ctxType, loc),
+        args: [ctx],
+        type: RESTORE_FN,
+        loc,
+    };
+    return {
+        kind: "exprStmt",
+        expr: {
+            kind: "libCall",
+            fn: tracker ? "test.ctxMockTrack" : "test.mockTrack",
+            args: tracker ? [tracker, restore] : [restore],
+            type: VOID,
+            loc,
+        },
+        loc,
+    };
+}
+/** The context record literal of a new mock. */
+function mockContextLiteral(ctxType, fields, implementation, original, unmock, loc) {
+    return {
+        kind: "recordLit",
+        fields: [
+            { name: "%impl", value: implementation },
+            { name: "%once", value: { kind: "arrayLit", elems: [], type: fields.once, loc } },
+            { name: "%original", value: original },
+            { name: "%unmock", value: { kind: "arrayLit", elems: unmock, type: fields.unmock, loc } },
+            { name: "calls", value: { kind: "arrayLit", elems: [], type: fields.calls, loc } },
+        ],
+        type: ctxType,
+        loc,
+    };
+}
+/** The Mock<F> record over a context: { %call: wrapper, mock: context }. */
+function mockRecord(lowerer, mockType, ctxType, ctx, loc) {
+    const { fn } = mockContextFields(lowerer, ctxType);
+    return {
+        kind: "recordLit",
+        fields: [
+            {
+                name: "%call",
+                value: {
+                    kind: "call",
+                    callee: mockWrapperFactory(lowerer, ctxType, loc),
+                    args: [ctx],
+                    type: fn,
+                    loc,
+                },
+            },
+            { name: "mock", value: ctx },
+        ],
+        type: mockType,
+        loc,
+    };
+}
+/** A union return type needs an undefined arm: the calls log records
+ * undefined for calls that throw. */
+function requireUndefinedResultArm(lowerer, fields, call, what) {
+    if (fields.fn.ret.kind === "union" && typeKey(fields.result) !== typeKey(fields.fn.ret)) {
+        lowerer.noLowering(`${what} of a function returning '${lowerer.fmt(fields.fn.ret)}'`, call, "a union return type needs an undefined arm here (the calls log records undefined for calls that throw)");
+    }
+}
+/** `%mock.noop.N`: mock.fn()'s original, Node's `function () {}` — it
+ * returns undefined. Null when the function type's return type cannot hold
+ * undefined. */
+function mockNoopOriginal(lowerer, ctxType, fn, loc) {
+    const voidReturn = fn.ret.kind === "void" || fn.ret.kind === "undefinedT";
+    const undefinedValue = voidReturn ? null : lowerer.wrappedUndefined(fn.ret, loc);
+    if (!voidReturn && !undefinedValue)
+        return null;
+    const name = liftOnce(lowerer, ctxType, "noop", (name) => {
+        const params = fn.params.map((type, i) => ({ localId: `p${i}.0`, name: `p${i}`, type }));
+        if (fn.rest === true && fn.restAbi === undefined)
+            params.push({ localId: "rest.0", name: "args", type: DYN });
+        lowerer.liftedFns.push({
+            name,
+            params,
+            returnType: fn.ret,
+            locals: params.map((p) => local(p.localId, p.name, p.type)),
+            body: [{ kind: "return", value: undefinedValue, loc }],
+            loc,
+        });
+    });
+    return { kind: "closure", fnName: name, captures: [], type: fn, loc };
+}
+/** mock.fn(original?, implementation?) and t.mock.fn(...). Without an
+ * original, the mock's original and implementation are a function that
+ * returns undefined, as in Node. */
+export function lowerMockFn(lowerer, call, what, tracker) {
     const loc = locOf(call);
     const mockType = lowerer.mapTypeOf(lowerer.typeOf(call));
     const shape = mockType?.kind === "record" ? lowerer.shapes.get(mockType.shapeId) : undefined;
@@ -289,70 +568,276 @@ export function lowerMockFn(lowerer, call, what) {
         !shape.fields.some((f) => f.name === "%call") ||
         !ctxType ||
         !isMockContextType(lowerer, ctxType)) {
-        lowerer.noLowering(`${what} of this function type`, call, "mock functions lower for functions with fixed parameters, or a single rest array parameter");
+        lowerer.noLowering(`${what} of this function type`, call, "mock functions lower for functions with fixed parameters, or a single rest array parameter, and an implementation of the same type");
     }
-    const { fn, calls, once, result } = mockContextFields(lowerer, ctxType);
-    if (fn.ret.kind === "union" && typeKey(result) !== typeKey(fn.ret)) {
-        lowerer.noLowering(`${what} of a function returning '${lowerer.fmt(fn.ret)}'`, call, "a union return type needs an undefined arm here (the calls log records undefined for calls that throw)");
+    const fields = mockContextFields(lowerer, ctxType);
+    const { fn } = fields;
+    requireUndefinedResultArm(lowerer, fields, call, what);
+    const args = call.arguments.nodes;
+    if (args.length > 2 || args.some(ts.isSpreadElement)) {
+        lowerer.noLowering(`${what} with ${args.length} arguments`, call, "the supported forms are mock.fn(), mock.fn(original) and mock.fn(original, implementation); mock options have no lowering");
     }
-    const args = call.arguments;
-    if (args.length === 0 || args.length > 2 || args.some(ts.isSpreadElement)) {
-        lowerer.noLowering(`${what} with ${args.length} arguments`, call, "the supported forms are mock.fn(original) and mock.fn(original, implementation); mock.fn() and mock options have no lowering");
+    const noop = args.length === 0 ? mockNoopOriginal(lowerer, ctxType, fn, loc) : null;
+    if (args.length === 0 && !noop) {
+        lowerer.noLowering(`${what}() of a function returning '${lowerer.fmt(fn.ret)}'`, call, "mock.fn() without an original returns undefined: pass an original, or use a function type whose return type includes undefined");
     }
     const stmts = [];
     const originalLocal = lowerer.declareHiddenLocal("%mockOriginal", fn);
     stmts.push({
         kind: "varDecl",
         localId: originalLocal.id,
-        init: lowerer.lowerExprExpecting(args[0], fn),
+        init: noop ?? lowerer.lowerExprExpecting(args[0], fn),
         loc,
     });
     const implementation = args.length === 2
         ? lowerer.lowerExprExpecting(args[1], fn)
         : varRef(originalLocal.id, fn, loc);
     const ctxLocal = lowerer.declareHiddenLocal("%mockContext", ctxType);
+    const ctx = () => varRef(ctxLocal.id, ctxType, loc);
     stmts.push({
         kind: "varDecl",
         localId: ctxLocal.id,
-        init: {
-            kind: "recordLit",
-            fields: [
-                { name: "%impl", value: implementation },
-                { name: "%once", value: { kind: "arrayLit", elems: [], type: once, loc } },
-                { name: "%original", value: varRef(originalLocal.id, fn, loc) },
-                { name: "calls", value: { kind: "arrayLit", elems: [], type: calls, loc } },
-            ],
-            type: ctxType,
-            loc,
-        },
+        init: mockContextLiteral(ctxType, fields, implementation, varRef(originalLocal.id, fn, loc), [], loc),
+        loc,
+    }, trackMock(lowerer, tracker, ctxType, ctx(), loc));
+    return {
+        kind: "seqExpr",
+        stmts,
+        result: mockRecord(lowerer, mockType, ctxType, ctx(), loc),
+        type: mockType,
+        loc,
+    };
+}
+const METHOD_HINT = "mock.method lowers for objects whose type maps to a record (object literals and interface-typed objects) and a function-valued field named by a string literal";
+/** mock.method(object, methodName, implementation?) and t.mock.method. The
+ * field's function type F is the mock's type; an implementation must have
+ * the same type, unless the call's result is discarded. */
+export function lowerMockMethod(lowerer, call, what, tracker) {
+    const loc = locOf(call);
+    const args = call.arguments.nodes;
+    if (args.length < 2 || args.length > 3 || args.some(ts.isSpreadElement)) {
+        lowerer.noLowering(`${what} with ${args.length} arguments`, call, "the supported forms are mock.method(object, methodName) and mock.method(object, methodName, implementation); mock options have no lowering");
+    }
+    const nameArg = args[1];
+    if (!ts.isStringLiteralLike(nameArg)) {
+        lowerer.noLowering(`${what} with a computed method name`, nameArg, METHOD_HINT);
+    }
+    const field = nameArg.text;
+    if (args.length === 3 &&
+        lowerer.checker.getCallSignatures(lowerer.typeOf(args[2])).length === 0) {
+        lowerer.noLowering(`${what} with an options object`, args[2], "mock options (times, getter and setter) have no lowering");
+    }
+    const objType = lowerer.mapTypeOf(lowerer.typeOf(args[0]));
+    const objShape = objType?.kind === "record" ? lowerer.shapes.get(objType.shapeId) : undefined;
+    const fn = objShape?.fields.find((f) => f.name === field)?.type;
+    if (!objType || !objShape || fn?.kind !== "func") {
+        const typeName = ts.symbolNameOf(lowerer.typeOf(args[0]).getSymbol());
+        lowerer.noLowering(typeName && !typeName.startsWith("__")
+            ? `${what} on '${typeName}'`
+            : `${what} on this object`, args[0], METHOD_HINT);
+    }
+    const mockType = mockHybridType(fn, lowerer.typeCtx);
+    const ctxType = mockType?.kind === "record"
+        ? lowerer.shapes.get(mockType.shapeId)?.fields.find((f) => f.name === "mock")?.type
+        : undefined;
+    if (!mockType || !ctxType || !isMockContextType(lowerer, ctxType)) {
+        lowerer.noLowering(`${what} of a '${lowerer.fmt(fn)}' method`, call, "mock functions lower for functions with fixed parameters, or a single rest array parameter");
+    }
+    if (!resultIsDiscarded(call)) {
+        const resultType = lowerer.mapTypeOf(lowerer.typeOf(call));
+        if (!resultType || typeKey(resultType) !== typeKey(mockType)) {
+            lowerer.noLowering(`${what} with an implementation of another type`, args[2] ?? call, "give the implementation the method's parameter and return types, or discard the result");
+        }
+    }
+    const fields = mockContextFields(lowerer, ctxType);
+    requireUndefinedResultArm(lowerer, fields, call, what);
+    const stmts = [];
+    const objLocal = lowerer.declareHiddenLocal("%mockObject", objType);
+    const obj = () => varRef(objLocal.id, objType, loc);
+    stmts.push({ kind: "varDecl", localId: objLocal.id, init: lowerer.lowerExpr(args[0]), loc });
+    const originalLocal = lowerer.declareHiddenLocal("%mockOriginal", fn);
+    const original = () => varRef(originalLocal.id, fn, loc);
+    stmts.push({
+        kind: "varDecl",
+        localId: originalLocal.id,
+        init: recordGet(obj(), field, fn, loc),
         loc,
     });
-    const factory = mockWrapperFactory(lowerer, ctxType, loc);
+    const implementation = args.length === 3 ? lowerer.lowerExprExpecting(args[2], fn) : original();
+    const unmock = {
+        kind: "call",
+        callee: mockUnmockFactory(lowerer, ctxType, objType, field, loc),
+        args: [obj(), original()],
+        type: RESTORE_FN,
+        loc,
+    };
+    const ctxLocal = lowerer.declareHiddenLocal("%mockContext", ctxType);
+    const ctx = () => varRef(ctxLocal.id, ctxType, loc);
+    stmts.push({
+        kind: "varDecl",
+        localId: ctxLocal.id,
+        init: mockContextLiteral(ctxType, fields, implementation, original(), [unmock], loc),
+        loc,
+    }, trackMock(lowerer, tracker, ctxType, ctx(), loc), 
+    // The object's field: the wrapper that records the object as `this`.
+    recordSet(obj(), field, {
+        kind: "call",
+        callee: mockWrapperFactory(lowerer, ctxType, loc, true),
+        args: [ctx(), lowerer.coerceToExpected(obj(), DYN)],
+        type: fn,
+        loc,
+    }, loc));
     return {
         kind: "seqExpr",
         stmts,
-        result: {
-            kind: "recordLit",
-            fields: [
-                {
-                    name: "%call",
-                    value: {
-                        kind: "call",
-                        callee: factory,
-                        args: [varRef(ctxLocal.id, ctxType, loc)],
-                        type: fn,
-                        loc,
-                    },
-                },
-                { name: "mock", value: varRef(ctxLocal.id, ctxType, loc) },
-            ],
-            type: mockType,
-            loc,
-        },
+        result: mockRecord(lowerer, mockType, ctxType, ctx(), loc),
         type: mockType,
         loc,
     };
 }
+/** The trackers' restoreAll() and reset(): `mock.restoreAll()`,
+ * `t.mock.reset()`. */
+export function lowerMockTrackerCall(lowerer, call, member, tracker) {
+    if (call.arguments.nodes.length > 0) {
+        lowerer.noLowering(`MockTracker.${member} with ${call.arguments.nodes.length} arguments`, call);
+    }
+    const fn = tracker
+        ? member === "reset"
+            ? "test.ctxMockReset"
+            : "test.ctxMockRestoreAll"
+        : member === "reset"
+            ? "test.mockReset"
+            : "test.mockRestoreAll";
+    return {
+        kind: "libCall",
+        fn,
+        args: tracker ? [tracker] : [],
+        type: VOID,
+        loc: locOf(call),
+    };
+}
+const MOCK_TIMERS_HINT = "enable, tick, runAll, reset and setTime are the supported mock.timers members";
+const MOCK_TIMERS_APIS_HINT = "list the mocked APIs as string literals: enable({ apis: ['setTimeout', 'Date'] })";
+/** The codes scr_test.c reads for the APIs enable() mocks, in Node's
+ * SUPPORTED_APIS order. */
+const MOCK_TIMERS_API_CODES = {
+    setTimeout: "T",
+    setInterval: "I",
+    setImmediate: "M",
+    Date: "D",
+    "scheduler.wait": "W",
+    "AbortSignal.timeout": "A",
+};
+/** enable() and enable({ now }) without `apis` mock every API. */
+const MOCK_TIMERS_ALL_APIS = "TIMDWA";
+/** `mock.timers.enable(...)` and the other MockTimers members, on the
+ * module's `mock` (tracker null) and t.mock. enable() takes no options or
+ * an object literal whose `apis`, when given, is an array literal of API
+ * names. */
+export function lowerMockTimersCall(lowerer, call, member, what, tracker, sym) {
+    const loc = locOf(call);
+    const args = call.arguments.nodes;
+    const optionalNumber = (fallback) => {
+        if (args.length > 1)
+            lowerer.noLowering(`${what}.${member} with ${args.length} arguments`, call);
+        return [args.length === 1 ? lowerer.lowerExprExpecting(args[0], F64) : numLit(fallback, loc)];
+    };
+    if (!["enable", "tick", "setTime", "runAll", "reset"].includes(member)) {
+        lowerer.noLowering(`${what}.${member}`, call, MOCK_TIMERS_HINT, sym);
+    }
+    // The receiver evaluates before the arguments.
+    const t = tracker();
+    let rest;
+    switch (member) {
+        case "enable":
+            rest = lowerMockTimersOptions(lowerer, call, what);
+            break;
+        case "tick":
+            rest = optionalNumber(1);
+            break;
+        case "setTime":
+            rest = optionalNumber(0);
+            break;
+        default:
+            if (args.length > 0) {
+                lowerer.noLowering(`${what}.${member} with ${args.length} arguments`, call);
+            }
+            rest = [];
+    }
+    const name = member[0].toUpperCase() + member.slice(1);
+    return {
+        kind: "libCall",
+        fn: (t ? `test.ctxMockTimers${name}` : `test.mockTimers${name}`),
+        args: t ? [t, ...rest] : rest,
+        type: VOID,
+        loc,
+    };
+}
+/** enable()'s { apis, now } as the libCall's API codes, `now` and flags
+ * (1 = `now` given, 2 = it is a Date). */
+function lowerMockTimersOptions(lowerer, call, what) {
+    const loc = locOf(call);
+    const options = call.arguments.nodes[0];
+    if (call.arguments.nodes.length > 1) {
+        lowerer.noLowering(`${what}.enable with ${call.arguments.nodes.length} arguments`, call);
+    }
+    if (options === undefined) {
+        return [strLit(MOCK_TIMERS_ALL_APIS, loc), numLit(0, loc), numLit(0, loc)];
+    }
+    if (!ts.isObjectLiteralExpression(options)) {
+        lowerer.noLowering(`${what}.enable with a non-literal options object`, options, MOCK_TIMERS_APIS_HINT);
+    }
+    let codes = "";
+    let listed = false;
+    let now = numLit(0, loc);
+    let flags = 0;
+    for (const prop of options.properties.nodes) {
+        // `{ apis: [...] }`, `{ "now": n }` and the `{ now }` shorthand.
+        const init = ts.isPropertyAssignment(prop)
+            ? prop.initializer
+            : ts.isShorthandPropertyAssignment(prop) && ts.isIdentifier(prop.name)
+                ? prop.name
+                : null;
+        const key = init && prop.name && (ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name))
+            ? prop.name.text
+            : null;
+        if (key === "apis") {
+            const list = init;
+            if (!ts.isArrayLiteralExpression(list)) {
+                lowerer.noLowering(`${what}.enable with a non-literal apis list`, list, MOCK_TIMERS_APIS_HINT);
+            }
+            listed = true;
+            for (const el of list.elements.nodes) {
+                if (!ts.isStringLiteralLike(el)) {
+                    lowerer.noLowering(`${what}.enable with a non-literal API name`, el, MOCK_TIMERS_APIS_HINT);
+                }
+                const code = MOCK_TIMERS_API_CODES[el.text] ?? "";
+                if (code === "") {
+                    lowerer.noLowering(`${what}.enable with the ${el.text} API`, el, MOCK_TIMERS_APIS_HINT);
+                }
+                codes += code;
+            }
+        }
+        else if (key === "now") {
+            const value = lowerer.lowerExpr(init);
+            if (value.type.kind === "date") {
+                now = { kind: "libCall", fn: "date.getTime", args: [value], type: F64, loc };
+                flags = 3;
+            }
+            else if (value.type.kind === "f64") {
+                now = value;
+                flags = 1;
+            }
+            else {
+                lowerer.noLowering(`${what}.enable with a now value of this type`, prop, "now takes a number or a Date");
+            }
+        }
+        else {
+            lowerer.noLowering(`${what}.enable with this option`, prop, "apis and now are the supported enable options");
+        }
+    }
+    return [strLit(listed ? codes : MOCK_TIMERS_ALL_APIS, loc), now, numLit(flags, loc)];
+}
 /** `fn.mock.calls`: a copy of the log, as Node's getter returns. Null for
  * other reads. */
 export function lowerMockContextProperty(lowerer, expr) {
@@ -380,7 +865,7 @@ export function lowerMockContextCall(lowerer, call, access) {
     const { fn, calls, once, onceEntry } = mockContextFields(lowerer, ctxType);
     const loc = locOf(call);
     const member = access.name.text;
-    const args = call.arguments;
+    const args = call.arguments.nodes;
     const arity = (min, max = min) => {
         if (args.length < min || args.length > max || args.some(ts.isSpreadElement))
             lowerer.noLowering(`MockFunctionContext.${member} with ${args.length} arguments`, call);
@@ -492,11 +977,9 @@ export function lowerMockContextCall(lowerer, call, access) {
             ], loc);
             return helperCall(helper, []);
         }
-        case "restore": {
+        case "restore":
             arity(0);
-            const helper = mockHelper(lowerer, ctxType, "restore", [], (ctx) => [recordSet(ctx(), "%impl", recordGet(ctx(), "%original", fn, loc), loc)], loc);
-            return helperCall(helper, []);
-        }
+            return helperCall(mockRestoreHelper(lowerer, ctxType, loc), []);
         default:
             return lowerer.noLowering(`MockFunctionContext.${member}`, call, "calls, callCount, mockImplementation, mockImplementationOnce, resetCalls and restore are the supported mock context members");
     }