From fdb1e0e0ff73e9ba87f0b2f3df38fa8e4dc67121 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Wed, 28 Oct 2026 05:58:18 -0700 Subject: [PATCH 1/4] chore(quest): claim quest/m2/ts-shared.md Quest-Claim: 9d12ea6fc7996515 From a1734275a8fad516123dd6f9f5e929625ac7a11a Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Wed, 28 Oct 2026 06:14:09 -0700 Subject: [PATCH 2/4] feat(ts): translate OnceCell and OnceLock Co-Authored-By: Claude Opus 5.5 --- ts/README.md | 1 + ts/fixtures/lang/caller.ts | 21 +- ts/fixtures/lang/expected/cells.ts | 1031 +++++++++++++++++ ts/fixtures/lang/expected/harness.ts | 3 +- ts/fixtures/lang/src/cells.rs | 119 ++ ts/fixtures/lang/src/harness.rs | 3 +- ts/fixtures/lang/src/lib.rs | 3 +- ts/fixtures/task/expected/drops.ts | 6 + .../task/expected/drops/once.Cached.ts | 33 + .../task/expected/drops/once.CellProbe.ts | 51 + .../task/expected/drops/once.LockProbe.ts | 51 + ts/fixtures/task/expected/drops/once.ts | 533 +++++++++ ts/fixtures/task/expected/lib.ts | 18 + ts/fixtures/task/src/drops.rs | 6 + ts/fixtures/task/src/drops/once.rs | 149 +++ ts/fixtures/task/src/harness.rs | 1 + ts/fixtures/task/ts.toml | 1 + ts/runtime/rt/task.ts | 100 +- ts/src/lower/drop.rs | 33 +- ts/src/lower/library.rs | 10 + ts/src/lower/mod.rs | 16 + ts/src/lower/task.rs | 66 ++ ts/tests/task.ts | 4 + 23 files changed, 2247 insertions(+), 12 deletions(-) create mode 100644 ts/fixtures/lang/expected/cells.ts create mode 100644 ts/fixtures/lang/src/cells.rs create mode 100644 ts/fixtures/task/expected/drops/once.Cached.ts create mode 100644 ts/fixtures/task/expected/drops/once.CellProbe.ts create mode 100644 ts/fixtures/task/expected/drops/once.LockProbe.ts create mode 100644 ts/fixtures/task/expected/drops/once.ts create mode 100644 ts/fixtures/task/src/drops/once.rs diff --git a/ts/README.md b/ts/README.md index cedda1358..cb6cb7f65 100644 --- a/ts/README.md +++ b/ts/README.md @@ -91,6 +91,7 @@ in `rt/str.ts`, collections in `rt/collections.ts`, ownership, atomics, and asyn | a type that drops | a class with `[Symbol.dispose]`: its `Drop` impl, then its fields | | a type's function | a function of the type's module, taking `self` first: `Decoder.slice(dec, 4)` after `import * as Decoder` | | `Arc`, `Weak`, `Mutex` | `rt.Arc`, counted; `rt.Weak`; `rt.Mutex`, its own guard | +| `OnceCell`, `OnceLock` | `rt.OnceCell` and `rt.OnceLock`, holding the `Option` in `v`; a `OnceLock` initialized from within its own initialization panics, as wasm32's does | | `AtomicU32` and the others of `bool` and integers | `rt.Atomic`, the `rt.Place` of its value; an `atomic::Ordering` is its discriminant, and one an operation can't take panics as std's does | | `async fn` | a function returning `rt.Future`: a class of its own, its coroutine's state machine | | `Poll`, `Waker`, `Context` | `T \| typeof rt.Pending`, refused if `T` can already be pending; `rt.Waker`, which is also the context | diff --git a/ts/fixtures/lang/caller.ts b/ts/fixtures/lang/caller.ts index 06bfceeff..a1b789277 100644 --- a/ts/fixtures/lang/caller.ts +++ b/ts/fixtures/lang/caller.ts @@ -215,4 +215,23 @@ const utf8 = [ [0x80, 0xf8, 0xff], ].map((bytes) => Uint8Array.of(op("utf8::decodes"), 0, ...bytes)); -export const cases: Uint8Array[] = [...loops, ...durations, ...ints(), ...utf8, ...floats]; +/** + * `cells` scripts of (op, operand) pairs on every kind, so each cell and value type: reads + * and sets, a `None` and a `()` held, initializing from within initialization and + * panicking in it, empty and full, and a cell replaced. + */ +const cellsOp = op("cells::cells"); +const cellScripts = [ + [0, 0, 1, 5, 0, 0, 1, 6, 2, 7, 4, 0, 0, 0, 4, 0, 2, 9, 0, 0], + [1, 3, 0, 0, 1, 4, 4, 0, 1, 6, 2, 3], + [3, 4, 3, 5], + [5, 3], + [6, 3], + [7, 1], + [2, 1, 5, 3, 6, 3, 7, 1], + [8, 4, 0, 0, 8, 5, 0, 0, 1, 3, 8, 6], + [], +]; +const cells = Array.from({ length: 256 }, (_, kind) => cellScripts.map((script) => Uint8Array.of(cellsOp, kind, ...script))).flat(); + +export const cases: Uint8Array[] = [...loops, ...durations, ...ints(), ...utf8, ...floats, ...cells]; diff --git a/ts/fixtures/lang/expected/cells.ts b/ts/fixtures/lang/expected/cells.ts new file mode 100644 index 000000000..384a0f845 --- /dev/null +++ b/ts/fixtures/lang/expected/cells.ts @@ -0,0 +1,1031 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; + +/** Steps of an operation and an operand on one cell, each putting what it read. */ +export function cellOption(data: rt.ByteSlice, out: rt.ByteVec): void { + const make: (a0: rt.u8) => rt.u8 | undefined = maybe; + const put: (a0: rt.ByteVec, a1: rt.u8 | undefined) => void = putMaybe; + let cell: rt.OnceCell = new rt.OnceCell(rt.None); + let dataData: Uint8Array = data.data; + let dataStart: number = data.start; + let dataLen: number = data.length; + while (dataLen >= 2) { + const op: rt.u8 = dataData[dataStart]; + const v: rt.u8 = dataData[dataStart + 1]; + const restData: Uint8Array = dataData; + const restStart: number = dataStart + 2; + const restLen: number = dataLen - 2; + dataData = restData; + dataStart = restStart; + dataLen = restLen; + const op2: rt.u8 = op; + const v2: rt.u8 = v; + const _18: rt.u8 = rt.u8Rem(op2, 9); + if (_18 === 0) { + const _20: rt.u8 | undefined | rt.None = cell.v; + if (_20 === rt.None) { + rt.byteVecPush(out, 0); + } else { + rt.byteVecPush(out, 1); + put(out, _20); + } + } else if (_18 === 1) { + const _26: rt.Result = rt.onceSet(cell, make(v2), rt.None); + if (_26.ok) { + rt.byteVecPush(out, 1); + } else { + const t: rt.u8 | undefined = _26.error; + rt.byteVecPush(out, 0); + put(out, t); + } + } else if (_18 === 2) { + const _34: rt.u8 | undefined = rt.onceGetOrInit(cell, (): rt.u8 | undefined => { + return make(v2); + }, undefined, undefined, rt.None); + put(out, _34); + } else if (_18 === 3) { + let seen: rt.u8 = 2; + const _44: rt.OnceCell = cell; + const t2: rt.u8 | undefined = rt.onceGetOrInit(cell, (): rt.u8 | undefined => { + seen = _44.v !== rt.None ? 1 : 0; + return make(v2); + }, undefined, undefined, rt.None); + put(out, t2); + rt.byteVecPush(out, seen); + } else if (_18 === 4) { + const _50: rt.u8 | undefined | rt.None = rt.onceTake(cell, rt.None); + if (_50 === rt.None) { + rt.byteVecPush(out, 0); + } else { + const t3: rt.u8 | undefined = _50; + rt.byteVecPush(out, 1); + put(out, t3); + } + } else if (_18 === 5) { + const _60: rt.OnceCell = cell; + const _57: rt.u8 | undefined = rt.onceGetOrInit(cell, (): rt.u8 | undefined => { + rt.onceSet(_60, make(v2 ^ 1), rt.None); + return make(v2); + }, undefined, undefined, rt.None); + put(out, _57); + } else if (_18 === 6) { + const inner: rt.ByteVec = new rt.ByteVec(); + const _69: rt.OnceCell = cell; + const t4: rt.u8 | undefined = rt.onceGetOrInit(cell, (): rt.u8 | undefined => { + put(inner, rt.onceGetOrInit(_69, (): rt.u8 | undefined => { + return make(v2 ^ 1); + }, undefined, undefined, rt.None)); + return make(v2); + }, undefined, undefined, rt.None); + put(out, t4); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(inner)); + } else if (_18 === 7) { + const _76: rt.u8 | undefined = rt.onceGetOrInit(cell, (): rt.u8 | undefined => { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(v2, f)]; + rt.panicFmt(["init ", args2[0]]); + }, undefined, undefined, rt.None); + put(out, _76); + } else if (rt.u8Rem(v2, 2) === 0) { + cell = new rt.OnceCell(make(v2)); + } else { + cell = new rt.OnceCell(rt.None); + } + } + const _85: rt.u8 | undefined | rt.None = cell.v; + if (_85 === rt.None) { + rt.byteVecPush(out, 238); + } else { + put(out, _85); + } +} + +/** Steps of an operation and an operand on one cell, each putting what it read. */ +export function cellString(data: rt.ByteSlice, out: rt.ByteVec): void { + const make: (a0: rt.u8) => string = (v3: rt.u8): string => { + return rt.fmtToString((f: rt.Formatter) => rt.u8Display(v3, f)); + }; + const put: (a0: rt.ByteVec, a1: string) => void = (out2: rt.ByteVec, t6: string): void => { + rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(t6)); + }; + let cell: rt.OnceCell = new rt.OnceCell(undefined); + let dataData: Uint8Array = data.data; + let dataStart: number = data.start; + let dataLen: number = data.length; + while (dataLen >= 2) { + const op: rt.u8 = dataData[dataStart]; + const v: rt.u8 = dataData[dataStart + 1]; + const restData: Uint8Array = dataData; + const restStart: number = dataStart + 2; + const restLen: number = dataLen - 2; + dataData = restData; + dataStart = restStart; + dataLen = restLen; + const op2: rt.u8 = op; + const v2: rt.u8 = v; + const _18: rt.u8 = rt.u8Rem(op2, 9); + if (_18 === 0) { + const _20: string | undefined = cell.v; + if (_20 === undefined) { + rt.byteVecPush(out, 0); + } else { + rt.byteVecPush(out, 1); + put(out, _20); + } + } else if (_18 === 1) { + const _26: rt.Result = rt.onceSet(cell, make(v2)); + if (_26.ok) { + rt.byteVecPush(out, 1); + } else { + const t: string = _26.error; + rt.byteVecPush(out, 0); + put(out, t); + } + } else if (_18 === 2) { + const _34: string = rt.onceGetOrInit(cell, (): string => { + return make(v2); + }); + put(out, _34); + } else if (_18 === 3) { + let seen: rt.u8 = 2; + const _44: rt.OnceCell = cell; + const t2: string = rt.onceGetOrInit(cell, (): string => { + seen = _44.v !== undefined ? 1 : 0; + return make(v2); + }); + put(out, t2); + rt.byteVecPush(out, seen); + } else if (_18 === 4) { + const _50: string | undefined = rt.onceTake(cell); + if (_50 === undefined) { + rt.byteVecPush(out, 0); + } else { + const t3: string = _50; + rt.byteVecPush(out, 1); + put(out, t3); + } + } else if (_18 === 5) { + const _60: rt.OnceCell = cell; + const _57: string = rt.onceGetOrInit(cell, (): string => { + rt.onceSet(_60, make(v2 ^ 1)); + return make(v2); + }); + put(out, _57); + } else if (_18 === 6) { + const inner: rt.ByteVec = new rt.ByteVec(); + const _69: rt.OnceCell = cell; + const t4: string = rt.onceGetOrInit(cell, (): string => { + put(inner, rt.onceGetOrInit(_69, (): string => { + return make(v2 ^ 1); + })); + return make(v2); + }); + put(out, t4); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(inner)); + } else if (_18 === 7) { + const _76: string = rt.onceGetOrInit(cell, (): string => { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(v2, f)]; + rt.panicFmt(["init ", args2[0]]); + }); + put(out, _76); + } else if (rt.u8Rem(v2, 2) === 0) { + cell = new rt.OnceCell(make(v2)); + } else { + cell = new rt.OnceCell(undefined); + } + } + const _85: string | undefined = cell.v; + if (_85 === undefined) { + rt.byteVecPush(out, 238); + } else { + put(out, _85); + } +} + +/** Steps of an operation and an operand on one cell, each putting what it read. */ +export function cellU64(data: rt.ByteSlice, out: rt.ByteVec): void { + const make: (a0: rt.u8) => rt.u64 = wide; + const put: (a0: rt.ByteVec, a1: rt.u64) => void = (out2: rt.ByteVec, t6: rt.u64): void => { + rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u64ToBeBytes(t6))); + }; + let cell: rt.OnceCell = new rt.OnceCell(undefined); + let dataData: Uint8Array = data.data; + let dataStart: number = data.start; + let dataLen: number = data.length; + while (dataLen >= 2) { + const op: rt.u8 = dataData[dataStart]; + const v: rt.u8 = dataData[dataStart + 1]; + const restData: Uint8Array = dataData; + const restStart: number = dataStart + 2; + const restLen: number = dataLen - 2; + dataData = restData; + dataStart = restStart; + dataLen = restLen; + const op2: rt.u8 = op; + const v2: rt.u8 = v; + const _18: rt.u8 = rt.u8Rem(op2, 9); + if (_18 === 0) { + const _20: rt.u64 | undefined = cell.v; + if (_20 === undefined) { + rt.byteVecPush(out, 0); + } else { + rt.byteVecPush(out, 1); + put(out, _20); + } + } else if (_18 === 1) { + const _26: rt.Result = rt.onceSet(cell, make(v2)); + if (_26.ok) { + rt.byteVecPush(out, 1); + } else { + const t: rt.u64 = _26.error; + rt.byteVecPush(out, 0); + put(out, t); + } + } else if (_18 === 2) { + const _34: rt.u64 = rt.onceGetOrInit(cell, (): rt.u64 => { + return make(v2); + }); + put(out, _34); + } else if (_18 === 3) { + let seen: rt.u8 = 2; + const _44: rt.OnceCell = cell; + const t2: rt.u64 = rt.onceGetOrInit(cell, (): rt.u64 => { + seen = _44.v !== undefined ? 1 : 0; + return make(v2); + }); + put(out, t2); + rt.byteVecPush(out, seen); + } else if (_18 === 4) { + const _50: rt.u64 | undefined = rt.onceTake(cell); + if (_50 === undefined) { + rt.byteVecPush(out, 0); + } else { + const t3: rt.u64 = _50; + rt.byteVecPush(out, 1); + put(out, t3); + } + } else if (_18 === 5) { + const _60: rt.OnceCell = cell; + const _57: rt.u64 = rt.onceGetOrInit(cell, (): rt.u64 => { + rt.onceSet(_60, make(v2 ^ 1)); + return make(v2); + }); + put(out, _57); + } else if (_18 === 6) { + const inner: rt.ByteVec = new rt.ByteVec(); + const _69: rt.OnceCell = cell; + const t4: rt.u64 = rt.onceGetOrInit(cell, (): rt.u64 => { + put(inner, rt.onceGetOrInit(_69, (): rt.u64 => { + return make(v2 ^ 1); + })); + return make(v2); + }); + put(out, t4); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(inner)); + } else if (_18 === 7) { + const _76: rt.u64 = rt.onceGetOrInit(cell, (): rt.u64 => { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(v2, f)]; + rt.panicFmt(["init ", args2[0]]); + }); + put(out, _76); + } else if (rt.u8Rem(v2, 2) === 0) { + cell = new rt.OnceCell(make(v2)); + } else { + cell = new rt.OnceCell(undefined); + } + } + const _85: rt.u64 | undefined = cell.v; + if (_85 === undefined) { + rt.byteVecPush(out, 238); + } else { + put(out, _85); + } +} + +/** Steps of an operation and an operand on one cell, each putting what it read. */ +export function cellU8(data: rt.ByteSlice, out: rt.ByteVec): void { + const make: (a0: rt.u8) => rt.u8 = (v3: rt.u8): rt.u8 => { + return v3; + }; + const put: (a0: rt.ByteVec, a1: rt.u8) => void = (out2: rt.ByteVec, t6: rt.u8): void => { + rt.byteVecPush(out2, t6); + }; + let cell: rt.OnceCell = new rt.OnceCell(undefined); + let dataData: Uint8Array = data.data; + let dataStart: number = data.start; + let dataLen: number = data.length; + while (dataLen >= 2) { + const op: rt.u8 = dataData[dataStart]; + const v: rt.u8 = dataData[dataStart + 1]; + const restData: Uint8Array = dataData; + const restStart: number = dataStart + 2; + const restLen: number = dataLen - 2; + dataData = restData; + dataStart = restStart; + dataLen = restLen; + const op2: rt.u8 = op; + const v2: rt.u8 = v; + const _18: rt.u8 = rt.u8Rem(op2, 9); + if (_18 === 0) { + const _20: rt.u8 | undefined = cell.v; + if (_20 === undefined) { + rt.byteVecPush(out, 0); + } else { + rt.byteVecPush(out, 1); + put(out, _20); + } + } else if (_18 === 1) { + const _26: rt.Result = rt.onceSet(cell, make(v2)); + if (_26.ok) { + rt.byteVecPush(out, 1); + } else { + const t: rt.u8 = _26.error; + rt.byteVecPush(out, 0); + put(out, t); + } + } else if (_18 === 2) { + const _34: rt.u8 = rt.onceGetOrInit(cell, (): rt.u8 => { + return make(v2); + }); + put(out, _34); + } else if (_18 === 3) { + let seen: rt.u8 = 2; + const _44: rt.OnceCell = cell; + const t2: rt.u8 = rt.onceGetOrInit(cell, (): rt.u8 => { + seen = _44.v !== undefined ? 1 : 0; + return make(v2); + }); + put(out, t2); + rt.byteVecPush(out, seen); + } else if (_18 === 4) { + const _50: rt.u8 | undefined = rt.onceTake(cell); + if (_50 === undefined) { + rt.byteVecPush(out, 0); + } else { + const t3: rt.u8 = _50; + rt.byteVecPush(out, 1); + put(out, t3); + } + } else if (_18 === 5) { + const _60: rt.OnceCell = cell; + const _57: rt.u8 = rt.onceGetOrInit(cell, (): rt.u8 => { + rt.onceSet(_60, make(v2 ^ 1)); + return make(v2); + }); + put(out, _57); + } else if (_18 === 6) { + const inner: rt.ByteVec = new rt.ByteVec(); + const _69: rt.OnceCell = cell; + const t4: rt.u8 = rt.onceGetOrInit(cell, (): rt.u8 => { + put(inner, rt.onceGetOrInit(_69, (): rt.u8 => { + return make(v2 ^ 1); + })); + return make(v2); + }); + put(out, t4); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(inner)); + } else if (_18 === 7) { + const _76: rt.u8 = rt.onceGetOrInit(cell, (): rt.u8 => { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(v2, f)]; + rt.panicFmt(["init ", args2[0]]); + }); + put(out, _76); + } else if (rt.u8Rem(v2, 2) === 0) { + cell = new rt.OnceCell(make(v2)); + } else { + cell = new rt.OnceCell(undefined); + } + } + const _85: rt.u8 | undefined = cell.v; + if (_85 === undefined) { + rt.byteVecPush(out, 238); + } else { + put(out, _85); + } +} + +/** Steps of an operation and an operand on one cell, each putting what it read. */ +export function cellUnit(data: rt.ByteSlice, out: rt.ByteVec): void { + const make: (a0: rt.u8) => void = (_2: rt.u8): void => {}; + const put: (a0: rt.ByteVec, a1: undefined) => void = (out2: rt.ByteVec, _3: undefined): void => { + rt.byteVecPush(out2, 170); + }; + let cell: rt.OnceCell = new rt.OnceCell(rt.None); + let dataData: Uint8Array = data.data; + let dataStart: number = data.start; + let dataLen: number = data.length; + while (dataLen >= 2) { + const op: rt.u8 = dataData[dataStart]; + const v: rt.u8 = dataData[dataStart + 1]; + const restData: Uint8Array = dataData; + const restStart: number = dataStart + 2; + const restLen: number = dataLen - 2; + dataData = restData; + dataStart = restStart; + dataLen = restLen; + const op2: rt.u8 = op; + const v2: rt.u8 = v; + const _18: rt.u8 = rt.u8Rem(op2, 9); + if (_18 === 0) { + const _20: undefined | rt.None = cell.v; + if (_20 === rt.None) { + rt.byteVecPush(out, 0); + } else { + rt.byteVecPush(out, 1); + put(out, _20); + } + } else if (_18 === 1) { + const _27: rt.OnceCell = cell; + make(v2); + if (rt.onceSet(_27, undefined, rt.None).ok) { + rt.byteVecPush(out, 1); + } else { + rt.byteVecPush(out, 0); + put(out, undefined); + } + } else if (_18 === 2) { + const _34: undefined = rt.onceGetOrInit(cell, (): void => { + make(v2); + }, undefined, undefined, rt.None); + put(out, _34); + } else if (_18 === 3) { + let seen: rt.u8 = 2; + const _44: rt.OnceCell = cell; + const t: undefined = rt.onceGetOrInit(cell, (): void => { + seen = _44.v !== rt.None ? 1 : 0; + make(v2); + }, undefined, undefined, rt.None); + put(out, t); + rt.byteVecPush(out, seen); + } else if (_18 === 4) { + if (rt.onceTake(cell, rt.None) === rt.None) { + rt.byteVecPush(out, 0); + } else { + rt.byteVecPush(out, 1); + put(out, undefined); + } + } else if (_18 === 5) { + const _60: rt.OnceCell = cell; + const _57: undefined = rt.onceGetOrInit(cell, (): void => { + make(v2 ^ 1); + rt.onceSet(_60, undefined, rt.None); + make(v2); + }, undefined, undefined, rt.None); + put(out, _57); + } else if (_18 === 6) { + const inner: rt.ByteVec = new rt.ByteVec(); + const _69: rt.OnceCell = cell; + const t2: undefined = rt.onceGetOrInit(cell, (): void => { + put(inner, rt.onceGetOrInit(_69, (): void => { + make(v2 ^ 1); + }, undefined, undefined, rt.None)); + make(v2); + }, undefined, undefined, rt.None); + put(out, t2); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(inner)); + } else if (_18 === 7) { + const _76: undefined = rt.onceGetOrInit(cell, (): void => { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(v2, f)]; + rt.panicFmt(["init ", args2[0]]); + }, undefined, undefined, rt.None); + put(out, _76); + } else if (rt.u8Rem(v2, 2) === 0) { + make(v2); + cell = new rt.OnceCell(undefined); + } else { + cell = new rt.OnceCell(rt.None); + } + } + if (cell.v === rt.None) { + rt.byteVecPush(out, 238); + } else { + put(out, undefined); + } +} + +/** Steps on the cell and value type `kind` picks. */ +export function cells(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + const cases: Array<(a0: rt.ByteSlice, a1: rt.ByteVec) => void> = [cellU8, lockU8, cellU64, lockU64, cellOption, lockOption, cellUnit, lockUnit, cellString, lockString]; + cases[rt.idx(cases, rt.usizeRem(kind as rt.usize, cases.length))](data, out); +} + +/** Steps of an operation and an operand on one cell, each putting what it read. */ +export function lockOption(data: rt.ByteSlice, out: rt.ByteVec): void { + const make: (a0: rt.u8) => rt.u8 | undefined = maybe; + const put: (a0: rt.ByteVec, a1: rt.u8 | undefined) => void = putMaybe; + let cell: rt.OnceLock = new rt.OnceLock(rt.None); + let dataData: Uint8Array = data.data; + let dataStart: number = data.start; + let dataLen: number = data.length; + while (dataLen >= 2) { + const op: rt.u8 = dataData[dataStart]; + const v: rt.u8 = dataData[dataStart + 1]; + const restData: Uint8Array = dataData; + const restStart: number = dataStart + 2; + const restLen: number = dataLen - 2; + dataData = restData; + dataStart = restStart; + dataLen = restLen; + const op2: rt.u8 = op; + const v2: rt.u8 = v; + const _18: rt.u8 = rt.u8Rem(op2, 9); + if (_18 === 0) { + const _20: rt.u8 | undefined | rt.None = cell.v; + if (_20 === rt.None) { + rt.byteVecPush(out, 0); + } else { + rt.byteVecPush(out, 1); + put(out, _20); + } + } else if (_18 === 1) { + const _26: rt.Result = rt.onceSet(cell, make(v2), rt.None); + if (_26.ok) { + rt.byteVecPush(out, 1); + } else { + const t: rt.u8 | undefined = _26.error; + rt.byteVecPush(out, 0); + put(out, t); + } + } else if (_18 === 2) { + const _34: rt.u8 | undefined = rt.onceGetOrInit(cell, (): rt.u8 | undefined => { + return make(v2); + }, undefined, undefined, rt.None); + put(out, _34); + } else if (_18 === 3) { + let seen: rt.u8 = 2; + const _44: rt.OnceLock = cell; + const t2: rt.u8 | undefined = rt.onceGetOrInit(cell, (): rt.u8 | undefined => { + seen = _44.v !== rt.None ? 1 : 0; + return make(v2); + }, undefined, undefined, rt.None); + put(out, t2); + rt.byteVecPush(out, seen); + } else if (_18 === 4) { + const _50: rt.u8 | undefined | rt.None = rt.onceTake(cell, rt.None); + if (_50 === rt.None) { + rt.byteVecPush(out, 0); + } else { + const t3: rt.u8 | undefined = _50; + rt.byteVecPush(out, 1); + put(out, t3); + } + } else if (_18 === 5) { + const _60: rt.OnceLock = cell; + const _57: rt.u8 | undefined = rt.onceGetOrInit(cell, (): rt.u8 | undefined => { + rt.onceSet(_60, make(v2 ^ 1), rt.None); + return make(v2); + }, undefined, undefined, rt.None); + put(out, _57); + } else if (_18 === 6) { + const inner: rt.ByteVec = new rt.ByteVec(); + const _69: rt.OnceLock = cell; + const t4: rt.u8 | undefined = rt.onceGetOrInit(cell, (): rt.u8 | undefined => { + put(inner, rt.onceGetOrInit(_69, (): rt.u8 | undefined => { + return make(v2 ^ 1); + }, undefined, undefined, rt.None)); + return make(v2); + }, undefined, undefined, rt.None); + put(out, t4); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(inner)); + } else if (_18 === 7) { + const _76: rt.u8 | undefined = rt.onceGetOrInit(cell, (): rt.u8 | undefined => { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(v2, f)]; + rt.panicFmt(["init ", args2[0]]); + }, undefined, undefined, rt.None); + put(out, _76); + } else if (rt.u8Rem(v2, 2) === 0) { + cell = new rt.OnceLock(make(v2)); + } else { + cell = new rt.OnceLock(rt.None); + } + } + const _85: rt.u8 | undefined | rt.None = cell.v; + if (_85 === rt.None) { + rt.byteVecPush(out, 238); + } else { + put(out, _85); + } +} + +/** Steps of an operation and an operand on one cell, each putting what it read. */ +export function lockString(data: rt.ByteSlice, out: rt.ByteVec): void { + const make: (a0: rt.u8) => string = (v3: rt.u8): string => { + return rt.fmtToString((f: rt.Formatter) => rt.u8Display(v3, f)); + }; + const put: (a0: rt.ByteVec, a1: string) => void = (out2: rt.ByteVec, t6: string): void => { + rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(t6)); + }; + let cell: rt.OnceLock = new rt.OnceLock(undefined); + let dataData: Uint8Array = data.data; + let dataStart: number = data.start; + let dataLen: number = data.length; + while (dataLen >= 2) { + const op: rt.u8 = dataData[dataStart]; + const v: rt.u8 = dataData[dataStart + 1]; + const restData: Uint8Array = dataData; + const restStart: number = dataStart + 2; + const restLen: number = dataLen - 2; + dataData = restData; + dataStart = restStart; + dataLen = restLen; + const op2: rt.u8 = op; + const v2: rt.u8 = v; + const _18: rt.u8 = rt.u8Rem(op2, 9); + if (_18 === 0) { + const _20: string | undefined = cell.v; + if (_20 === undefined) { + rt.byteVecPush(out, 0); + } else { + rt.byteVecPush(out, 1); + put(out, _20); + } + } else if (_18 === 1) { + const _26: rt.Result = rt.onceSet(cell, make(v2)); + if (_26.ok) { + rt.byteVecPush(out, 1); + } else { + const t: string = _26.error; + rt.byteVecPush(out, 0); + put(out, t); + } + } else if (_18 === 2) { + const _34: string = rt.onceGetOrInit(cell, (): string => { + return make(v2); + }); + put(out, _34); + } else if (_18 === 3) { + let seen: rt.u8 = 2; + const _44: rt.OnceLock = cell; + const t2: string = rt.onceGetOrInit(cell, (): string => { + seen = _44.v !== undefined ? 1 : 0; + return make(v2); + }); + put(out, t2); + rt.byteVecPush(out, seen); + } else if (_18 === 4) { + const _50: string | undefined = rt.onceTake(cell); + if (_50 === undefined) { + rt.byteVecPush(out, 0); + } else { + const t3: string = _50; + rt.byteVecPush(out, 1); + put(out, t3); + } + } else if (_18 === 5) { + const _60: rt.OnceLock = cell; + const _57: string = rt.onceGetOrInit(cell, (): string => { + rt.onceSet(_60, make(v2 ^ 1)); + return make(v2); + }); + put(out, _57); + } else if (_18 === 6) { + const inner: rt.ByteVec = new rt.ByteVec(); + const _69: rt.OnceLock = cell; + const t4: string = rt.onceGetOrInit(cell, (): string => { + put(inner, rt.onceGetOrInit(_69, (): string => { + return make(v2 ^ 1); + })); + return make(v2); + }); + put(out, t4); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(inner)); + } else if (_18 === 7) { + const _76: string = rt.onceGetOrInit(cell, (): string => { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(v2, f)]; + rt.panicFmt(["init ", args2[0]]); + }); + put(out, _76); + } else if (rt.u8Rem(v2, 2) === 0) { + cell = new rt.OnceLock(make(v2)); + } else { + cell = new rt.OnceLock(undefined); + } + } + const _85: string | undefined = cell.v; + if (_85 === undefined) { + rt.byteVecPush(out, 238); + } else { + put(out, _85); + } +} + +/** Steps of an operation and an operand on one cell, each putting what it read. */ +export function lockU64(data: rt.ByteSlice, out: rt.ByteVec): void { + const make: (a0: rt.u8) => rt.u64 = wide; + const put: (a0: rt.ByteVec, a1: rt.u64) => void = (out2: rt.ByteVec, t6: rt.u64): void => { + rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u64ToBeBytes(t6))); + }; + let cell: rt.OnceLock = new rt.OnceLock(undefined); + let dataData: Uint8Array = data.data; + let dataStart: number = data.start; + let dataLen: number = data.length; + while (dataLen >= 2) { + const op: rt.u8 = dataData[dataStart]; + const v: rt.u8 = dataData[dataStart + 1]; + const restData: Uint8Array = dataData; + const restStart: number = dataStart + 2; + const restLen: number = dataLen - 2; + dataData = restData; + dataStart = restStart; + dataLen = restLen; + const op2: rt.u8 = op; + const v2: rt.u8 = v; + const _18: rt.u8 = rt.u8Rem(op2, 9); + if (_18 === 0) { + const _20: rt.u64 | undefined = cell.v; + if (_20 === undefined) { + rt.byteVecPush(out, 0); + } else { + rt.byteVecPush(out, 1); + put(out, _20); + } + } else if (_18 === 1) { + const _26: rt.Result = rt.onceSet(cell, make(v2)); + if (_26.ok) { + rt.byteVecPush(out, 1); + } else { + const t: rt.u64 = _26.error; + rt.byteVecPush(out, 0); + put(out, t); + } + } else if (_18 === 2) { + const _34: rt.u64 = rt.onceGetOrInit(cell, (): rt.u64 => { + return make(v2); + }); + put(out, _34); + } else if (_18 === 3) { + let seen: rt.u8 = 2; + const _44: rt.OnceLock = cell; + const t2: rt.u64 = rt.onceGetOrInit(cell, (): rt.u64 => { + seen = _44.v !== undefined ? 1 : 0; + return make(v2); + }); + put(out, t2); + rt.byteVecPush(out, seen); + } else if (_18 === 4) { + const _50: rt.u64 | undefined = rt.onceTake(cell); + if (_50 === undefined) { + rt.byteVecPush(out, 0); + } else { + const t3: rt.u64 = _50; + rt.byteVecPush(out, 1); + put(out, t3); + } + } else if (_18 === 5) { + const _60: rt.OnceLock = cell; + const _57: rt.u64 = rt.onceGetOrInit(cell, (): rt.u64 => { + rt.onceSet(_60, make(v2 ^ 1)); + return make(v2); + }); + put(out, _57); + } else if (_18 === 6) { + const inner: rt.ByteVec = new rt.ByteVec(); + const _69: rt.OnceLock = cell; + const t4: rt.u64 = rt.onceGetOrInit(cell, (): rt.u64 => { + put(inner, rt.onceGetOrInit(_69, (): rt.u64 => { + return make(v2 ^ 1); + })); + return make(v2); + }); + put(out, t4); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(inner)); + } else if (_18 === 7) { + const _76: rt.u64 = rt.onceGetOrInit(cell, (): rt.u64 => { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(v2, f)]; + rt.panicFmt(["init ", args2[0]]); + }); + put(out, _76); + } else if (rt.u8Rem(v2, 2) === 0) { + cell = new rt.OnceLock(make(v2)); + } else { + cell = new rt.OnceLock(undefined); + } + } + const _85: rt.u64 | undefined = cell.v; + if (_85 === undefined) { + rt.byteVecPush(out, 238); + } else { + put(out, _85); + } +} + +/** Steps of an operation and an operand on one cell, each putting what it read. */ +export function lockU8(data: rt.ByteSlice, out: rt.ByteVec): void { + const make: (a0: rt.u8) => rt.u8 = (v3: rt.u8): rt.u8 => { + return v3; + }; + const put: (a0: rt.ByteVec, a1: rt.u8) => void = (out2: rt.ByteVec, t6: rt.u8): void => { + rt.byteVecPush(out2, t6); + }; + let cell: rt.OnceLock = new rt.OnceLock(undefined); + let dataData: Uint8Array = data.data; + let dataStart: number = data.start; + let dataLen: number = data.length; + while (dataLen >= 2) { + const op: rt.u8 = dataData[dataStart]; + const v: rt.u8 = dataData[dataStart + 1]; + const restData: Uint8Array = dataData; + const restStart: number = dataStart + 2; + const restLen: number = dataLen - 2; + dataData = restData; + dataStart = restStart; + dataLen = restLen; + const op2: rt.u8 = op; + const v2: rt.u8 = v; + const _18: rt.u8 = rt.u8Rem(op2, 9); + if (_18 === 0) { + const _20: rt.u8 | undefined = cell.v; + if (_20 === undefined) { + rt.byteVecPush(out, 0); + } else { + rt.byteVecPush(out, 1); + put(out, _20); + } + } else if (_18 === 1) { + const _26: rt.Result = rt.onceSet(cell, make(v2)); + if (_26.ok) { + rt.byteVecPush(out, 1); + } else { + const t: rt.u8 = _26.error; + rt.byteVecPush(out, 0); + put(out, t); + } + } else if (_18 === 2) { + const _34: rt.u8 = rt.onceGetOrInit(cell, (): rt.u8 => { + return make(v2); + }); + put(out, _34); + } else if (_18 === 3) { + let seen: rt.u8 = 2; + const _44: rt.OnceLock = cell; + const t2: rt.u8 = rt.onceGetOrInit(cell, (): rt.u8 => { + seen = _44.v !== undefined ? 1 : 0; + return make(v2); + }); + put(out, t2); + rt.byteVecPush(out, seen); + } else if (_18 === 4) { + const _50: rt.u8 | undefined = rt.onceTake(cell); + if (_50 === undefined) { + rt.byteVecPush(out, 0); + } else { + const t3: rt.u8 = _50; + rt.byteVecPush(out, 1); + put(out, t3); + } + } else if (_18 === 5) { + const _60: rt.OnceLock = cell; + const _57: rt.u8 = rt.onceGetOrInit(cell, (): rt.u8 => { + rt.onceSet(_60, make(v2 ^ 1)); + return make(v2); + }); + put(out, _57); + } else if (_18 === 6) { + const inner: rt.ByteVec = new rt.ByteVec(); + const _69: rt.OnceLock = cell; + const t4: rt.u8 = rt.onceGetOrInit(cell, (): rt.u8 => { + put(inner, rt.onceGetOrInit(_69, (): rt.u8 => { + return make(v2 ^ 1); + })); + return make(v2); + }); + put(out, t4); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(inner)); + } else if (_18 === 7) { + const _76: rt.u8 = rt.onceGetOrInit(cell, (): rt.u8 => { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(v2, f)]; + rt.panicFmt(["init ", args2[0]]); + }); + put(out, _76); + } else if (rt.u8Rem(v2, 2) === 0) { + cell = new rt.OnceLock(make(v2)); + } else { + cell = new rt.OnceLock(undefined); + } + } + const _85: rt.u8 | undefined = cell.v; + if (_85 === undefined) { + rt.byteVecPush(out, 238); + } else { + put(out, _85); + } +} + +/** Steps of an operation and an operand on one cell, each putting what it read. */ +export function lockUnit(data: rt.ByteSlice, out: rt.ByteVec): void { + const make: (a0: rt.u8) => void = (_2: rt.u8): void => {}; + const put: (a0: rt.ByteVec, a1: undefined) => void = (out2: rt.ByteVec, _3: undefined): void => { + rt.byteVecPush(out2, 170); + }; + let cell: rt.OnceLock = new rt.OnceLock(rt.None); + let dataData: Uint8Array = data.data; + let dataStart: number = data.start; + let dataLen: number = data.length; + while (dataLen >= 2) { + const op: rt.u8 = dataData[dataStart]; + const v: rt.u8 = dataData[dataStart + 1]; + const restData: Uint8Array = dataData; + const restStart: number = dataStart + 2; + const restLen: number = dataLen - 2; + dataData = restData; + dataStart = restStart; + dataLen = restLen; + const op2: rt.u8 = op; + const v2: rt.u8 = v; + const _18: rt.u8 = rt.u8Rem(op2, 9); + if (_18 === 0) { + const _20: undefined | rt.None = cell.v; + if (_20 === rt.None) { + rt.byteVecPush(out, 0); + } else { + rt.byteVecPush(out, 1); + put(out, _20); + } + } else if (_18 === 1) { + const _27: rt.OnceLock = cell; + make(v2); + if (rt.onceSet(_27, undefined, rt.None).ok) { + rt.byteVecPush(out, 1); + } else { + rt.byteVecPush(out, 0); + put(out, undefined); + } + } else if (_18 === 2) { + const _34: undefined = rt.onceGetOrInit(cell, (): void => { + make(v2); + }, undefined, undefined, rt.None); + put(out, _34); + } else if (_18 === 3) { + let seen: rt.u8 = 2; + const _44: rt.OnceLock = cell; + const t: undefined = rt.onceGetOrInit(cell, (): void => { + seen = _44.v !== rt.None ? 1 : 0; + make(v2); + }, undefined, undefined, rt.None); + put(out, t); + rt.byteVecPush(out, seen); + } else if (_18 === 4) { + if (rt.onceTake(cell, rt.None) === rt.None) { + rt.byteVecPush(out, 0); + } else { + rt.byteVecPush(out, 1); + put(out, undefined); + } + } else if (_18 === 5) { + const _60: rt.OnceLock = cell; + const _57: undefined = rt.onceGetOrInit(cell, (): void => { + make(v2 ^ 1); + rt.onceSet(_60, undefined, rt.None); + make(v2); + }, undefined, undefined, rt.None); + put(out, _57); + } else if (_18 === 6) { + const inner: rt.ByteVec = new rt.ByteVec(); + const _69: rt.OnceLock = cell; + const t2: undefined = rt.onceGetOrInit(cell, (): void => { + put(inner, rt.onceGetOrInit(_69, (): void => { + make(v2 ^ 1); + }, undefined, undefined, rt.None)); + make(v2); + }, undefined, undefined, rt.None); + put(out, t2); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(inner)); + } else if (_18 === 7) { + const _76: undefined = rt.onceGetOrInit(cell, (): void => { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(v2, f)]; + rt.panicFmt(["init ", args2[0]]); + }, undefined, undefined, rt.None); + put(out, _76); + } else if (rt.u8Rem(v2, 2) === 0) { + make(v2); + cell = new rt.OnceLock(undefined); + } else { + cell = new rt.OnceLock(rt.None); + } + } + if (cell.v === rt.None) { + rt.byteVecPush(out, 238); + } else { + put(out, undefined); + } +} + +/** A `u64` past 2^53, from one byte. */ +export function wide(v: rt.u8): rt.u64 { + return rt.u64Mul(v as rt.u64, { hi: 0x1010101, lo: 0x1010101 } as rt.u64); +} + +/** `None` for every third byte. */ +export function maybe(v: rt.u8): rt.u8 | undefined { + return rt.thenSome(rt.u8Rem(v, 3) !== 0, v); +} + +export function putMaybe(out: rt.ByteVec, t: rt.u8 | undefined): void { + if (t === undefined) { + rt.byteVecPush(out, 2); + } else { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(1, t))); + } +} + +//# sourceMappingURL=cells.ts.map diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 6561fd200..9b71a09ea 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -2,6 +2,7 @@ import * as rt from "./rt.ts"; import { atomics } from "./atomics.ts"; +import { cells } from "./cells.ts"; import { chars } from "./chars.ts"; import { chunks } from "./chunks.ts"; import { hashMaps, sets, btreeMaps, deques, vecs, stores } from "./collections.ts"; @@ -74,7 +75,7 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) counts(data22, out22); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::rounding", (_232: rt.u8, _310: rt.ByteSlice, out23: rt.ByteVec): void => { rounding(out23); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::skips", skips] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["wrappers::wrappers", wrappers] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["edits::edits", edits] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["utf8::decodes", decodes] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["floats::floats", floats] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["atomics::atomics", atomics] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void]]; + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::skips", skips] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["wrappers::wrappers", wrappers] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["edits::edits", edits] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["utf8::decodes", decodes] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["floats::floats", floats] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["atomics::atomics", atomics] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["cells::cells", cells] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void]]; } /** Run one case. */ diff --git a/ts/fixtures/lang/src/cells.rs b/ts/fixtures/lang/src/cells.rs new file mode 100644 index 000000000..e64bd4cac --- /dev/null +++ b/ts/fixtures/lang/src/cells.rs @@ -0,0 +1,119 @@ +//! One-time cells, `OnceCell` and `OnceLock`, of values that are numbers, wide integers, +//! `Option`s whose `None` is `rt.None`, `()`, and strings: read, set, initialized, taken, +//! and initialized again from within their own initialization, which panics. + +use std::cell::OnceCell; +use std::sync::OnceLock; + +macro_rules! cells { + ($($name:ident: $cell:ident<$t:ty>, $make:expr, $put:expr;)*) => {$( + /// Steps of an operation and an operand on one cell, each putting what it read. + fn $name(data: &[u8], out: &mut Vec) { + let make: fn(u8) -> $t = $make; + let put: fn(&mut Vec, &$t) = $put; + let mut cell: $cell<$t> = $cell::new(); + let mut data = data; + while let [op, v, rest @ ..] = data { + data = rest; + let (op, v) = (*op, *v); + match op % 9 { + 0 => match cell.get() { + Some(t) => { + out.push(1); + put(out, t); + } + None => out.push(0), + }, + 1 => match cell.set(make(v)) { + Ok(()) => out.push(1), + Err(t) => { + out.push(0); + put(out, &t); + } + }, + 2 => put(out, cell.get_or_init(|| make(v))), + // Empty while it initializes. + 3 => { + let mut seen = 2; + let t = cell.get_or_init(|| { + seen = cell.get().is_some() as u8; + make(v) + }); + put(out, t); + out.push(seen); + } + 4 => match cell.take() { + Some(t) => { + out.push(1); + put(out, &t); + } + None => out.push(0), + }, + // Set from within its own initialization. + 5 => put( + out, + cell.get_or_init(|| { + _ = cell.set(make(v ^ 1)); + make(v) + }), + ), + 6 => { + let mut inner = Vec::new(); + let t = cell.get_or_init(|| { + put(&mut inner, cell.get_or_init(|| make(v ^ 1))); + make(v) + }); + put(out, t); + out.extend_from_slice(&inner); + } + 7 => put(out, cell.get_or_init(|| panic!("init {v}"))), + _ => match v % 2 { + 0 => cell = $cell::from(make(v)), + _ => cell = Default::default(), + }, + } + } + match cell.into_inner() { + Some(t) => put(out, &t), + None => out.push(0xee), + } + } + )* + + /// Steps on the cell and value type `kind` picks. + pub fn cells(kind: u8, data: &[u8], out: &mut Vec) { + let cases: Vec)> = vec![$($name),*]; + cases[usize::from(kind) % cases.len()](data, out) + } + }; +} + +cells! { + cell_u8: OnceCell, |v| v, |out, t| out.push(*t); + lock_u8: OnceLock, |v| v, |out, t| out.push(*t); + cell_u64: OnceCell, wide, |out, t| out.extend_from_slice(&t.to_be_bytes()); + lock_u64: OnceLock, wide, |out, t| out.extend_from_slice(&t.to_be_bytes()); + cell_option: OnceCell>, maybe, put_maybe; + lock_option: OnceLock>, maybe, put_maybe; + cell_unit: OnceCell<()>, |_| (), |out, _| out.push(0xaa); + lock_unit: OnceLock<()>, |_| (), |out, _| out.push(0xaa); + cell_string: OnceCell, |v| v.to_string(), |out, t| out.extend_from_slice(t.as_bytes()); + lock_string: OnceLock, |v| v.to_string(), |out, t| out.extend_from_slice(t.as_bytes()); +} + +/// A `u64` past 2^53, from one byte. +fn wide(v: u8) -> u64 { + u64::from(v) * 0x0101_0101_0101_0101 +} + +/// `None` for every third byte. +fn maybe(v: u8) -> Option { + (v % 3 != 0).then_some(v) +} + +fn put_maybe(out: &mut Vec, t: &Option) { + match t { + Some(v) => out.extend_from_slice(&[1, *v]), + None => out.push(2), + } +} diff --git a/ts/fixtures/lang/src/harness.rs b/ts/fixtures/lang/src/harness.rs index 0922af242..f5d4ae360 100644 --- a/ts/fixtures/lang/src/harness.rs +++ b/ts/fixtures/lang/src/harness.rs @@ -2,7 +2,7 @@ //! case and the rest is its input. use crate::{ - atomics, chars, chunks, collections, combinators, cows, durations, edits, floats, fmt, generics, ints, iters, keys, + atomics, cells, chars, chunks, collections, combinators, cows, durations, edits, floats, fmt, generics, ints, iters, keys, nested, refs, shapes, splits, strs, utf8, wrappers, }; @@ -82,6 +82,7 @@ fn cases() -> Vec<(&'static str, Case)> { ("utf8::decodes", utf8::decodes), ("floats::floats", floats::floats), ("atomics::atomics", atomics::atomics), + ("cells::cells", cells::cells), ] } diff --git a/ts/fixtures/lang/src/lib.rs b/ts/fixtures/lang/src/lib.rs index feadbf48f..4ae202f9b 100644 --- a/ts/fixtures/lang/src/lib.rs +++ b/ts/fixtures/lang/src/lib.rs @@ -4,12 +4,13 @@ //! aggregates, closures, traits, generic types, formatting, collections, UTF-8 //! decoding, `&mut` to values JS copies, the standard library calls it maps, //! `Option`'s and `Result`'s combinators from core's MIR, `Option`s of values that can -//! already be `undefined`, and atomics. +//! already be `undefined`, atomics, and one-time cells. //! //! `harness::run` is the entry point both sides of the differential test run, and //! `fmt::Fault` an error only `caller.ts` prints. mod atomics; +mod cells; mod chars; mod chunks; mod collections; diff --git a/ts/fixtures/task/expected/drops.ts b/ts/fixtures/task/expected/drops.ts index a1db9f3be..7875a5414 100644 --- a/ts/fixtures/task/expected/drops.ts +++ b/ts/fixtures/task/expected/drops.ts @@ -6,6 +6,7 @@ import { isSomeAnd$Option_Guard_options_closure7, unwrapOr$Option_Guard, unwrapO import { ok$Result_Guard_Guard, err$Result_Guard_Guard, mapOrElse$Result_Guard_Guard_u32_options_closure9_options_closure10, inspectErr$Result_u8_Key_tripped_closure6, andThen$Result_Guard_Guard_Guard_options_closure8, unwrapOr$Result_Guard_Guard } from "./core/result.ts"; import { scoped, discarded, iterated, blasted } from "./drops/closures.ts"; import { looped, collected, drained, extended, bombed, spent } from "./drops/iters.ts"; +import { run as once_run } from "./drops/once.ts"; import * as Bomb from "./drops.Bomb.ts"; import * as Entries from "./drops.Entries.ts"; import type * as Fault from "./drops.Fault.ts"; @@ -21,6 +22,11 @@ import type * as Consumer from "./kio.Consumer.ts"; import * as Log from "./log.Log.ts"; import * as Guard from "./model.Guard.ts"; +/** Run one-time cells' scenario `at`. */ +export function cells(log: Log.Log, id: rt.u32, at: rt.u8): void { + once_run(log, id, at); +} + /** * Run scenario `arg % 23`, panicking at the point `arg / 23 % 11` names, if any: what * every value std holds drops, where Rust drops it, and in Rust's order. diff --git a/ts/fixtures/task/expected/drops/once.Cached.ts b/ts/fixtures/task/expected/drops/once.Cached.ts new file mode 100644 index 000000000..589ccc0f9 --- /dev/null +++ b/ts/fixtures/task/expected/drops/once.Cached.ts @@ -0,0 +1,33 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "../rt.ts"; +import { drop$Option_Held } from "../lib.ts"; +import type * as Held from "../drops.Held.ts"; +import type * as Guard from "../model.Guard.ts"; + +/** A struct holding a cell, as moq's caches do. */ +export class Cached { + sweep: rt.OnceLock; + guard: Guard.Guard; + + constructor(fields: { sweep: rt.OnceLock; guard: Guard.Guard }) { + this.sweep = fields.sweep; + this.guard = fields.guard; + } + + [Symbol.dispose](): void { + let dropped: number = 0; + try { + drop$Option_Held(this.sweep.v); + dropped = 1; + rt.drop(this.guard); + } catch (e) { + if (dropped < 1) { + rt.drop(this.guard); + } + throw e; + } + } +} + +//# sourceMappingURL=once.Cached.ts.map diff --git a/ts/fixtures/task/expected/drops/once.CellProbe.ts b/ts/fixtures/task/expected/drops/once.CellProbe.ts new file mode 100644 index 000000000..e1c3f9ad6 --- /dev/null +++ b/ts/fixtures/task/expected/drops/once.CellProbe.ts @@ -0,0 +1,51 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "../rt.ts"; +import * as Log from "../log.Log.ts"; +import * as Guard from "../model.Guard.ts"; + +/** As it drops, notes whether `cell` is empty, then fills it. */ +export class CellProbe { + _0: rt.OnceCell; + _1: Guard.Guard; + + constructor(_0: rt.OnceCell, _1: Guard.Guard) { + this._0 = _0; + this._1 = _1; + } + + [Symbol.dispose](): void { + let dropped: number = 0; + try { + drop$Drop(this); + dropped = 1; + rt.drop(this._1); + } catch (e) { + if (dropped < 1) { + rt.drop(this._1); + } + throw e; + } + } +} + +export function drop$Drop(self: CellProbe): void { + const part = self._0.v !== undefined; + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part, f)]; + const _4: string = rt.fmtFormat(["probe ", args2[0]]); + Guard.note(self._1, _4); + const id: rt.u32 = rt.u32Add(Guard.id(self._1), 1); + const log: Log.Log = Log.clone$Clone(Guard.log(self._1)); + const _44: rt.OnceCell = self._0; + const captured = log; + const part2 = Guard.id(rt.onceGetOrInit(_44, rt.closure((): Guard.Guard => { + return Guard.new(id, captured); + }, (): void => { + rt.drop(captured); + }), rt.drop, rt.drop)); + const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part2, f)]; + const _30: string = rt.fmtFormat(["filled ", args4[0]]); + Guard.note(self._1, _30); +} + +//# sourceMappingURL=once.CellProbe.ts.map diff --git a/ts/fixtures/task/expected/drops/once.LockProbe.ts b/ts/fixtures/task/expected/drops/once.LockProbe.ts new file mode 100644 index 000000000..77d301bc0 --- /dev/null +++ b/ts/fixtures/task/expected/drops/once.LockProbe.ts @@ -0,0 +1,51 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "../rt.ts"; +import * as Log from "../log.Log.ts"; +import * as Guard from "../model.Guard.ts"; + +/** [`CellProbe`] of a `OnceLock`, which must also be free to initialize again. */ +export class LockProbe { + _0: rt.OnceLock; + _1: Guard.Guard; + + constructor(_0: rt.OnceLock, _1: Guard.Guard) { + this._0 = _0; + this._1 = _1; + } + + [Symbol.dispose](): void { + let dropped: number = 0; + try { + drop$Drop(this); + dropped = 1; + rt.drop(this._1); + } catch (e) { + if (dropped < 1) { + rt.drop(this._1); + } + throw e; + } + } +} + +export function drop$Drop(self: LockProbe): void { + const part = self._0.v !== undefined; + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part, f)]; + const _4: string = rt.fmtFormat(["probe ", args2[0]]); + Guard.note(self._1, _4); + const id: rt.u32 = rt.u32Add(Guard.id(self._1), 1); + const log: Log.Log = Log.clone$Clone(Guard.log(self._1)); + const _44: rt.OnceLock = self._0; + const captured = log; + const part2 = Guard.id(rt.onceGetOrInit(_44, rt.closure((): Guard.Guard => { + return Guard.new(id, captured); + }, (): void => { + rt.drop(captured); + }), rt.drop, rt.drop)); + const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part2, f)]; + const _30: string = rt.fmtFormat(["filled ", args4[0]]); + Guard.note(self._1, _30); +} + +//# sourceMappingURL=once.LockProbe.ts.map diff --git a/ts/fixtures/task/expected/drops/once.ts b/ts/fixtures/task/expected/drops/once.ts new file mode 100644 index 000000000..c97b02762 --- /dev/null +++ b/ts/fixtures/task/expected/drops/once.ts @@ -0,0 +1,533 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "../rt.ts"; +import { drop$Held, drop$Option_Held, drop$Result_unit_Guard, drop$Result_unit_Held, drop$Result_unit_Option_Guard } from "../lib.ts"; +import { mapOr$Option_Guard_u32_drained_closure4 } from "../core/option.ts"; +import * as Cached from "../drops/once.Cached.ts"; +import * as CellProbe from "../drops/once.CellProbe.ts"; +import * as LockProbe from "../drops/once.LockProbe.ts"; +import type * as Held from "../drops.Held.ts"; +import * as Log from "../log.Log.ts"; +import * as Guard from "../model.Guard.ts"; + +/** Run scenario `at`: what each cell drops, where Rust drops it, and in Rust's order. */ +export function run(log: Log.Log, id: rt.u32, at: rt.u8): void { + let cell!: rt.OnceCell; + let _17!: rt.Result; + let refused!: rt.Result; + let lock!: rt.OnceLock; + let _64!: Guard.Guard; + let cell2!: rt.OnceLock; + let other!: rt.OnceCell; + let cell3!: rt.OnceCell; + let taken!: Guard.Guard | undefined; + let _166!: Guard.Guard | undefined; + let cell4!: rt.OnceCell; + let cell5!: rt.OnceCell; + let _probe!: CellProbe.CellProbe; + let lock3!: rt.OnceLock; + let _probe2!: LockProbe.LockProbe; + let shared!: rt.Arc; + let _232!: rt.OnceLock; + let other2!: rt.Arc; + let cells!: rt.OnceCell[]; + let v!: rt.OnceCell[]; + let cell6!: rt.OnceCell; + let _310!: rt.Result; + let _325!: rt.Result; + let _405!: boolean; + let _406!: boolean; + let _407!: boolean; + let _408!: boolean; + let _409!: boolean; + let _410!: boolean; + let _411!: boolean; + let _412!: boolean; + let unwind: number = 0; + try { + _412 = false; + _411 = false; + _410 = false; + _409 = false; + _408 = false; + _407 = false; + _406 = false; + _405 = false; + const guard: (a0: rt.u32) => Guard.Guard = (n: rt.u32): Guard.Guard => { + return Guard.new(rt.u32Add(id, n), Log.clone$Clone(log)); + }; + const _6: rt.u8 = rt.u8Rem(at, 8); + if (_6 === 0) { + _412 = true; + cell = new rt.OnceCell(undefined); + unwind = 234; + const _19: Guard.Guard = guard(1); + _17 = rt.onceSet(cell, _19); + unwind = 217; + const part13 = _17.ok; + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part13, f)]; + const _11: string = rt.fmtFormat(["set ", args2[0]]); + unwind = 234; + drop$Result_unit_Guard(_17); + Log.note(log, _11); + const _28: Guard.Guard = guard(2); + refused = rt.onceSet(cell, _28); + unwind = 232; + _411 = true; + const part14 = !refused.ok; + const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part14, f)]; + Log.note(log, rt.fmtFormat(["refused ", args4[0]])); + _411 = false; + drop$Result_unit_Guard(refused); + const part15 = mapOr$Option_Guard_u32_drained_closure4(cell.v, 0, (g2: Guard.Guard): rt.u32 => { + return rt.u32Sub(Guard.id(g2), id); + }); + const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part15, f)]; + Log.note(log, rt.fmtFormat(["held ", args6[0]])); + _412 = false; + rt.drop(cell); + _64 = guard(3); + unwind = 216; + const _67: Guard.Guard = guard(4); + unwind = 232; + lock = new rt.OnceLock({ tag: "Two", _0: _64, _1: _67 } as Held.Held); + unwind = 215; + const _72 = { tag: "One", _0: guard(5) } as Held.Held; + drop$Result_unit_Held(rt.onceSet(lock, _72)); + const part16 = lock.v !== undefined; + const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part16, f)]; + Log.note(log, rt.fmtFormat(["kept ", args8[0]])); + unwind = 232; + drop$Option_Held(lock.v); + _411 = false; + _412 = false; + } else if (_6 === 1) { + cell2 = new rt.OnceLock(undefined); + unwind = 214; + const captured7 = guard(11); + const captured8 = guard; + const part11 = rt.u32Sub(Guard.id(rt.onceGetOrInit(cell2, rt.closure((): Guard.Guard => { + let unwind6: number = 0; + try { + unwind6 = 5; + Guard.note(captured7, "init"); + const _07: Guard.Guard = captured8(12); + unwind6 = 0; + rt.drop(captured7); + return _07; + } catch (e6) { + if (unwind6 === 0) { + throw e6; + } + rt.drop(captured7); + throw e6; + } + }, (): void => { + rt.drop(captured7); + }), rt.drop, rt.drop)), id); + const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part11, f)]; + Log.note(log, rt.fmtFormat(["made ", args10[0]])); + const captured9 = guard(13); + const captured10 = guard; + const part12 = rt.u32Sub(Guard.id(rt.onceGetOrInit(cell2, rt.closure((): Guard.Guard => { + let unwind7: number = 0; + try { + unwind7 = 5; + Guard.note(captured9, "init"); + const _08: Guard.Guard = captured10(14); + unwind7 = 0; + rt.drop(captured9); + return _08; + } catch (e7) { + if (unwind7 === 0) { + throw e7; + } + rt.drop(captured9); + throw e7; + } + }, (): void => { + rt.drop(captured9); + }), rt.drop, rt.drop)), id); + const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part12, f)]; + Log.note(log, rt.fmtFormat(["kept ", args12[0]])); + other = new rt.OnceCell(undefined); + unwind = 230; + _410 = true; + const captured11 = guard(15); + const captured12 = guard; + rt.onceGetOrInit(other, rt.closure((): Held.Held => { + let _25!: Guard.Guard; + let unwind8: number = 0; + try { + unwind8 = 3; + _25 = captured11; + return { tag: "Two", _0: _25, _1: captured12(16) } as Held.Held; + } catch (e8) { + if (unwind8 === 0) { + throw e8; + } + rt.drop(_25); + throw e8; + } + }, (): void => { + rt.drop(captured11); + }), drop$Held, rt.drop); + _410 = false; + drop$Option_Held(other.v); + unwind = 0; + _410 = false; + rt.drop(cell2); + } else if (_6 === 2) { + cell3 = new rt.OnceCell(guard(21)); + unwind = 228; + _409 = true; + taken = rt.onceTake(cell3); + unwind = 226; + _408 = true; + const part8 = taken !== undefined; + const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part8, f)]; + Log.note(log, rt.fmtFormat(["taken ", args14[0]])); + _408 = false; + rt.drop(taken); + _166 = rt.onceTake(cell3); + unwind = 213; + const part9 = _166 === undefined; + const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part9, f)]; + const _160: string = rt.fmtFormat(["empty ", args16[0]]); + unwind = 226; + rt.drop(_166); + Log.note(log, _160); + const _174: Guard.Guard = guard(22); + drop$Result_unit_Guard(rt.onceSet(cell3, _174)); + rt.drop(new rt.OnceLock(guard(23)).v); + _409 = false; + const part10 = mapOr$Option_Guard_u32_drained_closure4(cell3.v, 0, (g: Guard.Guard): rt.u32 => { + let unwind5: number = 0; + try { + unwind5 = 5; + const _610: rt.u32 = rt.u32Sub(Guard.id(g), id); + unwind5 = 0; + rt.drop(g); + return _610; + } catch (e5) { + if (unwind5 === 0) { + throw e5; + } + rt.drop(g); + throw e5; + } + }); + const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part10, f)]; + Log.note(log, rt.fmtFormat(["inner ", args18[0]])); + _408 = false; + _409 = false; + } else if (_6 === 3) { + cell4 = new rt.OnceCell(undefined); + unwind = 212; + const owned3: Guard.Guard = guard(31); + const captured5 = guard; + const captured6 = owned3; + rt.onceGetOrInit(cell4, rt.closure((): Guard.Guard => { + let unwind4: number = 0; + try { + unwind4 = 8; + drop$Result_unit_Guard(rt.onceSet(cell4, captured5(32))); + Guard.note(captured6, "init"); + const _05: Guard.Guard = captured5(33); + unwind4 = 0; + rt.drop(captured6); + return _05; + } catch (e4) { + if (unwind4 === 0) { + throw e4; + } + rt.drop(captured6); + throw e4; + } + }, (): void => { + rt.drop(captured6); + }), rt.drop, rt.drop); + unwind = 0; + rt.drop(cell4); + } else if (_6 === 4) { + cell5 = new rt.OnceCell(undefined); + unwind = 211; + const _209: Guard.Guard = guard(40); + unwind = 210; + _probe = new CellProbe.CellProbe(cell5, _209); + const captured3 = guard(42); + const captured4 = id; + rt.onceGetOrInit(cell5, rt.closure((): Guard.Guard => { + let unwind3: number = 0; + try { + unwind3 = 5; + Guard.note(captured3, "init"); + const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(captured4, f)]; + rt.panicFmt(["d", args38[0], " init"]); + } catch (e3) { + if (unwind3 === 0) { + throw e3; + } + rt.drop(captured3); + throw e3; + } + }, (): void => { + rt.drop(captured3); + }), rt.drop, rt.drop); + unwind = 211; + rt.drop(_probe); + unwind = 0; + rt.drop(cell5); + } else if (_6 === 5) { + lock3 = new rt.OnceLock(undefined); + unwind = 209; + const _221: Guard.Guard = guard(50); + unwind = 208; + _probe2 = new LockProbe.LockProbe(lock3, _221); + const captured = guard(52); + const captured2 = id; + rt.onceGetOrInit(lock3, rt.closure((): Guard.Guard => { + let unwind2: number = 0; + try { + unwind2 = 5; + Guard.note(captured, "init"); + const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(captured2, f)]; + rt.panicFmt(["d", args36[0], " init"]); + } catch (e2) { + if (unwind2 === 0) { + throw e2; + } + rt.drop(captured); + throw e2; + } + }, (): void => { + rt.drop(captured); + }), rt.drop, rt.drop); + unwind = 209; + rt.drop(_probe2); + unwind = 0; + rt.drop(lock3); + } else if (_6 === 6) { + _232 = new rt.OnceLock(undefined); + unwind = 207; + const _233: Guard.Guard = guard(61); + unwind = 0; + shared = new rt.Arc(new Cached.Cached({ sweep: _232, guard: _233 })); + unwind = 224; + _407 = true; + other2 = rt.arcClone(shared); + unwind = 222; + _406 = true; + rt.onceGetOrInit(shared.value.sweep, (): Held.Held => { + return { tag: "One", _0: guard(62) } as Held.Held; + }, drop$Held); + _407 = false; + rt.drop(shared); + const part6 = other2.value.sweep.v !== undefined; + const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part6, f)]; + Log.note(log, rt.fmtFormat(["swept ", args20[0]])); + _406 = false; + rt.drop(other2); + v = []; + unwind = 206; + const _268: rt.OnceCell = new rt.OnceCell(guard(63)); + v.push(_268); + const _274: rt.OnceCell = new rt.OnceCell(undefined); + v.push(_274); + const _277: rt.OnceCell = new rt.OnceCell(guard(64)); + v.push(_277); + unwind = 220; + _405 = true; + cells = v; + const part7 = cells.length; + const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part7, f)]; + Log.note(log, rt.fmtFormat(["cells ", args22[0]])); + _405 = false; + rt.dropAll(cells); + rt.drop(new rt.OnceLock(guard(65))); + _405 = false; + _406 = false; + _407 = false; + } else { + cell6 = new rt.OnceCell(rt.None); + unwind = 205; + _310 = rt.onceSet(cell6, undefined as Guard.Guard | undefined, rt.None); + unwind = 204; + const part = _310.ok; + const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part, f)]; + const _304: string = rt.fmtFormat(["none ", args24[0]]); + unwind = 205; + drop$Result_unit_Option_Guard(_310); + Log.note(log, _304); + const _327: Guard.Guard | undefined = guard(71); + _325 = rt.onceSet(cell6, _327, rt.None); + unwind = 203; + const part2 = !_325.ok; + const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part2, f)]; + const _319: string = rt.fmtFormat(["full ", args26[0]]); + unwind = 205; + drop$Result_unit_Option_Guard(_325); + Log.note(log, _319); + const unit: rt.OnceLock = new rt.OnceLock(rt.None); + unwind = 202; + const part3 = rt.onceSet(unit, undefined, rt.None).ok; + const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part3, f)]; + Log.note(log, rt.fmtFormat(["unit ", args28[0]])); + const part4 = !rt.onceSet(unit, undefined, rt.None).ok; + const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part4, f)]; + Log.note(log, rt.fmtFormat(["again ", args30[0]])); + const part5 = cell6.v !== rt.None; + const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part5, f)]; + Log.note(log, rt.fmtFormat(["got ", args32[0]])); + unwind = 0; + rt.drop(cell6); + } + unwind = 0; + const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(id, f)]; + Log.note(log, rt.fmtFormat(["d", args34[0], " cells done"])); + } catch (e) { + b1: { + b2: { + b3: { + b4: { + b5: { + b6: { + b7: { + b8: { + b9: { + b10: { + if (unwind === 0) { + throw e; + } + if (unwind === 202) { + break b2; + } + if (unwind === 203) { + drop$Result_unit_Option_Guard(_325); + break b2; + } + if (unwind === 204) { + drop$Result_unit_Option_Guard(_310); + break b2; + } + if (unwind === 205) { + break b2; + } + if (unwind === 206) { + rt.dropAll(v); + break b4; + } + if (unwind === 207) { + drop$Option_Held(_232.v); + break b1; + } + if (unwind === 208) { + rt.drop(_probe2); + break b5; + } + if (unwind === 209) { + break b5; + } + if (unwind === 210) { + rt.drop(_probe); + break b6; + } + if (unwind === 211) { + break b6; + } + if (unwind === 212) { + rt.drop(cell4); + break b1; + } + if (unwind === 213) { + rt.drop(_166); + break b8; + } + if (unwind === 214) { + break b9; + } + if (unwind === 215) { + drop$Option_Held(lock.v); + } else if (unwind === 216) { + rt.drop(_64); + } else { + if (unwind === 217) { + drop$Result_unit_Guard(_17); + break b10; + } + if (unwind === 220) { + if (!_405) { + break b4; + } + rt.dropAll(cells); + break b4; + } + if (unwind === 222) { + break b4; + } + if (unwind === 224) { + break b3; + } + if (unwind === 226) { + break b8; + } + if (unwind === 228) { + break b7; + } + if (unwind === 230) { + if (!_410) { + break b9; + } + drop$Option_Held(other.v); + break b9; + } + if (unwind !== 232) { + break b10; + } + } + if (_411) { + drop$Result_unit_Guard(refused); + } + } + if (!_412) { + break b1; + } + rt.drop(cell); + break b1; + } + rt.drop(cell2); + break b1; + } + if (_408) { + rt.drop(taken); + } + } + if (!_409) { + break b1; + } + rt.drop(cell3); + break b1; + } + rt.drop(cell5); + break b1; + } + rt.drop(lock3); + break b1; + } + if (_406) { + rt.drop(other2); + } + } + if (!_407) { + break b1; + } + rt.drop(shared); + break b1; + } + rt.drop(cell6); + } + throw e; + } +} + +//# sourceMappingURL=once.ts.map diff --git a/ts/fixtures/task/expected/lib.ts b/ts/fixtures/task/expected/lib.ts index 628fc357d..ee6020ea6 100644 --- a/ts/fixtures/task/expected/lib.ts +++ b/ts/fixtures/task/expected/lib.ts @@ -229,6 +229,24 @@ export function drop$Result_u8_Key(_1: rt.Result): void { } } +export function drop$Result_unit_Guard(_1: rt.Result): void { + if (!_1.ok) { + rt.drop(_1.error); + } +} + +export function drop$Result_unit_Held(_1: rt.Result): void { + if (!_1.ok) { + drop$Held(_1.error); + } +} + +export function drop$Result_unit_Option_Guard(_1: rt.Result): void { + if (!_1.ok) { + rt.drop(_1.error); + } +} + export function drop$Text(_1: Text.Text): void { if (_1.tag !== "Borrowed") { rt.drop(_1._0); diff --git a/ts/fixtures/task/src/drops.rs b/ts/fixtures/task/src/drops.rs index 47708fcd9..56c8373dd 100644 --- a/ts/fixtures/task/src/drops.rs +++ b/ts/fixtures/task/src/drops.rs @@ -23,6 +23,7 @@ macro_rules! list { mod closures; mod iters; +mod once; /// A value of a type that drops, with no `[Symbol.dispose]` of its own. pub enum Held { @@ -64,6 +65,11 @@ pub struct Named<'a>(Text<'a>); /// order, the second after the first panics. pub struct Entries(Vec<(K, V)>); +/// Run one-time cells' scenario `at`. +pub fn cells(log: &Log, id: u32, at: u8) { + once::run(log, id, at); +} + /// Run scenario `arg % 23`, panicking at the point `arg / 23 % 11` names, if any: what /// every value std holds drops, where Rust drops it, and in Rust's order. pub fn run(log: &Log, id: u32, arg: u8) { diff --git a/ts/fixtures/task/src/drops/once.rs b/ts/fixtures/task/src/drops/once.rs new file mode 100644 index 000000000..d660a0838 --- /dev/null +++ b/ts/fixtures/task/src/drops/once.rs @@ -0,0 +1,149 @@ +//! What one-time cells drop: the value they hold, as they drop; a value `set` refuses, by +//! whoever it goes back to; an initializing closure, as a call consumes it, or uncalled +//! when the cell is full; and what a `OnceCell` initialized from within its own +//! initialization made, before it panics. A panic in the initializing closure leaves the +//! cell empty, which a value dropping as it unwinds sees and fills. + +use std::cell::OnceCell; +use std::sync::{Arc, OnceLock}; + +use super::Held; +use crate::log::Log; +use crate::model::Guard; + +/// As it drops, notes whether `cell` is empty, then fills it. +struct CellProbe<'a>(&'a OnceCell, Guard); + +impl Drop for CellProbe<'_> { + fn drop(&mut self) { + self.1.note(&format!("probe {}", self.0.get().is_some())); + let id = self.1.id() + 1; + let log = self.1.log().clone(); + let filled = self.0.get_or_init(|| Guard::new(id, log)); + self.1.note(&format!("filled {}", filled.id())); + } +} + +/// [`CellProbe`] of a `OnceLock`, which must also be free to initialize again. +struct LockProbe<'a>(&'a OnceLock, Guard); + +impl Drop for LockProbe<'_> { + fn drop(&mut self) { + self.1.note(&format!("probe {}", self.0.get().is_some())); + let id = self.1.id() + 1; + let log = self.1.log().clone(); + let filled = self.0.get_or_init(|| Guard::new(id, log)); + self.1.note(&format!("filled {}", filled.id())); + } +} + +/// A struct holding a cell, as moq's caches do. +struct Cached { + sweep: OnceLock, + guard: Guard, +} + +/// Run scenario `at`: what each cell drops, where Rust drops it, and in Rust's order. +pub fn run(log: &Log, id: u32, at: u8) { + let guard = |n: u32| Guard::new(id + n, log.clone()); + match at % 8 { + 0 => { + let cell = OnceCell::new(); + log.note(format!("set {}", cell.set(guard(1)).is_ok())); + let refused = cell.set(guard(2)); + log.note(format!("refused {}", refused.is_err())); + drop(refused); + log.note(format!("held {}", cell.get().map_or(0, |g| g.id() - id))); + drop(cell); + let lock = OnceLock::from(Held::Two(guard(3), guard(4))); + // A refused value no one keeps drops as the statement ends. + _ = lock.set(Held::One(guard(5))); + log.note(format!("kept {}", lock.get().is_some())); + } + 1 => { + let cell = OnceLock::new(); + let owned = guard(11); + let made = cell.get_or_init(move || { + owned.note("init"); + guard(12) + }); + log.note(format!("made {}", made.id() - id)); + let unused = guard(13); + let kept = cell.get_or_init(move || { + unused.note("init"); + guard(14) + }); + log.note(format!("kept {}", kept.id() - id)); + let other: OnceCell = OnceCell::default(); + let owned = guard(15); + other.get_or_init(move || Held::Two(owned, guard(16))); + drop(other); + } + 2 => { + let mut cell = OnceCell::from(guard(21)); + let taken = cell.take(); + log.note(format!("taken {}", taken.is_some())); + drop(taken); + log.note(format!("empty {}", cell.take().is_none())); + _ = cell.set(guard(22)); + let lock = OnceLock::from(guard(23)); + drop(lock.into_inner()); + log.note(format!("inner {}", cell.into_inner().map_or(0, |g| g.id() - id))); + } + 3 => { + let cell = OnceCell::new(); + let inner = &cell; + let owned = guard(31); + cell.get_or_init(move || { + _ = inner.set(guard(32)); + owned.note("init"); + guard(33) + }); + } + 4 => { + let cell = OnceCell::new(); + let _probe = CellProbe(&cell, guard(40)); + let owned = guard(42); + cell.get_or_init(move || -> Guard { + owned.note("init"); + panic!("d{id} init"); + }); + } + 5 => { + let lock = OnceLock::new(); + let _probe = LockProbe(&lock, guard(50)); + let owned = guard(52); + lock.get_or_init(move || -> Guard { + owned.note("init"); + panic!("d{id} init"); + }); + } + 6 => { + let shared = Arc::new(Cached { + sweep: OnceLock::new(), + guard: guard(61), + }); + let other = shared.clone(); + shared.sweep.get_or_init(|| Held::One(guard(62))); + drop(shared); + log.note(format!("swept {}", other.sweep.get().is_some())); + drop(other); + let cells = list![OnceCell::from(guard(63)), OnceCell::new(), OnceCell::from(guard(64))]; + log.note(format!("cells {}", cells.len())); + drop(cells); + let maybe = Some(OnceLock::from(guard(65))); + drop(maybe); + } + _ => { + // A cell that holds `None`, and one of `()`, which JS can't tell from empty. + let cell: OnceCell> = OnceCell::new(); + log.note(format!("none {}", cell.set(None).is_ok())); + log.note(format!("full {}", cell.set(Some(guard(71))).is_err())); + let unit = OnceLock::new(); + log.note(format!("unit {}", unit.set(()).is_ok())); + log.note(format!("again {}", unit.set(()).is_err())); + log.note(format!("got {}", cell.get().is_some())); + } + } + log.note(format!("d{id} cells done")); +} diff --git a/ts/fixtures/task/src/harness.rs b/ts/fixtures/task/src/harness.rs index 5b452c872..3f6c3e598 100644 --- a/ts/fixtures/task/src/harness.rs +++ b/ts/fixtures/task/src/harness.rs @@ -133,6 +133,7 @@ fn steps() -> Vec<(&'static str, Step)> { exec.spawn(futures::boxed(channels[c].consumer(), guard)); } }), + ("cells", |log, exec, _, arg| drops::cells(log, 1000 * exec.len() as u32, arg)), ] } diff --git a/ts/fixtures/task/ts.toml b/ts/fixtures/task/ts.toml index a59bae47d..367a02686 100644 --- a/ts/fixtures/task/ts.toml +++ b/ts/fixtures/task/ts.toml @@ -11,6 +11,7 @@ roots = [ "drops::run", "drops::held", "drops::edited", + "drops::cells", "futures::helpers", "futures::boxed", ] diff --git a/ts/runtime/rt/task.ts b/ts/runtime/rt/task.ts index cd0d95e6b..7d30f014f 100644 --- a/ts/runtime/rt/task.ts +++ b/ts/runtime/rt/task.ts @@ -1,10 +1,10 @@ // Ownership and async, for rust2-ts output: what Rust's `Drop`, `Arc`, `Mutex`, atomics, -// and futures do that plain JS does not. `rt.ts` re-exports all of it. +// one-time cells, and futures do that plain JS does not. `rt.ts` re-exports all of it. // // A value whose drop JS can observe has `[Symbol.dispose]`, which runs its `Drop` impl // and drops its fields. `None` is `undefined`, which drops as nothing. -import { Err, Ok, Panic, panic, type Place, type Result } from "../rt.ts"; +import { Err, type None, Ok, Panic, panic, type Place, type Result } from "../rt.ts"; // Drops @@ -232,6 +232,102 @@ export function fence(order: AtomicOrdering): void { if (order === 0) panic("there is no such thing as a relaxed fence"); } +// One-time cells + +/** + * `OnceCell`: the `Option` it holds, whose `None`, `N`, is `undefined`, or + * `rt.None` where `T` can already be `undefined`. + */ +export class OnceCell implements Disposable { + v: T | N; + + // The cell's type is its place's: its first value, often its `None`, would narrow it. + constructor(v: NoInfer) { + this.v = v; + } + + [Symbol.dispose](): void { + drop(this.v); + } +} + +/** + * `OnceLock`, which one thread never races, but which knows it is being initialized: + * initializing it again from within panics, as wasm32's `Once` does. + */ +export class OnceLock extends OnceCell { + running = false; +} + +/** A `OnceLock` initialized from within its own initialization. */ +function recursive(cell: OnceCell): void { + if (cell instanceof OnceLock && cell.running) panic("one-time initialization may not be performed recursively"); +} + +/** `OnceCell::set`: `Err(value)` back if it holds one already. */ +export function onceSet(cell: OnceCell, value: T): Result; +export function onceSet(cell: OnceCell, value: T, none: None): Result; +export function onceSet(cell: OnceCell, value: T, none?: None): Result { + recursive(cell); + if (cell.v !== none) return Err(value); + cell.v = value; + return Ok(undefined); +} + +/** `OnceCell::take`: what it holds, leaving it empty. */ +export function onceTake(cell: OnceCell): T | undefined; +export function onceTake(cell: OnceCell, none: None): T | None; +export function onceTake(cell: OnceCell, none?: None): T | None | undefined { + const v = cell.v; + cell.v = none; + return v; +} + +/** + * `OnceCell::get_or_init`: what it holds, which `f` makes first if it holds nothing, + * dropping `f` by `dropF` if not. A panic in `f` leaves it empty. A `OnceCell` that `f` + * sets itself drops what `f` made by `dropValue` and panics, as std's does. `f` of a + * `()` returns `void`. + */ +export function onceGetOrInit(cell: OnceCell, f: () => T | void, dropValue?: (value: T) => void, dropF?: (f: () => T | void) => void): T; +export function onceGetOrInit( + cell: OnceCell, + f: () => T | void, + dropValue: ((value: T) => void) | undefined, + dropF: ((f: () => T | void) => void) | undefined, + none: None, +): T; +export function onceGetOrInit( + cell: OnceCell, + f: () => T | void, + dropValue?: (value: T) => void, + dropF?: (f: () => T | void) => void, + none?: None, +): T { + if (cell.v !== none) { + dropF?.(f); + return cell.v as T; + } + recursive(cell); + let value: T; + if (cell instanceof OnceLock) { + cell.running = true; + try { + value = f() as T; + } finally { + cell.running = false; + } + } else { + value = f() as T; + if (cell.v !== none) { + dropValue?.(value); + panic("reentrant init"); + } + } + cell.v = value; + return value; +} + // Futures /** `Poll::Pending`; `Poll::Ready(v)` is `v` itself. */ diff --git a/ts/src/lower/drop.rs b/ts/src/lower/drop.rs index 847c8643f..f7f9692a7 100644 --- a/ts/src/lower/drop.rs +++ b/ts/src/lower/drop.rs @@ -39,6 +39,8 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { | Std::Box | Std::Vec | Std::Mutex + | Std::OnceCell + | Std::OnceLock | Std::Poll | Std::Pin | Std::PollFn @@ -120,9 +122,16 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { ty::Adt(adt, args) => match Std::of(self.tcx, adt.did()) { // Each drops by what it was given. Some(Std::Waker | Std::PollFn) => true, - Some(Std::Arc | Std::Mutex | Std::Option | Std::Box | Std::Pin | Std::Reverse) => { - self.disposable(args.type_at(0), span) - } + Some( + Std::Arc + | Std::Mutex + | Std::OnceCell + | Std::OnceLock + | Std::Option + | Std::Box + | Std::Pin + | Std::Reverse, + ) => self.disposable(args.type_at(0), span), // An `rt.Iter` drops what it was given to. None | Some(Std::Peekable) if self.std_iter(ty) => self.closures_held(ty), Some(_) => false, @@ -217,9 +226,17 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { ty::Adt(adt, _) if self.bound_drops(adt.did()).is_some() => true, ty::Adt(adt, args) => match Std::of(self.tcx, adt.did()) { // Each is its contents in JS. - Some(Std::Option | Std::Box | Std::Mutex | Std::MutexGuard | Std::Poll | Std::Pin | Std::Reverse) => { - args.types().all(|t| self.inert(t)) - } + Some( + Std::Option + | Std::Box + | Std::Mutex + | Std::MutexGuard + | Std::OnceCell + | Std::OnceLock + | Std::Poll + | Std::Pin + | Std::Reverse, + ) => args.types().all(|t| self.inert(t)), // Its waker. Some(Std::Context) => false, Some(_) => true, @@ -263,6 +280,10 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { let (name, args) = match std { Std::Arc => ("arcDrop", vec![value, each(self, 0)?]), Std::Mutex => return self.drop_value(value.member("value"), args.type_at(0), span), + Std::OnceCell | Std::OnceLock => { + let option = Ty::new_option(self.tcx, args.type_at(0)); + return self.drop_value(value.member("v"), option, span); + } Std::Box | Std::Pin | Std::Reverse => return self.drop_value(value, args.type_at(0), span), Std::HashMap => ("hashDrop", vec![value, each(self, 0)?, each(self, 1)?]), Std::BTreeMap => ("btreeDrop", vec![value, each(self, 0)?, each(self, 1)?]), diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index dfd4c18ba..cd19c2045 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -60,6 +60,9 @@ pub enum Std { Atomic, /// `rt.AtomicOrdering`: its discriminant. AtomicOrdering, + /// `rt.OnceCell` and `rt.OnceLock`: the `Option` each holds. + OnceCell, + OnceLock, /// `rt.Waker`. Waker, /// `rt.Context`: its waker. @@ -206,6 +209,8 @@ impl Std { ["convert", "Infallible"] => Some(Self::Infallible), ["cmp", "Ordering"] => Some(Self::Ordering), ["sync", "atomic", "Ordering"] => Some(Self::AtomicOrdering), + ["cell", "once", "OnceCell"] => Some(Self::OnceCell), + ["sync", "once_lock", "OnceLock"] => Some(Self::OnceLock), ["cmp", "Reverse"] => Some(Self::Reverse), ["ops", "range", "Bound"] => Some(Self::Bound), ["num", "nonzero", "NonZero"] => Some(Self::NonZero), @@ -541,6 +546,9 @@ fn discards(owner: &str, name: &str) -> Option<&'static [usize]> { // `then_some::` drops its value when false, and `then::` its function. ("bool", "then_some") => &[0], ("bool", "then") => &[1], + // `get_or_init::` drops its function if the cell is set, and what it made if + // it set the cell itself. + ("OnceCell" | "OnceLock", "get_or_init") => &[0, 1], _ => return None, }) } @@ -556,6 +564,7 @@ fn takes_none(owner: &str, name: &str) -> bool { "Option", "is_some" | "is_none" | "as_ref" | "copied" | "cloned" | "iter" | "iter_mut" ) | ("Iterator", "next") + | ("OnceCell" | "OnceLock", "get" | "set" | "get_or_init" | "take" | "into_inner") | ("DoubleEndedIterator", "next_back" | "nth_back") ) } @@ -1672,6 +1681,7 @@ pub fn default_value<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>) -> Option super::task::once_new(b, ty), _ => return None, }, _ => return None, diff --git a/ts/src/lower/mod.rs b/ts/src/lower/mod.rs index 0a9953372..4d7e77a76 100644 --- a/ts/src/lower/mod.rs +++ b/ts/src/lower/mod.rs @@ -953,6 +953,8 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { | library::Std::Mutex | library::Std::MutexGuard | library::Std::Atomic + | library::Std::OnceCell + | library::Std::OnceLock | library::Std::Waker | library::Std::Context | library::Std::Pin @@ -1223,6 +1225,20 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { library::Std::PoisonError => Type::Builtin("never"), library::Std::Atomic => Type::Rt("Atomic", vec![self.ty(args.type_at(0), span)]), library::Std::AtomicOrdering => Type::Rt("AtomicOrdering", vec![]), + // With the `Option`'s `None` where it is `rt.None`. + std @ (library::Std::OnceCell | library::Std::OnceLock) => { + let inner = args.type_at(0); + if let Some(msg) = self.erasure_conflict(Ty::new_option(tcx, inner)) { + self.err(span, msg); + } + let mut args = vec![self.ty(inner, span)]; + args.extend(self.erases_to(inner).undefined.then(|| Type::Rt("None", vec![]))); + let name = match std { + library::Std::OnceCell => "OnceCell", + _ => "OnceLock", + }; + Type::Rt(name, args) + } library::Std::Waker => Type::Rt("Waker", vec![]), library::Std::Context => Type::Rt("Context", vec![]), library::Std::Poll => { diff --git a/ts/src/lower/task.rs b/ts/src/lower/task.rs index b86ec68f5..1bff9765a 100644 --- a/ts/src/lower/task.rs +++ b/ts/src/lower/task.rs @@ -179,6 +179,11 @@ pub fn call<'tcx>( first(args) } ("Atomic", _) => return atomic(b, call, name, args), + ("OnceCell" | "OnceLock", _) => return once(b, call, name, args), + ("From", "from") if matches!(self_std, Some(Std::OnceCell | Std::OnceLock)) => { + let cell = self_ty.expect("a `From` impl's type"); + Expr::New(Box::new(Expr::Rt(once_class(b, cell).into())), args) + } ("atomic", "fence" | "compiler_fence") => Expr::rt("fence", args), ("Waker", "wake_by_ref") => first(args).member("wakeByRef").call(vec![]), ("Waker", "wake") => first(args).member("wake").call(vec![]), @@ -304,6 +309,67 @@ fn atomic<'tcx>( Ok(Some(e)) } +/// A `OnceCell` or `OnceLock` method: its `Option`, `v`, read or written as std +/// does, with that `Option`'s `None` where it is `rt.None`. `Ok(None)` refuses it. +fn once<'tcx>( + b: &mut Body<'_, '_, 'tcx>, + call: &Call<'tcx>, + name: &str, + args: Vec, +) -> Result, Vec> { + let tcx = b.t.tcx; + let imp = tcx.inherent_impl_of_assoc(call.def_id).expect("an inherent method"); + let generics = tcx.generics_of(imp).count(); + let cell = tcx + .type_of(imp) + .instantiate(tcx, &call.args[..generics]) + .skip_norm_wip(); + let inner = call.args.type_at(0); + let none = b.t.none_arg(inner); + let e = match name { + "new" => once_new(b, cell), + "get" | "into_inner" => first(args).member("v"), + "set" | "take" => Expr::rt( + match name { + "set" => "onceSet", + _ => "onceTake", + }, + args.into_iter().chain(none).collect(), + ), + // With what drops the value `f` made, and `f`, as `discards` says. + "get_or_init" => { + let Some(mut droppers) = b.t.droppers([inner, call.args.type_at(1)], call.span) else { + return Ok(Some(Expr::undefined())); + }; + if none.is_some() { + droppers.resize(2, Expr::undefined()); + } + Expr::rt("onceGetOrInit", args.into_iter().chain(droppers).chain(none).collect()) + } + _ => return Ok(None), + }; + Ok(Some(e)) +} + +/// `OnceCell::new()` or `OnceLock::new()` of `cell`: empty. +pub fn once_new<'tcx>(b: &Body<'_, '_, 'tcx>, cell: Ty<'tcx>) -> Expr { + let ty::Adt(_, args) = cell.kind() else { + unreachable!("a one-time cell is a struct") + }; + Expr::New( + Box::new(Expr::Rt(once_class(b, cell).into())), + vec![b.t.none(args.type_at(0))], + ) +} + +/// The runtime class of `cell`, a `OnceCell` or `OnceLock`. +fn once_class<'tcx>(b: &Body<'_, '_, 'tcx>, cell: Ty<'tcx>) -> &'static str { + match b.t.std_of(cell) { + Some(Std::OnceLock) => "OnceLock", + _ => "OnceCell", + } +} + /// `(old, value) => old op value` over `ty`, negated if `not`. fn binary<'tcx>(b: &mut Body<'_, '_, 'tcx>, op: BinOp, not: bool, ty: Ty<'tcx>, span: Span) -> Expr { let operand = |name: &str| Operand { diff --git a/ts/tests/task.ts b/ts/tests/task.ts index 50edc9308..f1a383b2e 100644 --- a/ts/tests/task.ts +++ b/ts/tests/task.ts @@ -50,6 +50,7 @@ export interface Fixture { run(log: Log, id: number, arg: number): void; held(rx: Consumer, guard: Guard): Future; edited(log: Log, id: number, at: number): void; + cells(log: Log, id: number, at: number): void; }; futures: { helpers(rx: Consumer, guard: Guard): Future; @@ -285,6 +286,7 @@ export const steps: [string, (r: Run, arg: number) => void][] = [ if (c !== undefined) r.exec.spawn(r.f.futures.boxed(r.f.Channel.consumer(r.channels[c]), guard(r))); }, ], + ["cells", (r, arg) => r.f.drops.cells(r.log, 1000 * r.exec.tasks.length, arg)], ]; /** @@ -369,4 +371,6 @@ export const cases: Uint8Array[] = [ ...Array.from({ length: 253 }, (_, arg) => script(["drops", arg])), // Each of a `Vec`'s edits, its and a tuple's `clone`, and `Ord`'s defaults, panicking at each point or none. ...Array.from({ length: 8 }, (_, at) => script(["edited", at])), + // What one-time cells drop, for every argument, which picks the scenario. + ...Array.from({ length: 256 }, (_, at) => script(["cells", at])), ]; From d66b41a49da71601dce5ae856b961aad31d49e73 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Wed, 28 Oct 2026 06:25:45 -0700 Subject: [PATCH 3/4] chore(ts): format, and rewrite ts-shared to what remains Co-Authored-By: Claude Opus 5.5 --- quest/m2/ts-shared.md | 11 +++++++---- ts/fixtures/lang/src/harness.rs | 4 ++-- ts/fixtures/task/src/harness.rs | 4 +++- ts/src/lower/library.rs | 5 ++++- 4 files changed, 16 insertions(+), 8 deletions(-) diff --git a/quest/m2/ts-shared.md b/quest/m2/ts-shared.md index e2b0470fc..c43bba09c 100644 --- a/quest/m2/ts-shared.md +++ b/quest/m2/ts-shared.md @@ -5,8 +5,8 @@ [rust2-ts](/ts/README.md) translates `Arc`, `Rc`, and `Weak` with Rust's exact counts: `strong_count`, `weak_count`, and `upgrade` match native, and the last strong drop runs `Drop` where Rust runs it. `Mutex`, `RwLock`, atomics, -`OnceLock`, `Cell`, and `RefCell` translate as the single-threaded values they -are in JS, proven by differential tests. +`OnceLock`, `OnceCell`, `Cell`, and `RefCell` translate as the single-threaded +values they are in JS, proven by differential tests. ## Plan @@ -18,8 +18,11 @@ The async spike ([#16](https://github.com/kixelated/rust2/pull/16)) landed what kio-shaped fixture needs, in `rt/task.ts`: `rt.Arc` counts strong references and drops its value with the last, `rt.Weak` upgrades while one is left, and `rt.Mutex` is its own guard. `rt.Atomic` holds a `bool` or an integer, and its operations check -their orderings as std does. Left: `Rc`, `weak_count` (a dropped `Weak` counts nothing -yet), `RwLock`, `OnceLock`, `Cell`, and `RefCell`. +their orderings as std does. `rt.OnceCell` and `rt.OnceLock` hold their `Option`, and +a `OnceLock` initialized from within its own initialization panics as wasm32's does; +their `Clone`, `Debug`, `PartialEq`, `get_mut`, and `get_or_try_init` are still refused. +Left: `Rc`, `weak_count` (a dropped `Weak` counts nothing yet), `RwLock`, `Cell`, and +`RefCell`. - `Send` and `Sync` bounds have no meaning in JS; accept them. - Keep Rust's failure modes where they are defined: a `RefCell` double borrow diff --git a/ts/fixtures/lang/src/harness.rs b/ts/fixtures/lang/src/harness.rs index f5d4ae360..3e323a0e9 100644 --- a/ts/fixtures/lang/src/harness.rs +++ b/ts/fixtures/lang/src/harness.rs @@ -2,8 +2,8 @@ //! case and the rest is its input. use crate::{ - atomics, cells, chars, chunks, collections, combinators, cows, durations, edits, floats, fmt, generics, ints, iters, keys, - nested, refs, shapes, splits, strs, utf8, wrappers, + atomics, cells, chars, chunks, collections, combinators, cows, durations, edits, floats, fmt, generics, ints, + iters, keys, nested, refs, shapes, splits, strs, utf8, wrappers, }; /// The native side's entry: [`run`], except that a case starting with 0xff prints a diff --git a/ts/fixtures/task/src/harness.rs b/ts/fixtures/task/src/harness.rs index 3f6c3e598..e3ebfcdd4 100644 --- a/ts/fixtures/task/src/harness.rs +++ b/ts/fixtures/task/src/harness.rs @@ -133,7 +133,9 @@ fn steps() -> Vec<(&'static str, Step)> { exec.spawn(futures::boxed(channels[c].consumer(), guard)); } }), - ("cells", |log, exec, _, arg| drops::cells(log, 1000 * exec.len() as u32, arg)), + ("cells", |log, exec, _, arg| { + drops::cells(log, 1000 * exec.len() as u32, arg) + }), ] } diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index cd19c2045..27e15942c 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -564,7 +564,10 @@ fn takes_none(owner: &str, name: &str) -> bool { "Option", "is_some" | "is_none" | "as_ref" | "copied" | "cloned" | "iter" | "iter_mut" ) | ("Iterator", "next") - | ("OnceCell" | "OnceLock", "get" | "set" | "get_or_init" | "take" | "into_inner") + | ( + "OnceCell" | "OnceLock", + "get" | "set" | "get_or_init" | "take" | "into_inner" + ) | ("DoubleEndedIterator", "next_back" | "nth_back") ) } From c1ed513be6fb4b39b6f0651e4996e59108623b45 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Wed, 28 Oct 2026 06:36:00 -0700 Subject: [PATCH 4/4] fix(ts): drop what a recursive OnceLock init took as it panics Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/expected/cells.ts | 16 +++++++-------- ts/fixtures/task/expected/drops/once.ts | 18 ++++++++--------- ts/runtime/rt/task.ts | 26 ++++++++++++++++--------- ts/src/lower/library.rs | 4 ++-- ts/src/lower/task.rs | 21 ++++++++++++-------- ts/tests/once.ts | 26 +++++++++++++++++++++++++ ts/tests/runtime.rs | 11 +++++++++++ 7 files changed, 86 insertions(+), 36 deletions(-) create mode 100644 ts/tests/once.ts diff --git a/ts/fixtures/lang/expected/cells.ts b/ts/fixtures/lang/expected/cells.ts index 384a0f845..84780d9fa 100644 --- a/ts/fixtures/lang/expected/cells.ts +++ b/ts/fixtures/lang/expected/cells.ts @@ -31,7 +31,7 @@ export function cellOption(data: rt.ByteSlice, out: rt.ByteVec): void { put(out, _20); } } else if (_18 === 1) { - const _26: rt.Result = rt.onceSet(cell, make(v2), rt.None); + const _26: rt.Result = rt.onceSet(cell, make(v2), undefined, rt.None); if (_26.ok) { rt.byteVecPush(out, 1); } else { @@ -65,7 +65,7 @@ export function cellOption(data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_18 === 5) { const _60: rt.OnceCell = cell; const _57: rt.u8 | undefined = rt.onceGetOrInit(cell, (): rt.u8 | undefined => { - rt.onceSet(_60, make(v2 ^ 1), rt.None); + rt.onceSet(_60, make(v2 ^ 1), undefined, rt.None); return make(v2); }, undefined, undefined, rt.None); put(out, _57); @@ -437,7 +437,7 @@ export function cellUnit(data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_18 === 1) { const _27: rt.OnceCell = cell; make(v2); - if (rt.onceSet(_27, undefined, rt.None).ok) { + if (rt.onceSet(_27, undefined, undefined, rt.None).ok) { rt.byteVecPush(out, 1); } else { rt.byteVecPush(out, 0); @@ -468,7 +468,7 @@ export function cellUnit(data: rt.ByteSlice, out: rt.ByteVec): void { const _60: rt.OnceCell = cell; const _57: undefined = rt.onceGetOrInit(cell, (): void => { make(v2 ^ 1); - rt.onceSet(_60, undefined, rt.None); + rt.onceSet(_60, undefined, undefined, rt.None); make(v2); }, undefined, undefined, rt.None); put(out, _57); @@ -538,7 +538,7 @@ export function lockOption(data: rt.ByteSlice, out: rt.ByteVec): void { put(out, _20); } } else if (_18 === 1) { - const _26: rt.Result = rt.onceSet(cell, make(v2), rt.None); + const _26: rt.Result = rt.onceSet(cell, make(v2), undefined, rt.None); if (_26.ok) { rt.byteVecPush(out, 1); } else { @@ -572,7 +572,7 @@ export function lockOption(data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_18 === 5) { const _60: rt.OnceLock = cell; const _57: rt.u8 | undefined = rt.onceGetOrInit(cell, (): rt.u8 | undefined => { - rt.onceSet(_60, make(v2 ^ 1), rt.None); + rt.onceSet(_60, make(v2 ^ 1), undefined, rt.None); return make(v2); }, undefined, undefined, rt.None); put(out, _57); @@ -944,7 +944,7 @@ export function lockUnit(data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_18 === 1) { const _27: rt.OnceLock = cell; make(v2); - if (rt.onceSet(_27, undefined, rt.None).ok) { + if (rt.onceSet(_27, undefined, undefined, rt.None).ok) { rt.byteVecPush(out, 1); } else { rt.byteVecPush(out, 0); @@ -975,7 +975,7 @@ export function lockUnit(data: rt.ByteSlice, out: rt.ByteVec): void { const _60: rt.OnceLock = cell; const _57: undefined = rt.onceGetOrInit(cell, (): void => { make(v2 ^ 1); - rt.onceSet(_60, undefined, rt.None); + rt.onceSet(_60, undefined, undefined, rt.None); make(v2); }, undefined, undefined, rt.None); put(out, _57); diff --git a/ts/fixtures/task/expected/drops/once.ts b/ts/fixtures/task/expected/drops/once.ts index c97b02762..bef170376 100644 --- a/ts/fixtures/task/expected/drops/once.ts +++ b/ts/fixtures/task/expected/drops/once.ts @@ -62,7 +62,7 @@ export function run(log: Log.Log, id: rt.u32, at: rt.u8): void { cell = new rt.OnceCell(undefined); unwind = 234; const _19: Guard.Guard = guard(1); - _17 = rt.onceSet(cell, _19); + _17 = rt.onceSet(cell, _19, rt.drop); unwind = 217; const part13 = _17.ok; const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part13, f)]; @@ -71,7 +71,7 @@ export function run(log: Log.Log, id: rt.u32, at: rt.u8): void { drop$Result_unit_Guard(_17); Log.note(log, _11); const _28: Guard.Guard = guard(2); - refused = rt.onceSet(cell, _28); + refused = rt.onceSet(cell, _28, rt.drop); unwind = 232; _411 = true; const part14 = !refused.ok; @@ -93,7 +93,7 @@ export function run(log: Log.Log, id: rt.u32, at: rt.u8): void { lock = new rt.OnceLock({ tag: "Two", _0: _64, _1: _67 } as Held.Held); unwind = 215; const _72 = { tag: "One", _0: guard(5) } as Held.Held; - drop$Result_unit_Held(rt.onceSet(lock, _72)); + drop$Result_unit_Held(rt.onceSet(lock, _72, drop$Held)); const part16 = lock.v !== undefined; const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part16, f)]; Log.note(log, rt.fmtFormat(["kept ", args8[0]])); @@ -198,7 +198,7 @@ export function run(log: Log.Log, id: rt.u32, at: rt.u8): void { rt.drop(_166); Log.note(log, _160); const _174: Guard.Guard = guard(22); - drop$Result_unit_Guard(rt.onceSet(cell3, _174)); + drop$Result_unit_Guard(rt.onceSet(cell3, _174, rt.drop)); rt.drop(new rt.OnceLock(guard(23)).v); _409 = false; const part10 = mapOr$Option_Guard_u32_drained_closure4(cell3.v, 0, (g: Guard.Guard): rt.u32 => { @@ -231,7 +231,7 @@ export function run(log: Log.Log, id: rt.u32, at: rt.u8): void { let unwind4: number = 0; try { unwind4 = 8; - drop$Result_unit_Guard(rt.onceSet(cell4, captured5(32))); + drop$Result_unit_Guard(rt.onceSet(cell4, captured5(32), rt.drop)); Guard.note(captured6, "init"); const _05: Guard.Guard = captured5(33); unwind4 = 0; @@ -351,7 +351,7 @@ export function run(log: Log.Log, id: rt.u32, at: rt.u8): void { } else { cell6 = new rt.OnceCell(rt.None); unwind = 205; - _310 = rt.onceSet(cell6, undefined as Guard.Guard | undefined, rt.None); + _310 = rt.onceSet(cell6, undefined as Guard.Guard | undefined, rt.drop, rt.None); unwind = 204; const part = _310.ok; const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part, f)]; @@ -360,7 +360,7 @@ export function run(log: Log.Log, id: rt.u32, at: rt.u8): void { drop$Result_unit_Option_Guard(_310); Log.note(log, _304); const _327: Guard.Guard | undefined = guard(71); - _325 = rt.onceSet(cell6, _327, rt.None); + _325 = rt.onceSet(cell6, _327, rt.drop, rt.None); unwind = 203; const part2 = !_325.ok; const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part2, f)]; @@ -370,10 +370,10 @@ export function run(log: Log.Log, id: rt.u32, at: rt.u8): void { Log.note(log, _319); const unit: rt.OnceLock = new rt.OnceLock(rt.None); unwind = 202; - const part3 = rt.onceSet(unit, undefined, rt.None).ok; + const part3 = rt.onceSet(unit, undefined, undefined, rt.None).ok; const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part3, f)]; Log.note(log, rt.fmtFormat(["unit ", args28[0]])); - const part4 = !rt.onceSet(unit, undefined, rt.None).ok; + const part4 = !rt.onceSet(unit, undefined, undefined, rt.None).ok; const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part4, f)]; Log.note(log, rt.fmtFormat(["again ", args30[0]])); const part5 = cell6.v !== rt.None; diff --git a/ts/runtime/rt/task.ts b/ts/runtime/rt/task.ts index 7d30f014f..bf05c135e 100644 --- a/ts/runtime/rt/task.ts +++ b/ts/runtime/rt/task.ts @@ -259,16 +259,24 @@ export class OnceLock extends OnceCel running = false; } -/** A `OnceLock` initialized from within its own initialization. */ -function recursive(cell: OnceCell): void { - if (cell instanceof OnceLock && cell.running) panic("one-time initialization may not be performed recursively"); +/** + * A `OnceLock` initialized from within its own initialization panics, as wasm32's `Once` + * does, dropping `dropped`, what the call took, as it unwinds. + */ +function recursive(cell: OnceCell, dropped: () => void): void { + if (!(cell instanceof OnceLock && cell.running)) return; + try { + panic("one-time initialization may not be performed recursively"); + } finally { + dropped(); + } } /** `OnceCell::set`: `Err(value)` back if it holds one already. */ -export function onceSet(cell: OnceCell, value: T): Result; -export function onceSet(cell: OnceCell, value: T, none: None): Result; -export function onceSet(cell: OnceCell, value: T, none?: None): Result { - recursive(cell); +export function onceSet(cell: OnceCell, value: T, dropValue?: (value: T) => void): Result; +export function onceSet(cell: OnceCell, value: T, dropValue: ((value: T) => void) | undefined, none: None): Result; +export function onceSet(cell: OnceCell, value: T, dropValue?: (value: T) => void, none?: None): Result { + recursive(cell, () => dropValue?.(value)); if (cell.v !== none) return Err(value); cell.v = value; return Ok(undefined); @@ -285,7 +293,7 @@ export function onceTake(cell: OnceCell, none?: None): T /** * `OnceCell::get_or_init`: what it holds, which `f` makes first if it holds nothing, - * dropping `f` by `dropF` if not. A panic in `f` leaves it empty. A `OnceCell` that `f` + * dropping `f` by `dropF` if not, or if a `OnceLock` panics as `recursive` does. A panic in `f` leaves it empty. A `OnceCell` that `f` * sets itself drops what `f` made by `dropValue` and panics, as std's does. `f` of a * `()` returns `void`. */ @@ -308,7 +316,7 @@ export function onceGetOrInit( dropF?.(f); return cell.v as T; } - recursive(cell); + recursive(cell, () => dropF?.(f)); let value: T; if (cell instanceof OnceLock) { cell.running = true; diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index 97540066d..cecdbdcd9 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -546,8 +546,8 @@ fn discards(owner: &str, name: &str) -> Option<&'static [usize]> { // `then_some::` drops its value when false, and `then::` its function. ("bool", "then_some") => &[0], ("bool", "then") => &[1], - // `get_or_init::` drops its function if the cell is set, and what it made if - // it set the cell itself. + // `get_or_init::` drops its function uncalled if the cell is set or a + // `OnceLock` is initializing, and what it made if it set the cell itself. ("OnceCell" | "OnceLock", "get_or_init") => &[0, 1], _ => return None, }) diff --git a/ts/src/lower/task.rs b/ts/src/lower/task.rs index 1bff9765a..2c2f0d494 100644 --- a/ts/src/lower/task.rs +++ b/ts/src/lower/task.rs @@ -329,14 +329,19 @@ fn once<'tcx>( let e = match name { "new" => once_new(b, cell), "get" | "into_inner" => first(args).member("v"), - "set" | "take" => Expr::rt( - match name { - "set" => "onceSet", - _ => "onceTake", - }, - args.into_iter().chain(none).collect(), - ), - // With what drops the value `f` made, and `f`, as `discards` says. + "take" => Expr::rt("onceTake", args.into_iter().chain(none).collect()), + // With what drops the value, which a recursive `OnceLock::set` drops as it panics. + "set" => { + let Some(mut droppers) = b.t.droppers([inner], call.span) else { + return Ok(Some(Expr::undefined())); + }; + if none.is_some() { + droppers.resize(1, Expr::undefined()); + } + Expr::rt("onceSet", args.into_iter().chain(droppers).chain(none).collect()) + } + // With what drops the value `f` made, and `f`, as `discards` says, which a recursive + // `OnceLock` init drops as it panics. "get_or_init" => { let Some(mut droppers) = b.t.droppers([inner, call.args.type_at(1)], call.span) else { return Ok(Some(Expr::undefined())); diff --git a/ts/tests/once.ts b/ts/tests/once.ts new file mode 100644 index 000000000..4a743625a --- /dev/null +++ b/ts/tests/once.ts @@ -0,0 +1,26 @@ +// What a `OnceLock` initialized from within its own initialization drops, which native +// Rust can't show: wasm32's `Once` panics, which traps there, and the host's deadlocks. +// The call drops what it took, an uncalled function or a value, as std's unwinding does. +// +// usage: node once.ts + +import { strict as assert } from "node:assert"; + +import * as rt from "../runtime/rt.ts"; + +const dropped: string[] = []; +const recursive = (f: () => void) => assert.throws(f, (e: Error) => e instanceof rt.Panic && e.message === "one-time initialization may not be performed recursively"); + +const lock = new rt.OnceLock(undefined); +const made = rt.onceGetOrInit(lock, () => { + recursive(() => rt.onceSet(lock, "set", (v) => dropped.push(v))); + recursive(() => rt.onceGetOrInit(lock, () => "inner", undefined, () => dropped.push("f"))); + return "outer"; +}); +assert.equal(made, "outer"); +assert.deepEqual(dropped, ["set", "f"]); + +// Once initialized, neither panics, and the value `set` refuses comes back undropped. +const refused = rt.onceSet(lock, "again", (v) => dropped.push(v)); +assert.deepEqual(refused, rt.Err("again")); +assert.deepEqual(dropped, ["set", "f"]); diff --git a/ts/tests/runtime.rs b/ts/tests/runtime.rs index ca06c6c28..64da946bf 100644 --- a/ts/tests/runtime.rs +++ b/ts/tests/runtime.rs @@ -25,6 +25,17 @@ fn nan_payloads() { assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr)); } +/// A recursive `OnceLock` init drops what it took as it panics, which `once.ts` checks. +#[test] +fn once_recursive() { + let script = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests").join("once.ts"); + let output = Command::new("node") + .arg(script) + .output() + .expect("running node, which the dev shell provides"); + assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr)); +} + /// The runtime's B-tree runs `btree.ts`'s script of random operations as std's does. #[test] fn btree_script() {