From 9c37c82c269ec0677c6b270f1086ddecf5277aec Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 19:09:38 -0700 Subject: [PATCH 1/6] chore(quest): claim quest/m3/ts-generic-pointer-fields.md Quest-Claim: 839ab9f55dfedb49 From 021f8a193dd43d0d8d74f75b74af33be7e9f7eb8 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 19:56:33 -0700 Subject: [PATCH 2/6] feat(ts): type a generic type's pointer to its parameter as each instance holds it Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/expected/harness.ts | 4 +- ts/fixtures/lang/expected/pointers.Aimed.ts | 16 + ts/fixtures/lang/expected/pointers.Borrows.ts | 11 + .../lang/expected/pointers.Enclosed.ts | 10 + ts/fixtures/lang/expected/pointers.Housed.ts | 26 + ts/fixtures/lang/expected/pointers.Leaning.ts | 29 + ts/fixtures/lang/expected/pointers.Paired.ts | 23 + ts/fixtures/lang/expected/pointers.Slot.ts | 9 - ts/fixtures/lang/expected/pointers.Swapped.ts | 10 + ts/fixtures/lang/expected/pointers.To.ts | 7 + ts/fixtures/lang/expected/pointers.Window.ts | 4 +- ts/fixtures/lang/expected/pointers.ts | 772 +++++++++++++++++- ts/fixtures/lang/src/harness.rs | 1 + ts/fixtures/lang/src/pointers.rs | 282 ++++++- ts/runtime/rt.ts | 6 + ts/src/lower/mir/place.rs | 31 +- ts/src/lower/mod.rs | 31 +- ts/src/lower/pointer.rs | 19 + ts/src/ts.rs | 23 +- 19 files changed, 1263 insertions(+), 51 deletions(-) create mode 100644 ts/fixtures/lang/expected/pointers.Aimed.ts create mode 100644 ts/fixtures/lang/expected/pointers.Borrows.ts create mode 100644 ts/fixtures/lang/expected/pointers.Enclosed.ts create mode 100644 ts/fixtures/lang/expected/pointers.Housed.ts create mode 100644 ts/fixtures/lang/expected/pointers.Leaning.ts create mode 100644 ts/fixtures/lang/expected/pointers.Paired.ts delete mode 100644 ts/fixtures/lang/expected/pointers.Slot.ts create mode 100644 ts/fixtures/lang/expected/pointers.Swapped.ts create mode 100644 ts/fixtures/lang/expected/pointers.To.ts diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 48d57b60d..b310908e5 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -41,7 +41,7 @@ import { u8s as methods_u8s, u16s as methods_u16s, u32s as methods_u32s, u64s as import { nested as nested_nested } from "./nested.ts"; import { objects } from "./objects.ts"; import { orders, bytes as orders_bytes, tuples as orders_tuples, held as orders_held, btrees } from "./orders.ts"; -import { lists as pointers_lists, shared as pointers_shared, places as pointers_places, unchecked, nested as pointers_nested, copies as pointers_copies, sentinels, cells as pointers_cells, rebound as pointers_rebound, lapsed, writers, made as pointers_made, segments, uninitRuns, iteratedRuns, besideWritten, waiters, taken as pointers_taken, bytes as pointers_bytes, loaded, reattached, partWritten } from "./pointers.ts"; +import { lists as pointers_lists, shared as pointers_shared, places as pointers_places, unchecked, nested as pointers_nested, copies as pointers_copies, sentinels, cells as pointers_cells, rebound as pointers_rebound, lapsed, writers, made as pointers_made, segments, uninitRuns, iteratedRuns, besideWritten, waiters, taken as pointers_taken, bytes as pointers_bytes, loaded, reattached, partWritten, aimed } from "./pointers.ts"; import { refs, toRefs } from "./refs.ts"; import { u8s as saturates_u8s, u16s as saturates_u16s, u32s as saturates_u32s, u64s as saturates_u64s, u128s as saturates_u128s, usizes as saturates_usizes, i8s as saturates_i8s, i16s as saturates_i16s, i32s as saturates_i32s, i64s as saturates_i64s, i128s as saturates_i128s, isizes as saturates_isizes } from "./saturates.ts"; import { separated } from "./separated.ts"; @@ -238,6 +238,8 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) reattached(data86, out87); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::part_written", (_2187: rt.u8, data87: rt.ByteSlice, out88: rt.ByteVec): undefined => { partWritten(data87, out88); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::aimed", (_2188: rt.u8, data88: rt.ByteSlice, out89: rt.ByteVec): undefined => { + aimed(data88, out89); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::flattened", arrays_flattened as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; } diff --git a/ts/fixtures/lang/expected/pointers.Aimed.ts b/ts/fixtures/lang/expected/pointers.Aimed.ts new file mode 100644 index 000000000..0b7c32c5a --- /dev/null +++ b/ts/fixtures/lang/expected/pointers.Aimed.ts @@ -0,0 +1,16 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import type * as To from "./pointers.To.ts"; + +/** Pointers to `T` in each shape a field holds one. */ +export interface Aimed { + at: rt.Ptr; + seen: rt.Ptr; + held: rt.Ptr; + maybe: rt.Ptr | undefined; + tagged: [rt.Ptr, rt.u8]; + to: To.To; +} + +//# sourceMappingURL=pointers.Aimed.ts.map diff --git a/ts/fixtures/lang/expected/pointers.Borrows.ts b/ts/fixtures/lang/expected/pointers.Borrows.ts new file mode 100644 index 000000000..a3e034b44 --- /dev/null +++ b/ts/fixtures/lang/expected/pointers.Borrows.ts @@ -0,0 +1,11 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; + +/** References to `T`. */ +export interface Borrows { + to: rt.Ptr; + seen: rt.Ptr; +} + +//# sourceMappingURL=pointers.Borrows.ts.map diff --git a/ts/fixtures/lang/expected/pointers.Enclosed.ts b/ts/fixtures/lang/expected/pointers.Enclosed.ts new file mode 100644 index 000000000..6f6411adf --- /dev/null +++ b/ts/fixtures/lang/expected/pointers.Enclosed.ts @@ -0,0 +1,10 @@ +// Generated by rust2-ts. Do not edit. + +import type * as Aimed from "./pointers.Aimed.ts"; + +/** A generic type holding another's instance. */ +export interface Enclosed { + inner: Aimed.Aimed; +} + +//# sourceMappingURL=pointers.Enclosed.ts.map diff --git a/ts/fixtures/lang/expected/pointers.Housed.ts b/ts/fixtures/lang/expected/pointers.Housed.ts new file mode 100644 index 000000000..f457ad1f8 --- /dev/null +++ b/ts/fixtures/lang/expected/pointers.Housed.ts @@ -0,0 +1,26 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; + +/** An instance of another generic type. */ +export class Housed { + _0: T; + + constructor(_0: T) { + this._0 = _0; + } +} + +export function made$pointers_Aim_u8(n: rt.u8): Housed { + return new Housed(n ^ 153); +} + +export function get$pointers_Aim_u8(self: Housed): rt.u8 { + return self._0; +} + +export function put$pointers_Aim_u8(self: Housed, n: rt.u8): void { + self._0 = rt.u8WrappingAdd(self._0, n) ^ 16; +} + +//# sourceMappingURL=pointers.Housed.ts.map diff --git a/ts/fixtures/lang/expected/pointers.Leaning.ts b/ts/fixtures/lang/expected/pointers.Leaning.ts new file mode 100644 index 000000000..7e30c6939 --- /dev/null +++ b/ts/fixtures/lang/expected/pointers.Leaning.ts @@ -0,0 +1,29 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; + +/** An enum, an object JS copies, so pointers to it are places, as pointers to a number are. */ +export type Leaning = { tag: "Pos"; _0: rt.u8 } | { tag: "Neg"; _0: rt.u8 }; + +export function made$pointers_Aim(n: rt.u8): Leaning { + return { tag: "Neg", _0: n ^ 85 } as Leaning; +} + +export function get$pointers_Aim(self: Leaning): rt.u8 { + if (self.tag === "Pos") { + return self._0; + } + return ~self._0 & 0xff; +} + +export function put$pointers_Aim(self: rt.Place, n: rt.u8): void { + let _3!: Leaning; + if (self.v.tag === "Pos") { + _3 = { tag: "Neg", _0: rt.u8WrappingAdd(self.v._0, n) } as Leaning; + } else { + _3 = { tag: "Pos", _0: rt.u8WrappingSub(self.v._0, n) } as Leaning; + } + self.v = _3; +} + +//# sourceMappingURL=pointers.Leaning.ts.map diff --git a/ts/fixtures/lang/expected/pointers.Paired.ts b/ts/fixtures/lang/expected/pointers.Paired.ts new file mode 100644 index 000000000..3abda2896 --- /dev/null +++ b/ts/fixtures/lang/expected/pointers.Paired.ts @@ -0,0 +1,23 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; + +/** A struct JS keeps as an object, which pointers to are. */ +export interface Paired { + _0: rt.u8; + _1: rt.u8; +} + +export function made$pointers_Aim(n: rt.u8): Paired { + return { _0: n, _1: n ^ 15 }; +} + +export function get$pointers_Aim(self: Paired): rt.u8 { + return self._0 ^ self._1; +} + +export function put$pointers_Aim(self: Paired, n: rt.u8): void { + self._1 = rt.u8WrappingAdd(self._0, n); +} + +//# sourceMappingURL=pointers.Paired.ts.map diff --git a/ts/fixtures/lang/expected/pointers.Slot.ts b/ts/fixtures/lang/expected/pointers.Slot.ts deleted file mode 100644 index aae223177..000000000 --- a/ts/fixtures/lang/expected/pointers.Slot.ts +++ /dev/null @@ -1,9 +0,0 @@ -// Generated by rust2-ts. Do not edit. - -import type * as Reattached from "./pointers.Reattached.ts"; - -export interface Slot { - at: Reattached.Reattached; -} - -//# sourceMappingURL=pointers.Slot.ts.map diff --git a/ts/fixtures/lang/expected/pointers.Swapped.ts b/ts/fixtures/lang/expected/pointers.Swapped.ts new file mode 100644 index 000000000..3a2c6cee6 --- /dev/null +++ b/ts/fixtures/lang/expected/pointers.Swapped.ts @@ -0,0 +1,10 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; + +/** An `AtomicPtr` to `T`. */ +export interface Swapped { + at: rt.Atomic>; +} + +//# sourceMappingURL=pointers.Swapped.ts.map diff --git a/ts/fixtures/lang/expected/pointers.To.ts b/ts/fixtures/lang/expected/pointers.To.ts new file mode 100644 index 000000000..67270de10 --- /dev/null +++ b/ts/fixtures/lang/expected/pointers.To.ts @@ -0,0 +1,7 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; + +export type To = { tag: "At"; _0: rt.Ptr } | { tag: "Nowhere" }; + +//# sourceMappingURL=pointers.To.ts.map diff --git a/ts/fixtures/lang/expected/pointers.Window.ts b/ts/fixtures/lang/expected/pointers.Window.ts index eb8d236a0..d23668be4 100644 --- a/ts/fixtures/lang/expected/pointers.Window.ts +++ b/ts/fixtures/lang/expected/pointers.Window.ts @@ -2,8 +2,8 @@ import * as rt from "./rt.ts"; -export interface Window { - at: rt.u16[]; +export interface Window { + at: rt.Ptr; } //# sourceMappingURL=pointers.Window.ts.map diff --git a/ts/fixtures/lang/expected/pointers.ts b/ts/fixtures/lang/expected/pointers.ts index e22c82f65..e08da7dc1 100644 --- a/ts/fixtures/lang/expected/pointers.ts +++ b/ts/fixtures/lang/expected/pointers.ts @@ -1,17 +1,20 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; -import { copy$Option_pointers_Pair, copy$array_ptr_array4_u8, copy$array_u8, copy$array_unit, copy$mem_MaybeUninit_array_u32, copy$mem_MaybeUninit_array_u8, copy$mem_MaybeUninit_tuple2_u8_u8, copy$pointers_ByCall, copy$pointers_ByClosure, copy$pointers_ByObject, copy$pointers_Duo, copy$pointers_Halves, copy$pointers_Outer, copy$pointers_Pair, copy$tuple2_array2_u32_u8, copy$tuple2_u32_u32, copy$tuple2_u8_u8, drop$pointers_List_String, drop$pointers_List_sync_Arc_u8 } from "./lib.ts"; +import { copy$Option_pointers_Pair, copy$array_ptr_array4_u8, copy$array_u16, copy$array_u8, copy$array_unit, copy$mem_MaybeUninit_array_u32, copy$mem_MaybeUninit_array_u8, copy$mem_MaybeUninit_tuple2_u8_u8, copy$pointers_ByCall, copy$pointers_ByClosure, copy$pointers_ByObject, copy$pointers_Duo, copy$pointers_Halves, copy$pointers_Outer, copy$pointers_Pair, copy$tuple2_array2_u32_u8, copy$tuple2_u32_u32, copy$tuple2_u8_u8, drop$pointers_List_String, drop$pointers_List_sync_Arc_u8 } from "./lib.ts"; import { unwrapOr$0mkoact as option_unwrapOr$0mkoact, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$1cfrse5 as option_map$1cfrse5, mapOr$08xz81a as option_mapOr$08xz81a, mapOr$1wxcg5q as option_mapOr$1wxcg5q, filter$0tnmmii } from "./core/option.ts"; import * as Bin from "./pointers.Bin.ts"; import type * as ByCall from "./pointers.ByCall.ts"; import * as ByClosure from "./pointers.ByClosure.ts"; import type * as ByObject from "./pointers.ByObject.ts"; import type * as Duo from "./pointers.Duo.ts"; +import type * as Enclosed from "./pointers.Enclosed.ts"; import type * as pointers_Gauge from "./pointers.Gauge.ts"; import type * as pointers_Halves from "./pointers.Halves.ts"; import * as pointers_Held from "./pointers.Held.ts"; +import * as Housed from "./pointers.Housed.ts"; import type * as Inner from "./pointers.Inner.ts"; +import * as Leaning from "./pointers.Leaning.ts"; import * as Lent from "./pointers.Lent.ts"; import type * as Links from "./pointers.Links.ts"; import * as List from "./pointers.List.ts"; @@ -20,15 +23,17 @@ import type * as Log from "./pointers.Log.ts"; import type * as pointers_Node from "./pointers.Node.ts"; import type * as Outer from "./pointers.Outer.ts"; import type * as pointers_Pair from "./pointers.Pair.ts"; +import * as Paired from "./pointers.Paired.ts"; import * as Pointing from "./pointers.Pointing.ts"; import type * as Reattached from "./pointers.Reattached.ts"; import type * as Refilled from "./pointers.Refilled.ts"; import * as Reset from "./pointers.Reset.ts"; import type * as pointers_Run from "./pointers.Run.ts"; import * as Segment from "./pointers.Segment.ts"; -import type * as pointers_Slot from "./pointers.Slot.ts"; import type * as Span from "./pointers.Span.ts"; import type * as Stable from "./pointers.Stable.ts"; +import type * as Swapped from "./pointers.Swapped.ts"; +import type * as To from "./pointers.To.ts"; import type * as Viewed from "./pointers.Viewed.ts"; import type * as Waiter from "./pointers.Waiter.ts"; import * as Waiters from "./pointers.Waiters.ts"; @@ -1307,21 +1312,21 @@ export function nextRead$pointers_Loaded(items: rt.Iter): Loaded. * one into an array and one into a struct. */ export function reattached(data: rt.ByteSlice, out: rt.ByteVec): void { - const window: pointers_Window.Window = { at: rt.NULL }; + const window: pointers_Window.Window = { at: rt.NULL }; let buf: rt.u16[] = Array.from({ length: 4 }, (): rt.u16 => { return 0; }); - const slot: pointers_Slot.Slot = { at: rt.NULL }; + const slot: pointers_Window.Window = { at: rt.NULL }; let pair: Reattached.Reattached = { _0: 0, _1: 0 }; for (const n of rt.byteSliceView(data)) { const _17: rt.u16[] = buf; - attach$array4_u16(rt.place(() => window.at, (value) => window.at = value), _17); + attach$array4_u16(rt.place(() => window.at as rt.u16[], (value) => (window.at as rt.u16[]) = value), _17); const _18: rt.u16 = (((n as rt.u16)) << 7) & 0xffff; const _22: rt.usize = rt.u8Rem(n, 4) as rt.usize; if (!(_22 < 4)) { rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _22); } - window.at[_22] = window.at[_22] ^ _18; + (window.at as rt.u16[])[_22] = (window.at as rt.u16[])[_22] ^ _18; rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap(buf, (b: rt.u16): rt.u8 => { return (b >> 4) & 0xff; })), undefined, true); @@ -1330,9 +1335,9 @@ export function reattached(data: rt.ByteSlice, out: rt.ByteVec): void { return _29; }); const _32: Reattached.Reattached = pair; - attach$pointers_Reattached(rt.place(() => slot.at, (value2) => slot.at = value2), _32); - const _33: rt.u8 = rt.u8WrappingAdd(slot.at._0, n); - slot.at._1 = _33; + attach$pointers_Reattached(rt.place(() => slot.at as Reattached.Reattached, (value2) => (slot.at as Reattached.Reattached) = value2), _32); + const _33: rt.u8 = rt.u8WrappingAdd((slot.at as Reattached.Reattached)._0, n); + (slot.at as Reattached.Reattached)._1 = _33; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(pair._0, pair._1)), undefined, true); pair = { _0: pair._1, _1: n }; } @@ -1396,4 +1401,753 @@ export function swapCell(c: rt.Cell, n: rt.u8): void { _5 = rt.replaceIn(c, _5); } +/** + * Pointers a generic type holds to its type parameter, in each shape a field can hold + * one, instantiated where JS keeps the pointee as an object, a number it copies, an + * enum it copies, the bytes of a `[u8; N]`, a cell, an array, and another generic + * type's instance: read and written through, and compared where JS can compare them. + * An `AtomicPtr` to the parameter and references to it are held beside them. + */ +export function aimed(data: rt.ByteSlice, out: rt.ByteVec): void { + let _17!: Paired.Paired | undefined; + let _22!: To.To; + let _42!: rt.Place | undefined; + let _47!: To.To; + let signed!: Leaning.Leaning; + let _70!: rt.Place | undefined; + let _75!: To.To; + let _95!: rt.ByteSlice | undefined; + let _100!: To.To; + let _120!: rt.Place> | undefined; + let _125!: To.To>; + let _149!: rt.u16[] | undefined; + let _154!: To.To; + let _174!: Housed.Housed | undefined; + let _179!: To.To>; + let _207!: Paired.Paired | undefined; + let _212!: To.To; + let same!: boolean[]; + let _222!: boolean; + let _228!: boolean; + let _234!: boolean; + let _237!: boolean; + let _245!: boolean; + let _247!: boolean; + let _277!: rt.ByteSlice | undefined; + let _282!: To.To; + let same2!: boolean[]; + let _292!: boolean; + let _298!: boolean; + let _304!: boolean; + let _307!: boolean; + let _315!: boolean; + let _317!: boolean; + let _347!: Housed.Housed | undefined; + let _352!: To.To>; + let same3!: boolean[]; + let _362!: boolean; + let _368!: boolean; + let _374!: boolean; + let _377!: boolean; + let _385!: boolean; + let _387!: boolean; + const _257: (a0: boolean[]) => rt.u8 = (b: boolean[]): rt.u8 => { + return rt.iterFold(rt.iterSlice(b), 0, (acc: rt.u8, _34: boolean): rt.u8 => { + return ((acc << 1) & 0xff) | ((_34 ? 1 : 0)); + }); + }; + const _327: (a0: boolean[]) => rt.u8 = (b3: boolean[]): rt.u8 => { + return rt.iterFold(rt.iterSlice(b3), 0, (acc2: rt.u8, _36: boolean): rt.u8 => { + return ((acc2 << 1) & 0xff) | ((_36 ? 1 : 0)); + }); + }; + const _397: (a0: boolean[]) => rt.u8 = (b5: boolean[]): rt.u8 => { + return rt.iterFold(rt.iterSlice(b5), 0, (acc3: rt.u8, _38: boolean): rt.u8 => { + return ((acc3 << 1) & 0xff) | ((_38 ? 1 : 0)); + }); + }; + for (const n of rt.byteSliceView(data)) { + const pair: Paired.Paired = { _0: n, _1: ~n & 0xff }; + const at: Paired.Paired = pair; + const pointer = at; + const held: Paired.Paired = rt.optionUnwrap(pointer === rt.NULL ? undefined : pointer); + const _16: Paired.Paired = at; + if (!(rt.u8Rem(n, 2) === 0)) { + _17 = undefined; + } else { + _17 = held; + } + const _21: [Paired.Paired, rt.u8] = [at, n]; + if (!(rt.u8Rem(n, 3) === 0)) { + _22 = { tag: "Nowhere" } as To.To; + } else { + _22 = { tag: "At", _0: at } as To.To; + } + through$pointers_Paired({ inner: { at, seen: _16, held, maybe: _17, tagged: _21, to: _22 } }, n, out); + swappedIn$pointers_Paired(pair, n, out); + lend$pointers_Paired(pair, n, out); + rt.byteVecPush(out, Paired.get$pointers_Aim(pair)); + let num: rt.u8 = n; + const at2: rt.Place = rt.place(() => num, (value) => num = value); + const pointer2 = at2; + const held2: rt.Place = rt.optionUnwrap(pointer2 === rt.NULL ? undefined : pointer2); + const _41: rt.Place = at2; + if (!(rt.u8Rem(n, 2) === 0)) { + _42 = undefined; + } else { + _42 = held2; + } + const _46: [rt.Place, rt.u8] = [at2, n]; + if (!(rt.u8Rem(n, 3) === 0)) { + _47 = { tag: "Nowhere" } as To.To; + } else { + _47 = { tag: "At", _0: at2 } as To.To; + } + through$u8({ inner: { at: at2, seen: _41, held: held2, maybe: _42, tagged: _46, to: _47 } }, n, out); + swappedIn$u8(rt.place(() => num, (value2) => num = value2), n, out); + lend$u8(rt.place(() => num, (value3) => num = value3), n, out); + rt.byteVecPush(out, get$pointers_Aim_u8(num)); + if (!(rt.u8Rem(n, 2) === 0)) { + signed = { tag: "Neg", _0: n } as Leaning.Leaning; + } else { + signed = { tag: "Pos", _0: n } as Leaning.Leaning; + } + const at3: rt.Place = rt.place(() => signed, (value4) => signed = value4); + const pointer3 = at3; + const held3: rt.Place = rt.optionUnwrap(pointer3 === rt.NULL ? undefined : pointer3); + const _69: rt.Place = at3; + if (!(rt.u8Rem(n, 2) === 0)) { + _70 = undefined; + } else { + _70 = held3; + } + const _74: [rt.Place, rt.u8] = [at3, n]; + if (!(rt.u8Rem(n, 3) === 0)) { + _75 = { tag: "Nowhere" } as To.To; + } else { + _75 = { tag: "At", _0: at3 } as To.To; + } + through$pointers_Leaning({ inner: { at: at3, seen: _69, held: held3, maybe: _70, tagged: _74, to: _75 } }, n, out); + swappedIn$pointers_Leaning(rt.place(() => signed, (value5) => signed = value5), n, out); + lend$pointers_Leaning(rt.place(() => signed, (value6) => signed = value6), n, out); + rt.byteVecPush(out, Leaning.get$pointers_Aim(signed)); + const bytes: Uint8Array = rt.bytes(4).fill(n); + const at4: rt.ByteSlice = rt.byteSliceFrom(bytes); + const pointer4 = at4; + const held4: rt.ByteSlice = rt.optionUnwrap(pointer4 === rt.NULL ? undefined : pointer4); + const _94: rt.ByteSlice = at4; + if (!(rt.u8Rem(n, 2) === 0)) { + _95 = undefined; + } else { + _95 = held4; + } + const _99: [rt.ByteSlice, rt.u8] = [at4, n]; + if (!(rt.u8Rem(n, 3) === 0)) { + _100 = { tag: "Nowhere" } as To.To; + } else { + _100 = { tag: "At", _0: at4 } as To.To; + } + through$array4_u8({ inner: { at: at4, seen: _94, held: held4, maybe: _95, tagged: _99, to: _100 } }, n, out); + swappedIn$array4_u8(rt.byteSliceFrom(bytes), n, out); + lend$array4_u8(rt.byteSliceFrom(bytes), n, out); + rt.byteVecPush(out, get$pointers_Aim_array4_u8(rt.byteSliceFrom(bytes))); + let cell: rt.Cell = new rt.Cell(n); + const at5: rt.Place> = rt.place(() => cell, (value7) => cell = value7); + const pointer5 = at5; + const held5: rt.Place> = rt.optionUnwrap(pointer5 === rt.NULL ? undefined : pointer5); + const _119: rt.Place> = at5; + if (!(rt.u8Rem(n, 2) === 0)) { + _120 = undefined; + } else { + _120 = held5; + } + const _124: [rt.Place>, rt.u8] = [at5, n]; + if (!(rt.u8Rem(n, 3) === 0)) { + _125 = { tag: "Nowhere" } as To.To>; + } else { + _125 = { tag: "At", _0: at5 } as To.To>; + } + through$Cell_u8({ inner: { at: at5, seen: _119, held: held5, maybe: _120, tagged: _124, to: _125 } }, n, out); + swappedIn$Cell_u8(rt.place(() => cell, (value8) => cell = value8), n, out); + lend$Cell_u8(cell, n, out); + rt.byteVecPush(out, cell.v); + const _139: rt.u16 = (((n as rt.u16)) << 4) & 0xffff; + const wide: rt.u16[] = Array.from({ length: 2 }, (): rt.u16 => { + return _139; + }); + const at6: rt.u16[] = wide; + const pointer6 = at6; + const held6: rt.u16[] = rt.optionUnwrap(pointer6 === rt.NULL ? undefined : pointer6); + const _148: rt.u16[] = at6; + if (!(rt.u8Rem(n, 2) === 0)) { + _149 = undefined; + } else { + _149 = held6; + } + const _153: [rt.u16[], rt.u8] = [at6, n]; + if (!(rt.u8Rem(n, 3) === 0)) { + _154 = { tag: "Nowhere" } as To.To; + } else { + _154 = { tag: "At", _0: at6 } as To.To; + } + through$array2_u16({ inner: { at: at6, seen: _148, held: held6, maybe: _149, tagged: _153, to: _154 } }, n, out); + swappedIn$array2_u16(wide, n, out); + lend$array2_u16(wide, n, out); + rt.byteVecPush(out, get$pointers_Aim_array2_u16(wide)); + const wrap: Housed.Housed = new Housed.Housed(n); + const at7: Housed.Housed = wrap; + const pointer7 = at7; + const held7: Housed.Housed = rt.optionUnwrap(pointer7 === rt.NULL ? undefined : pointer7); + const _173: Housed.Housed = at7; + if (!(rt.u8Rem(n, 2) === 0)) { + _174 = undefined; + } else { + _174 = held7; + } + const _178: [Housed.Housed, rt.u8] = [at7, n]; + if (!(rt.u8Rem(n, 3) === 0)) { + _179 = { tag: "Nowhere" } as To.To>; + } else { + _179 = { tag: "At", _0: at7 } as To.To>; + } + through$pointers_Housed_u8({ inner: { at: at7, seen: _173, held: held7, maybe: _174, tagged: _178, to: _179 } }, n, out); + swappedIn$pointers_Housed_u8(wrap, n, out); + lend$pointers_Housed_u8(wrap, n, out); + rt.byteVecPush(out, Housed.get$pointers_Aim_u8(wrap)); + const other: Paired.Paired = { _0: ~n & 0xff, _1: n }; + const otherBytes: Uint8Array = rt.bytes(4).fill(~n & 0xff); + const otherWrap: Housed.Housed = new Housed.Housed(~n & 0xff); + const other2: Paired.Paired = other; + const at8: Paired.Paired = pair; + const pointer8 = at8; + const held8: Paired.Paired = rt.optionUnwrap(pointer8 === rt.NULL ? undefined : pointer8); + const _206: Paired.Paired = at8; + if (false) { + _207 = undefined; + } else { + _207 = held8; + } + const _211: [Paired.Paired, rt.u8] = [at8, 0]; + if (false) { + _212 = { tag: "Nowhere" } as To.To; + } else { + _212 = { tag: "At", _0: at8 } as To.To; + } + const nest8: Enclosed.Enclosed = { inner: { at: at8, seen: _206, held: held8, maybe: _207, tagged: _211, to: _212 } }; + const _218: boolean = (nest8.inner.at as Paired.Paired) === nest8.inner.seen as Paired.Paired; + const pointer9 = nest8.inner.at as Paired.Paired; + const _225: Paired.Paired = rt.optionUnwrap(pointer9 === rt.NULL ? undefined : pointer9); + b19: { + _222 = (nest8.inner.held as Paired.Paired) === _225; + if ((nest8.inner.maybe as Paired.Paired | undefined) !== undefined) { + if (((nest8.inner.maybe as Paired.Paired | undefined) as Paired.Paired) === nest8.inner.held as Paired.Paired) { + _228 = true; + break b19; + } + } + _228 = false; + } + b21: { + _234 = (nest8.inner.tagged as [Paired.Paired, rt.u8])[0] === nest8.inner.at as Paired.Paired; + if (nest8.inner.to.tag === "At") { + if ((nest8.inner.to._0 as Paired.Paired) === nest8.inner.at as Paired.Paired) { + _237 = true; + break b21; + } + } + _237 = false; + } + b23: { + _245 = (nest8.inner.at as Paired.Paired) === other2; + const scrutinee2 = nest8.inner.maybe as Paired.Paired | undefined; + same = [_218, _222, _228, _234, _237]; + if (scrutinee2 !== undefined) { + if ((((nest8.inner.maybe as Paired.Paired | undefined) as Paired.Paired)) === other2) { + _247 = true; + break b23; + } + } + _247 = false; + } + const apart: boolean[] = [_245, _247, (nest8.inner.seen as Paired.Paired) === other2]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_257(same), _257(apart))), undefined, true); + const other3: rt.ByteSlice = rt.byteSliceFrom(otherBytes); + const at9: rt.ByteSlice = rt.byteSliceFrom(bytes); + const pointer10 = at9; + const held9: rt.ByteSlice = rt.optionUnwrap(pointer10 === rt.NULL ? undefined : pointer10); + const _276: rt.ByteSlice = at9; + if (false) { + _277 = undefined; + } else { + _277 = held9; + } + const _281: [rt.ByteSlice, rt.u8] = [at9, 0]; + if (false) { + _282 = { tag: "Nowhere" } as To.To; + } else { + _282 = { tag: "At", _0: at9 } as To.To; + } + const nest9: Enclosed.Enclosed = { inner: { at: at9, seen: _276, held: held9, maybe: _277, tagged: _281, to: _282 } }; + const _288: boolean = rt.byteSliceSame(nest9.inner.at as rt.ByteSlice, nest9.inner.seen as rt.ByteSlice); + const pointer11 = nest9.inner.at as rt.ByteSlice; + const _295: rt.ByteSlice = rt.optionUnwrap(pointer11 === rt.NULL ? undefined : pointer11); + b27: { + _292 = rt.byteSliceSame(nest9.inner.held as rt.ByteSlice, _295); + if ((nest9.inner.maybe as rt.ByteSlice | undefined) !== undefined) { + if (rt.byteSliceSame((nest9.inner.maybe as rt.ByteSlice | undefined) as rt.ByteSlice, nest9.inner.held as rt.ByteSlice)) { + _298 = true; + break b27; + } + } + _298 = false; + } + b29: { + _304 = rt.byteSliceSame((nest9.inner.tagged as [rt.ByteSlice, rt.u8])[0], nest9.inner.at as rt.ByteSlice); + if (nest9.inner.to.tag === "At") { + if (rt.byteSliceSame(nest9.inner.to._0 as rt.ByteSlice, nest9.inner.at as rt.ByteSlice)) { + _307 = true; + break b29; + } + } + _307 = false; + } + b31: { + _315 = rt.byteSliceSame(nest9.inner.at as rt.ByteSlice, other3); + const scrutinee4 = nest9.inner.maybe as rt.ByteSlice | undefined; + same2 = [_288, _292, _298, _304, _307]; + if (scrutinee4 !== undefined) { + if (rt.byteSliceSame((nest9.inner.maybe as rt.ByteSlice | undefined) as rt.ByteSlice, other3)) { + _317 = true; + break b31; + } + } + _317 = false; + } + const apart2: boolean[] = [_315, _317, rt.byteSliceSame(nest9.inner.seen as rt.ByteSlice, other3)]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_327(same2), _327(apart2))), undefined, true); + const other4: Housed.Housed = otherWrap; + const at10: Housed.Housed = wrap; + const pointer12 = at10; + const held10: Housed.Housed = rt.optionUnwrap(pointer12 === rt.NULL ? undefined : pointer12); + const _346: Housed.Housed = at10; + if (false) { + _347 = undefined; + } else { + _347 = held10; + } + const _351: [Housed.Housed, rt.u8] = [at10, 0]; + if (false) { + _352 = { tag: "Nowhere" } as To.To>; + } else { + _352 = { tag: "At", _0: at10 } as To.To>; + } + const nest10: Enclosed.Enclosed> = { inner: { at: at10, seen: _346, held: held10, maybe: _347, tagged: _351, to: _352 } }; + const _358: boolean = (nest10.inner.at as Housed.Housed) === nest10.inner.seen as Housed.Housed; + const pointer13 = nest10.inner.at as Housed.Housed; + const _365: Housed.Housed = rt.optionUnwrap(pointer13 === rt.NULL ? undefined : pointer13); + b35: { + _362 = (nest10.inner.held as Housed.Housed) === _365; + if ((nest10.inner.maybe as Housed.Housed | undefined) !== undefined) { + if (((nest10.inner.maybe as Housed.Housed | undefined) as Housed.Housed) === nest10.inner.held as Housed.Housed) { + _368 = true; + break b35; + } + } + _368 = false; + } + b37: { + _374 = (nest10.inner.tagged as [Housed.Housed, rt.u8])[0] === nest10.inner.at as Housed.Housed; + if (nest10.inner.to.tag === "At") { + if ((nest10.inner.to._0 as Housed.Housed) === nest10.inner.at as Housed.Housed) { + _377 = true; + break b37; + } + } + _377 = false; + } + b39: { + _385 = (nest10.inner.at as Housed.Housed) === other4; + const scrutinee6 = nest10.inner.maybe as Housed.Housed | undefined; + same3 = [_358, _362, _368, _374, _377]; + if (scrutinee6 !== undefined) { + if ((((nest10.inner.maybe as Housed.Housed | undefined) as Housed.Housed)) === other4) { + _387 = true; + break b39; + } + } + _387 = false; + } + const apart3: boolean[] = [_385, _387, (nest10.inner.seen as Housed.Housed) === other4]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_397(same3), _397(apart3))), undefined, true); + } +} + +export function made$pointers_Aim_u8(n: rt.u8): rt.u8 { + return n ^ 60; +} + +export function get$pointers_Aim_u8(self: rt.u8): rt.u8 { + return self; +} + +export function put$pointers_Aim_u8(self: rt.Place, n: rt.u8): void { + self.v = rt.u8WrappingAdd(rt.u8WrappingMul(self.v, 3), n); +} + +export function made$pointers_Aim_array4_u8(n: rt.u8): Uint8Array { + return Uint8Array.of(n, ~n & 0xff, n ^ 1, n ^ 2); +} + +export function get$pointers_Aim_array4_u8(self: rt.ByteSlice): rt.u8 { + return self.data[self.start] ^ self.data[self.start + 3]; +} + +export function put$pointers_Aim_array4_u8(self: rt.ByteSlice, n: rt.u8): void { + const _3: rt.u8 = rt.u8WrappingAdd(self.data[self.start], n); + const _7: rt.usize = rt.u8Rem(n, 4) as rt.usize; + if (!(_7 < 4)) { + rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _7); + } + self.data[self.start + _7] = _3; +} + +export function made$pointers_Aim_Cell_u8(n: rt.u8): rt.Cell { + return new rt.Cell(n ^ 119); +} + +export function get$pointers_Aim_Cell_u8(self: rt.Cell): rt.u8 { + return self.v; +} + +export function put$pointers_Aim_Cell_u8(self: rt.Cell, n: rt.u8): void { + rt.cellSet(self, rt.intRotateLeft(self.v, 1, 8, false) ^ n); +} + +export function made$pointers_Aim_array2_u16(n: rt.u8): rt.u16[] { + return [(((n as rt.u16)) << 4) & 0xffff, ((((~n & 0xff) as rt.u16)) << 4) & 0xffff]; +} + +export function get$pointers_Aim_array2_u16(self: rt.u16[]): rt.u8 { + return ((self[0] ^ self[1]) >> 4) & 0xff; +} + +export function put$pointers_Aim_array2_u16(self: rt.u16[], n: rt.u8): void { + const _3: rt.u16 = (((n as rt.u16)) << 4) & 0xffff; + const _7: rt.usize = rt.u8Rem(n, 2) as rt.usize; + if (!(_7 < 2)) { + rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _7); + } + self[_7] = self[_7] ^ _3; +} + +/** Reads and writes through each of `nest`'s pointers. */ +export function through$Cell_u8(nest: Enclosed.Enclosed>, n: rt.u8, out: rt.ByteVec): void { + let _39!: boolean; + rt.byteVecPush(out, get$pointers_Aim_Cell_u8((nest.inner.seen as rt.Place>).v)); + put$pointers_Aim_Cell_u8((nest.inner.at as rt.Place>).v, n); + rt.byteVecPush(out, get$pointers_Aim_Cell_u8(((nest.inner.held as rt.Place>)).v)); + if ((nest.inner.maybe as rt.Place> | undefined) !== undefined) { + put$pointers_Aim_Cell_u8((((nest.inner.maybe as rt.Place> | undefined) as rt.Place>)).v, n ^ 3); + } + const _52: rt.Place> = (nest.inner.tagged as [rt.Place>, rt.u8])[0]; + const _23: rt.u8 = rt.u8WrappingAdd(n, (nest.inner.tagged as [rt.Place>, rt.u8])[1]); + put$pointers_Aim_Cell_u8(_52.v, _23); + if (nest.inner.to.tag === "At") { + put$pointers_Aim_Cell_u8((nest.inner.to._0 as rt.Place>).v, ~n & 0xff); + } + const _32: rt.u8 = ((((nest.inner.maybe as rt.Place> | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; + if (nest.inner.to.tag === "At") { + _39 = true; + } else { + _39 = false; + } + rt.byteVecPush(out, _32 | ((_39 ? 1 : 0))); + if (rt.u8Rem(n, 5) === 0) { + (nest.inner.at as rt.Place>).v = made$pointers_Aim_Cell_u8(n); + } + rt.byteVecPush(out, get$pointers_Aim_Cell_u8((nest.inner.seen as rt.Place>).v)); +} + +/** Reads and writes through each of `nest`'s pointers. */ +export function through$array2_u16(nest: Enclosed.Enclosed, n: rt.u8, out: rt.ByteVec): void { + let _39!: boolean; + rt.byteVecPush(out, get$pointers_Aim_array2_u16(nest.inner.seen as rt.u16[])); + put$pointers_Aim_array2_u16(nest.inner.at as rt.u16[], n); + rt.byteVecPush(out, get$pointers_Aim_array2_u16(nest.inner.held as rt.u16[])); + if ((nest.inner.maybe as rt.u16[] | undefined) !== undefined) { + put$pointers_Aim_array2_u16((nest.inner.maybe as rt.u16[] | undefined) as rt.u16[], n ^ 3); + } + put$pointers_Aim_array2_u16((nest.inner.tagged as [rt.u16[], rt.u8])[0], rt.u8WrappingAdd(n, (nest.inner.tagged as [rt.u16[], rt.u8])[1])); + if (nest.inner.to.tag === "At") { + put$pointers_Aim_array2_u16(nest.inner.to._0 as rt.u16[], ~n & 0xff); + } + const _32: rt.u8 = ((((nest.inner.maybe as rt.u16[] | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; + if (nest.inner.to.tag === "At") { + _39 = true; + } else { + _39 = false; + } + rt.byteVecPush(out, _32 | ((_39 ? 1 : 0))); + if (rt.u8Rem(n, 5) === 0) { + rt.ptrWrite(nest.inner.at as rt.u16[], copy$array_u16(made$pointers_Aim_array2_u16(n))); + } + rt.byteVecPush(out, get$pointers_Aim_array2_u16(nest.inner.seen as rt.u16[])); +} + +/** Reads and writes through each of `nest`'s pointers. */ +export function through$array4_u8(nest: Enclosed.Enclosed, n: rt.u8, out: rt.ByteVec): void { + let _39!: boolean; + rt.byteVecPush(out, get$pointers_Aim_array4_u8(nest.inner.seen as rt.ByteSlice)); + put$pointers_Aim_array4_u8(nest.inner.at as rt.ByteSlice, n); + rt.byteVecPush(out, get$pointers_Aim_array4_u8(nest.inner.held as rt.ByteSlice)); + if ((nest.inner.maybe as rt.ByteSlice | undefined) !== undefined) { + put$pointers_Aim_array4_u8((nest.inner.maybe as rt.ByteSlice | undefined) as rt.ByteSlice, n ^ 3); + } + put$pointers_Aim_array4_u8((nest.inner.tagged as [rt.ByteSlice, rt.u8])[0], rt.u8WrappingAdd(n, (nest.inner.tagged as [rt.ByteSlice, rt.u8])[1])); + if (nest.inner.to.tag === "At") { + put$pointers_Aim_array4_u8(nest.inner.to._0 as rt.ByteSlice, ~n & 0xff); + } + const _32: rt.u8 = ((((nest.inner.maybe as rt.ByteSlice | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; + if (nest.inner.to.tag === "At") { + _39 = true; + } else { + _39 = false; + } + rt.byteVecPush(out, _32 | ((_39 ? 1 : 0))); + if (rt.u8Rem(n, 5) === 0) { + rt.byteSliceSet(nest.inner.at as rt.ByteSlice, copy$array_u8(made$pointers_Aim_array4_u8(n))); + } + rt.byteVecPush(out, get$pointers_Aim_array4_u8(nest.inner.seen as rt.ByteSlice)); +} + +/** Reads and writes through each of `nest`'s pointers. */ +export function through$pointers_Housed_u8(nest: Enclosed.Enclosed>, n: rt.u8, out: rt.ByteVec): void { + let _39!: boolean; + rt.byteVecPush(out, Housed.get$pointers_Aim_u8(nest.inner.seen as Housed.Housed)); + Housed.put$pointers_Aim_u8(nest.inner.at as Housed.Housed, n); + rt.byteVecPush(out, Housed.get$pointers_Aim_u8(nest.inner.held as Housed.Housed)); + if ((nest.inner.maybe as Housed.Housed | undefined) !== undefined) { + Housed.put$pointers_Aim_u8((nest.inner.maybe as Housed.Housed | undefined) as Housed.Housed, n ^ 3); + } + Housed.put$pointers_Aim_u8((nest.inner.tagged as [Housed.Housed, rt.u8])[0], rt.u8WrappingAdd(n, (nest.inner.tagged as [Housed.Housed, rt.u8])[1])); + if (nest.inner.to.tag === "At") { + Housed.put$pointers_Aim_u8(nest.inner.to._0 as Housed.Housed, ~n & 0xff); + } + const _32: rt.u8 = ((((nest.inner.maybe as Housed.Housed | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; + if (nest.inner.to.tag === "At") { + _39 = true; + } else { + _39 = false; + } + rt.byteVecPush(out, _32 | ((_39 ? 1 : 0))); + if (rt.u8Rem(n, 5) === 0) { + rt.ptrWrite(nest.inner.at as Housed.Housed, Housed.made$pointers_Aim_u8(n)); + } + rt.byteVecPush(out, Housed.get$pointers_Aim_u8(nest.inner.seen as Housed.Housed)); +} + +/** Reads and writes through each of `nest`'s pointers. */ +export function through$pointers_Leaning(nest: Enclosed.Enclosed, n: rt.u8, out: rt.ByteVec): void { + let _39!: boolean; + rt.byteVecPush(out, Leaning.get$pointers_Aim((nest.inner.seen as rt.Place).v)); + Leaning.put$pointers_Aim(nest.inner.at as rt.Place, n); + rt.byteVecPush(out, Leaning.get$pointers_Aim(((nest.inner.held as rt.Place)).v)); + if ((nest.inner.maybe as rt.Place | undefined) !== undefined) { + Leaning.put$pointers_Aim((nest.inner.maybe as rt.Place | undefined) as rt.Place, n ^ 3); + } + Leaning.put$pointers_Aim((nest.inner.tagged as [rt.Place, rt.u8])[0], rt.u8WrappingAdd(n, (nest.inner.tagged as [rt.Place, rt.u8])[1])); + if (nest.inner.to.tag === "At") { + Leaning.put$pointers_Aim(nest.inner.to._0 as rt.Place, ~n & 0xff); + } + const _32: rt.u8 = ((((nest.inner.maybe as rt.Place | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; + if (nest.inner.to.tag === "At") { + _39 = true; + } else { + _39 = false; + } + rt.byteVecPush(out, _32 | ((_39 ? 1 : 0))); + if (rt.u8Rem(n, 5) === 0) { + (nest.inner.at as rt.Place).v = Leaning.made$pointers_Aim(n); + } + rt.byteVecPush(out, Leaning.get$pointers_Aim((nest.inner.seen as rt.Place).v)); +} + +/** Reads and writes through each of `nest`'s pointers. */ +export function through$pointers_Paired(nest: Enclosed.Enclosed, n: rt.u8, out: rt.ByteVec): void { + let _39!: boolean; + rt.byteVecPush(out, Paired.get$pointers_Aim(nest.inner.seen as Paired.Paired)); + Paired.put$pointers_Aim(nest.inner.at as Paired.Paired, n); + rt.byteVecPush(out, Paired.get$pointers_Aim(nest.inner.held as Paired.Paired)); + if ((nest.inner.maybe as Paired.Paired | undefined) !== undefined) { + Paired.put$pointers_Aim((nest.inner.maybe as Paired.Paired | undefined) as Paired.Paired, n ^ 3); + } + Paired.put$pointers_Aim((nest.inner.tagged as [Paired.Paired, rt.u8])[0], rt.u8WrappingAdd(n, (nest.inner.tagged as [Paired.Paired, rt.u8])[1])); + if (nest.inner.to.tag === "At") { + Paired.put$pointers_Aim(nest.inner.to._0 as Paired.Paired, ~n & 0xff); + } + const _32: rt.u8 = ((((nest.inner.maybe as Paired.Paired | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; + if (nest.inner.to.tag === "At") { + _39 = true; + } else { + _39 = false; + } + rt.byteVecPush(out, _32 | ((_39 ? 1 : 0))); + if (rt.u8Rem(n, 5) === 0) { + rt.ptrWrite(nest.inner.at as Paired.Paired, Paired.made$pointers_Aim(n)); + } + rt.byteVecPush(out, Paired.get$pointers_Aim(nest.inner.seen as Paired.Paired)); +} + +/** Reads and writes through each of `nest`'s pointers. */ +export function through$u8(nest: Enclosed.Enclosed, n: rt.u8, out: rt.ByteVec): void { + let _39!: boolean; + rt.byteVecPush(out, get$pointers_Aim_u8((nest.inner.seen as rt.Place).v)); + put$pointers_Aim_u8(nest.inner.at as rt.Place, n); + rt.byteVecPush(out, get$pointers_Aim_u8(((nest.inner.held as rt.Place)).v)); + if ((nest.inner.maybe as rt.Place | undefined) !== undefined) { + put$pointers_Aim_u8((nest.inner.maybe as rt.Place | undefined) as rt.Place, n ^ 3); + } + put$pointers_Aim_u8((nest.inner.tagged as [rt.Place, rt.u8])[0], rt.u8WrappingAdd(n, (nest.inner.tagged as [rt.Place, rt.u8])[1])); + if (nest.inner.to.tag === "At") { + put$pointers_Aim_u8(nest.inner.to._0 as rt.Place, ~n & 0xff); + } + const _32: rt.u8 = ((((nest.inner.maybe as rt.Place | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; + if (nest.inner.to.tag === "At") { + _39 = true; + } else { + _39 = false; + } + rt.byteVecPush(out, _32 | ((_39 ? 1 : 0))); + if (rt.u8Rem(n, 5) === 0) { + (nest.inner.at as rt.Place).v = made$pointers_Aim_u8(n); + } + rt.byteVecPush(out, get$pointers_Aim_u8((nest.inner.seen as rt.Place).v)); +} + +/** Reads and writes through an `AtomicPtr` to what `to` points at, swapped in for null. */ +export function swappedIn$Cell_u8(to: rt.Place>, n: rt.u8, out: rt.ByteVec): void { + const shared: Swapped.Swapped> = { at: new rt.Atomic(rt.NULL) }; + rt.byteVecPush(out, rt.atomicLoad(shared.at as rt.Atomic>>, 4) === rt.NULL ? 1 : 0); + rt.atomicStore(shared.at as rt.Atomic>>, to, 4); + const at: rt.Place> = rt.atomicLoad(shared.at as rt.Atomic>>, 4); + put$pointers_Aim_Cell_u8(at.v, n); + rt.byteVecPush(out, get$pointers_Aim_Cell_u8(at.v)); + rt.byteVecPush(out, rt.atomicSwap(shared.at as rt.Atomic>>, rt.NULL, 4) === rt.NULL ? 1 : 0); +} + +/** Reads and writes through an `AtomicPtr` to what `to` points at, swapped in for null. */ +export function swappedIn$array2_u16(to: rt.u16[], n: rt.u8, out: rt.ByteVec): void { + const shared: Swapped.Swapped = { at: new rt.Atomic(rt.NULL) }; + rt.byteVecPush(out, rt.atomicLoad(shared.at as rt.Atomic, 4) === rt.NULL ? 1 : 0); + rt.atomicStore(shared.at as rt.Atomic, to, 4); + const at: rt.u16[] = rt.atomicLoad(shared.at as rt.Atomic, 4); + put$pointers_Aim_array2_u16(at, n); + rt.byteVecPush(out, get$pointers_Aim_array2_u16(at)); + rt.byteVecPush(out, rt.atomicSwap(shared.at as rt.Atomic, rt.NULL, 4) === rt.NULL ? 1 : 0); +} + +/** Reads and writes through an `AtomicPtr` to what `to` points at, swapped in for null. */ +export function swappedIn$array4_u8(to: rt.ByteSlice, n: rt.u8, out: rt.ByteVec): void { + const shared: Swapped.Swapped = { at: new rt.Atomic(rt.NULL) }; + rt.byteVecPush(out, rt.atomicLoad(shared.at as rt.Atomic, 4) === rt.NULL ? 1 : 0); + rt.atomicStore(shared.at as rt.Atomic, to, 4); + const at: rt.ByteSlice = rt.atomicLoad(shared.at as rt.Atomic, 4); + put$pointers_Aim_array4_u8(at, n); + rt.byteVecPush(out, get$pointers_Aim_array4_u8(at)); + rt.byteVecPush(out, rt.atomicSwap(shared.at as rt.Atomic, rt.NULL, 4) === rt.NULL ? 1 : 0); +} + +/** Reads and writes through an `AtomicPtr` to what `to` points at, swapped in for null. */ +export function swappedIn$pointers_Housed_u8(to: Housed.Housed, n: rt.u8, out: rt.ByteVec): void { + const shared: Swapped.Swapped> = { at: new rt.Atomic(rt.NULL) }; + rt.byteVecPush(out, rt.atomicLoad(shared.at as rt.Atomic>, 4) === rt.NULL ? 1 : 0); + rt.atomicStore(shared.at as rt.Atomic>, to, 4); + const at: Housed.Housed = rt.atomicLoad(shared.at as rt.Atomic>, 4); + Housed.put$pointers_Aim_u8(at, n); + rt.byteVecPush(out, Housed.get$pointers_Aim_u8(at)); + rt.byteVecPush(out, rt.atomicSwap(shared.at as rt.Atomic>, rt.NULL, 4) === rt.NULL ? 1 : 0); +} + +/** Reads and writes through an `AtomicPtr` to what `to` points at, swapped in for null. */ +export function swappedIn$pointers_Leaning(to: rt.Place, n: rt.u8, out: rt.ByteVec): void { + const shared: Swapped.Swapped = { at: new rt.Atomic(rt.NULL) }; + rt.byteVecPush(out, rt.atomicLoad(shared.at as rt.Atomic>, 4) === rt.NULL ? 1 : 0); + rt.atomicStore(shared.at as rt.Atomic>, to, 4); + const at: rt.Place = rt.atomicLoad(shared.at as rt.Atomic>, 4); + Leaning.put$pointers_Aim(at, n); + rt.byteVecPush(out, Leaning.get$pointers_Aim(at.v)); + rt.byteVecPush(out, rt.atomicSwap(shared.at as rt.Atomic>, rt.NULL, 4) === rt.NULL ? 1 : 0); +} + +/** Reads and writes through an `AtomicPtr` to what `to` points at, swapped in for null. */ +export function swappedIn$pointers_Paired(to: Paired.Paired, n: rt.u8, out: rt.ByteVec): void { + const shared: Swapped.Swapped = { at: new rt.Atomic(rt.NULL) }; + rt.byteVecPush(out, rt.atomicLoad(shared.at as rt.Atomic, 4) === rt.NULL ? 1 : 0); + rt.atomicStore(shared.at as rt.Atomic, to, 4); + const at: Paired.Paired = rt.atomicLoad(shared.at as rt.Atomic, 4); + Paired.put$pointers_Aim(at, n); + rt.byteVecPush(out, Paired.get$pointers_Aim(at)); + rt.byteVecPush(out, rt.atomicSwap(shared.at as rt.Atomic, rt.NULL, 4) === rt.NULL ? 1 : 0); +} + +/** Reads and writes through an `AtomicPtr` to what `to` points at, swapped in for null. */ +export function swappedIn$u8(to: rt.Place, n: rt.u8, out: rt.ByteVec): void { + const shared: Swapped.Swapped = { at: new rt.Atomic(rt.NULL) }; + rt.byteVecPush(out, rt.atomicLoad(shared.at as rt.Atomic>, 4) === rt.NULL ? 1 : 0); + rt.atomicStore(shared.at as rt.Atomic>, to, 4); + const at: rt.Place = rt.atomicLoad(shared.at as rt.Atomic>, 4); + put$pointers_Aim_u8(at, n); + rt.byteVecPush(out, get$pointers_Aim_u8(at.v)); + rt.byteVecPush(out, rt.atomicSwap(shared.at as rt.Atomic>, rt.NULL, 4) === rt.NULL ? 1 : 0); +} + +/** Reads and writes `to` through references to it and to another `T`. */ +export function lend$Cell_u8(to: rt.Cell, n: rt.u8, out: rt.ByteVec): void { + const made: rt.Cell = made$pointers_Aim_Cell_u8(n); + put$pointers_Aim_Cell_u8(to, n >> 1); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(get$pointers_Aim_Cell_u8(to), get$pointers_Aim_Cell_u8(made))), undefined, true); +} + +/** Reads and writes `to` through references to it and to another `T`. */ +export function lend$array2_u16(to: rt.u16[], n: rt.u8, out: rt.ByteVec): void { + const made: rt.u16[] = made$pointers_Aim_array2_u16(n); + put$pointers_Aim_array2_u16(to, n >> 1); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(get$pointers_Aim_array2_u16(to), get$pointers_Aim_array2_u16(made))), undefined, true); +} + +/** Reads and writes `to` through references to it and to another `T`. */ +export function lend$array4_u8(to: rt.ByteSlice, n: rt.u8, out: rt.ByteVec): void { + const _6: rt.ByteSlice = rt.byteSliceFrom(made$pointers_Aim_array4_u8(n)); + put$pointers_Aim_array4_u8(to, n >> 1); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(get$pointers_Aim_array4_u8(to), get$pointers_Aim_array4_u8(_6))), undefined, true); +} + +/** Reads and writes `to` through references to it and to another `T`. */ +export function lend$pointers_Housed_u8(to: Housed.Housed, n: rt.u8, out: rt.ByteVec): void { + const made: Housed.Housed = Housed.made$pointers_Aim_u8(n); + Housed.put$pointers_Aim_u8(to, n >> 1); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(Housed.get$pointers_Aim_u8(to), Housed.get$pointers_Aim_u8(made))), undefined, true); +} + +/** Reads and writes `to` through references to it and to another `T`. */ +export function lend$pointers_Leaning(to: rt.Place, n: rt.u8, out: rt.ByteVec): void { + const made: Leaning.Leaning = Leaning.made$pointers_Aim(n); + Leaning.put$pointers_Aim(to, n >> 1); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(Leaning.get$pointers_Aim(to.v), Leaning.get$pointers_Aim(made))), undefined, true); +} + +/** Reads and writes `to` through references to it and to another `T`. */ +export function lend$pointers_Paired(to: Paired.Paired, n: rt.u8, out: rt.ByteVec): void { + const made: Paired.Paired = Paired.made$pointers_Aim(n); + Paired.put$pointers_Aim(to, n >> 1); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(Paired.get$pointers_Aim(to), Paired.get$pointers_Aim(made))), undefined, true); +} + +/** Reads and writes `to` through references to it and to another `T`. */ +export function lend$u8(to: rt.Place, n: rt.u8, out: rt.ByteVec): void { + const made: rt.u8 = made$pointers_Aim_u8(n); + put$pointers_Aim_u8(to, n >> 1); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(get$pointers_Aim_u8(to.v), get$pointers_Aim_u8(made))), undefined, true); +} + //# sourceMappingURL=pointers.ts.map diff --git a/ts/fixtures/lang/src/harness.rs b/ts/fixtures/lang/src/harness.rs index 4c5f244ff..c563d6f7c 100644 --- a/ts/fixtures/lang/src/harness.rs +++ b/ts/fixtures/lang/src/harness.rs @@ -261,6 +261,7 @@ fn cases() -> Vec<(&'static str, Case)> { ("pointers::part_written", |_, data, out| { pointers::part_written(data, out) }), + ("pointers::aimed", |_, data, out| pointers::aimed(data, out)), ("arrays::flattened", arrays::flattened), ] } diff --git a/ts/fixtures/lang/src/pointers.rs b/ts/fixtures/lang/src/pointers.rs index 901f2d545..c39a739eb 100644 --- a/ts/fixtures/lang/src/pointers.rs +++ b/ts/fixtures/lang/src/pointers.rs @@ -7,7 +7,7 @@ //! nodes that an `AtomicPtr` and memory hold pointers to; pointers to arrays of bytes; and //! a pointer into a cell that other functions write whole through a `&mut` to it. -use std::cell::UnsafeCell; +use std::cell::{Cell, UnsafeCell}; use std::mem::MaybeUninit; use std::ptr::{self, NonNull}; use std::rc::Rc; @@ -1458,7 +1458,7 @@ pub fn reattached(data: &[u8], out: &mut Vec) { at: std::ptr::null_mut(), }; let mut buf = [0u16; 4]; - let mut slot = Slot { + let mut slot = Window { at: std::ptr::null_mut(), }; let mut pair = Reattached(0, 0); @@ -1478,12 +1478,8 @@ pub fn reattached(data: &[u8], out: &mut Vec) { /// A struct JS keeps as an object that only [`reattached`] points into. struct Reattached(u8, u8); -struct Window { - at: *mut [u16; 4], -} - -struct Slot { - at: *mut Reattached, +struct Window { + at: *mut T, } fn attach(at: &mut *mut T, to: &mut T) { @@ -1554,3 +1550,273 @@ fn refill(r: &mut Refilled, n: u8) -> u8 { fn swap_cell(c: &mut UnsafeCell, n: u8) { std::mem::swap(c, &mut UnsafeCell::new(n)); } + +/// An [`Enclosed`] of pointers to `$to`, a local of the body making them. +macro_rules! aim { + ($to:expr, $n:expr) => {{ + let at: *mut _ = &raw mut $to; + let held = NonNull::new(at).unwrap(); + Enclosed { + inner: Aimed { + at, + seen: at, + held, + maybe: if $n % 2 == 0 { Some(held) } else { None }, + tagged: (at, $n), + to: if $n % 3 == 0 { To::At(at) } else { To::Nowhere }, + }, + } + }}; +} + +/// Whether pointers that JS keeps as the pointee, or as where its bytes are, compare as +/// Rust's do: equal however they were made, and apart from another's. Written out for +/// each type, as comparing pointers to a type parameter would compare every type's. +macro_rules! compared { + ($to:expr, $other:expr) => {{ + let other: *mut _ = &raw mut $other; + let nest = aim!($to, 0u8); + let a = &nest.inner; + let same = [ + a.at as *const _ == a.seen, + a.held == NonNull::new(a.at).unwrap(), + matches!(a.maybe, Some(p) if p == a.held), + a.tagged.0 == a.at, + matches!(a.to, To::At(p) if p == a.at), + ]; + let apart = [ + a.at == other, + matches!(a.maybe, Some(p) if p.as_ptr() == other), + ptr::eq(a.seen, other), + ]; + let bits = |b: &[bool]| b.iter().fold(0u8, |acc, &b| acc << 1 | u8::from(b)); + [bits(&same), bits(&apart)] + }}; +} + +/// Reads and writes `$to` through an [`Enclosed`] of pointers to it, an `AtomicPtr` to it, +/// and references to it, then reads it. +macro_rules! aimed_at { + ($to:ident, $n:expr, $out:expr) => {{ + let nest = aim!($to, $n); + through(&nest, $n, $out); + swapped_in(&raw mut $to, $n, $out); + lend(&mut $to, $n, $out); + $out.push($to.get()); + }}; +} + +/// Pointers a generic type holds to its type parameter, in each shape a field can hold +/// one, instantiated where JS keeps the pointee as an object, a number it copies, an +/// enum it copies, the bytes of a `[u8; N]`, a cell, an array, and another generic +/// type's instance: read and written through, and compared where JS can compare them. +/// An `AtomicPtr` to the parameter and references to it are held beside them. +pub fn aimed(data: &[u8], out: &mut Vec) { + for &n in data { + let mut pair = Paired(n, !n); + aimed_at!(pair, n, out); + let mut num = n; + aimed_at!(num, n, out); + let mut signed = if n % 2 == 0 { Leaning::Pos(n) } else { Leaning::Neg(n) }; + aimed_at!(signed, n, out); + let mut bytes = [n; 4]; + aimed_at!(bytes, n, out); + let mut cell = Cell::new(n); + aimed_at!(cell, n, out); + let mut wide = [u16::from(n) << 4; 2]; + aimed_at!(wide, n, out); + let mut wrap = Housed(n); + aimed_at!(wrap, n, out); + let mut other = Paired(!n, n); + let mut other_bytes = [!n; 4]; + let mut other_wrap = Housed(!n); + out.extend(compared!(pair, other)); + out.extend(compared!(bytes, other_bytes)); + out.extend(compared!(wrap, other_wrap)); + } +} + +/// A pointee that reads and writes as a byte, whatever JS keeps it as. +trait Aim { + fn made(n: u8) -> Self; + fn get(&self) -> u8; + fn put(&mut self, n: u8); +} + +/// A struct JS keeps as an object, which pointers to are. +struct Paired(u8, u8); + +impl Aim for Paired { + fn made(n: u8) -> Self { + Paired(n, n ^ 0x0f) + } + fn get(&self) -> u8 { + self.0 ^ self.1 + } + fn put(&mut self, n: u8) { + self.1 = self.0.wrapping_add(n); + } +} + +impl Aim for u8 { + fn made(n: u8) -> Self { + n ^ 0x3c + } + fn get(&self) -> u8 { + *self + } + fn put(&mut self, n: u8) { + *self = self.wrapping_mul(3).wrapping_add(n); + } +} + +/// An enum, an object JS copies, so pointers to it are places, as pointers to a number are. +enum Leaning { + Pos(u8), + Neg(u8), +} + +impl Aim for Leaning { + fn made(n: u8) -> Self { + Leaning::Neg(n ^ 0x55) + } + fn get(&self) -> u8 { + match self { + Leaning::Pos(n) => *n, + Leaning::Neg(n) => !*n, + } + } + fn put(&mut self, n: u8) { + *self = match self { + Leaning::Pos(m) => Leaning::Neg(m.wrapping_add(n)), + Leaning::Neg(m) => Leaning::Pos(m.wrapping_sub(n)), + }; + } +} + +impl Aim for [u8; 4] { + fn made(n: u8) -> Self { + [n, !n, n ^ 1, n ^ 2] + } + fn get(&self) -> u8 { + self[0] ^ self[3] + } + fn put(&mut self, n: u8) { + self[usize::from(n % 4)] = self[0].wrapping_add(n); + } +} + +impl Aim for Cell { + fn made(n: u8) -> Self { + Cell::new(n ^ 0x77) + } + fn get(&self) -> u8 { + Cell::get(self) + } + fn put(&mut self, n: u8) { + self.set(self.get().rotate_left(1) ^ n); + } +} + +impl Aim for [u16; 2] { + fn made(n: u8) -> Self { + [u16::from(n) << 4, u16::from(!n) << 4] + } + fn get(&self) -> u8 { + ((self[0] ^ self[1]) >> 4) as u8 + } + fn put(&mut self, n: u8) { + self[usize::from(n % 2)] ^= u16::from(n) << 4; + } +} + +/// An instance of another generic type. +struct Housed(T); + +impl Aim for Housed { + fn made(n: u8) -> Self { + Housed(n ^ 0x99) + } + fn get(&self) -> u8 { + self.0 + } + fn put(&mut self, n: u8) { + self.0 = self.0.wrapping_add(n) ^ 0x10; + } +} + +/// Pointers to `T` in each shape a field holds one. +struct Aimed { + at: *mut T, + seen: *const T, + held: NonNull, + maybe: Option>, + tagged: (*mut T, u8), + to: To, +} + +enum To { + At(*mut T), + Nowhere, +} + +/// A generic type holding another's instance. +struct Enclosed { + inner: Aimed, +} + +/// References to `T`. +struct Borrows<'a, T> { + to: &'a mut T, + seen: &'a T, +} + +/// An `AtomicPtr` to `T`. +struct Swapped { + at: AtomicPtr, +} + +/// Reads and writes through each of `nest`'s pointers. +fn through(nest: &Enclosed, n: u8, out: &mut Vec) { + let a = &nest.inner; + unsafe { + out.push((*a.seen).get()); + (*a.at).put(n); + out.push((*a.held.as_ptr()).get()); + if let Some(p) = a.maybe { + (*p.as_ptr()).put(n ^ 3); + } + (*a.tagged.0).put(n.wrapping_add(a.tagged.1)); + if let To::At(p) = a.to { + (*p).put(!n); + } + out.push(u8::from(a.maybe.is_some()) << 1 | u8::from(matches!(a.to, To::At(_)))); + if n % 5 == 0 { + a.at.write(T::made(n)); + } + out.push((*a.seen).get()); + } +} + +/// Reads and writes through an `AtomicPtr` to what `to` points at, swapped in for null. +fn swapped_in(to: *mut T, n: u8, out: &mut Vec) { + let shared: Swapped = Swapped { + at: AtomicPtr::new(ptr::null_mut()), + }; + out.push(u8::from(shared.at.load(SeqCst).is_null())); + shared.at.store(to, SeqCst); + unsafe { + let at = shared.at.load(SeqCst); + (*at).put(n); + out.push((*at).get()); + } + out.push(u8::from(shared.at.swap(ptr::null_mut(), SeqCst).is_null())); +} + +/// Reads and writes `to` through references to it and to another `T`. +fn lend(to: &mut T, n: u8, out: &mut Vec) { + let made = T::made(n); + let lent = Borrows { to, seen: &made }; + lent.to.put(n >> 1); + out.extend([lent.to.get(), lent.seen.get()]); +} diff --git a/ts/runtime/rt.ts b/ts/runtime/rt.ts index de59c53f1..b950c3f66 100644 --- a/ts/runtime/rt.ts +++ b/ts/runtime/rt.ts @@ -111,6 +111,12 @@ export const DANGLING: never = /* @__PURE__ */ Object.freeze({}) as never; /** A dangling pointer to `()`, std's every one: a place that holds only `()`. */ export const DANGLING_UNIT: Place = { v: undefined }; +/** + * A generic type's pointer or reference to a `T` that only an instance decides: the object, + * the `Place` of a value JS copies, or the `ByteSlice` of a `[u8; N]`'s bytes. + */ +export type Ptr = T | Place | ByteSlice; + /** * `ptr::write` of `value` through a pointer to an object: `value` copied into it, one * object deep, so every pointer to it sees the write. diff --git a/ts/src/lower/mir/place.rs b/ts/src/lower/mir/place.rs index 8344c77c1..f3a8705c7 100644 --- a/ts/src/lower/mir/place.rs +++ b/ts/src/lower/mir/place.rs @@ -441,11 +441,14 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { /// `base`, a `ty`, cast to its `variant`, which MIR reads without a switch where the /// others can't be, as a derived `==` reads the other operand after comparing - /// discriminants. `tsc` narrows only what a switch tests. + /// discriminants. `tsc` narrows only what a switch tests, and nothing read through a + /// cast, as a generic type's `rt.Ptr` field is read as its instance's type. fn as_variant(&mut self, base: Expr, ty: Ty<'tcx>, variant: VariantIdx, span: Span) -> Expr { match ty.kind() { ty::Adt(adt, _) - if self.b.t.crates.translates(adt.did()) || Std::of(self.tcx, adt.did()) == Some(Std::Result) => + if self.b.t.crates.translates(adt.did()) + || Std::of(self.tcx, adt.did()) == Some(Std::Result) + || matches!(base, Expr::As(..)) => { match self.variant_ty(ty, variant, span) { Some(variant) => Expr::As(Box::new(base), variant), @@ -610,17 +613,21 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { _ if transparent(self.b.t, ty) || crate::lower::library::wrapped(tcx, ty).is_some() => base, None if self.b.t.own(adt.did()) => { let info = self.b.t.adt(*adt, span); - match info.repr { + let def = &adt.variant(variant.unwrap_or(rustc_abi::FIRST_VARIANT)).fields[field]; + let read = match info.repr { AdtRepr::Struct { fields, .. } => base.field(fields[field.index()]), AdtRepr::Slots(_) => { - self.err(span, format!("a field of union `{ty}` read apart from its place")) + return self.err(span, format!("a field of union `{ty}` read apart from its place")); } AdtRepr::Union | AdtRepr::Tags => { - let variant = variant.unwrap_or(rustc_abi::FIRST_VARIANT); - let def = &adt.variant(variant).fields[field]; - let name = crate::lower::field_name(def.name.as_str(), field.index()); - base.member(name) + base.member(crate::lower::field_name(def.name.as_str(), field.index())) } + }; + let ty::Adt(_, args) = ty.kind() else { unreachable!() }; + // The definition's `rt.Ptr`, as what this instance holds there. + match self.b.t.ptr_field(def.did, args, span) { + Some(held) => Expr::As(Box::new(read), held), + None => read, } } _ => self.err(span, format!("a field of `{ty}`")), @@ -1021,8 +1028,9 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { Expr::rt("place", vec![get, set]) } - /// The `rt.Place` of `place`, a reborrow `&mut *r` of a reference `r` that is one, which is `r`'s. - /// A shared reborrow `&*r` is what `r` points at instead. + /// The `rt.Place` of `place`, a reborrow `&mut *r` of a reference or pointer `r` that is + /// one, which is `r`'s. A shared reborrow `&*r` is what `r` points at instead, and so is + /// a `&mut` to an object that a pointer to is a place, such as a `Cell`. pub(super) fn reborrowed( &mut self, kind: mir::BorrowKind, @@ -1030,7 +1038,8 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { span: Span, out: &mut Vec, ) -> Option { - if !matches!(kind, mir::BorrowKind::Mut { .. }) { + if !matches!(kind, mir::BorrowKind::Mut { .. }) || !self.b.t.needs_place(place.ty(&self.mir.local_decls, self.tcx).ty) + { return None; } let [rest @ .., ProjectionElem::Deref] = place.projection.as_slice() else { diff --git a/ts/src/lower/mod.rs b/ts/src/lower/mod.rs index 8ece3f813..fff3a89f9 100644 --- a/ts/src/lower/mod.rs +++ b/ts/src/lower/mod.rs @@ -191,6 +191,9 @@ pub struct Translator<'a, 'tcx> { instances: rustc_data_structures::fx::FxHashMap, SymId>, queue: VecDeque<(Instance<'tcx>, SymId)>, adts: rustc_data_structures::fx::FxHashMap, + /// The fields of generic types whose definition types a pointer as an `rt.Ptr`, which + /// an instance's read casts to what it holds. + ptr_fields: rustc_data_structures::fx::FxHashSet, /// Source files by name, as indexes into `program.sources`. sources: rustc_data_structures::fx::FxHashMap>, failed: bool, @@ -428,6 +431,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { instances: Default::default(), queue: VecDeque::new(), adts: Default::default(), + ptr_fields: Default::default(), sources: Default::default(), failed: false, env: TypingEnv::fully_monomorphized(), @@ -1049,7 +1053,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { let span = tcx.def_span(field.did); ts::Field { id, - ty: self.ty(field.ty(tcx, identity).skip_norm_wip(), span), + ty: self.defined_field_ty(field, identity, span), doc: self.doc(field.did), init: ts::FieldInit::Ctor, } @@ -1093,7 +1097,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { let mut fields = vec![("tag".to_string(), Type::StrLit(v.name.to_string()))]; for (i, field) in v.fields.iter().enumerate() { let span = tcx.def_span(field.did); - let ty = self.ty(field.ty(tcx, identity).skip_norm_wip(), span); + let ty = self.defined_field_ty(field, identity, span); fields.push((field_name(field.name.as_str(), i), ty)); } Type::Object(fields) @@ -1272,6 +1276,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { ty::Never => Type::Builtin("never"), ty::Tuple(tys) if tys.is_empty() => Type::Builtin("undefined"), ty::Tuple(tys) => Type::Tuple(tys.iter().map(|t| self.ty(t, span)).collect()), + ty::Ref(_, inner, _) if self.instance_pointee(*inner) => Type::Rt("Ptr", vec![self.ty(*inner, span)]), ty::Ref(_, inner, rustc_ast::Mutability::Mut) if self.needs_place(*inner) => { Type::Rt("Place", vec![self.ty(*inner, span)]) } @@ -1613,6 +1618,28 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { Type::Sym(info.sym, args) } + /// The TypeScript type of `field` in its type's definition, with `identity` its own + /// parameters, noting a field that holds an `rt.Ptr` for [`Self::ptr_field`]. + fn defined_field_ty(&mut self, field: &ty::FieldDef, identity: GenericArgsRef<'tcx>, span: Span) -> Type { + let ty = self.ty(field.ty(self.tcx, identity).skip_norm_wip(), span); + if ty.any(&|t| matches!(t, Type::Rt("Ptr", _))) { + self.ptr_fields.insert(field.did); + } + ty + } + + /// The type an instance with `args` holds in `field`, if its definition types a pointer + /// in it as an `rt.Ptr`, which a read casts to it. + pub fn ptr_field(&mut self, field: DefId, args: GenericArgsRef<'tcx>, span: Span) -> Option { + match self.ptr_fields.contains(&field) { + true => { + let ty = self.field_ty(field, args); + Some(self.ty(ty, span)) + } + false => None, + } + } + /// Why an instance of the crate's generic `adt` with `args` can't hold its fields' values, /// if it can't: an `Option` or a `Poll` over a type parameter that its definition types /// `T | undefined` or `rt.Poll`, whose `None` or `Pending` this instance's `T` makes diff --git a/ts/src/lower/pointer.rs b/ts/src/lower/pointer.rs index 4350f2fdc..2ab442ad3 100644 --- a/ts/src/lower/pointer.rs +++ b/ts/src/lower/pointer.rs @@ -112,8 +112,27 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { ty } + /// Whether only an instance decides what a pointer or reference to `ty` is, as in a + /// generic type's definition: `ty` a type parameter, an array of one, either through + /// `MaybeUninit`s, or a binding's generic type, which an instance decides is `Copy`. + pub fn instance_pointee(&self, ty: Ty<'tcx>) -> bool { + if self.polymorphic() || !ty.has_param() { + return false; + } + let open = |ty: Ty<'tcx>| matches!(ty.kind(), ty::Param(_) | ty::Alias(..)); + let ty = self.uninit_inner(ty); + match ty.kind() { + ty::Array(elem, _) => open(*elem), + ty::Adt(adt, _) => self.bound_drops(adt.did()).is_some(), + _ => open(ty), + } + } + /// The TypeScript type of a raw pointer or `NonNull` to `pointee`. pub fn pointer_ty(&mut self, pointee: Ty<'tcx>, span: Span) -> Type { + if self.instance_pointee(pointee) { + return Type::Rt("Ptr", vec![self.ty(pointee, span)]); + } match self.pointee(pointee) { Pointee::Place => Type::Rt("Place", vec![self.ty(pointee, span)]), Pointee::Object => self.ty(pointee, span), diff --git a/ts/src/ts.rs b/ts/src/ts.rs index ccb35497a..191828286 100644 --- a/ts/src/ts.rs +++ b/ts/src/ts.rs @@ -594,16 +594,21 @@ pub enum Type { impl Type { /// Whether it names the type parameter `param`. pub fn names(&self, param: &str) -> bool { - match self { - Type::Param(name) => name == param, - Type::Builtin(_) | Type::StrLit(_) => false, - Type::Rt(_, tys) | Type::Sym(_, tys) | Type::Union(tys) | Type::Tuple(tys) => { - tys.iter().any(|t| t.names(param)) + self.any(&|t| matches!(t, Type::Param(name) if name == param)) + } + + /// Whether it, or any type in it, is one `f` picks. + pub fn any(&self, f: &impl Fn(&Type) -> bool) -> bool { + f(self) + || match self { + Type::Param(_) | Type::Builtin(_) | Type::StrLit(_) => false, + Type::Rt(_, tys) | Type::Sym(_, tys) | Type::Union(tys) | Type::Tuple(tys) => { + tys.iter().any(|t| t.any(f)) + } + Type::Array(t) => t.any(f), + Type::Func(tys, ret) => ret.any(f) || tys.iter().any(|t| t.any(f)), + Type::Object(fields) => fields.iter().any(|(_, t)| t.any(f)), } - Type::Array(t) => t.names(param), - Type::Func(tys, ret) => ret.names(param) || tys.iter().any(|t| t.names(param)), - Type::Object(fields) => fields.iter().any(|(_, t)| t.names(param)), - } } } From 626dcd9150f1dc586408f5e525eaa6cae6a68717 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 19:59:24 -0700 Subject: [PATCH 3/6] docs: record generic pointer fields and follow-up quests Co-Authored-By: Claude Opus 5.5 --- quest/m3/README.md | 4 +++- quest/m3/ts-check-output.md | 23 +++++++++++++++++++++++ quest/m3/ts-generic-byte-fields.md | 19 +++++++++++++++++++ quest/m3/ts-generic-pointer-fields.md | 20 -------------------- quest/m3/ts-option-pointer-eq.md | 16 ++++++++++++++++ ts/README.md | 10 +++++++--- ts/fixtures/lang/src/pointers.rs | 9 +++++---- 7 files changed, 73 insertions(+), 28 deletions(-) create mode 100644 quest/m3/ts-check-output.md create mode 100644 quest/m3/ts-generic-byte-fields.md delete mode 100644 quest/m3/ts-generic-pointer-fields.md create mode 100644 quest/m3/ts-option-pointer-eq.md diff --git a/quest/m3/README.md b/quest/m3/README.md index cad053705..7fc38364d 100644 --- a/quest/m3/README.md +++ b/quest/m3/README.md @@ -20,15 +20,17 @@ generic std gap is planned here even when moq never calls it. - [BufMut's provided writes through a &mut](/quest/m3/ts-buf-mut-forward.md) - `put`, `put_bytes`, `put_uint`, and `put_int` of a `&mut Vec` or `&mut BytesMut` translate - [Trait objects](/quest/m3/ts-dyn.md) - `dyn Error`, `dyn Iterator`, `dyn Buf`, and `Arc` translate, so a consumer neither rewrites nor binds them - [Placeholders written to a crate's own fmt::Write](/quest/m3/ts-fmt-calls.md) - `write!` with placeholders into a crate's own writer translates, its `write_str` seeing each call std makes +- [Type-check the output before success](/quest/m3/ts-check-output.md) - translation fails at a Rust span on output `tsc` rejects, rather than at the consumer's `tsc` - [Waiting: type-check in process with tsrs](/quest/m3/ts-tsrs.md) - rust2-ts checks bindings through tsrs instead of `tsc` once it is a stable library - [Drop order in std's folds and iterators](/quest/m3/ts-drop-order.md) - the values that drop still refused in std's consumers, flattens, and collects drop as std's do - [Fresh writes in a body generic over a type](/quest/m3/ts-fresh-type-params.md) - a whole write into fresh memory holding a type parameter's values fills it, as one generic over a length alone does - [Result's iterators](/quest/m3/ts-result-iters.md) - `Result::iter`, `iter_mut`, `into_iter`, and `flatten` over `Result`s translate -- [Raw pointers to a type parameter in a struct](/quest/m3/ts-generic-pointer-fields.md) - a `*mut T` field of a generic struct is typed as each instance stores it, or refuses +- [A generic type's bytes at u8](/quest/m3/ts-generic-byte-fields.md) - a `[T; N]`, `Vec`, or `&[T]` field of a generic type is typed as its `u8` instance holds it, or refused - [std's conversions of a reference](/quest/m3/ts-ref-conversions.md) - `to_owned`, `clone_from`, `binary_search`, `size_of_val`, `from_ref`/`from_mut`, and `AsRef`/`Borrow` as a slice translate - [Waiting: a slice object for a mutable part of other values](/quest/m3/ts-slice-object.md) - waits on a moq profile showing the `Proxy` view's traps matter, then decides on an `rt.ByteSlice`-like form - [Port the workflow guard to kixelated/quest](/quest/m3/quest-workflow-guard.md) - quest's environment guard parses YAML as this repository's does - [A deque's two slices](/quest/m3/ts-deque-slices.md) - `VecDeque::as_slices` and `{:?}` of a deque's `Iter`, `IterMut`, and `Drain` translate, split where std's are +- [== of an Option of NonNull](/quest/m3/ts-option-pointer-eq.md) - `==` of `Option>` translates - [ptr::replace whose result nothing reads](/quest/m3/ts-ptr-replace-unread.md) - `ptr::replace` with its result discarded type-checks - [std's sorts call their tests in std's order](/quest/m3/ts-sort-order.md) - `slice::sort` and a B-tree's `collect` call `lt` or `cmp` as std's driftsort does past 16 elements - [A B-tree's searches call Ord as std's do](/quest/m3/ts-btree-search-order.md) - a B-tree's lookups and inserts call a key's own `Ord` in std's order and number diff --git a/quest/m3/ts-check-output.md b/quest/m3/ts-check-output.md new file mode 100644 index 000000000..e58da4f72 --- /dev/null +++ b/quest/m3/ts-check-output.md @@ -0,0 +1,23 @@ +# [M] Type-check the output before success + +## Goal + +[rust2-ts](/ts/README.md) fails translation, at the Rust span the source map names, on +output `tsc` rejects, so a typing gap fails loud where the consumer's crate translates +rather than in the consumer's own `tsc`, and measures what the check costs a moq-net +translation. + +## Plan + +Found by [the generic pointer fields](https://github.com/moq-dev/rust2/pull/371): a +generic type's `*mut T` field translated, and only `tsc` rejected it. `just ts test` +type-checks the fixtures and the nightly `just ts moq` moq's output, but nothing checks +another consumer's. Translation already runs the flake's `tsc` on bindings, so the +output could go through the same run. A rejection is a translator bug, so the error +should say so beside the span. + +Public API: translation fails where it succeeded on ill-typed output. + +## Related + +- [Waiting: type-check in process with tsrs](/quest/m3/ts-tsrs.md) - would make the check cheaper; this needs no wait diff --git a/quest/m3/ts-generic-byte-fields.md b/quest/m3/ts-generic-byte-fields.md new file mode 100644 index 000000000..100cd69ce --- /dev/null +++ b/quest/m3/ts-generic-byte-fields.md @@ -0,0 +1,19 @@ +# [S] A generic type's bytes at u8 + +## Goal + +[rust2-ts](/ts/README.md) types a `[T; N]`, `Vec`, or `&[T]` field of a generic type as +its `u8` instance holds it, or refuses that instance with a span, proven by a differential +test against native Rust of one such type instantiated at `u8` and at another element. + +## Plan + +Found beside [the generic pointer fields](https://github.com/moq-dev/rust2/pull/371): the +definition types each field `T[]`, but an instance at `u8` stores a `Uint8Array`, an +`rt.ByteVec`, or an `rt.ByteSlice`, so `tsc` rejects the instance's code while +translation succeeds. A field whose definition types a pointer as an `rt.Ptr` is +already read as its instance's type through a cast; a union of the element array and +the byte form, cast on read the same way, may fit, as may refusing the `u8` instance as +`generic_erasure` refuses an `Option` of a type parameter that can be `undefined`. + +Public API: the translator's output. diff --git a/quest/m3/ts-generic-pointer-fields.md b/quest/m3/ts-generic-pointer-fields.md deleted file mode 100644 index 45dede4eb..000000000 --- a/quest/m3/ts-generic-pointer-fields.md +++ /dev/null @@ -1,20 +0,0 @@ -# [S] Raw pointers to a type parameter in a struct - -## Goal - -[rust2-ts](/ts/README.md) types a `*mut T` or `*const T` field of a generic struct as -each instance stores it, or refuses the struct with a span, proven by a differential -test against native Rust of `struct Window { at: *mut T }` instantiated with a -struct and with a `u8`. - -## Plan - -Found by [ts-taken-precision](/quest/m2/ts-taken-precision.md)'s lang case: the -interface declares `at: rt.Place`, because `pointee` of a type parameter outside an -instance is a `Place`, but `Window`'s code stores the object itself, so -`tsc` rejects the assignment and `(*w.at).0`. Either type the field by a conditional -type that picks `T` for an object and `rt.Place` otherwise, or refuse a raw pointer -to a type parameter in a field until [Unsafe code the translator can model](/quest/m3/ts-unsafe.md) -types pointers. - -Public API: the translator's output. diff --git a/quest/m3/ts-option-pointer-eq.md b/quest/m3/ts-option-pointer-eq.md new file mode 100644 index 000000000..47ef3f18e --- /dev/null +++ b/quest/m3/ts-option-pointer-eq.md @@ -0,0 +1,16 @@ +# [XS] == of an Option of NonNull + +## Goal + +[rust2-ts](/ts/README.md) translates `==` of an `Option>`, proven by a +differential test against native Rust for pointers to an object and to a `[u8; N]`, +equal and apart, and `None`. + +## Plan + +Found writing [the generic pointer fields](https://github.com/moq-dev/rust2/pull/371)' +fixture: `a.maybe == Some(a.held)` is refused as an unsupported call to `Option`'s +`PartialEq::eq`, while `matches!(a.maybe, Some(p) if p == a.held)` translates. Pointers +to a value JS copies stay refused, as their `==` is. + +Public API: the translator's output. diff --git a/ts/README.md b/ts/README.md index c508f0839..e45e1ad6b 100644 --- a/ts/README.md +++ b/ts/README.md @@ -316,7 +316,10 @@ function is suffixed instead by a hash of its text, with what it calls by name, `map$1cf8u0y`: instances that print the same are one function, whichever of them translation reaches. Types are translated once, generically, so a function of a generic type is one instance's, declaring the instance it takes as `self`: -`fmt$fmt_Debug_fmt_Pair(self: Wrap, f: rt.Formatter)`. A type's module exports the +`fmt$fmt_Debug_fmt_Pair(self: Wrap, f: rt.Formatter)`. A reference or pointer +in a generic type to what only an instance decides the form of, such as `*mut T` or +`&'a mut T`, is an `rt.Ptr`: the object, an `rt.Place`, or an `rt.ByteSlice`, +which each read of an instance's field casts to what it holds. A type's module exports the type by its own name, which a caller writes `Decoder.Decoder`, and a function whose name and exports it as its own: `function new_` is `Decoder.new`. A module imports a function or value by its name, and a type's module whole by the type's, `import * as Decoder`, @@ -800,8 +803,9 @@ built natively for wasm32 and run beside its translation on the same inputs by that log what each is called with, `concat` and `join` of arrays, slices, `Vec`s, and `Cow`s, of bytes and of items whose `Clone` logs, std's `Bound`, `Reverse`, and `NonZero`, and raw pointers: a linked list of boxed nodes as `hashlink` keeps one, through a union and a - `MaybeUninit` entry, pointers to locals, fields, and whole structs, and those - `UnsafeCell::get` gives, as crossbeam-epoch's own `OnceLock` keeps its collector. Its + `MaybeUninit` entry, pointers to locals, fields, and whole structs, those + `UnsafeCell::get` gives, as crossbeam-epoch's own `OnceLock` keeps its collector, and + those a generic type holds to its parameter, at each form a pointer takes. Its differential test runs through `caller.ts`, a hand-written caller that also prints a `printable` error nothing translated prints, and adds every 64- and 128-bit case over each pair of values next to a power of two, diff --git a/ts/fixtures/lang/src/pointers.rs b/ts/fixtures/lang/src/pointers.rs index c39a739eb..d533eccc7 100644 --- a/ts/fixtures/lang/src/pointers.rs +++ b/ts/fixtures/lang/src/pointers.rs @@ -4,8 +4,9 @@ //! and compared; pointers to the parts of a struct kept as objects; the pointers //! `UnsafeCell::get` gives; slots of fresh memory written whole before any pointer //! into them is taken, by index or through std's iterators over them; pointers into -//! nodes that an `AtomicPtr` and memory hold pointers to; pointers to arrays of bytes; and -//! a pointer into a cell that other functions write whole through a `&mut` to it. +//! nodes that an `AtomicPtr` and memory hold pointers to; pointers to arrays of bytes; a +//! pointer into a cell that other functions write whole through a `&mut` to it; and +//! pointers a generic type holds to its parameter, at each form a pointer takes. use std::cell::{Cell, UnsafeCell}; use std::mem::MaybeUninit; @@ -1451,8 +1452,8 @@ fn next_read(items: &mut std::slice::Iter<'_, T>) -> Option { /// Pointers callees keep, through references, to values with no cell in them, which their /// variables are assigned again past while they are kept: each made again before it is -/// read, as zlib's stream takes its window each round, by a callee over a type parameter: -/// one into an array and one into a struct. +/// read, as zlib's stream takes its window each round, by a callee over a type parameter, +/// into fields of one generic type: one into an array and one into a struct. pub fn reattached(data: &[u8], out: &mut Vec) { let mut window = Window { at: std::ptr::null_mut(), From acf79d7a5b129898fc6655a0b47b1680c435a14e Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 20:09:09 -0700 Subject: [PATCH 4/6] fix(ts): cast a generic type's pointer field where an instance's copy reads it Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/expected/lib.ts | 60 ++++++ ts/fixtures/lang/expected/pointers.Aimed.ts | 2 +- ts/fixtures/lang/expected/pointers.ts | 202 +++++++++++++++----- ts/fixtures/lang/src/pointers.rs | 32 +++- ts/src/lower/copy.rs | 9 +- ts/src/lower/mir/place.rs | 9 +- ts/src/lower/mod.rs | 18 +- ts/src/lower/unions.rs | 3 +- 8 files changed, 262 insertions(+), 73 deletions(-) diff --git a/ts/fixtures/lang/expected/lib.ts b/ts/fixtures/lang/expected/lib.ts index d1004a173..de57a0638 100644 --- a/ts/fixtures/lang/expected/lib.ts +++ b/ts/fixtures/lang/expected/lib.ts @@ -22,15 +22,19 @@ import type * as Lopsided from "./keys.Lopsided.ts"; import * as lengths_Tagged from "./lengths.Tagged.ts"; import type * as locals_Twin from "./locals.Twin.ts"; import type * as locks_Tally from "./locks.Tally.ts"; +import type * as Aimed from "./pointers.Aimed.ts"; import type * as ByCall from "./pointers.ByCall.ts"; import type * as ByClosure from "./pointers.ByClosure.ts"; import type * as ByObject from "./pointers.ByObject.ts"; import type * as Duo from "./pointers.Duo.ts"; import type * as pointers_Halves from "./pointers.Halves.ts"; +import type * as Housed from "./pointers.Housed.ts"; import type * as Inner from "./pointers.Inner.ts"; +import type * as Leaning from "./pointers.Leaning.ts"; import * as List from "./pointers.List.ts"; import type * as Outer from "./pointers.Outer.ts"; import type * as pointers_Pair from "./pointers.Pair.ts"; +import type * as Paired from "./pointers.Paired.ts"; import * as saturates_Gauge from "./saturates.Gauge.ts"; import type * as shapes_Gauge from "./shapes.Gauge.ts"; import type * as shapes_Held from "./shapes.Held.ts"; @@ -494,6 +498,34 @@ export function copy$ops_ControlFlow_unit_array2_u8(v: rt.Result>): Aimed.Aimed> { + return { at: v.at as rt.Place>, seen: v.seen as rt.Place>, held: v.held as rt.Place>, maybe: v.maybe as rt.Place> | undefined, tagged: copy$tuple2_mutPtr_Cell_u8_u8(v.tagged as [rt.Place>, rt.u8]), to: v.to }; +} + +export function copy$pointers_Aimed_array2_u16(v: Aimed.Aimed): Aimed.Aimed { + return { at: v.at as rt.u16[], seen: v.seen as rt.u16[], held: v.held as rt.u16[], maybe: v.maybe as rt.u16[] | undefined, tagged: copy$tuple2_mutPtr_array2_u16_u8(v.tagged as [rt.u16[], rt.u8]), to: v.to }; +} + +export function copy$pointers_Aimed_array4_u8(v: Aimed.Aimed): Aimed.Aimed { + return { at: v.at as rt.ByteSlice, seen: v.seen as rt.ByteSlice, held: v.held as rt.ByteSlice, maybe: v.maybe as rt.ByteSlice | undefined, tagged: copy$tuple2_mutPtr_array4_u8_u8(v.tagged as [rt.ByteSlice, rt.u8]), to: v.to }; +} + +export function copy$pointers_Aimed_pointers_Housed_u8(v: Aimed.Aimed>): Aimed.Aimed> { + return { at: v.at as Housed.Housed, seen: v.seen as Housed.Housed, held: v.held as Housed.Housed, maybe: v.maybe as Housed.Housed | undefined, tagged: copy$tuple2_mutPtr_pointers_Housed_u8_u8(v.tagged as [Housed.Housed, rt.u8]), to: v.to }; +} + +export function copy$pointers_Aimed_pointers_Leaning(v: Aimed.Aimed): Aimed.Aimed { + return { at: v.at as rt.Place, seen: v.seen as rt.Place, held: v.held as rt.Place, maybe: v.maybe as rt.Place | undefined, tagged: copy$tuple2_mutPtr_pointers_Leaning_u8(v.tagged as [rt.Place, rt.u8]), to: v.to }; +} + +export function copy$pointers_Aimed_pointers_Paired(v: Aimed.Aimed): Aimed.Aimed { + return { at: v.at as Paired.Paired, seen: v.seen as Paired.Paired, held: v.held as Paired.Paired, maybe: v.maybe as Paired.Paired | undefined, tagged: copy$tuple2_mutPtr_pointers_Paired_u8(v.tagged as [Paired.Paired, rt.u8]), to: v.to }; +} + +export function copy$pointers_Aimed_u8(v: Aimed.Aimed): Aimed.Aimed { + return { at: v.at as rt.Place, seen: v.seen as rt.Place, held: v.held as rt.Place, maybe: v.maybe as rt.Place | undefined, tagged: copy$tuple2_mutPtr_u8_u8(v.tagged as [rt.Place, rt.u8]), to: v.to }; +} + export function copy$pointers_ByCall(v: ByCall.ByCall): ByCall.ByCall { return { _0: v._0, _1: v._1 }; } @@ -624,6 +656,34 @@ export function copy$tuple2_locals_Twin_locals_Twin(v: [locals_Twin.Twin, locals return [copy$locals_Twin(v[0]), copy$locals_Twin(v[1])]; } +export function copy$tuple2_mutPtr_Cell_u8_u8(v: [rt.Place>, rt.u8]): [rt.Place>, rt.u8] { + return [v[0], v[1]]; +} + +export function copy$tuple2_mutPtr_array2_u16_u8(v: [rt.u16[], rt.u8]): [rt.u16[], rt.u8] { + return [v[0], v[1]]; +} + +export function copy$tuple2_mutPtr_array4_u8_u8(v: [rt.ByteSlice, rt.u8]): [rt.ByteSlice, rt.u8] { + return [v[0], v[1]]; +} + +export function copy$tuple2_mutPtr_pointers_Housed_u8_u8(v: [Housed.Housed, rt.u8]): [Housed.Housed, rt.u8] { + return [v[0], v[1]]; +} + +export function copy$tuple2_mutPtr_pointers_Leaning_u8(v: [rt.Place, rt.u8]): [rt.Place, rt.u8] { + return [v[0], v[1]]; +} + +export function copy$tuple2_mutPtr_pointers_Paired_u8(v: [Paired.Paired, rt.u8]): [Paired.Paired, rt.u8] { + return [v[0], v[1]]; +} + +export function copy$tuple2_mutPtr_u8_u8(v: [rt.Place, rt.u8]): [rt.Place, rt.u8] { + return [v[0], v[1]]; +} + export function copy$tuple2_ref_sync_Mutex_u8_u8(v: [rt.Mutex, rt.u8]): [rt.Mutex, rt.u8] { return [v[0], v[1]]; } diff --git a/ts/fixtures/lang/expected/pointers.Aimed.ts b/ts/fixtures/lang/expected/pointers.Aimed.ts index 0b7c32c5a..443a20206 100644 --- a/ts/fixtures/lang/expected/pointers.Aimed.ts +++ b/ts/fixtures/lang/expected/pointers.Aimed.ts @@ -3,7 +3,7 @@ import * as rt from "./rt.ts"; import type * as To from "./pointers.To.ts"; -/** Pointers to `T` in each shape a field holds one. */ +/** Pointers to `T` in each shape a field holds one, copied as Rust copies them. */ export interface Aimed { at: rt.Ptr; seen: rt.Ptr; diff --git a/ts/fixtures/lang/expected/pointers.ts b/ts/fixtures/lang/expected/pointers.ts index e08da7dc1..e3f6ed0de 100644 --- a/ts/fixtures/lang/expected/pointers.ts +++ b/ts/fixtures/lang/expected/pointers.ts @@ -1,8 +1,9 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; -import { copy$Option_pointers_Pair, copy$array_ptr_array4_u8, copy$array_u16, copy$array_u8, copy$array_unit, copy$mem_MaybeUninit_array_u32, copy$mem_MaybeUninit_array_u8, copy$mem_MaybeUninit_tuple2_u8_u8, copy$pointers_ByCall, copy$pointers_ByClosure, copy$pointers_ByObject, copy$pointers_Duo, copy$pointers_Halves, copy$pointers_Outer, copy$pointers_Pair, copy$tuple2_array2_u32_u8, copy$tuple2_u32_u32, copy$tuple2_u8_u8, drop$pointers_List_String, drop$pointers_List_sync_Arc_u8 } from "./lib.ts"; +import { copy$Option_pointers_Pair, copy$array_ptr_array4_u8, copy$array_u16, copy$array_u8, copy$array_unit, copy$mem_MaybeUninit_array_u32, copy$mem_MaybeUninit_array_u8, copy$mem_MaybeUninit_tuple2_u8_u8, copy$pointers_Aimed_Cell_u8, copy$pointers_Aimed_array2_u16, copy$pointers_Aimed_array4_u8, copy$pointers_Aimed_pointers_Housed_u8, copy$pointers_Aimed_pointers_Leaning, copy$pointers_Aimed_pointers_Paired, copy$pointers_Aimed_u8, copy$pointers_ByCall, copy$pointers_ByClosure, copy$pointers_ByObject, copy$pointers_Duo, copy$pointers_Halves, copy$pointers_Outer, copy$pointers_Pair, copy$tuple2_array2_u32_u8, copy$tuple2_u32_u32, copy$tuple2_u8_u8, drop$pointers_List_String, drop$pointers_List_sync_Arc_u8 } from "./lib.ts"; import { unwrapOr$0mkoact as option_unwrapOr$0mkoact, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$1cfrse5 as option_map$1cfrse5, mapOr$08xz81a as option_mapOr$08xz81a, mapOr$1wxcg5q as option_mapOr$1wxcg5q, filter$0tnmmii } from "./core/option.ts"; +import type * as Aimed from "./pointers.Aimed.ts"; import * as Bin from "./pointers.Bin.ts"; import type * as ByCall from "./pointers.ByCall.ts"; import * as ByClosure from "./pointers.ByClosure.ts"; @@ -1308,8 +1309,8 @@ export function nextRead$pointers_Loaded(items: rt.Iter): Loaded. /** * Pointers callees keep, through references, to values with no cell in them, which their * variables are assigned again past while they are kept: each made again before it is - * read, as zlib's stream takes its window each round, by a callee over a type parameter: - * one into an array and one into a struct. + * read, as zlib's stream takes its window each round, by a callee over a type parameter, + * into fields of one generic type: one into an array and one into a struct. */ export function reattached(data: rt.ByteSlice, out: rt.ByteVec): void { const window: pointers_Window.Window = { at: rt.NULL }; @@ -1840,37 +1841,57 @@ export function put$pointers_Aim_array2_u16(self: rt.u16[], n: rt.u8): void { self[_7] = self[_7] ^ _3; } -/** Reads and writes through each of `nest`'s pointers. */ +/** + * Reads and writes through each of `nest`'s pointers, and through those of a copy of + * them, whose own tag changes apart from theirs. + */ export function through$Cell_u8(nest: Enclosed.Enclosed>, n: rt.u8, out: rt.ByteVec): void { - let _39!: boolean; + let _49!: boolean; + const copy: Aimed.Aimed> = copy$pointers_Aimed_Cell_u8(nest.inner); + (copy.tagged as [rt.Place>, rt.u8])[1] = (copy.tagged as [rt.Place>, rt.u8])[1] ^ 64; + const _8: [rt.Place>, rt.u8] = tagged$Cell_u8(copy); + const at: rt.Place> = _8[0]; + const tag: rt.u8 = _8[1]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of((nest.inner.tagged as [rt.Place>, rt.u8])[1], tag)), undefined, true); + put$pointers_Aim_Cell_u8(at.v, tag); rt.byteVecPush(out, get$pointers_Aim_Cell_u8((nest.inner.seen as rt.Place>).v)); put$pointers_Aim_Cell_u8((nest.inner.at as rt.Place>).v, n); rt.byteVecPush(out, get$pointers_Aim_Cell_u8(((nest.inner.held as rt.Place>)).v)); if ((nest.inner.maybe as rt.Place> | undefined) !== undefined) { put$pointers_Aim_Cell_u8((((nest.inner.maybe as rt.Place> | undefined) as rt.Place>)).v, n ^ 3); } - const _52: rt.Place> = (nest.inner.tagged as [rt.Place>, rt.u8])[0]; - const _23: rt.u8 = rt.u8WrappingAdd(n, (nest.inner.tagged as [rt.Place>, rt.u8])[1]); - put$pointers_Aim_Cell_u8(_52.v, _23); + const _62: rt.Place> = (nest.inner.tagged as [rt.Place>, rt.u8])[0]; + const _33: rt.u8 = rt.u8WrappingAdd(n, (nest.inner.tagged as [rt.Place>, rt.u8])[1]); + put$pointers_Aim_Cell_u8(_62.v, _33); if (nest.inner.to.tag === "At") { put$pointers_Aim_Cell_u8((nest.inner.to._0 as rt.Place>).v, ~n & 0xff); } - const _32: rt.u8 = ((((nest.inner.maybe as rt.Place> | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; + const _42: rt.u8 = ((((nest.inner.maybe as rt.Place> | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; if (nest.inner.to.tag === "At") { - _39 = true; + _49 = true; } else { - _39 = false; + _49 = false; } - rt.byteVecPush(out, _32 | ((_39 ? 1 : 0))); + rt.byteVecPush(out, _42 | ((_49 ? 1 : 0))); if (rt.u8Rem(n, 5) === 0) { (nest.inner.at as rt.Place>).v = made$pointers_Aim_Cell_u8(n); } rt.byteVecPush(out, get$pointers_Aim_Cell_u8((nest.inner.seen as rt.Place>).v)); } -/** Reads and writes through each of `nest`'s pointers. */ +/** + * Reads and writes through each of `nest`'s pointers, and through those of a copy of + * them, whose own tag changes apart from theirs. + */ export function through$array2_u16(nest: Enclosed.Enclosed, n: rt.u8, out: rt.ByteVec): void { - let _39!: boolean; + let _49!: boolean; + const copy: Aimed.Aimed = copy$pointers_Aimed_array2_u16(nest.inner); + (copy.tagged as [rt.u16[], rt.u8])[1] = (copy.tagged as [rt.u16[], rt.u8])[1] ^ 64; + const _8: [rt.u16[], rt.u8] = tagged$array2_u16(copy); + const at: rt.u16[] = _8[0]; + const tag: rt.u8 = _8[1]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of((nest.inner.tagged as [rt.u16[], rt.u8])[1], tag)), undefined, true); + put$pointers_Aim_array2_u16(at, tag); rt.byteVecPush(out, get$pointers_Aim_array2_u16(nest.inner.seen as rt.u16[])); put$pointers_Aim_array2_u16(nest.inner.at as rt.u16[], n); rt.byteVecPush(out, get$pointers_Aim_array2_u16(nest.inner.held as rt.u16[])); @@ -1881,22 +1902,32 @@ export function through$array2_u16(nest: Enclosed.Enclosed, n: rt.u8, if (nest.inner.to.tag === "At") { put$pointers_Aim_array2_u16(nest.inner.to._0 as rt.u16[], ~n & 0xff); } - const _32: rt.u8 = ((((nest.inner.maybe as rt.u16[] | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; + const _42: rt.u8 = ((((nest.inner.maybe as rt.u16[] | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; if (nest.inner.to.tag === "At") { - _39 = true; + _49 = true; } else { - _39 = false; + _49 = false; } - rt.byteVecPush(out, _32 | ((_39 ? 1 : 0))); + rt.byteVecPush(out, _42 | ((_49 ? 1 : 0))); if (rt.u8Rem(n, 5) === 0) { rt.ptrWrite(nest.inner.at as rt.u16[], copy$array_u16(made$pointers_Aim_array2_u16(n))); } rt.byteVecPush(out, get$pointers_Aim_array2_u16(nest.inner.seen as rt.u16[])); } -/** Reads and writes through each of `nest`'s pointers. */ +/** + * Reads and writes through each of `nest`'s pointers, and through those of a copy of + * them, whose own tag changes apart from theirs. + */ export function through$array4_u8(nest: Enclosed.Enclosed, n: rt.u8, out: rt.ByteVec): void { - let _39!: boolean; + let _49!: boolean; + const copy: Aimed.Aimed = copy$pointers_Aimed_array4_u8(nest.inner); + (copy.tagged as [rt.ByteSlice, rt.u8])[1] = (copy.tagged as [rt.ByteSlice, rt.u8])[1] ^ 64; + const _8: [rt.ByteSlice, rt.u8] = tagged$array4_u8(copy); + const at: rt.ByteSlice = _8[0]; + const tag: rt.u8 = _8[1]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of((nest.inner.tagged as [rt.ByteSlice, rt.u8])[1], tag)), undefined, true); + put$pointers_Aim_array4_u8(at, tag); rt.byteVecPush(out, get$pointers_Aim_array4_u8(nest.inner.seen as rt.ByteSlice)); put$pointers_Aim_array4_u8(nest.inner.at as rt.ByteSlice, n); rt.byteVecPush(out, get$pointers_Aim_array4_u8(nest.inner.held as rt.ByteSlice)); @@ -1907,22 +1938,32 @@ export function through$array4_u8(nest: Enclosed.Enclosed, n: rt.u8, if (nest.inner.to.tag === "At") { put$pointers_Aim_array4_u8(nest.inner.to._0 as rt.ByteSlice, ~n & 0xff); } - const _32: rt.u8 = ((((nest.inner.maybe as rt.ByteSlice | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; + const _42: rt.u8 = ((((nest.inner.maybe as rt.ByteSlice | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; if (nest.inner.to.tag === "At") { - _39 = true; + _49 = true; } else { - _39 = false; + _49 = false; } - rt.byteVecPush(out, _32 | ((_39 ? 1 : 0))); + rt.byteVecPush(out, _42 | ((_49 ? 1 : 0))); if (rt.u8Rem(n, 5) === 0) { rt.byteSliceSet(nest.inner.at as rt.ByteSlice, copy$array_u8(made$pointers_Aim_array4_u8(n))); } rt.byteVecPush(out, get$pointers_Aim_array4_u8(nest.inner.seen as rt.ByteSlice)); } -/** Reads and writes through each of `nest`'s pointers. */ +/** + * Reads and writes through each of `nest`'s pointers, and through those of a copy of + * them, whose own tag changes apart from theirs. + */ export function through$pointers_Housed_u8(nest: Enclosed.Enclosed>, n: rt.u8, out: rt.ByteVec): void { - let _39!: boolean; + let _49!: boolean; + const copy: Aimed.Aimed> = copy$pointers_Aimed_pointers_Housed_u8(nest.inner); + (copy.tagged as [Housed.Housed, rt.u8])[1] = (copy.tagged as [Housed.Housed, rt.u8])[1] ^ 64; + const _8: [Housed.Housed, rt.u8] = tagged$pointers_Housed_u8(copy); + const at: Housed.Housed = _8[0]; + const tag: rt.u8 = _8[1]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of((nest.inner.tagged as [Housed.Housed, rt.u8])[1], tag)), undefined, true); + Housed.put$pointers_Aim_u8(at, tag); rt.byteVecPush(out, Housed.get$pointers_Aim_u8(nest.inner.seen as Housed.Housed)); Housed.put$pointers_Aim_u8(nest.inner.at as Housed.Housed, n); rt.byteVecPush(out, Housed.get$pointers_Aim_u8(nest.inner.held as Housed.Housed)); @@ -1933,22 +1974,32 @@ export function through$pointers_Housed_u8(nest: Enclosed.Enclosed, ~n & 0xff); } - const _32: rt.u8 = ((((nest.inner.maybe as Housed.Housed | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; + const _42: rt.u8 = ((((nest.inner.maybe as Housed.Housed | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; if (nest.inner.to.tag === "At") { - _39 = true; + _49 = true; } else { - _39 = false; + _49 = false; } - rt.byteVecPush(out, _32 | ((_39 ? 1 : 0))); + rt.byteVecPush(out, _42 | ((_49 ? 1 : 0))); if (rt.u8Rem(n, 5) === 0) { rt.ptrWrite(nest.inner.at as Housed.Housed, Housed.made$pointers_Aim_u8(n)); } rt.byteVecPush(out, Housed.get$pointers_Aim_u8(nest.inner.seen as Housed.Housed)); } -/** Reads and writes through each of `nest`'s pointers. */ +/** + * Reads and writes through each of `nest`'s pointers, and through those of a copy of + * them, whose own tag changes apart from theirs. + */ export function through$pointers_Leaning(nest: Enclosed.Enclosed, n: rt.u8, out: rt.ByteVec): void { - let _39!: boolean; + let _49!: boolean; + const copy: Aimed.Aimed = copy$pointers_Aimed_pointers_Leaning(nest.inner); + (copy.tagged as [rt.Place, rt.u8])[1] = (copy.tagged as [rt.Place, rt.u8])[1] ^ 64; + const _8: [rt.Place, rt.u8] = tagged$pointers_Leaning(copy); + const at: rt.Place = _8[0]; + const tag: rt.u8 = _8[1]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of((nest.inner.tagged as [rt.Place, rt.u8])[1], tag)), undefined, true); + Leaning.put$pointers_Aim(at, tag); rt.byteVecPush(out, Leaning.get$pointers_Aim((nest.inner.seen as rt.Place).v)); Leaning.put$pointers_Aim(nest.inner.at as rt.Place, n); rt.byteVecPush(out, Leaning.get$pointers_Aim(((nest.inner.held as rt.Place)).v)); @@ -1959,22 +2010,32 @@ export function through$pointers_Leaning(nest: Enclosed.Enclosed, ~n & 0xff); } - const _32: rt.u8 = ((((nest.inner.maybe as rt.Place | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; + const _42: rt.u8 = ((((nest.inner.maybe as rt.Place | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; if (nest.inner.to.tag === "At") { - _39 = true; + _49 = true; } else { - _39 = false; + _49 = false; } - rt.byteVecPush(out, _32 | ((_39 ? 1 : 0))); + rt.byteVecPush(out, _42 | ((_49 ? 1 : 0))); if (rt.u8Rem(n, 5) === 0) { (nest.inner.at as rt.Place).v = Leaning.made$pointers_Aim(n); } rt.byteVecPush(out, Leaning.get$pointers_Aim((nest.inner.seen as rt.Place).v)); } -/** Reads and writes through each of `nest`'s pointers. */ +/** + * Reads and writes through each of `nest`'s pointers, and through those of a copy of + * them, whose own tag changes apart from theirs. + */ export function through$pointers_Paired(nest: Enclosed.Enclosed, n: rt.u8, out: rt.ByteVec): void { - let _39!: boolean; + let _49!: boolean; + const copy: Aimed.Aimed = copy$pointers_Aimed_pointers_Paired(nest.inner); + (copy.tagged as [Paired.Paired, rt.u8])[1] = (copy.tagged as [Paired.Paired, rt.u8])[1] ^ 64; + const _8: [Paired.Paired, rt.u8] = tagged$pointers_Paired(copy); + const at: Paired.Paired = _8[0]; + const tag: rt.u8 = _8[1]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of((nest.inner.tagged as [Paired.Paired, rt.u8])[1], tag)), undefined, true); + Paired.put$pointers_Aim(at, tag); rt.byteVecPush(out, Paired.get$pointers_Aim(nest.inner.seen as Paired.Paired)); Paired.put$pointers_Aim(nest.inner.at as Paired.Paired, n); rt.byteVecPush(out, Paired.get$pointers_Aim(nest.inner.held as Paired.Paired)); @@ -1985,22 +2046,32 @@ export function through$pointers_Paired(nest: Enclosed.Enclosed, if (nest.inner.to.tag === "At") { Paired.put$pointers_Aim(nest.inner.to._0 as Paired.Paired, ~n & 0xff); } - const _32: rt.u8 = ((((nest.inner.maybe as Paired.Paired | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; + const _42: rt.u8 = ((((nest.inner.maybe as Paired.Paired | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; if (nest.inner.to.tag === "At") { - _39 = true; + _49 = true; } else { - _39 = false; + _49 = false; } - rt.byteVecPush(out, _32 | ((_39 ? 1 : 0))); + rt.byteVecPush(out, _42 | ((_49 ? 1 : 0))); if (rt.u8Rem(n, 5) === 0) { rt.ptrWrite(nest.inner.at as Paired.Paired, Paired.made$pointers_Aim(n)); } rt.byteVecPush(out, Paired.get$pointers_Aim(nest.inner.seen as Paired.Paired)); } -/** Reads and writes through each of `nest`'s pointers. */ +/** + * Reads and writes through each of `nest`'s pointers, and through those of a copy of + * them, whose own tag changes apart from theirs. + */ export function through$u8(nest: Enclosed.Enclosed, n: rt.u8, out: rt.ByteVec): void { - let _39!: boolean; + let _49!: boolean; + const copy: Aimed.Aimed = copy$pointers_Aimed_u8(nest.inner); + (copy.tagged as [rt.Place, rt.u8])[1] = (copy.tagged as [rt.Place, rt.u8])[1] ^ 64; + const _8: [rt.Place, rt.u8] = tagged$u8(copy); + const at: rt.Place = _8[0]; + const tag: rt.u8 = _8[1]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of((nest.inner.tagged as [rt.Place, rt.u8])[1], tag)), undefined, true); + put$pointers_Aim_u8(at, tag); rt.byteVecPush(out, get$pointers_Aim_u8((nest.inner.seen as rt.Place).v)); put$pointers_Aim_u8(nest.inner.at as rt.Place, n); rt.byteVecPush(out, get$pointers_Aim_u8(((nest.inner.held as rt.Place)).v)); @@ -2011,19 +2082,54 @@ export function through$u8(nest: Enclosed.Enclosed, n: rt.u8, out: rt.Byt if (nest.inner.to.tag === "At") { put$pointers_Aim_u8(nest.inner.to._0 as rt.Place, ~n & 0xff); } - const _32: rt.u8 = ((((nest.inner.maybe as rt.Place | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; + const _42: rt.u8 = ((((nest.inner.maybe as rt.Place | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; if (nest.inner.to.tag === "At") { - _39 = true; + _49 = true; } else { - _39 = false; + _49 = false; } - rt.byteVecPush(out, _32 | ((_39 ? 1 : 0))); + rt.byteVecPush(out, _42 | ((_49 ? 1 : 0))); if (rt.u8Rem(n, 5) === 0) { (nest.inner.at as rt.Place).v = made$pointers_Aim_u8(n); } rt.byteVecPush(out, get$pointers_Aim_u8((nest.inner.seen as rt.Place).v)); } +/** `a`'s tagged pointer and tag, taken apart. */ +export function tagged$Cell_u8(a: Aimed.Aimed>): [rt.Place>, rt.u8] { + return [(a.tagged as [rt.Place>, rt.u8])[0], (a.tagged as [rt.Place>, rt.u8])[1]] as [rt.Place>, rt.u8]; +} + +/** `a`'s tagged pointer and tag, taken apart. */ +export function tagged$array2_u16(a: Aimed.Aimed): [rt.u16[], rt.u8] { + return [(a.tagged as [rt.u16[], rt.u8])[0], (a.tagged as [rt.u16[], rt.u8])[1]] as [rt.u16[], rt.u8]; +} + +/** `a`'s tagged pointer and tag, taken apart. */ +export function tagged$array4_u8(a: Aimed.Aimed): [rt.ByteSlice, rt.u8] { + return [(a.tagged as [rt.ByteSlice, rt.u8])[0], (a.tagged as [rt.ByteSlice, rt.u8])[1]] as [rt.ByteSlice, rt.u8]; +} + +/** `a`'s tagged pointer and tag, taken apart. */ +export function tagged$pointers_Housed_u8(a: Aimed.Aimed>): [Housed.Housed, rt.u8] { + return [(a.tagged as [Housed.Housed, rt.u8])[0], (a.tagged as [Housed.Housed, rt.u8])[1]] as [Housed.Housed, rt.u8]; +} + +/** `a`'s tagged pointer and tag, taken apart. */ +export function tagged$pointers_Leaning(a: Aimed.Aimed): [rt.Place, rt.u8] { + return [(a.tagged as [rt.Place, rt.u8])[0], (a.tagged as [rt.Place, rt.u8])[1]] as [rt.Place, rt.u8]; +} + +/** `a`'s tagged pointer and tag, taken apart. */ +export function tagged$pointers_Paired(a: Aimed.Aimed): [Paired.Paired, rt.u8] { + return [(a.tagged as [Paired.Paired, rt.u8])[0], (a.tagged as [Paired.Paired, rt.u8])[1]] as [Paired.Paired, rt.u8]; +} + +/** `a`'s tagged pointer and tag, taken apart. */ +export function tagged$u8(a: Aimed.Aimed): [rt.Place, rt.u8] { + return [(a.tagged as [rt.Place, rt.u8])[0], (a.tagged as [rt.Place, rt.u8])[1]] as [rt.Place, rt.u8]; +} + /** Reads and writes through an `AtomicPtr` to what `to` points at, swapped in for null. */ export function swappedIn$Cell_u8(to: rt.Place>, n: rt.u8, out: rt.ByteVec): void { const shared: Swapped.Swapped> = { at: new rt.Atomic(rt.NULL) }; diff --git a/ts/fixtures/lang/src/pointers.rs b/ts/fixtures/lang/src/pointers.rs index d533eccc7..453355e8c 100644 --- a/ts/fixtures/lang/src/pointers.rs +++ b/ts/fixtures/lang/src/pointers.rs @@ -1746,7 +1746,7 @@ impl Aim for Housed { } } -/// Pointers to `T` in each shape a field holds one. +/// Pointers to `T` in each shape a field holds one, copied as Rust copies them. struct Aimed { at: *mut T, seen: *const T, @@ -1756,11 +1756,27 @@ struct Aimed { to: To, } +impl Clone for Aimed { + fn clone(&self) -> Self { + *self + } +} + +impl Copy for Aimed {} + enum To { At(*mut T), Nowhere, } +impl Clone for To { + fn clone(&self) -> Self { + *self + } +} + +impl Copy for To {} + /// A generic type holding another's instance. struct Enclosed { inner: Aimed, @@ -1777,10 +1793,16 @@ struct Swapped { at: AtomicPtr, } -/// Reads and writes through each of `nest`'s pointers. +/// Reads and writes through each of `nest`'s pointers, and through those of a copy of +/// them, whose own tag changes apart from theirs. fn through(nest: &Enclosed, n: u8, out: &mut Vec) { let a = &nest.inner; + let mut copy = *a; + copy.tagged.1 ^= 0x40; + let (at, tag) = tagged(copy); + out.extend([a.tagged.1, tag]); unsafe { + (*at).put(tag); out.push((*a.seen).get()); (*a.at).put(n); out.push((*a.held.as_ptr()).get()); @@ -1799,6 +1821,12 @@ fn through(nest: &Enclosed, n: u8, out: &mut Vec) { } } +/// `a`'s tagged pointer and tag, taken apart. +fn tagged(a: Aimed) -> (*mut T, u8) { + let Aimed { tagged: (at, tag), .. } = a; + (at, tag) +} + /// Reads and writes through an `AtomicPtr` to what `to` points at, swapped in for null. fn swapped_in(to: *mut T, n: u8, out: &mut Vec) { let shared: Swapped = Swapped { diff --git a/ts/src/lower/copy.rs b/ts/src/lower/copy.rs index f664078fe..ba85eccbb 100644 --- a/ts/src/lower/copy.rs +++ b/ts/src/lower/copy.rs @@ -279,7 +279,8 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { let values = (variant.fields.iter().zip(&fields)) .map(|(field, &id)| { let field_ty = self.field_ty(field.did, args); - self.snapshot(v().field(id), part(field_ty), span) + let read = self.held_field(v().field(id), field.did, args, span); + self.snapshot(read, part(field_ty), span) }) .collect(); ret(self.construct(info.sym, &ctor, &fields, values)) @@ -293,10 +294,8 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { for (i, field) in variant.fields.iter().enumerate() { let name = field_name(field.name.as_str(), i); let field_ty = self.field_ty(field.did, args); - props.push(( - Key::Name(name.clone()), - self.snapshot(v().member(name), field_ty, span), - )); + let read = self.held_field(v().member(name.clone()), field.did, args, span); + props.push((Key::Name(name), self.snapshot(read, field_ty, span))); } body.push( StmtKind::If { diff --git a/ts/src/lower/mir/place.rs b/ts/src/lower/mir/place.rs index f3a8705c7..61fc5fe4e 100644 --- a/ts/src/lower/mir/place.rs +++ b/ts/src/lower/mir/place.rs @@ -624,11 +624,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } }; let ty::Adt(_, args) = ty.kind() else { unreachable!() }; - // The definition's `rt.Ptr`, as what this instance holds there. - match self.b.t.ptr_field(def.did, args, span) { - Some(held) => Expr::As(Box::new(read), held), - None => read, - } + self.b.t.held_field(read, def.did, args, span) } _ => self.err(span, format!("a field of `{ty}`")), }, @@ -1038,7 +1034,8 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { span: Span, out: &mut Vec, ) -> Option { - if !matches!(kind, mir::BorrowKind::Mut { .. }) || !self.b.t.needs_place(place.ty(&self.mir.local_decls, self.tcx).ty) + if !matches!(kind, mir::BorrowKind::Mut { .. }) + || !self.b.t.needs_place(place.ty(&self.mir.local_decls, self.tcx).ty) { return None; } diff --git a/ts/src/lower/mod.rs b/ts/src/lower/mod.rs index fff3a89f9..ea827c83f 100644 --- a/ts/src/lower/mod.rs +++ b/ts/src/lower/mod.rs @@ -1619,7 +1619,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } /// The TypeScript type of `field` in its type's definition, with `identity` its own - /// parameters, noting a field that holds an `rt.Ptr` for [`Self::ptr_field`]. + /// parameters, noting a field that holds an `rt.Ptr` for [`Self::held_field`]. fn defined_field_ty(&mut self, field: &ty::FieldDef, identity: GenericArgsRef<'tcx>, span: Span) -> Type { let ty = self.ty(field.ty(self.tcx, identity).skip_norm_wip(), span); if ty.any(&|t| matches!(t, Type::Rt("Ptr", _))) { @@ -1628,16 +1628,14 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { ty } - /// The type an instance with `args` holds in `field`, if its definition types a pointer - /// in it as an `rt.Ptr`, which a read casts to it. - pub fn ptr_field(&mut self, field: DefId, args: GenericArgsRef<'tcx>, span: Span) -> Option { - match self.ptr_fields.contains(&field) { - true => { - let ty = self.field_ty(field, args); - Some(self.ty(ty, span)) - } - false => None, + /// `read`, of `field` of an instance with `args`, cast to what the instance holds there + /// where the definition types a pointer in it as an `rt.Ptr`. + pub fn held_field(&mut self, read: ts::Expr, field: DefId, args: GenericArgsRef<'tcx>, span: Span) -> ts::Expr { + if !self.ptr_fields.contains(&field) { + return read; } + let ty = self.field_ty(field, args); + ts::Expr::As(Box::new(read), self.ty(ty, span)) } /// Why an instance of the crate's generic `adt` with `args` can't hold its fields' values, diff --git a/ts/src/lower/unions.rs b/ts/src/lower/unions.rs index 5dbc0bc9b..af4b172de 100644 --- a/ts/src/lower/unions.rs +++ b/ts/src/lower/unions.rs @@ -194,7 +194,8 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { }; let field = &adt.non_enum_variant().fields[FieldIdx::from_usize(first)]; let part_ty = self.field_ty(field.did, args); - self.part_of(value.field(fields[first]), part_ty, rest, span) + let read = self.held_field(value.field(fields[first]), field.did, args, span); + self.part_of(read, part_ty, rest, span) } _ => unreachable!("a union's part is in a tuple or a struct"), } From 5a57a3e0813722a9d4ae89ddb862fe42f2da7a75 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 20:32:40 -0700 Subject: [PATCH 5/6] docs(ts): note rt.Ptr fields in MIGRATE Co-Authored-By: Claude Opus 5.5 --- ts/MIGRATE.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/ts/MIGRATE.md b/ts/MIGRATE.md index e1a7ecdb1..05222c6ed 100644 --- a/ts/MIGRATE.md +++ b/ts/MIGRATE.md @@ -34,6 +34,10 @@ `rt.charStep` too, to step past the surrogates. One of unsigned `NonZero`s takes `rt.nonZeroStep` of its integer's `Step` and maximum, as in `new rt.RangeInclusive(lo, hi, rt.nonZeroStep(rt.u8Step, 255))`. +- A generic type's field holding a reference or pointer to what only an instance decides + the form of, such as `*mut T`, `NonNull`, or `&'a mut T`, is an `rt.Ptr`, the + object, an `rt.Place`, or an `rt.ByteSlice`, rather than `rt.Place` or `T`: a + caller reading one casts it to what its instance holds, as the output does. - A closure, a `fn` pointer, a `dyn Fn`, or a function item as a value returns `undefined` for `()`, not `void`, as in `(a0: rt.u8) => undefined`: a caller passes such a parameter a function typed `=> undefined`. From a266757b76ab5233978e369dd43f4e433d7977a9 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 20:56:14 -0700 Subject: [PATCH 6/6] fix(ts): cast a function of a generic type's pointer where an instance is made Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/expected/lib.ts | 14 +- ts/fixtures/lang/expected/pointers.Aimed.ts | 2 + ts/fixtures/lang/expected/pointers.ts | 415 +++++++++++--------- ts/fixtures/lang/src/pointers.rs | 10 +- ts/src/lower/body.rs | 5 +- ts/src/lower/consts.rs | 7 +- ts/src/lower/copy.rs | 3 +- ts/src/lower/mir/rvalue.rs | 7 +- ts/src/lower/mod.rs | 39 +- ts/src/lower/pointer.rs | 19 +- ts/src/lower/unions.rs | 10 +- ts/src/ts.rs | 29 ++ 12 files changed, 337 insertions(+), 223 deletions(-) diff --git a/ts/fixtures/lang/expected/lib.ts b/ts/fixtures/lang/expected/lib.ts index 469035fab..79069092b 100644 --- a/ts/fixtures/lang/expected/lib.ts +++ b/ts/fixtures/lang/expected/lib.ts @@ -500,31 +500,31 @@ export function copy$ops_ControlFlow_unit_array2_u8(v: rt.Result>): Aimed.Aimed> { - return { at: v.at as rt.Place>, seen: v.seen as rt.Place>, held: v.held as rt.Place>, maybe: v.maybe as rt.Place> | undefined, tagged: copy$tuple2_mutPtr_Cell_u8_u8(v.tagged as [rt.Place>, rt.u8]), to: v.to }; + return { at: v.at as rt.Place>, seen: v.seen as rt.Place>, held: v.held as rt.Place>, maybe: v.maybe as rt.Place> | undefined, tagged: copy$tuple2_mutPtr_Cell_u8_u8(v.tagged as [rt.Place>, rt.u8]), to: v.to, read: (v.read as (a0: rt.Place>) => rt.u8) as (a0: rt.Ptr>) => rt.u8 }; } export function copy$pointers_Aimed_array2_u16(v: Aimed.Aimed): Aimed.Aimed { - return { at: v.at as rt.u16[], seen: v.seen as rt.u16[], held: v.held as rt.u16[], maybe: v.maybe as rt.u16[] | undefined, tagged: copy$tuple2_mutPtr_array2_u16_u8(v.tagged as [rt.u16[], rt.u8]), to: v.to }; + return { at: v.at as rt.u16[], seen: v.seen as rt.u16[], held: v.held as rt.u16[], maybe: v.maybe as rt.u16[] | undefined, tagged: copy$tuple2_mutPtr_array2_u16_u8(v.tagged as [rt.u16[], rt.u8]), to: v.to, read: (v.read as (a0: rt.u16[]) => rt.u8) as (a0: rt.Ptr) => rt.u8 }; } export function copy$pointers_Aimed_array4_u8(v: Aimed.Aimed): Aimed.Aimed { - return { at: v.at as rt.ByteSlice, seen: v.seen as rt.ByteSlice, held: v.held as rt.ByteSlice, maybe: v.maybe as rt.ByteSlice | undefined, tagged: copy$tuple2_mutPtr_array4_u8_u8(v.tagged as [rt.ByteSlice, rt.u8]), to: v.to }; + return { at: v.at as rt.ByteSlice, seen: v.seen as rt.ByteSlice, held: v.held as rt.ByteSlice, maybe: v.maybe as rt.ByteSlice | undefined, tagged: copy$tuple2_mutPtr_array4_u8_u8(v.tagged as [rt.ByteSlice, rt.u8]), to: v.to, read: (v.read as (a0: rt.ByteSlice) => rt.u8) as (a0: rt.Ptr) => rt.u8 }; } export function copy$pointers_Aimed_pointers_Housed_u8(v: Aimed.Aimed>): Aimed.Aimed> { - return { at: v.at as Housed.Housed, seen: v.seen as Housed.Housed, held: v.held as Housed.Housed, maybe: v.maybe as Housed.Housed | undefined, tagged: copy$tuple2_mutPtr_pointers_Housed_u8_u8(v.tagged as [Housed.Housed, rt.u8]), to: v.to }; + return { at: v.at as Housed.Housed, seen: v.seen as Housed.Housed, held: v.held as Housed.Housed, maybe: v.maybe as Housed.Housed | undefined, tagged: copy$tuple2_mutPtr_pointers_Housed_u8_u8(v.tagged as [Housed.Housed, rt.u8]), to: v.to, read: (v.read as (a0: Housed.Housed) => rt.u8) as (a0: rt.Ptr>) => rt.u8 }; } export function copy$pointers_Aimed_pointers_Leaning(v: Aimed.Aimed): Aimed.Aimed { - return { at: v.at as rt.Place, seen: v.seen as rt.Place, held: v.held as rt.Place, maybe: v.maybe as rt.Place | undefined, tagged: copy$tuple2_mutPtr_pointers_Leaning_u8(v.tagged as [rt.Place, rt.u8]), to: v.to }; + return { at: v.at as rt.Place, seen: v.seen as rt.Place, held: v.held as rt.Place, maybe: v.maybe as rt.Place | undefined, tagged: copy$tuple2_mutPtr_pointers_Leaning_u8(v.tagged as [rt.Place, rt.u8]), to: v.to, read: (v.read as (a0: rt.Place) => rt.u8) as (a0: rt.Ptr) => rt.u8 }; } export function copy$pointers_Aimed_pointers_Paired(v: Aimed.Aimed): Aimed.Aimed { - return { at: v.at as Paired.Paired, seen: v.seen as Paired.Paired, held: v.held as Paired.Paired, maybe: v.maybe as Paired.Paired | undefined, tagged: copy$tuple2_mutPtr_pointers_Paired_u8(v.tagged as [Paired.Paired, rt.u8]), to: v.to }; + return { at: v.at as Paired.Paired, seen: v.seen as Paired.Paired, held: v.held as Paired.Paired, maybe: v.maybe as Paired.Paired | undefined, tagged: copy$tuple2_mutPtr_pointers_Paired_u8(v.tagged as [Paired.Paired, rt.u8]), to: v.to, read: (v.read as (a0: Paired.Paired) => rt.u8) as (a0: rt.Ptr) => rt.u8 }; } export function copy$pointers_Aimed_u8(v: Aimed.Aimed): Aimed.Aimed { - return { at: v.at as rt.Place, seen: v.seen as rt.Place, held: v.held as rt.Place, maybe: v.maybe as rt.Place | undefined, tagged: copy$tuple2_mutPtr_u8_u8(v.tagged as [rt.Place, rt.u8]), to: v.to }; + return { at: v.at as rt.Place, seen: v.seen as rt.Place, held: v.held as rt.Place, maybe: v.maybe as rt.Place | undefined, tagged: copy$tuple2_mutPtr_u8_u8(v.tagged as [rt.Place, rt.u8]), to: v.to, read: (v.read as (a0: rt.Place) => rt.u8) as (a0: rt.Ptr) => rt.u8 }; } export function copy$pointers_ByCall(v: ByCall.ByCall): ByCall.ByCall { diff --git a/ts/fixtures/lang/expected/pointers.Aimed.ts b/ts/fixtures/lang/expected/pointers.Aimed.ts index 443a20206..776833442 100644 --- a/ts/fixtures/lang/expected/pointers.Aimed.ts +++ b/ts/fixtures/lang/expected/pointers.Aimed.ts @@ -11,6 +11,8 @@ export interface Aimed { maybe: rt.Ptr | undefined; tagged: [rt.Ptr, rt.u8]; to: To.To; + /** A function taking one, which JS takes as the instance's own pointer. */ + read: (a0: rt.Ptr) => rt.u8; } //# sourceMappingURL=pointers.Aimed.ts.map diff --git a/ts/fixtures/lang/expected/pointers.ts b/ts/fixtures/lang/expected/pointers.ts index e3f6ed0de..05788393d 100644 --- a/ts/fixtures/lang/expected/pointers.ts +++ b/ts/fixtures/lang/expected/pointers.ts @@ -1412,57 +1412,57 @@ export function swapCell(c: rt.Cell, n: rt.u8): void { export function aimed(data: rt.ByteSlice, out: rt.ByteVec): void { let _17!: Paired.Paired | undefined; let _22!: To.To; - let _42!: rt.Place | undefined; - let _47!: To.To; + let _43!: rt.Place | undefined; + let _48!: To.To; let signed!: Leaning.Leaning; - let _70!: rt.Place | undefined; - let _75!: To.To; - let _95!: rt.ByteSlice | undefined; - let _100!: To.To; - let _120!: rt.Place> | undefined; - let _125!: To.To>; - let _149!: rt.u16[] | undefined; - let _154!: To.To; - let _174!: Housed.Housed | undefined; - let _179!: To.To>; - let _207!: Paired.Paired | undefined; - let _212!: To.To; + let _72!: rt.Place | undefined; + let _77!: To.To; + let _98!: rt.ByteSlice | undefined; + let _103!: To.To; + let _124!: rt.Place> | undefined; + let _129!: To.To>; + let _154!: rt.u16[] | undefined; + let _159!: To.To; + let _180!: Housed.Housed | undefined; + let _185!: To.To>; + let _214!: Paired.Paired | undefined; + let _219!: To.To; let same!: boolean[]; - let _222!: boolean; - let _228!: boolean; - let _234!: boolean; - let _237!: boolean; + let _230!: boolean; + let _236!: boolean; + let _242!: boolean; let _245!: boolean; - let _247!: boolean; - let _277!: rt.ByteSlice | undefined; - let _282!: To.To; + let _253!: boolean; + let _255!: boolean; + let _285!: rt.ByteSlice | undefined; + let _290!: To.To; let same2!: boolean[]; - let _292!: boolean; - let _298!: boolean; - let _304!: boolean; + let _301!: boolean; let _307!: boolean; - let _315!: boolean; - let _317!: boolean; - let _347!: Housed.Housed | undefined; - let _352!: To.To>; + let _313!: boolean; + let _316!: boolean; + let _324!: boolean; + let _326!: boolean; + let _356!: Housed.Housed | undefined; + let _361!: To.To>; let same3!: boolean[]; - let _362!: boolean; - let _368!: boolean; - let _374!: boolean; - let _377!: boolean; - let _385!: boolean; + let _372!: boolean; + let _378!: boolean; + let _384!: boolean; let _387!: boolean; - const _257: (a0: boolean[]) => rt.u8 = (b: boolean[]): rt.u8 => { - return rt.iterFold(rt.iterSlice(b), 0, (acc: rt.u8, _34: boolean): rt.u8 => { - return ((acc << 1) & 0xff) | ((_34 ? 1 : 0)); + let _395!: boolean; + let _397!: boolean; + const _265: (a0: boolean[]) => rt.u8 = (b: boolean[]): rt.u8 => { + return rt.iterFold(rt.iterSlice(b), 0, (acc: rt.u8, _33: boolean): rt.u8 => { + return ((acc << 1) & 0xff) | ((_33 ? 1 : 0)); }); }; - const _327: (a0: boolean[]) => rt.u8 = (b3: boolean[]): rt.u8 => { + const _336: (a0: boolean[]) => rt.u8 = (b3: boolean[]): rt.u8 => { return rt.iterFold(rt.iterSlice(b3), 0, (acc2: rt.u8, _36: boolean): rt.u8 => { return ((acc2 << 1) & 0xff) | ((_36 ? 1 : 0)); }); }; - const _397: (a0: boolean[]) => rt.u8 = (b5: boolean[]): rt.u8 => { + const _407: (a0: boolean[]) => rt.u8 = (b5: boolean[]): rt.u8 => { return rt.iterFold(rt.iterSlice(b5), 0, (acc3: rt.u8, _38: boolean): rt.u8 => { return ((acc3 << 1) & 0xff) | ((_38 ? 1 : 0)); }); @@ -1484,7 +1484,7 @@ export function aimed(data: rt.ByteSlice, out: rt.ByteVec): void { } else { _22 = { tag: "At", _0: at } as To.To; } - through$pointers_Paired({ inner: { at, seen: _16, held, maybe: _17, tagged: _21, to: _22 } }, n, out); + through$pointers_Paired({ inner: { at, seen: _16, held, maybe: _17, tagged: _21, to: _22, read: readThrough$pointers_Paired as (a0: rt.Ptr) => rt.u8 } }, n, out); swappedIn$pointers_Paired(pair, n, out); lend$pointers_Paired(pair, n, out); rt.byteVecPush(out, Paired.get$pointers_Aim(pair)); @@ -1492,19 +1492,19 @@ export function aimed(data: rt.ByteSlice, out: rt.ByteVec): void { const at2: rt.Place = rt.place(() => num, (value) => num = value); const pointer2 = at2; const held2: rt.Place = rt.optionUnwrap(pointer2 === rt.NULL ? undefined : pointer2); - const _41: rt.Place = at2; + const _42: rt.Place = at2; if (!(rt.u8Rem(n, 2) === 0)) { - _42 = undefined; + _43 = undefined; } else { - _42 = held2; + _43 = held2; } - const _46: [rt.Place, rt.u8] = [at2, n]; + const _47: [rt.Place, rt.u8] = [at2, n]; if (!(rt.u8Rem(n, 3) === 0)) { - _47 = { tag: "Nowhere" } as To.To; + _48 = { tag: "Nowhere" } as To.To; } else { - _47 = { tag: "At", _0: at2 } as To.To; + _48 = { tag: "At", _0: at2 } as To.To; } - through$u8({ inner: { at: at2, seen: _41, held: held2, maybe: _42, tagged: _46, to: _47 } }, n, out); + through$u8({ inner: { at: at2, seen: _42, held: held2, maybe: _43, tagged: _47, to: _48, read: readThrough$u8 as (a0: rt.Ptr) => rt.u8 } }, n, out); swappedIn$u8(rt.place(() => num, (value2) => num = value2), n, out); lend$u8(rt.place(() => num, (value3) => num = value3), n, out); rt.byteVecPush(out, get$pointers_Aim_u8(num)); @@ -1516,19 +1516,19 @@ export function aimed(data: rt.ByteSlice, out: rt.ByteVec): void { const at3: rt.Place = rt.place(() => signed, (value4) => signed = value4); const pointer3 = at3; const held3: rt.Place = rt.optionUnwrap(pointer3 === rt.NULL ? undefined : pointer3); - const _69: rt.Place = at3; + const _71: rt.Place = at3; if (!(rt.u8Rem(n, 2) === 0)) { - _70 = undefined; + _72 = undefined; } else { - _70 = held3; + _72 = held3; } - const _74: [rt.Place, rt.u8] = [at3, n]; + const _76: [rt.Place, rt.u8] = [at3, n]; if (!(rt.u8Rem(n, 3) === 0)) { - _75 = { tag: "Nowhere" } as To.To; + _77 = { tag: "Nowhere" } as To.To; } else { - _75 = { tag: "At", _0: at3 } as To.To; + _77 = { tag: "At", _0: at3 } as To.To; } - through$pointers_Leaning({ inner: { at: at3, seen: _69, held: held3, maybe: _70, tagged: _74, to: _75 } }, n, out); + through$pointers_Leaning({ inner: { at: at3, seen: _71, held: held3, maybe: _72, tagged: _76, to: _77, read: readThrough$pointers_Leaning as (a0: rt.Ptr) => rt.u8 } }, n, out); swappedIn$pointers_Leaning(rt.place(() => signed, (value5) => signed = value5), n, out); lend$pointers_Leaning(rt.place(() => signed, (value6) => signed = value6), n, out); rt.byteVecPush(out, Leaning.get$pointers_Aim(signed)); @@ -1536,19 +1536,19 @@ export function aimed(data: rt.ByteSlice, out: rt.ByteVec): void { const at4: rt.ByteSlice = rt.byteSliceFrom(bytes); const pointer4 = at4; const held4: rt.ByteSlice = rt.optionUnwrap(pointer4 === rt.NULL ? undefined : pointer4); - const _94: rt.ByteSlice = at4; + const _97: rt.ByteSlice = at4; if (!(rt.u8Rem(n, 2) === 0)) { - _95 = undefined; + _98 = undefined; } else { - _95 = held4; + _98 = held4; } - const _99: [rt.ByteSlice, rt.u8] = [at4, n]; + const _102: [rt.ByteSlice, rt.u8] = [at4, n]; if (!(rt.u8Rem(n, 3) === 0)) { - _100 = { tag: "Nowhere" } as To.To; + _103 = { tag: "Nowhere" } as To.To; } else { - _100 = { tag: "At", _0: at4 } as To.To; + _103 = { tag: "At", _0: at4 } as To.To; } - through$array4_u8({ inner: { at: at4, seen: _94, held: held4, maybe: _95, tagged: _99, to: _100 } }, n, out); + through$array4_u8({ inner: { at: at4, seen: _97, held: held4, maybe: _98, tagged: _102, to: _103, read: readThrough$array4_u8 as (a0: rt.Ptr) => rt.u8 } }, n, out); swappedIn$array4_u8(rt.byteSliceFrom(bytes), n, out); lend$array4_u8(rt.byteSliceFrom(bytes), n, out); rt.byteVecPush(out, get$pointers_Aim_array4_u8(rt.byteSliceFrom(bytes))); @@ -1556,42 +1556,42 @@ export function aimed(data: rt.ByteSlice, out: rt.ByteVec): void { const at5: rt.Place> = rt.place(() => cell, (value7) => cell = value7); const pointer5 = at5; const held5: rt.Place> = rt.optionUnwrap(pointer5 === rt.NULL ? undefined : pointer5); - const _119: rt.Place> = at5; + const _123: rt.Place> = at5; if (!(rt.u8Rem(n, 2) === 0)) { - _120 = undefined; + _124 = undefined; } else { - _120 = held5; + _124 = held5; } - const _124: [rt.Place>, rt.u8] = [at5, n]; + const _128: [rt.Place>, rt.u8] = [at5, n]; if (!(rt.u8Rem(n, 3) === 0)) { - _125 = { tag: "Nowhere" } as To.To>; + _129 = { tag: "Nowhere" } as To.To>; } else { - _125 = { tag: "At", _0: at5 } as To.To>; + _129 = { tag: "At", _0: at5 } as To.To>; } - through$Cell_u8({ inner: { at: at5, seen: _119, held: held5, maybe: _120, tagged: _124, to: _125 } }, n, out); + through$Cell_u8({ inner: { at: at5, seen: _123, held: held5, maybe: _124, tagged: _128, to: _129, read: readThrough$Cell_u8 as (a0: rt.Ptr>) => rt.u8 } }, n, out); swappedIn$Cell_u8(rt.place(() => cell, (value8) => cell = value8), n, out); lend$Cell_u8(cell, n, out); rt.byteVecPush(out, cell.v); - const _139: rt.u16 = (((n as rt.u16)) << 4) & 0xffff; + const _144: rt.u16 = (((n as rt.u16)) << 4) & 0xffff; const wide: rt.u16[] = Array.from({ length: 2 }, (): rt.u16 => { - return _139; + return _144; }); const at6: rt.u16[] = wide; const pointer6 = at6; const held6: rt.u16[] = rt.optionUnwrap(pointer6 === rt.NULL ? undefined : pointer6); - const _148: rt.u16[] = at6; + const _153: rt.u16[] = at6; if (!(rt.u8Rem(n, 2) === 0)) { - _149 = undefined; + _154 = undefined; } else { - _149 = held6; + _154 = held6; } - const _153: [rt.u16[], rt.u8] = [at6, n]; + const _158: [rt.u16[], rt.u8] = [at6, n]; if (!(rt.u8Rem(n, 3) === 0)) { - _154 = { tag: "Nowhere" } as To.To; + _159 = { tag: "Nowhere" } as To.To; } else { - _154 = { tag: "At", _0: at6 } as To.To; + _159 = { tag: "At", _0: at6 } as To.To; } - through$array2_u16({ inner: { at: at6, seen: _148, held: held6, maybe: _149, tagged: _153, to: _154 } }, n, out); + through$array2_u16({ inner: { at: at6, seen: _153, held: held6, maybe: _154, tagged: _158, to: _159, read: readThrough$array2_u16 as (a0: rt.Ptr) => rt.u8 } }, n, out); swappedIn$array2_u16(wide, n, out); lend$array2_u16(wide, n, out); rt.byteVecPush(out, get$pointers_Aim_array2_u16(wide)); @@ -1599,19 +1599,19 @@ export function aimed(data: rt.ByteSlice, out: rt.ByteVec): void { const at7: Housed.Housed = wrap; const pointer7 = at7; const held7: Housed.Housed = rt.optionUnwrap(pointer7 === rt.NULL ? undefined : pointer7); - const _173: Housed.Housed = at7; + const _179: Housed.Housed = at7; if (!(rt.u8Rem(n, 2) === 0)) { - _174 = undefined; + _180 = undefined; } else { - _174 = held7; + _180 = held7; } - const _178: [Housed.Housed, rt.u8] = [at7, n]; + const _184: [Housed.Housed, rt.u8] = [at7, n]; if (!(rt.u8Rem(n, 3) === 0)) { - _179 = { tag: "Nowhere" } as To.To>; + _185 = { tag: "Nowhere" } as To.To>; } else { - _179 = { tag: "At", _0: at7 } as To.To>; + _185 = { tag: "At", _0: at7 } as To.To>; } - through$pointers_Housed_u8({ inner: { at: at7, seen: _173, held: held7, maybe: _174, tagged: _178, to: _179 } }, n, out); + through$pointers_Housed_u8({ inner: { at: at7, seen: _179, held: held7, maybe: _180, tagged: _184, to: _185, read: readThrough$pointers_Housed_u8 as (a0: rt.Ptr>) => rt.u8 } }, n, out); swappedIn$pointers_Housed_u8(wrap, n, out); lend$pointers_Housed_u8(wrap, n, out); rt.byteVecPush(out, Housed.get$pointers_Aim_u8(wrap)); @@ -1622,164 +1622,164 @@ export function aimed(data: rt.ByteSlice, out: rt.ByteVec): void { const at8: Paired.Paired = pair; const pointer8 = at8; const held8: Paired.Paired = rt.optionUnwrap(pointer8 === rt.NULL ? undefined : pointer8); - const _206: Paired.Paired = at8; + const _213: Paired.Paired = at8; if (false) { - _207 = undefined; + _214 = undefined; } else { - _207 = held8; + _214 = held8; } - const _211: [Paired.Paired, rt.u8] = [at8, 0]; + const _218: [Paired.Paired, rt.u8] = [at8, 0]; if (false) { - _212 = { tag: "Nowhere" } as To.To; + _219 = { tag: "Nowhere" } as To.To; } else { - _212 = { tag: "At", _0: at8 } as To.To; + _219 = { tag: "At", _0: at8 } as To.To; } - const nest8: Enclosed.Enclosed = { inner: { at: at8, seen: _206, held: held8, maybe: _207, tagged: _211, to: _212 } }; - const _218: boolean = (nest8.inner.at as Paired.Paired) === nest8.inner.seen as Paired.Paired; + const nest8: Enclosed.Enclosed = { inner: { at: at8, seen: _213, held: held8, maybe: _214, tagged: _218, to: _219, read: readThrough$pointers_Paired as (a0: rt.Ptr) => rt.u8 } }; + const _226: boolean = (nest8.inner.at as Paired.Paired) === nest8.inner.seen as Paired.Paired; const pointer9 = nest8.inner.at as Paired.Paired; - const _225: Paired.Paired = rt.optionUnwrap(pointer9 === rt.NULL ? undefined : pointer9); + const _233: Paired.Paired = rt.optionUnwrap(pointer9 === rt.NULL ? undefined : pointer9); b19: { - _222 = (nest8.inner.held as Paired.Paired) === _225; + _230 = (nest8.inner.held as Paired.Paired) === _233; if ((nest8.inner.maybe as Paired.Paired | undefined) !== undefined) { if (((nest8.inner.maybe as Paired.Paired | undefined) as Paired.Paired) === nest8.inner.held as Paired.Paired) { - _228 = true; + _236 = true; break b19; } } - _228 = false; + _236 = false; } b21: { - _234 = (nest8.inner.tagged as [Paired.Paired, rt.u8])[0] === nest8.inner.at as Paired.Paired; + _242 = (nest8.inner.tagged as [Paired.Paired, rt.u8])[0] === nest8.inner.at as Paired.Paired; if (nest8.inner.to.tag === "At") { if ((nest8.inner.to._0 as Paired.Paired) === nest8.inner.at as Paired.Paired) { - _237 = true; + _245 = true; break b21; } } - _237 = false; + _245 = false; } b23: { - _245 = (nest8.inner.at as Paired.Paired) === other2; + _253 = (nest8.inner.at as Paired.Paired) === other2; const scrutinee2 = nest8.inner.maybe as Paired.Paired | undefined; - same = [_218, _222, _228, _234, _237]; + same = [_226, _230, _236, _242, _245]; if (scrutinee2 !== undefined) { if ((((nest8.inner.maybe as Paired.Paired | undefined) as Paired.Paired)) === other2) { - _247 = true; + _255 = true; break b23; } } - _247 = false; + _255 = false; } - const apart: boolean[] = [_245, _247, (nest8.inner.seen as Paired.Paired) === other2]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_257(same), _257(apart))), undefined, true); + const apart: boolean[] = [_253, _255, (nest8.inner.seen as Paired.Paired) === other2]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_265(same), _265(apart))), undefined, true); const other3: rt.ByteSlice = rt.byteSliceFrom(otherBytes); const at9: rt.ByteSlice = rt.byteSliceFrom(bytes); const pointer10 = at9; const held9: rt.ByteSlice = rt.optionUnwrap(pointer10 === rt.NULL ? undefined : pointer10); - const _276: rt.ByteSlice = at9; + const _284: rt.ByteSlice = at9; if (false) { - _277 = undefined; + _285 = undefined; } else { - _277 = held9; + _285 = held9; } - const _281: [rt.ByteSlice, rt.u8] = [at9, 0]; + const _289: [rt.ByteSlice, rt.u8] = [at9, 0]; if (false) { - _282 = { tag: "Nowhere" } as To.To; + _290 = { tag: "Nowhere" } as To.To; } else { - _282 = { tag: "At", _0: at9 } as To.To; + _290 = { tag: "At", _0: at9 } as To.To; } - const nest9: Enclosed.Enclosed = { inner: { at: at9, seen: _276, held: held9, maybe: _277, tagged: _281, to: _282 } }; - const _288: boolean = rt.byteSliceSame(nest9.inner.at as rt.ByteSlice, nest9.inner.seen as rt.ByteSlice); + const nest9: Enclosed.Enclosed = { inner: { at: at9, seen: _284, held: held9, maybe: _285, tagged: _289, to: _290, read: readThrough$array4_u8 as (a0: rt.Ptr) => rt.u8 } }; + const _297: boolean = rt.byteSliceSame(nest9.inner.at as rt.ByteSlice, nest9.inner.seen as rt.ByteSlice); const pointer11 = nest9.inner.at as rt.ByteSlice; - const _295: rt.ByteSlice = rt.optionUnwrap(pointer11 === rt.NULL ? undefined : pointer11); + const _304: rt.ByteSlice = rt.optionUnwrap(pointer11 === rt.NULL ? undefined : pointer11); b27: { - _292 = rt.byteSliceSame(nest9.inner.held as rt.ByteSlice, _295); + _301 = rt.byteSliceSame(nest9.inner.held as rt.ByteSlice, _304); if ((nest9.inner.maybe as rt.ByteSlice | undefined) !== undefined) { if (rt.byteSliceSame((nest9.inner.maybe as rt.ByteSlice | undefined) as rt.ByteSlice, nest9.inner.held as rt.ByteSlice)) { - _298 = true; + _307 = true; break b27; } } - _298 = false; + _307 = false; } b29: { - _304 = rt.byteSliceSame((nest9.inner.tagged as [rt.ByteSlice, rt.u8])[0], nest9.inner.at as rt.ByteSlice); + _313 = rt.byteSliceSame((nest9.inner.tagged as [rt.ByteSlice, rt.u8])[0], nest9.inner.at as rt.ByteSlice); if (nest9.inner.to.tag === "At") { if (rt.byteSliceSame(nest9.inner.to._0 as rt.ByteSlice, nest9.inner.at as rt.ByteSlice)) { - _307 = true; + _316 = true; break b29; } } - _307 = false; + _316 = false; } b31: { - _315 = rt.byteSliceSame(nest9.inner.at as rt.ByteSlice, other3); + _324 = rt.byteSliceSame(nest9.inner.at as rt.ByteSlice, other3); const scrutinee4 = nest9.inner.maybe as rt.ByteSlice | undefined; - same2 = [_288, _292, _298, _304, _307]; + same2 = [_297, _301, _307, _313, _316]; if (scrutinee4 !== undefined) { if (rt.byteSliceSame((nest9.inner.maybe as rt.ByteSlice | undefined) as rt.ByteSlice, other3)) { - _317 = true; + _326 = true; break b31; } } - _317 = false; + _326 = false; } - const apart2: boolean[] = [_315, _317, rt.byteSliceSame(nest9.inner.seen as rt.ByteSlice, other3)]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_327(same2), _327(apart2))), undefined, true); + const apart2: boolean[] = [_324, _326, rt.byteSliceSame(nest9.inner.seen as rt.ByteSlice, other3)]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_336(same2), _336(apart2))), undefined, true); const other4: Housed.Housed = otherWrap; const at10: Housed.Housed = wrap; const pointer12 = at10; const held10: Housed.Housed = rt.optionUnwrap(pointer12 === rt.NULL ? undefined : pointer12); - const _346: Housed.Housed = at10; + const _355: Housed.Housed = at10; if (false) { - _347 = undefined; + _356 = undefined; } else { - _347 = held10; + _356 = held10; } - const _351: [Housed.Housed, rt.u8] = [at10, 0]; + const _360: [Housed.Housed, rt.u8] = [at10, 0]; if (false) { - _352 = { tag: "Nowhere" } as To.To>; + _361 = { tag: "Nowhere" } as To.To>; } else { - _352 = { tag: "At", _0: at10 } as To.To>; + _361 = { tag: "At", _0: at10 } as To.To>; } - const nest10: Enclosed.Enclosed> = { inner: { at: at10, seen: _346, held: held10, maybe: _347, tagged: _351, to: _352 } }; - const _358: boolean = (nest10.inner.at as Housed.Housed) === nest10.inner.seen as Housed.Housed; + const nest10: Enclosed.Enclosed> = { inner: { at: at10, seen: _355, held: held10, maybe: _356, tagged: _360, to: _361, read: readThrough$pointers_Housed_u8 as (a0: rt.Ptr>) => rt.u8 } }; + const _368: boolean = (nest10.inner.at as Housed.Housed) === nest10.inner.seen as Housed.Housed; const pointer13 = nest10.inner.at as Housed.Housed; - const _365: Housed.Housed = rt.optionUnwrap(pointer13 === rt.NULL ? undefined : pointer13); + const _375: Housed.Housed = rt.optionUnwrap(pointer13 === rt.NULL ? undefined : pointer13); b35: { - _362 = (nest10.inner.held as Housed.Housed) === _365; + _372 = (nest10.inner.held as Housed.Housed) === _375; if ((nest10.inner.maybe as Housed.Housed | undefined) !== undefined) { if (((nest10.inner.maybe as Housed.Housed | undefined) as Housed.Housed) === nest10.inner.held as Housed.Housed) { - _368 = true; + _378 = true; break b35; } } - _368 = false; + _378 = false; } b37: { - _374 = (nest10.inner.tagged as [Housed.Housed, rt.u8])[0] === nest10.inner.at as Housed.Housed; + _384 = (nest10.inner.tagged as [Housed.Housed, rt.u8])[0] === nest10.inner.at as Housed.Housed; if (nest10.inner.to.tag === "At") { if ((nest10.inner.to._0 as Housed.Housed) === nest10.inner.at as Housed.Housed) { - _377 = true; + _387 = true; break b37; } } - _377 = false; + _387 = false; } b39: { - _385 = (nest10.inner.at as Housed.Housed) === other4; + _395 = (nest10.inner.at as Housed.Housed) === other4; const scrutinee6 = nest10.inner.maybe as Housed.Housed | undefined; - same3 = [_358, _362, _368, _374, _377]; + same3 = [_368, _372, _378, _384, _387]; if (scrutinee6 !== undefined) { if ((((nest10.inner.maybe as Housed.Housed | undefined) as Housed.Housed)) === other4) { - _387 = true; + _397 = true; break b39; } } - _387 = false; + _397 = false; } - const apart3: boolean[] = [_385, _387, (nest10.inner.seen as Housed.Housed) === other4]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_397(same3), _397(apart3))), undefined, true); + const apart3: boolean[] = [_395, _397, (nest10.inner.seen as Housed.Housed) === other4]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_407(same3), _407(apart3))), undefined, true); } } @@ -1846,7 +1846,7 @@ export function put$pointers_Aim_array2_u16(self: rt.u16[], n: rt.u8): void { * them, whose own tag changes apart from theirs. */ export function through$Cell_u8(nest: Enclosed.Enclosed>, n: rt.u8, out: rt.ByteVec): void { - let _49!: boolean; + let _50!: boolean; const copy: Aimed.Aimed> = copy$pointers_Aimed_Cell_u8(nest.inner); (copy.tagged as [rt.Place>, rt.u8])[1] = (copy.tagged as [rt.Place>, rt.u8])[1] ^ 64; const _8: [rt.Place>, rt.u8] = tagged$Cell_u8(copy); @@ -1854,25 +1854,25 @@ export function through$Cell_u8(nest: Enclosed.Enclosed>, n: rt.u const tag: rt.u8 = _8[1]; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of((nest.inner.tagged as [rt.Place>, rt.u8])[1], tag)), undefined, true); put$pointers_Aim_Cell_u8(at.v, tag); - rt.byteVecPush(out, get$pointers_Aim_Cell_u8((nest.inner.seen as rt.Place>).v)); + rt.byteVecPush(out, (nest.inner.read as (a0: rt.Place>) => rt.u8)(nest.inner.seen as rt.Place>)); put$pointers_Aim_Cell_u8((nest.inner.at as rt.Place>).v, n); rt.byteVecPush(out, get$pointers_Aim_Cell_u8(((nest.inner.held as rt.Place>)).v)); if ((nest.inner.maybe as rt.Place> | undefined) !== undefined) { put$pointers_Aim_Cell_u8((((nest.inner.maybe as rt.Place> | undefined) as rt.Place>)).v, n ^ 3); } const _62: rt.Place> = (nest.inner.tagged as [rt.Place>, rt.u8])[0]; - const _33: rt.u8 = rt.u8WrappingAdd(n, (nest.inner.tagged as [rt.Place>, rt.u8])[1]); - put$pointers_Aim_Cell_u8(_62.v, _33); + const _34: rt.u8 = rt.u8WrappingAdd(n, (nest.inner.tagged as [rt.Place>, rt.u8])[1]); + put$pointers_Aim_Cell_u8(_62.v, _34); if (nest.inner.to.tag === "At") { put$pointers_Aim_Cell_u8((nest.inner.to._0 as rt.Place>).v, ~n & 0xff); } - const _42: rt.u8 = ((((nest.inner.maybe as rt.Place> | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; + const _43: rt.u8 = ((((nest.inner.maybe as rt.Place> | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; if (nest.inner.to.tag === "At") { - _49 = true; + _50 = true; } else { - _49 = false; + _50 = false; } - rt.byteVecPush(out, _42 | ((_49 ? 1 : 0))); + rt.byteVecPush(out, _43 | ((_50 ? 1 : 0))); if (rt.u8Rem(n, 5) === 0) { (nest.inner.at as rt.Place>).v = made$pointers_Aim_Cell_u8(n); } @@ -1884,7 +1884,7 @@ export function through$Cell_u8(nest: Enclosed.Enclosed>, n: rt.u * them, whose own tag changes apart from theirs. */ export function through$array2_u16(nest: Enclosed.Enclosed, n: rt.u8, out: rt.ByteVec): void { - let _49!: boolean; + let _50!: boolean; const copy: Aimed.Aimed = copy$pointers_Aimed_array2_u16(nest.inner); (copy.tagged as [rt.u16[], rt.u8])[1] = (copy.tagged as [rt.u16[], rt.u8])[1] ^ 64; const _8: [rt.u16[], rt.u8] = tagged$array2_u16(copy); @@ -1892,7 +1892,7 @@ export function through$array2_u16(nest: Enclosed.Enclosed, n: rt.u8, const tag: rt.u8 = _8[1]; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of((nest.inner.tagged as [rt.u16[], rt.u8])[1], tag)), undefined, true); put$pointers_Aim_array2_u16(at, tag); - rt.byteVecPush(out, get$pointers_Aim_array2_u16(nest.inner.seen as rt.u16[])); + rt.byteVecPush(out, (nest.inner.read as (a0: rt.u16[]) => rt.u8)(nest.inner.seen as rt.u16[])); put$pointers_Aim_array2_u16(nest.inner.at as rt.u16[], n); rt.byteVecPush(out, get$pointers_Aim_array2_u16(nest.inner.held as rt.u16[])); if ((nest.inner.maybe as rt.u16[] | undefined) !== undefined) { @@ -1902,13 +1902,13 @@ export function through$array2_u16(nest: Enclosed.Enclosed, n: rt.u8, if (nest.inner.to.tag === "At") { put$pointers_Aim_array2_u16(nest.inner.to._0 as rt.u16[], ~n & 0xff); } - const _42: rt.u8 = ((((nest.inner.maybe as rt.u16[] | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; + const _43: rt.u8 = ((((nest.inner.maybe as rt.u16[] | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; if (nest.inner.to.tag === "At") { - _49 = true; + _50 = true; } else { - _49 = false; + _50 = false; } - rt.byteVecPush(out, _42 | ((_49 ? 1 : 0))); + rt.byteVecPush(out, _43 | ((_50 ? 1 : 0))); if (rt.u8Rem(n, 5) === 0) { rt.ptrWrite(nest.inner.at as rt.u16[], copy$array_u16(made$pointers_Aim_array2_u16(n))); } @@ -1920,7 +1920,7 @@ export function through$array2_u16(nest: Enclosed.Enclosed, n: rt.u8, * them, whose own tag changes apart from theirs. */ export function through$array4_u8(nest: Enclosed.Enclosed, n: rt.u8, out: rt.ByteVec): void { - let _49!: boolean; + let _50!: boolean; const copy: Aimed.Aimed = copy$pointers_Aimed_array4_u8(nest.inner); (copy.tagged as [rt.ByteSlice, rt.u8])[1] = (copy.tagged as [rt.ByteSlice, rt.u8])[1] ^ 64; const _8: [rt.ByteSlice, rt.u8] = tagged$array4_u8(copy); @@ -1928,7 +1928,7 @@ export function through$array4_u8(nest: Enclosed.Enclosed, n: rt.u8, const tag: rt.u8 = _8[1]; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of((nest.inner.tagged as [rt.ByteSlice, rt.u8])[1], tag)), undefined, true); put$pointers_Aim_array4_u8(at, tag); - rt.byteVecPush(out, get$pointers_Aim_array4_u8(nest.inner.seen as rt.ByteSlice)); + rt.byteVecPush(out, (nest.inner.read as (a0: rt.ByteSlice) => rt.u8)(nest.inner.seen as rt.ByteSlice)); put$pointers_Aim_array4_u8(nest.inner.at as rt.ByteSlice, n); rt.byteVecPush(out, get$pointers_Aim_array4_u8(nest.inner.held as rt.ByteSlice)); if ((nest.inner.maybe as rt.ByteSlice | undefined) !== undefined) { @@ -1938,13 +1938,13 @@ export function through$array4_u8(nest: Enclosed.Enclosed, n: rt.u8, if (nest.inner.to.tag === "At") { put$pointers_Aim_array4_u8(nest.inner.to._0 as rt.ByteSlice, ~n & 0xff); } - const _42: rt.u8 = ((((nest.inner.maybe as rt.ByteSlice | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; + const _43: rt.u8 = ((((nest.inner.maybe as rt.ByteSlice | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; if (nest.inner.to.tag === "At") { - _49 = true; + _50 = true; } else { - _49 = false; + _50 = false; } - rt.byteVecPush(out, _42 | ((_49 ? 1 : 0))); + rt.byteVecPush(out, _43 | ((_50 ? 1 : 0))); if (rt.u8Rem(n, 5) === 0) { rt.byteSliceSet(nest.inner.at as rt.ByteSlice, copy$array_u8(made$pointers_Aim_array4_u8(n))); } @@ -1956,7 +1956,7 @@ export function through$array4_u8(nest: Enclosed.Enclosed, n: rt.u8, * them, whose own tag changes apart from theirs. */ export function through$pointers_Housed_u8(nest: Enclosed.Enclosed>, n: rt.u8, out: rt.ByteVec): void { - let _49!: boolean; + let _50!: boolean; const copy: Aimed.Aimed> = copy$pointers_Aimed_pointers_Housed_u8(nest.inner); (copy.tagged as [Housed.Housed, rt.u8])[1] = (copy.tagged as [Housed.Housed, rt.u8])[1] ^ 64; const _8: [Housed.Housed, rt.u8] = tagged$pointers_Housed_u8(copy); @@ -1964,7 +1964,7 @@ export function through$pointers_Housed_u8(nest: Enclosed.Enclosed, rt.u8])[1], tag)), undefined, true); Housed.put$pointers_Aim_u8(at, tag); - rt.byteVecPush(out, Housed.get$pointers_Aim_u8(nest.inner.seen as Housed.Housed)); + rt.byteVecPush(out, (nest.inner.read as (a0: Housed.Housed) => rt.u8)(nest.inner.seen as Housed.Housed)); Housed.put$pointers_Aim_u8(nest.inner.at as Housed.Housed, n); rt.byteVecPush(out, Housed.get$pointers_Aim_u8(nest.inner.held as Housed.Housed)); if ((nest.inner.maybe as Housed.Housed | undefined) !== undefined) { @@ -1974,13 +1974,13 @@ export function through$pointers_Housed_u8(nest: Enclosed.Enclosed, ~n & 0xff); } - const _42: rt.u8 = ((((nest.inner.maybe as Housed.Housed | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; + const _43: rt.u8 = ((((nest.inner.maybe as Housed.Housed | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; if (nest.inner.to.tag === "At") { - _49 = true; + _50 = true; } else { - _49 = false; + _50 = false; } - rt.byteVecPush(out, _42 | ((_49 ? 1 : 0))); + rt.byteVecPush(out, _43 | ((_50 ? 1 : 0))); if (rt.u8Rem(n, 5) === 0) { rt.ptrWrite(nest.inner.at as Housed.Housed, Housed.made$pointers_Aim_u8(n)); } @@ -1992,7 +1992,7 @@ export function through$pointers_Housed_u8(nest: Enclosed.Enclosed, n: rt.u8, out: rt.ByteVec): void { - let _49!: boolean; + let _50!: boolean; const copy: Aimed.Aimed = copy$pointers_Aimed_pointers_Leaning(nest.inner); (copy.tagged as [rt.Place, rt.u8])[1] = (copy.tagged as [rt.Place, rt.u8])[1] ^ 64; const _8: [rt.Place, rt.u8] = tagged$pointers_Leaning(copy); @@ -2000,7 +2000,7 @@ export function through$pointers_Leaning(nest: Enclosed.Enclosed, rt.u8])[1], tag)), undefined, true); Leaning.put$pointers_Aim(at, tag); - rt.byteVecPush(out, Leaning.get$pointers_Aim((nest.inner.seen as rt.Place).v)); + rt.byteVecPush(out, (nest.inner.read as (a0: rt.Place) => rt.u8)(nest.inner.seen as rt.Place)); Leaning.put$pointers_Aim(nest.inner.at as rt.Place, n); rt.byteVecPush(out, Leaning.get$pointers_Aim(((nest.inner.held as rt.Place)).v)); if ((nest.inner.maybe as rt.Place | undefined) !== undefined) { @@ -2010,13 +2010,13 @@ export function through$pointers_Leaning(nest: Enclosed.Enclosed, ~n & 0xff); } - const _42: rt.u8 = ((((nest.inner.maybe as rt.Place | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; + const _43: rt.u8 = ((((nest.inner.maybe as rt.Place | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; if (nest.inner.to.tag === "At") { - _49 = true; + _50 = true; } else { - _49 = false; + _50 = false; } - rt.byteVecPush(out, _42 | ((_49 ? 1 : 0))); + rt.byteVecPush(out, _43 | ((_50 ? 1 : 0))); if (rt.u8Rem(n, 5) === 0) { (nest.inner.at as rt.Place).v = Leaning.made$pointers_Aim(n); } @@ -2028,7 +2028,7 @@ export function through$pointers_Leaning(nest: Enclosed.Enclosed, n: rt.u8, out: rt.ByteVec): void { - let _49!: boolean; + let _50!: boolean; const copy: Aimed.Aimed = copy$pointers_Aimed_pointers_Paired(nest.inner); (copy.tagged as [Paired.Paired, rt.u8])[1] = (copy.tagged as [Paired.Paired, rt.u8])[1] ^ 64; const _8: [Paired.Paired, rt.u8] = tagged$pointers_Paired(copy); @@ -2036,7 +2036,7 @@ export function through$pointers_Paired(nest: Enclosed.Enclosed, const tag: rt.u8 = _8[1]; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of((nest.inner.tagged as [Paired.Paired, rt.u8])[1], tag)), undefined, true); Paired.put$pointers_Aim(at, tag); - rt.byteVecPush(out, Paired.get$pointers_Aim(nest.inner.seen as Paired.Paired)); + rt.byteVecPush(out, (nest.inner.read as (a0: Paired.Paired) => rt.u8)(nest.inner.seen as Paired.Paired)); Paired.put$pointers_Aim(nest.inner.at as Paired.Paired, n); rt.byteVecPush(out, Paired.get$pointers_Aim(nest.inner.held as Paired.Paired)); if ((nest.inner.maybe as Paired.Paired | undefined) !== undefined) { @@ -2046,13 +2046,13 @@ export function through$pointers_Paired(nest: Enclosed.Enclosed, if (nest.inner.to.tag === "At") { Paired.put$pointers_Aim(nest.inner.to._0 as Paired.Paired, ~n & 0xff); } - const _42: rt.u8 = ((((nest.inner.maybe as Paired.Paired | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; + const _43: rt.u8 = ((((nest.inner.maybe as Paired.Paired | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; if (nest.inner.to.tag === "At") { - _49 = true; + _50 = true; } else { - _49 = false; + _50 = false; } - rt.byteVecPush(out, _42 | ((_49 ? 1 : 0))); + rt.byteVecPush(out, _43 | ((_50 ? 1 : 0))); if (rt.u8Rem(n, 5) === 0) { rt.ptrWrite(nest.inner.at as Paired.Paired, Paired.made$pointers_Aim(n)); } @@ -2064,7 +2064,7 @@ export function through$pointers_Paired(nest: Enclosed.Enclosed, * them, whose own tag changes apart from theirs. */ export function through$u8(nest: Enclosed.Enclosed, n: rt.u8, out: rt.ByteVec): void { - let _49!: boolean; + let _50!: boolean; const copy: Aimed.Aimed = copy$pointers_Aimed_u8(nest.inner); (copy.tagged as [rt.Place, rt.u8])[1] = (copy.tagged as [rt.Place, rt.u8])[1] ^ 64; const _8: [rt.Place, rt.u8] = tagged$u8(copy); @@ -2072,7 +2072,7 @@ export function through$u8(nest: Enclosed.Enclosed, n: rt.u8, out: rt.Byt const tag: rt.u8 = _8[1]; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of((nest.inner.tagged as [rt.Place, rt.u8])[1], tag)), undefined, true); put$pointers_Aim_u8(at, tag); - rt.byteVecPush(out, get$pointers_Aim_u8((nest.inner.seen as rt.Place).v)); + rt.byteVecPush(out, (nest.inner.read as (a0: rt.Place) => rt.u8)(nest.inner.seen as rt.Place)); put$pointers_Aim_u8(nest.inner.at as rt.Place, n); rt.byteVecPush(out, get$pointers_Aim_u8(((nest.inner.held as rt.Place)).v)); if ((nest.inner.maybe as rt.Place | undefined) !== undefined) { @@ -2082,19 +2082,54 @@ export function through$u8(nest: Enclosed.Enclosed, n: rt.u8, out: rt.Byt if (nest.inner.to.tag === "At") { put$pointers_Aim_u8(nest.inner.to._0 as rt.Place, ~n & 0xff); } - const _42: rt.u8 = ((((nest.inner.maybe as rt.Place | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; + const _43: rt.u8 = ((((nest.inner.maybe as rt.Place | undefined) !== undefined ? 1 : 0)) << 1) & 0xff; if (nest.inner.to.tag === "At") { - _49 = true; + _50 = true; } else { - _49 = false; + _50 = false; } - rt.byteVecPush(out, _42 | ((_49 ? 1 : 0))); + rt.byteVecPush(out, _43 | ((_50 ? 1 : 0))); if (rt.u8Rem(n, 5) === 0) { (nest.inner.at as rt.Place).v = made$pointers_Aim_u8(n); } rt.byteVecPush(out, get$pointers_Aim_u8((nest.inner.seen as rt.Place).v)); } +/** What `at` points at, read as a byte. */ +export function readThrough$Cell_u8(at: rt.Place>): rt.u8 { + return get$pointers_Aim_Cell_u8(at.v); +} + +/** What `at` points at, read as a byte. */ +export function readThrough$array2_u16(at: rt.u16[]): rt.u8 { + return get$pointers_Aim_array2_u16(at); +} + +/** What `at` points at, read as a byte. */ +export function readThrough$array4_u8(at: rt.ByteSlice): rt.u8 { + return get$pointers_Aim_array4_u8(at); +} + +/** What `at` points at, read as a byte. */ +export function readThrough$pointers_Housed_u8(at: Housed.Housed): rt.u8 { + return Housed.get$pointers_Aim_u8(at); +} + +/** What `at` points at, read as a byte. */ +export function readThrough$pointers_Leaning(at: rt.Place): rt.u8 { + return Leaning.get$pointers_Aim(at.v); +} + +/** What `at` points at, read as a byte. */ +export function readThrough$pointers_Paired(at: Paired.Paired): rt.u8 { + return Paired.get$pointers_Aim(at); +} + +/** What `at` points at, read as a byte. */ +export function readThrough$u8(at: rt.Place): rt.u8 { + return get$pointers_Aim_u8(at.v); +} + /** `a`'s tagged pointer and tag, taken apart. */ export function tagged$Cell_u8(a: Aimed.Aimed>): [rt.Place>, rt.u8] { return [(a.tagged as [rt.Place>, rt.u8])[0], (a.tagged as [rt.Place>, rt.u8])[1]] as [rt.Place>, rt.u8]; diff --git a/ts/fixtures/lang/src/pointers.rs b/ts/fixtures/lang/src/pointers.rs index 453355e8c..1c4828fef 100644 --- a/ts/fixtures/lang/src/pointers.rs +++ b/ts/fixtures/lang/src/pointers.rs @@ -1565,6 +1565,7 @@ macro_rules! aim { maybe: if $n % 2 == 0 { Some(held) } else { None }, tagged: (at, $n), to: if $n % 3 == 0 { To::At(at) } else { To::Nowhere }, + read: read_through, }, } }}; @@ -1754,6 +1755,8 @@ struct Aimed { maybe: Option>, tagged: (*mut T, u8), to: To, + /// A function taking one, which JS takes as the instance's own pointer. + read: fn(*const T) -> u8, } impl Clone for Aimed { @@ -1803,7 +1806,7 @@ fn through(nest: &Enclosed, n: u8, out: &mut Vec) { out.extend([a.tagged.1, tag]); unsafe { (*at).put(tag); - out.push((*a.seen).get()); + out.push((a.read)(a.seen)); (*a.at).put(n); out.push((*a.held.as_ptr()).get()); if let Some(p) = a.maybe { @@ -1821,6 +1824,11 @@ fn through(nest: &Enclosed, n: u8, out: &mut Vec) { } } +/// What `at` points at, read as a byte. +fn read_through(at: *const T) -> u8 { + unsafe { (*at).get() } +} + /// `a`'s tagged pointer and tag, taken apart. fn tagged(a: Aimed) -> (*mut T, u8) { let Aimed { tagged: (at, tag), .. } = a; diff --git a/ts/src/lower/body.rs b/ts/src/lower/body.rs index 68b41295a..ec49ea8b5 100644 --- a/ts/src/lower/body.rs +++ b/ts/src/lower/body.rs @@ -202,7 +202,10 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { match info.repr { AdtRepr::Struct { ctor, fields } => { let args = (adt.variant(variant).fields.iter().zip(values)) - .map(|(field, value)| field_arg(tcx, field, value)) + .map(|(field, value)| { + let value = self.t.field_value(value, adt_id, field.did, gargs, span); + field_arg(tcx, field, value) + }) .collect(); self.t.construct(info.sym, &ctor, &fields, args) } diff --git a/ts/src/lower/consts.rs b/ts/src/lower/consts.rs index bacde13cb..ab79043b9 100644 --- a/ts/src/lower/consts.rs +++ b/ts/src/lower/consts.rs @@ -181,7 +181,12 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { let info = self.t.adt(*adt, span); let def = adt.variant(variant); match info.repr { - AdtRepr::Struct { ctor, fields } => self.t.construct(info.sym, &ctor, &fields, values), + AdtRepr::Struct { ctor, fields } => { + let values = (def.fields.iter().zip(values)) + .map(|(field, v)| self.t.field_value(v, adt.did(), field.did, args, span)) + .collect(); + self.t.construct(info.sym, &ctor, &fields, values) + } AdtRepr::Tags => { let ts_ty = self.t.ty(ty, span); Expr::As(Box::new(Expr::Str(def.name.to_string())), ts_ty) diff --git a/ts/src/lower/copy.rs b/ts/src/lower/copy.rs index ba85eccbb..390b94cc6 100644 --- a/ts/src/lower/copy.rs +++ b/ts/src/lower/copy.rs @@ -280,7 +280,8 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { .map(|(field, &id)| { let field_ty = self.field_ty(field.did, args); let read = self.held_field(v().field(id), field.did, args, span); - self.snapshot(read, part(field_ty), span) + let copy = self.snapshot(read, part(field_ty), span); + self.field_value(copy, adt.did(), field.did, args, span) }) .collect(); ret(self.construct(info.sym, &ctor, &fields, values)) diff --git a/ts/src/lower/mir/rvalue.rs b/ts/src/lower/mir/rvalue.rs index bd1482b9d..b3f48dc05 100644 --- a/ts/src/lower/mir/rvalue.rs +++ b/ts/src/lower/mir/rvalue.rs @@ -673,7 +673,12 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { false => value.typed(), } }; - let values = values.into_iter().enumerate().map(|(i, v)| field_arg(i, v)).collect(); + let values = (def.fields.iter().zip(values).enumerate()) + .map(|(i, (field, v))| { + let v = self.b.t.field_value(v, def_id, field.did, args, span); + field_arg(i, v) + }) + .collect(); self.b.t.construct(info.sym, &ctor, &fields, values) } AdtRepr::Tags => { diff --git a/ts/src/lower/mod.rs b/ts/src/lower/mod.rs index ea827c83f..31d1696e2 100644 --- a/ts/src/lower/mod.rs +++ b/ts/src/lower/mod.rs @@ -192,8 +192,9 @@ pub struct Translator<'a, 'tcx> { queue: VecDeque<(Instance<'tcx>, SymId)>, adts: rustc_data_structures::fx::FxHashMap, /// The fields of generic types whose definition types a pointer as an `rt.Ptr`, which - /// an instance's read casts to what it holds. - ptr_fields: rustc_data_structures::fx::FxHashSet, + /// an instance's read casts to what it holds, with that type where a function type in + /// it takes one, which an instance's value is cast to. + ptr_fields: rustc_data_structures::fx::FxHashMap>, /// Source files by name, as indexes into `program.sources`. sources: rustc_data_structures::fx::FxHashMap>, failed: bool, @@ -1622,16 +1623,44 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { /// parameters, noting a field that holds an `rt.Ptr` for [`Self::held_field`]. fn defined_field_ty(&mut self, field: &ty::FieldDef, identity: GenericArgsRef<'tcx>, span: Span) -> Type { let ty = self.ty(field.ty(self.tcx, identity).skip_norm_wip(), span); - if ty.any(&|t| matches!(t, Type::Rt("Ptr", _))) { - self.ptr_fields.insert(field.did); + let ptr = |t: &Type| matches!(t, Type::Rt("Ptr", _)); + if ty.any(&ptr) { + self.ptr_fields.insert(field.did, ty.takes(&ptr).then(|| ty.clone())); } ty } + /// `value`, for `field` of an instance of `adt` with `args`, cast to the field's type in + /// the definition at those arguments where a function type in it takes an `rt.Ptr`: a + /// function taking what the instance's pointer is takes no other form of one. + pub fn field_value( + &mut self, + value: ts::Expr, + adt: DefId, + field: DefId, + args: GenericArgsRef<'tcx>, + span: Span, + ) -> ts::Expr { + let Some(Some(defined)) = self.ptr_fields.get(&field).cloned() else { + return value; + }; + let params: Vec<(String, Type)> = (self.tcx.generics_of(adt).own_params.iter()) + .filter(|param| matches!(param.kind, ty::GenericParamDefKind::Type { .. })) + .map(|param| { + ( + param.name.to_string(), + self.ty(args.type_at(param.index as usize), span), + ) + }) + .collect(); + let at = defined.subst(&|name| params.iter().find(|(p, _)| p == name).map(|(_, t)| t.clone())); + ts::Expr::As(Box::new(value), at) + } + /// `read`, of `field` of an instance with `args`, cast to what the instance holds there /// where the definition types a pointer in it as an `rt.Ptr`. pub fn held_field(&mut self, read: ts::Expr, field: DefId, args: GenericArgsRef<'tcx>, span: Span) -> ts::Expr { - if !self.ptr_fields.contains(&field) { + if !self.ptr_fields.contains_key(&field) { return read; } let ty = self.field_ty(field, args); diff --git a/ts/src/lower/pointer.rs b/ts/src/lower/pointer.rs index 2ab442ad3..8fa441efa 100644 --- a/ts/src/lower/pointer.rs +++ b/ts/src/lower/pointer.rs @@ -206,19 +206,16 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { let info = self.adt(*adt, span); match info.repr { AdtRepr::Struct { ctor, fields } => { - let tys: Vec> = adt - .non_enum_variant() - .fields - .iter() - .map(|f| self.field_ty(f.did, args)) - .collect(); // A class's constructor types each of its parameters. let plain = self.plain(info.sym); - let values = tys - .into_iter() - .map(|t| match plain { - true => self.shell(t, span), - false => self.uninit(t, span), + let values = (adt.non_enum_variant().fields.iter()) + .map(|f| { + let t = self.field_ty(f.did, args); + let value = match plain { + true => self.shell(t, span), + false => self.uninit(t, span), + }; + self.field_value(value, adt.did(), f.did, args, span) }) .collect(); self.construct(info.sym, &ctor, &fields, values) diff --git a/ts/src/lower/unions.rs b/ts/src/lower/unions.rs index af4b172de..a917dbf97 100644 --- a/ts/src/lower/unions.rs +++ b/ts/src/lower/unions.rs @@ -236,12 +236,12 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { .iter() .map(|f| self.field_ty(f.did, args)) .collect(); - let values = tys - .into_iter() - .enumerate() - .map(|(i, t)| { + let defs = &adt.non_enum_variant().fields; + let values = (tys.into_iter().zip(defs.iter()).enumerate()) + .map(|(i, (t, field))| { let part = within(i); - self.of_slots(base.clone(), t, &part, span) + let value = self.of_slots(base.clone(), t, &part, span); + self.field_value(value, adt.did(), field.did, args, span) }) .collect(); self.construct(info.sym, &ctor, &fields, values) diff --git a/ts/src/ts.rs b/ts/src/ts.rs index 191828286..82cb423d3 100644 --- a/ts/src/ts.rs +++ b/ts/src/ts.rs @@ -597,6 +597,35 @@ impl Type { self.any(&|t| matches!(t, Type::Param(name) if name == param)) } + /// Whether a function type in it takes a parameter holding a type `f` picks. + pub fn takes(&self, f: &impl Fn(&Type) -> bool) -> bool { + match self { + Type::Func(params, ret) => params.iter().any(|t| t.any(f)) || ret.takes(f), + Type::Param(_) | Type::Builtin(_) | Type::StrLit(_) => false, + Type::Rt(_, tys) | Type::Sym(_, tys) | Type::Union(tys) | Type::Tuple(tys) => { + tys.iter().any(|t| t.takes(f)) + } + Type::Array(t) => t.takes(f), + Type::Object(fields) => fields.iter().any(|(_, t)| t.takes(f)), + } + } + + /// It with each type parameter `f` gives a type for replaced. + pub fn subst(&self, f: &impl Fn(&str) -> Option) -> Type { + let all = |tys: &[Type]| tys.iter().map(|t| t.subst(f)).collect(); + match self { + Type::Param(name) => f(name).unwrap_or_else(|| self.clone()), + Type::Builtin(_) | Type::StrLit(_) => self.clone(), + Type::Rt(name, tys) => Type::Rt(name, all(tys)), + Type::Sym(sym, tys) => Type::Sym(*sym, all(tys)), + Type::Union(tys) => Type::Union(all(tys)), + Type::Tuple(tys) => Type::Tuple(all(tys)), + Type::Array(t) => Type::Array(Box::new(t.subst(f))), + Type::Func(tys, ret) => Type::Func(all(tys), Box::new(ret.subst(f))), + Type::Object(fields) => Type::Object(fields.iter().map(|(k, t)| (k.clone(), t.subst(f))).collect()), + } + } + /// Whether it, or any type in it, is one `f` picks. pub fn any(&self, f: &impl Fn(&Type) -> bool) -> bool { f(self)