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/README.md b/ts/README.md index df98a462a..b4891fc01 100644 --- a/ts/README.md +++ b/ts/README.md @@ -92,6 +92,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 19d8df66e..530d2ef26 100644 --- a/ts/fixtures/lang/caller.ts +++ b/ts/fixtures/lang/caller.ts @@ -223,4 +223,23 @@ const dyns = [[], [1, 2], [3, 0, 7], [255, 1, 255, 0, 1, 2, 3, 4, 5], [0, 3, 2, Uint8Array.of(op("dyns::dyns"), 0, ...bytes), ); -export const cases: Uint8Array[] = [...loops, ...durations, ...ints(), ...utf8, ...floats, ...dyns]; +/** + * `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, ...dyns, ...cells]; diff --git a/ts/fixtures/lang/expected/cells.ts b/ts/fixtures/lang/expected/cells.ts new file mode 100644 index 000000000..84780d9fa --- /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), undefined, 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), undefined, 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, 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, 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), undefined, 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), undefined, 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, 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, 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 fddc43615..09de6221c 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"; @@ -77,7 +78,7 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) 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], ["keys::overrides", overrides] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["dyns::dyns", (_233: rt.u8, data23: rt.ByteSlice, out24: rt.ByteVec): void => { dyns(data23, out24); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void]]; + }] 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 e4157ed82..5003c3924 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, chars, chunks, collections, combinators, cows, durations, dyns, edits, floats, fmt, generics, ints, iters, - keys, nested, refs, shapes, splits, strs, utf8, wrappers, + atomics, cells, chars, chunks, collections, combinators, cows, durations, dyns, 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 @@ -84,6 +84,7 @@ fn cases() -> Vec<(&'static str, Case)> { ("atomics::atomics", atomics::atomics), ("keys::overrides", keys::overrides), ("dyns::dyns", |_, data, out| dyns::dyns(data, out)), + ("cells::cells", cells::cells), ] } diff --git a/ts/fixtures/lang/src/lib.rs b/ts/fixtures/lang/src/lib.rs index 7084ad1f5..54f53d853 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`, atomics, and trait objects. +//! already be `undefined`, atomics, trait objects, 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 a9a6a9ee0..e158d8afd 100644 --- a/ts/fixtures/task/expected/drops.ts +++ b/ts/fixtures/task/expected/drops.ts @@ -7,6 +7,7 @@ import { ok$Result_Guard_Guard, err$Result_Guard_Guard, mapOrElse$Result_Guard_G import { scoped, discarded, iterated, blasted } from "./drops/closures.ts"; import { looped, collected, drained, extended, bombed, spent } from "./drops/iters.ts"; import { boxed } from "./drops/objects.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"; @@ -27,6 +28,11 @@ export function dyns(log: Log.Log, id: rt.u32, at: rt.u8): void { boxed(log, id, at); } +/** 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..bef170376 --- /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, rt.drop); + 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, rt.drop); + 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, 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]])); + 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)); + 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), rt.drop)); + 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.drop, 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.drop, 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, 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, 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 4f5457c62..c03ae486e 100644 --- a/ts/fixtures/task/src/drops.rs +++ b/ts/fixtures/task/src/drops.rs @@ -24,6 +24,7 @@ macro_rules! list { mod closures; mod iters; mod objects; +mod once; /// A value of a type that drops, with no `[Symbol.dispose]` of its own. pub enum Held { @@ -70,6 +71,11 @@ pub fn dyns(log: &Log, id: u32, at: u8) { objects::boxed(log, id, at) } +/// 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 356ec3841..d26d7edb3 100644 --- a/ts/fixtures/task/src/harness.rs +++ b/ts/fixtures/task/src/harness.rs @@ -136,6 +136,9 @@ fn steps() -> Vec<(&'static str, Step)> { ("dyns", |log, exec, _, arg| { drops::dyns(log, 1000 * exec.len() as u32, arg % 6) }), + ("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 41e238a75..32e929d5f 100644 --- a/ts/fixtures/task/ts.toml +++ b/ts/fixtures/task/ts.toml @@ -12,6 +12,7 @@ roots = [ "drops::held", "drops::edited", "drops::dyns", + "drops::cells", "futures::helpers", "futures::boxed", ] diff --git a/ts/runtime/rt/task.ts b/ts/runtime/rt/task.ts index cd0d95e6b..bf05c135e 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,110 @@ 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 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, 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); +} + +/** `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, 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`. + */ +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, () => dropF?.(f)); + 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 a7300b9f4..fa4a1eced 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, @@ -218,9 +227,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, @@ -264,6 +281,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 226cdacf9..cecdbdcd9 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 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, }) } @@ -556,6 +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" + ) | ("DoubleEndedIterator", "next_back" | "nth_back") ) } @@ -1664,6 +1676,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 6fb9e1e17..412594216 100644 --- a/ts/src/lower/mod.rs +++ b/ts/src/lower/mod.rs @@ -962,6 +962,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 @@ -1235,6 +1237,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..2c2f0d494 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,72 @@ 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"), + "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())); + }; + 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/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() { diff --git a/ts/tests/task.ts b/ts/tests/task.ts index 03b0351a8..d92a6a474 100644 --- a/ts/tests/task.ts +++ b/ts/tests/task.ts @@ -51,6 +51,7 @@ export interface Fixture { held(rx: Consumer, guard: Guard): Future; edited(log: Log, id: number, at: number): void; dyns(log: Log, id: number, at: number): void; + cells(log: Log, id: number, at: number): void; }; futures: { helpers(rx: Consumer, guard: Guard): Future; @@ -287,6 +288,7 @@ export const steps: [string, (r: Run, arg: number) => void][] = [ }, ], ["dyns", (r, arg) => r.f.drops.dyns(r.log, 1000 * r.exec.tasks.length, arg % 6)], + ["cells", (r, arg) => r.f.drops.cells(r.log, 1000 * r.exec.tasks.length, arg)], ]; /** @@ -373,4 +375,6 @@ export const cases: Uint8Array[] = [ ...Array.from({ length: 8 }, (_, at) => script(["edited", at])), // What boxed trait objects drop, panicking at each point, in a `Drop`, or none. ...Array.from({ length: 6 }, (_, at) => script(["dyns", at])), + // What one-time cells drop, for every argument, which picks the scenario. + ...Array.from({ length: 256 }, (_, at) => script(["cells", at])), ];