diff --git a/quest/m2/ts-model/README.md b/quest/m2/ts-model/README.md index 5aab22361..43608c20b 100644 --- a/quest/m2/ts-model/README.md +++ b/quest/m2/ts-model/README.md @@ -49,7 +49,6 @@ Public API: the translator's output for moq-net's model. - [Shared ownership](/quest/m2/ts-shared.md) - kio's waiters are `Arc`/`Weak` with observable counts, and its atomics and locks are plain values - [Float formatting](/quest/m2/ts-model/floats.md) - `f64` formats and parses as std does - [The rest of std the model reaches](/quest/m2/ts-model/std-rest.md) - `Vec` and `VecDeque` capacity, and `RandomState` -- [Writes through places the model still refuses](/quest/m2/ts-model/places.md) - `get_or_insert_default` through a `&mut`, and `mem::take` of a captured `&mut Vec` - [std gaps kio reaches](/quest/m2/ts-model/kio-std.md) - `array::from_fn`, `Default` of arrays and `()`, and maps of `Option`s - [bytes' BytesMut, Buf, and BufMut](/quest/m2/ts-model/bytes.md) - map without config, so the model's `BytesMut` binding goes - [Async in the TypeScript translator](/quest/m2/ts-async.md) - kio's producers and consumers are futures diff --git a/quest/m2/ts-model/places.md b/quest/m2/ts-model/places.md deleted file mode 100644 index aa93ae935..000000000 --- a/quest/m2/ts-model/places.md +++ /dev/null @@ -1,26 +0,0 @@ -# [M] Writes through places the model still refuses - -## Goal - -rust2-ts translates the writes through a place that the model's census still refuses, -proven by differential tests against native Rust: - -- `Option::get_or_insert_default` on an `Option` reached through a `&mut`, such as a - `&mut Option>` from a match on `&mut self.fields` (moq-net's `group.rs`), and the - call it is still refused as outright (`origin.rs`). -- `mem::take` of a `&mut Vec` a closure captured (`origin.rs`), refused as "replacing the - value behind a reference". - -## Plan - -Found by [#168](https://github.com/kixelated/rust2/pull/168) on 2026-10-28: four -`get_or_insert_default` refusals stayed with [#149](https://github.com/kixelated/rust2/pull/149)'s -`rt.Place`s landed, and no quest owns them since #149 deleted its own. - -- Both are a place the lowering can't name: a captured `&mut` is a capture of a place, not a - std gap, and `get_or_insert_default` already lowers in `call.rs` where its place guard - allows. Find what each guard refuses, and widen it only as far as the semantics stay - exact. -- Report the model's census before and after. - -Public API: the translator's output. diff --git a/ts/fixtures/lang/expected/core/bool.ts b/ts/fixtures/lang/expected/core/bool.ts index c88ef0114..0048888e4 100644 --- a/ts/fixtures/lang/expected/core/bool.ts +++ b/ts/fixtures/lang/expected/core/bool.ts @@ -122,6 +122,13 @@ export function then$bool_Vec_u8_new(self: boolean, _: () => rt.ByteVec): rt.Byt return new rt.ByteVec(); } +export function then$bool_Vec_u8_restock_closure0(self: boolean, f: () => rt.ByteVec): rt.ByteVec | undefined { + if (!self) { + return undefined; + } + return f(); +} + export function then$bool_str_slices_closure1_closure0(self: boolean, f: () => string): string | undefined { if (!self) { return undefined; diff --git a/ts/fixtures/lang/expected/refs.Listing.ts b/ts/fixtures/lang/expected/refs.Listing.ts new file mode 100644 index 000000000..fc40c38a0 --- /dev/null +++ b/ts/fixtures/lang/expected/refs.Listing.ts @@ -0,0 +1,27 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; + +export function default$Default(): Listing { + return { source: undefined, listed: new rt.ByteVec(), stale: new rt.ByteVec() }; +} + +export function fmt$Debug(self: Listing, f: rt.Formatter): rt.Result { + const _3: string = "Listing"; + const _4: string = "source"; + const _5: rt.Fmt = (f: rt.Formatter) => rt.fmtOption(self.source, f, rt.u8Debug); + const _7: string = "listed"; + const _8: rt.Fmt = (f: rt.Formatter) => rt.fmtList(rt.byteVecView(self.listed), f, rt.u8Debug); + const _10: string = "stale"; + const _11: rt.Fmt = (f: rt.Formatter) => rt.fmtList(rt.byteVecView(self.stale), f, rt.u8Debug); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8), _10, _11)); +} + +/** moq-net's listing: a crate type's default, made in place only while there is none. */ +export interface Listing { + source: rt.u8 | undefined; + listed: rt.ByteVec; + stale: rt.ByteVec; +} + +//# sourceMappingURL=refs.Listing.ts.map diff --git a/ts/fixtures/lang/expected/refs.ts b/ts/fixtures/lang/expected/refs.ts index c02d605a8..eddf7610b 100644 --- a/ts/fixtures/lang/expected/refs.ts +++ b/ts/fixtures/lang/expected/refs.ts @@ -2,11 +2,12 @@ import * as rt from "./rt.ts"; import { copy$Option_u8_u8, copy$u32s } from "./lib.ts"; -import { thenSome$bool_u32 } from "./core/bool.ts"; -import { unwrapOr$Option_u32, unwrapOr$Option_u8, unwrapOr$Option_u8_u8, unwrapOrDefault$Option_String, map$Option_u8_u8_elements_closure8, map$Option_u8_u8_u8_elements_closure9, map$Option_u8_u8_u8_u8_lent_closure2, mapOr$Option_Option_u8_u8_refs_closure2_closure0, mapOr$Option_String_u8_refs_closure1, mapOr$Option_u32_u32_lent_closure4, mapOr$Option_u8_bool_take_largest_closure0, mapOr$Option_u8_u8_btree_maps_closure5, mapOr$Option_u8_u8_u8_btree_maps_closure0, andThen$Option_u32_u32_lent_closure3, filter$Option_u8_u8_lent_closure1, or$Option_u8 } from "./core/option.ts"; +import { thenSome$bool_u32, then$bool_Vec_u8_restock_closure0 } from "./core/bool.ts"; +import { unwrapOr$Option_u32, unwrapOr$Option_u8, unwrapOr$Option_u8_u8, unwrapOrDefault$Option_String, unwrapOrDefault$Option_Vec_u8, map$Option_u8_u8_elements_closure8, map$Option_u8_u8_u8_elements_closure9, map$Option_u8_u8_u8_u8_lent_closure2, mapOr$Option_Option_u8_u8_refs_closure2_closure0, mapOr$Option_String_u8_refs_closure1, mapOr$Option_u32_u32_lent_closure4, mapOr$Option_u8_bool_take_largest_closure0, mapOr$Option_u8_u8_btree_maps_closure5, mapOr$Option_u8_u8_u8_btree_maps_closure0, andThen$Option_u32_u32_lent_closure3, filter$Option_u8_u8_lent_closure1, or$Option_u8 } from "./core/option.ts"; import * as Counts from "./refs.Counts.ts"; import * as Cursor from "./refs.Cursor.ts"; import type * as Fetch from "./refs.Fetch.ts"; +import * as Listing from "./refs.Listing.ts"; import type * as Pair from "./refs.Pair.ts"; import type * as Pair2 from "./refs.Pair2.ts"; @@ -39,9 +40,9 @@ export function takeLargest(seen: rt.Place, next: rt.u8): rt. if (!(next === 0)) { return undefined; } - const taken = seen.v; + const taken_ = seen.v; seen.v = undefined; - return taken; + return taken_; } const old = seen.v; seen.v = next; @@ -59,13 +60,13 @@ export function rename(name: rt.Place, b: rt.u8): string | u /** A `&mut Option` passed on from inside a closure std calls. */ export function largestOf(seen: rt.Place, items: rt.ByteSlice): rt.u8 { - let taken: rt.u8 = 0; + let taken_: rt.u8 = 0; rt.iterForEach(rt.iterSlice(rt.byteSliceView(items)), (_2: rt.u8): void => { if (takeLargest(seen, _2) !== undefined) { - taken = rt.u8WrappingAdd(taken, 1); + taken_ = rt.u8WrappingAdd(taken_, 1); } }); - return taken; + return taken_; } /** moq-net's `&mut Box`: changed through, and replaced whole. */ @@ -106,9 +107,9 @@ export function refuse(f: rt.Place): void { export function pushTo(s: rt.Place, c: rt.char): void { s.v = s.v + String.fromCodePoint(c); if (c === 122) { - const taken = s.v; + const taken_ = s.v; s.v = ""; - const iter: rt.Iter = rt.iterTake(rt.strChars(taken), 2); + const iter: rt.Iter = rt.iterTake(rt.strChars(taken_), 2); while (true) { const _12: rt.char | rt.Done = iter.next(); if (_12 === rt.DONE) { @@ -480,9 +481,141 @@ export function lent(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(unwrapOr$Option_u32(_154, 61166)))); } + defaulted(data, out); + taken(data, out); elements(data, out); } +/** Filled in place by its default, through a `&mut` and from a closure, then reset. */ +export function defaulted(data: rt.ByteSlice, out: rt.ByteVec): void { + let listing: Listing.Listing | undefined = undefined; + for (const b of rt.byteSliceView(data)) { + const _11: rt.u8 = rt.u8Rem(b, 5); + if (_11 === 0) { + listing = undefined; + } else if (_11 === 1) { + list(rt.place(() => listing, (value4) => listing = value4), b); + } else if (_11 === 2) { + const _16: rt.Place = rt.place(() => listing, (value3) => listing = value3); + if (_16.v === undefined) { + _16.v = Listing.default$Default(); + } + const _17: rt.u8 | undefined = unwrapOr$Option_u8((_16.v as Listing.Listing).source, b) ^ b; + (_16.v as Listing.Listing).source = _17; + } else if (_11 === 3) { + const _22: rt.Place = rt.place(() => listing, (value2) => listing = value2); + const relist: (a0: rt.u8) => void = (b2: rt.u8): void => { + if (_22.v === undefined) { + _22.v = Listing.default$Default(); + } + rt.byteVecPush((_22.v as Listing.Listing).listed, b2); + }; + relist(b); + relist(b ^ 1); + } else { + const _31: rt.Place = rt.place(() => listing, (value) => listing = value); + if (_31.v === undefined) { + _31.v = Listing.default$Default(); + } + (_31.v as Listing.Listing).source = undefined; + rt.byteVecPop((_31.v as Listing.Listing).listed); + } + } + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(listing, f, (value: Listing.Listing, f: rt.Formatter) => Listing.fmt$Debug(value, f))]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +export function list(listing: rt.Place, b: rt.u8): void { + if (listing.v === undefined) { + listing.v = Listing.default$Default(); + } + (listing.v as Listing.Listing).source = b; + const _5: rt.ByteVec = rt.byteVecFrom(rt.byteVecView((listing.v as Listing.Listing).listed)); + (listing.v as Listing.Listing).stale = _5; + rt.byteVecPush((listing.v as Listing.Listing).listed, b); +} + +/** moq-net's ingest: a field of what a `&mut` parameter points at, taken by a closure. */ +export function restock(listing: Listing.Listing, b: rt.u8): rt.ByteVec | undefined { + return then$bool_Vec_u8_restock_closure0(rt.u8Rem(b, 2) === 0, (): rt.ByteVec => { + const _2: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(b)); + const old = listing.listed; + listing.listed = _2; + return old; + }); +} + +/** + * moq-net's front: a `Vec` a closure captured by reference, taken, replaced, and + * refilled on each call, read after by the caller. + */ +export function taken(data: rt.ByteSlice, out: rt.ByteVec): void { + let held: rt.ByteVec = rt.byteSliceToByteVec(data); + let wide: rt.u32[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u32 => { + return rt.u32Mul(_2 as rt.u32, 1000); + })); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(poll$taken_closure1(data, (b4: rt.u8): boolean => { + const taken_ = held; + held = new rt.ByteVec(); + for (const x of rt.byteVecView(taken_)) { + if (rt.u8Rem(x, 3) !== rt.u8Rem(b4, 3)) { + rt.byteVecPush(held, rt.u8Div(x, 2)); + } + } + ((): void => { + const _34: rt.u32[] = []; + const old2 = wide; + wide = _34; + wide = rt.iterToArray(rt.iterMap(rt.iterFilter(rt.iterSlice(old2), (_25: rt.u32): boolean => { + return _25 > ((b4 as rt.u32)); + }), (x3: rt.u32): rt.u32 => { + return rt.u32Div(x3, 2); + })); + })(); + return held.length === 0; + }) as rt.u32))); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(held)); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(wide, f, rt.u32Debug)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); + const pair: [rt.ByteVec, Listing.Listing] = [rt.byteSliceToByteVec(data), Listing.default$Default()]; + const swap: (a0: rt.u8) => rt.ByteVec = (b5: rt.u8): rt.ByteVec => { + const _36: rt.ByteVec = rt.byteVecOf(b5, rt.u8Rem(b5, 4) as rt.usize); + const old3 = pair[0]; + pair[0] = _36; + return old3; + }; + const swapped: rt.ByteVec = new rt.ByteVec(); + for (const _39 of rt.byteSliceView(data)) { + const _45: rt.ByteVec = swap(_39); + rt.iterExtendBytes(swapped, rt.iterSlice(rt.byteVecView(_45))); + } + const list_: (a0: rt.u8) => void = (b6: rt.u8): void => { + const taken2 = pair[1].listed; + pair[1].listed = new rt.ByteVec(); + pair[1].stale = taken2; + rt.byteVecPush(pair[1].listed, b6); + }; + rt.iterForEach(rt.iterSlice(rt.byteSliceView(data)), (_26: rt.u8): void => { + list_(_26); + }); + for (const _57 of rt.byteSliceView(data)) { + const _63: rt.ByteVec = unwrapOrDefault$Option_Vec_u8(restock(pair[1], _57)); + rt.iterExtendBytes(swapped, rt.iterSlice(rt.byteVecView(_63))); + } + const taken3 = pair[1].stale; + pair[1].stale = new rt.ByteVec(); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(taken3)); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(swapped)); + const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtList(rt.byteVecView(pair[0]), f, rt.u8Debug), (f: rt.Formatter) => Listing.fmt$Debug(pair[1], f)], f)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0]]))); +} + +export function poll$taken_closure1(data: rt.ByteSlice, f: (a0: rt.u8) => boolean): rt.usize { + return rt.iterCount(rt.iterTakeWhile(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): boolean => { + return !f(_2); + })); +} + /** * What std lends of the elements and values of slices and collections, which JS copies: * one, each in turn, or each to a closure. diff --git a/ts/fixtures/lang/src/refs.rs b/ts/fixtures/lang/src/refs.rs index 04279ffb8..cc2c96508 100644 --- a/ts/fixtures/lang/src/refs.rs +++ b/ts/fixtures/lang/src/refs.rs @@ -349,9 +349,104 @@ fn lent(data: &[u8], out: &mut Vec) { for x in [counts.a, counts.b, spare[0], spare[1]] { out.extend_from_slice(&x.unwrap_or(0xeeee).to_be_bytes()); } + defaulted(data, out); + taken(data, out); elements(data, out); } +/// moq-net's listing: a crate type's default, made in place only while there is none. +#[derive(Default, Debug)] +struct Listing { + source: Option, + listed: Vec, + stale: Vec, +} + +/// Filled in place by its default, through a `&mut` and from a closure, then reset. +fn defaulted(data: &[u8], out: &mut Vec) { + fn list(listing: &mut Option, b: u8) { + let state = listing.get_or_insert_default(); + state.source = Some(b); + state.stale = state.listed.clone(); + state.listed.push(b); + } + let mut listing: Option = None; + for &b in data { + match b % 5 { + 0 => listing = None, + 1 => list(&mut listing, b), + 2 => { + let state = listing.get_or_insert_with(Listing::default); + state.source = Some(state.source.unwrap_or(b) ^ b); + } + 3 => { + let mut relist = |b: u8| listing.get_or_insert_default().listed.push(b); + relist(b); + relist(b ^ 1); + } + _ => { + let state = listing.get_or_insert_default(); + state.source = None; + state.listed.pop(); + } + } + } + out.extend_from_slice(format!("{listing:?}").as_bytes()); +} + +/// moq-net's ingest: a field of what a `&mut` parameter points at, taken by a closure. +fn restock(listing: &mut Listing, b: u8) -> Option> { + (b % 2 == 0).then(|| std::mem::replace(&mut listing.listed, vec![b])) +} + +/// moq-net's front: a `Vec` a closure captured by reference, taken, replaced, and +/// refilled on each call, read after by the caller. +fn taken(data: &[u8], out: &mut Vec) { + fn poll bool>(data: &[u8], mut f: F) -> usize { + data.iter().take_while(|&&b| !f(b)).count() + } + let mut held = data.to_vec(); + let mut wide: Vec = data.iter().map(|&b| u32::from(b) * 1000).collect(); + let polls = poll(data, |b| { + for x in std::mem::take(&mut held) { + if x % 3 != b % 3 { + held.push(x / 2); + } + } + // From a closure inside this one, and replaced whole. + let mut halve = || { + let old = std::mem::replace(&mut wide, Vec::new()); + wide = old.into_iter().filter(|&x| x > u32::from(b)).map(|x| x / 2).collect(); + }; + halve(); + held.is_empty() + }); + out.extend_from_slice(&(polls as u32).to_be_bytes()); + out.extend_from_slice(&held); + out.extend_from_slice(format!("{wide:?}").as_bytes()); + // A `&mut` moved into the closure, and a field. + let mut pair = (data.to_vec(), Listing::default()); + let first = &mut pair.0; + let mut swap = move |b: u8| std::mem::replace(first, vec![b; usize::from(b % 4)]); + let mut swapped = Vec::new(); + for &b in data { + swapped.extend(swap(b)); + } + let mut list = |b: u8| { + let listed = std::mem::take(&mut pair.1.listed); + pair.1.stale = listed; + pair.1.listed.push(b); + }; + data.iter().for_each(|&b| list(b)); + for &b in data { + swapped.extend(restock(&mut pair.1, b).unwrap_or_default()); + } + let direct = std::mem::take(&mut pair.1.stale); + out.extend_from_slice(&direct); + out.extend_from_slice(&swapped); + out.extend_from_slice(format!("{pair:?}").as_bytes()); +} + /// What std lends of the elements and values of slices and collections, which JS copies: /// one, each in turn, or each to a closure. fn elements(data: &[u8], out: &mut Vec) { diff --git a/ts/fixtures/task/expected/kio.Pending.ts b/ts/fixtures/task/expected/kio.Pending.ts index f11f9fe13..e579e9dd4 100644 --- a/ts/fixtures/task/expected/kio.Pending.ts +++ b/ts/fixtures/task/expected/kio.Pending.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; -import { poll$Task_boxed_closure0_closure3, poll$Task_boxed_closure0_closure5, poll$Task_closed_closure0_closure0, poll$Task_recv_closure0_closure0, poll$Task_wait_closure0_closure0, poll$Task_watch_closure0_closure0 } from "./kio.ts"; +import { poll$Task_boxed_closure0_closure3, poll$Task_boxed_closure0_closure5, poll$Task_closed_closure0_closure0, poll$Task_front_closure0_closure0, poll$Task_recv_closure0_closure0, poll$Task_wait_closure0_closure0, poll$Task_watch_closure0_closure0 } from "./kio.ts"; import type * as Closed from "./kio.Closed.ts"; import * as Park from "./kio.Park.ts"; import type * as Waiter from "./kio.Waiter.ts"; @@ -39,6 +39,10 @@ export function new$closed_closure0_closure0(inner: (a0: Waiter.Waiter) => rt.Po return new Pending({ inner, park: Park.default$Default() }); } +export function new$front_closure0_closure0(inner: (a0: Waiter.Waiter) => rt.Poll): Pending<(a0: Waiter.Waiter) => rt.Poll> { + return new Pending({ inner, park: Park.default$Default() }); +} + export function new$recv_closure0_closure0(inner: (a0: Waiter.Waiter) => rt.Poll): Pending<(a0: Waiter.Waiter) => rt.Poll> { return new Pending({ inner, park: Park.default$Default() }); } @@ -85,6 +89,12 @@ export function poll$Future_closed_closure0_closure0(self: Pending<(a0: Waiter.W return poll$Task_closed_closure0_closure0(this_.inner, waiter); } +export function poll$Future_front_closure0_closure0(self: Pending<(a0: Waiter.Waiter) => rt.Poll>, cx: rt.Context): rt.Poll { + const this_: Pending<(a0: Waiter.Waiter) => rt.Poll> = self; + const waiter: Waiter.Waiter = Park.hold(this_.park, cx); + return poll$Task_front_closure0_closure0(this_.inner, waiter); +} + export function poll$Future_recv_closure0_closure0(self: Pending<(a0: Waiter.Waiter) => rt.Poll>, cx: rt.Context): rt.Poll { const this_: Pending<(a0: Waiter.Waiter) => rt.Poll> = self; const waiter: Waiter.Waiter = Park.hold(this_.park, cx); diff --git a/ts/fixtures/task/expected/kio.ts b/ts/fixtures/task/expected/kio.ts index ed699f4c7..7ea194afc 100644 --- a/ts/fixtures/task/expected/kio.ts +++ b/ts/fixtures/task/expected/kio.ts @@ -18,6 +18,10 @@ export function poll$Task_closed_closure0_closure0(self: (a0: Waiter.Waiter) => return self(waiter); } +export function poll$Task_front_closure0_closure0(self: (a0: Waiter.Waiter) => rt.Poll, waiter: Waiter.Waiter): rt.Poll { + return self(waiter); +} + export function poll$Task_recv_closure0_closure0(self: (a0: Waiter.Waiter) => rt.Poll, waiter: Waiter.Waiter): rt.Poll { return self(waiter); } @@ -45,6 +49,11 @@ export function wait$closed_closure0_closure0_unit(poll: (a0: Waiter.Waiter) => return Pending.new$closed_closure0_closure0(poll); } +/** A future from a poll function that receives a [`Waiter`]. */ +export function wait$front_closure0_closure0_usize(poll: (a0: Waiter.Waiter) => rt.Poll): Pending.Pending<(a0: Waiter.Waiter) => rt.Poll> { + return Pending.new$front_closure0_closure0(poll); +} + /** A future from a poll function that receives a [`Waiter`]. */ export function wait$recv_closure0_closure0_Option_u64(poll: (a0: Waiter.Waiter) => rt.Poll): Pending.Pending<(a0: Waiter.Waiter) => rt.Poll> { return Pending.new$recv_closure0_closure0(poll); diff --git a/ts/fixtures/task/expected/model.Listing.ts b/ts/fixtures/task/expected/model.Listing.ts new file mode 100644 index 000000000..0be10b3c2 --- /dev/null +++ b/ts/fixtures/task/expected/model.Listing.ts @@ -0,0 +1,26 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; + +export function default$Default(): Listing { + const _1: rt.u64 | undefined = undefined; + const _2: rt.u64[] = []; + return { last: _1, listed: _2 }; +} + +export function fmt$Debug(self: Listing, f: rt.Formatter): rt.Result { + const _3: string = "Listing"; + const _4: string = "last"; + const _5: rt.Fmt = (f: rt.Formatter) => rt.fmtOption(self.last, f, rt.u64Debug); + const _7: string = "listed"; + const _8: rt.Fmt = (f: rt.Formatter) => rt.fmtList(self.listed, f, rt.u64Debug); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); +} + +/** What [`front`] lists. */ +export interface Listing { + last: rt.u64 | undefined; + listed: rt.u64[]; +} + +//# sourceMappingURL=model.Listing.ts.map diff --git a/ts/fixtures/task/expected/model.ts b/ts/fixtures/task/expected/model.ts index bdb26ce3a..ed8ef8b78 100644 --- a/ts/fixtures/task/expected/model.ts +++ b/ts/fixtures/task/expected/model.ts @@ -4,7 +4,7 @@ import * as rt from "./rt.ts"; import { copy$Tally, drop$ControlFlow_Guard_u32, drop$Result_u32_Guard } from "./lib.ts"; import { unwrapOr$Option_u64, map$Option_u64_Result_u64_u64_streamed_closure0_closure0 } from "./core/option.ts"; import { map$Poll_Option_u64_Option_Result_u64_u64_streamed_closure0, map$Poll_u64_Option_u64_Some, isReady$Poll_unit, isPending$Poll_Option_u64 } from "./core/task/poll.ts"; -import { wait$watch_closure0_closure0_Option_u64, waitFuture$watch_closure0_closure1_usize, closedFuture, recvFuture } from "./kio.ts"; +import { wait$front_closure0_closure0_usize, wait$watch_closure0_closure0_Option_u64, waitFuture$watch_closure0_closure1_usize, closedFuture, recvFuture } from "./kio.ts"; import * as Closed from "./kio.Closed.ts"; import * as Consumer from "./kio.Consumer.ts"; import * as Pending from "./kio.Pending.ts"; @@ -13,6 +13,7 @@ import * as Log from "./log.Log.ts"; import * as Countdown from "./model.Countdown.ts"; import * as Guard from "./model.Guard.ts"; import * as Inner from "./model.Inner.ts"; +import * as Listing from "./model.Listing.ts"; import type * as Mark from "./model.Mark.ts"; import * as Outer from "./model.Outer.ts"; import type * as Tally from "./model.Tally.ts"; @@ -297,6 +298,157 @@ export class watchFuture { } } +/** + * moq's front: a listing a crate type's default fills in place between awaits, and + * values held in flight in a `Vec` that a `kio::wait` closure takes and refills on each + * poll, halving each until it is zero. The caller reads both after. + */ +export function front(rx: Consumer.Consumer, guard: Guard.Guard): rt.Future { + return new frontFuture(rx, guard); +} + +export class frontFuture { + #state: number = 0; + #rx: Consumer.Consumer; + #guard: Guard.Guard; + #listing!: Listing.Listing | undefined; + #inFlight!: rt.u64[]; + #awaitee!: rt.Future; + #awaitee$2!: Pending.Pending<(a0: Waiter.Waiter) => rt.Poll>; + + constructor(rx: Consumer.Consumer, guard: Guard.Guard) { + this.#rx = rx; + this.#guard = guard; + } + + [Symbol.dispose](): void { + if (this.#state === 0) { + rt.drop(this.#rx); + rt.drop(this.#guard); + return; + } + if (this.#state === 3) { + rt.drop(this.#awaitee); + } else if (this.#state === 4) { + rt.drop(this.#awaitee$2); + } else { + return; + } + rt.drop(this.#guard); + rt.drop(this.#rx); + } + + poll(_2: rt.Context): rt.Poll { + let value!: rt.u64; + let bb0: number = 0; + while (true) { + switch (bb0) { + case 0: + if (this.#state === 0) { + this.#listing = undefined as Listing.Listing | undefined; + this.#inFlight = []; + bb0 = 1; + continue; + } + if (this.#state === 1) { + rt.asyncFnResumed(); + } else { + if (this.#state === 3) { + bb0 = 4; + continue; + } + bb0 = 30; + continue; + } + case 1: + this.#awaitee = new recvFuture(this.#rx); + bb0 = 4; + continue; + case 4: + const _6: rt.Poll = this.#awaitee.poll(_2); + if (_6 !== rt.Pending) { + const result: rt.u64 | undefined = _6; + rt.drop(this.#awaitee); + if (result !== undefined) { + value = result; + if (!(rt.u64Rem(value, 3) === 0)) { + if (this.#listing === undefined) { + this.#listing = Listing.default$Default(); + } + (this.#listing as Listing.Listing).last = value; + (this.#listing as Listing.Listing).listed.push(value); + this.#inFlight.push(value); + if (!(rt.u64Rem(value, 3) === 2)) { + bb0 = 1; + continue; + } + bb0 = 20; + continue; + } + this.#listing = undefined; + bb0 = 1; + continue; + } + bb0 = 20; + continue; + } + this.#state = 3; + return rt.Pending; + case 20: + const arg = this.#listing; + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(arg, f, (value: Listing.Listing, f: rt.Formatter) => Listing.fmt$Debug(value, f))]; + const _32: string = rt.fmtFormat(["listing ", args2[0]]); + Guard.note(this.#guard, _32); + this.#awaitee$2 = wait$front_closure0_closure0_usize((waiter: Waiter.Waiter): rt.Poll => { + while (true) { + const _42: rt.Poll = Consumer.pollRecv(this.#rx, waiter); + if (_42 !== rt.Pending) { + const next: rt.u64 | undefined = _42; + if (next === undefined) { + return this.#inFlight.length; + } + this.#inFlight.push(next); + } else { + break; + } + } + const taken = this.#inFlight; + this.#inFlight = []; + for (const _15 of taken) { + const half: rt.u64 = rt.u64Div(_15, 2); + if (half === 0) { + Guard.note(this.#guard, "released"); + } else { + this.#inFlight.push(half); + } + } + return rt.Pending; + }); + bb0 = 30; + continue; + case 30: + const _50: rt.Poll = Pending.poll$Future_front_closure0_closure0(this.#awaitee$2, _2); + if (_50 !== rt.Pending) { + const closed: rt.usize = _50; + rt.drop(this.#awaitee$2); + const _69: rt.Fmt = (f: rt.Formatter) => rt.usizeDisplay(closed, f); + const arg2 = this.#inFlight; + const args4: rt.Fmt[] = [_69, (f: rt.Formatter) => rt.fmtList(arg2, f, rt.u64Debug)]; + const _60: string = rt.fmtFormat(["closed with ", args4[0], " in flight ", args4[1]]); + Guard.note(this.#guard, _60); + const _79: rt.u64 = rt.iterSum(rt.iterSlice(this.#inFlight), rt.u64Add, 0); + rt.drop(this.#guard); + rt.drop(this.#rx); + this.#state = 1; + return _79; + } + this.#state = 4; + return rt.Pending; + } + } + } +} + /** * `polled` as a stream's `poll_next` returns it, erring on a value of 3 modulo 4, then * back through `?`, which continues with its `Pending` and `Ready(None)`. diff --git a/ts/fixtures/task/src/harness.rs b/ts/fixtures/task/src/harness.rs index 859395222..ce1d6be46 100644 --- a/ts/fixtures/task/src/harness.rs +++ b/ts/fixtures/task/src/harness.rs @@ -135,6 +135,12 @@ fn steps() -> Vec<(&'static str, Step)> { exec.spawn(model::watch(channels[c].consumer(), guard)); } }), + ("front", |log, exec, channels, arg| { + if let Some(c) = pick(channels.len(), arg) { + let guard = Guard::new(exec.len() as u32, log.clone()); + exec.spawn(model::front(channels[c].consumer(), guard)); + } + }), ] } diff --git a/ts/fixtures/task/src/model.rs b/ts/fixtures/task/src/model.rs index 9013e291a..513630c63 100644 --- a/ts/fixtures/task/src/model.rs +++ b/ts/fixtures/task/src/model.rs @@ -143,6 +143,53 @@ pub async fn watch(mut rx: Consumer, guard: Guard) -> u64 { total } +/// moq's front: a listing a crate type's default fills in place between awaits, and +/// values held in flight in a `Vec` that a `kio::wait` closure takes and refills on each +/// poll, halving each until it is zero. The caller reads both after. +pub async fn front(mut rx: Consumer, guard: Guard) -> u64 { + let mut listing: Option = None; + let mut in_flight: Vec = Vec::new(); + while let Some(value) = rx.recv().await { + if value % 3 == 0 { + listing = None; + continue; + } + let state = listing.get_or_insert_default(); + state.last = Some(value); + state.listed.push(value); + in_flight.push(value); + if value % 3 == 2 { + break; + } + } + guard.note(&format!("listing {listing:?}")); + let closed = kio::wait(|waiter| { + while let Poll::Ready(next) = rx.poll_recv(waiter) { + match next { + Some(value) => in_flight.push(value), + None => return Poll::Ready(in_flight.len()), + } + } + for value in std::mem::take(&mut in_flight) { + match value / 2 { + 0 => guard.note("released"), + half => in_flight.push(half), + } + } + Poll::Pending + }) + .await; + guard.note(&format!("closed with {closed} in flight {in_flight:?}")); + in_flight.iter().sum() +} + +/// What [`front`] lists. +#[derive(Default, Debug)] +struct Listing { + last: Option, + listed: Vec, +} + /// The value at `index` of a channel, read by [`at`]. struct Watch { rx: Consumer, diff --git a/ts/fixtures/task/ts.toml b/ts/fixtures/task/ts.toml index b5a566c29..79b2ab1af 100644 --- a/ts/fixtures/task/ts.toml +++ b/ts/fixtures/task/ts.toml @@ -9,6 +9,7 @@ roots = [ "model::drain", "model::blocks", "model::watch", + "model::front", "drops::run", "drops::held", "drops::edited", diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index 8a53b451a..587871117 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -835,9 +835,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } let deref = self.tcx.mk_place_deref(*place); match &self.slots[place.local] { - Slot::Alias(Some(target)) - if (target.is_path() || matches!(target, Expr::Index(..))) && self.alias_of_place(place.local) => - { + Slot::Alias(Some(target)) if assignable(target) && self.alias_of_place(place.local) => { Some((target.clone(), Some(deref))) } _ if self.b.t.place_pointee(self.mir.local_decls[place.local].ty).is_some() => { @@ -885,6 +883,8 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let Some(payload) = payload else { return Some(Some((target, true))); }; + // The test reads it before either branch, so what it reads is set before both. + self.materialize(&target, out); let whole = tcx.mk_place_deref(args[0].node.place()?); let option_ty = whole.ty(&self.mir.local_decls, tcx).ty; // What it inserts, made before the `Option` is read, as Rust makes the argument. @@ -915,7 +915,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } value } - "get_or_insert_default" => library::default_value(self.b, payload_ty, span, &mut then)?, + "get_or_insert_default" => self.default_of(payload_ty, span, &mut then), _ => { let f_ty = args[1].node.ty(&self.mir.local_decls, tcx); if let ty::FnDef(f, f_args) = *f_ty.kind() { @@ -1295,3 +1295,12 @@ fn continued(ty: Ty<'_>) -> Ty<'_> { _ => unreachable!("checked by the caller"), } } + +/// Whether an assignment can write `e`: a path, an element, or a member of one. +fn assignable(e: &Expr) -> bool { + match e { + Expr::Index(..) => true, + Expr::Member(base, _) | Expr::Located(_, base) => assignable(base), + e => e.is_path(), + } +} diff --git a/ts/src/lower/mir/mod.rs b/ts/src/lower/mir/mod.rs index 906356000..bf4d1c450 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -158,7 +158,8 @@ pub enum Env { pub struct Capture { pub value: Expr, /// Whether `value` is the place a `&mut` captured by reference borrows, which the - /// closure reads and writes as JS's do, rather than an `rt.Place` of it. + /// closure reads and writes as JS's do, rather than an `rt.Place` of it or the object + /// there. pub pointee: bool, } diff --git a/ts/src/lower/mir/place.rs b/ts/src/lower/mir/place.rs index 15bec637f..c179a5dbe 100644 --- a/ts/src/lower/mir/place.rs +++ b/ts/src/lower/mir/place.rs @@ -94,8 +94,9 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { projection.next(); value } - // Passed on or kept whole, it is the place's `rt.Place`. - None if pointee => self.place_of(value, None), + // Passed on or kept whole, it is the place's `rt.Place`, or the + // object there. + None if pointee && self.b.t.place_pointee(pty.ty).is_some() => self.place_of(value, None), _ => value, } } diff --git a/ts/src/lower/mir/rvalue.rs b/ts/src/lower/mir/rvalue.rs index 904a51171..9aca67afa 100644 --- a/ts/src/lower/mir/rvalue.rs +++ b/ts/src/lower/mir/rvalue.rs @@ -597,9 +597,11 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let mut captures = Vec::with_capacity(ops.len()); for (field, op) in ops.iter_enumerated() { let ty = op.ty(&self.mir.local_decls, tcx); - // A `&mut` to a borrowed place the closure reads and writes as a JS closure does. + // A `&mut` to a borrowed place the closure reads and writes as a JS closure does, + // so it can replace an object there whole, as `mem::take` does. if let Some(local) = op.place().and_then(|p| p.as_local()) - && self.points_at_place(local) + && matches!(ty.kind(), ty::Ref(_, _, rustc_ast::Mutability::Mut)) + && self.alias_of_place(local) && let Slot::Alias(Some(target)) = &self.slots[local] { captures.push(Capture { diff --git a/ts/tests/fixtures.rs b/ts/tests/fixtures.rs index ba7a7fa26..51405949e 100644 --- a/ts/tests/fixtures.rs +++ b/ts/tests/fixtures.rs @@ -418,13 +418,13 @@ fn task_differential(out: &Path) { import * as Log from "./log.Log.ts"; import * as Channel from "./model.Channel.ts"; import * as Guard from "./model.Guard.ts"; -import {{ blocks, drain, sum, watch }} from "./model.ts"; +import {{ blocks, drain, front, sum, watch }} from "./model.ts"; import * as drops from "./drops.ts"; import * as futures from "./futures.ts"; import {{ harness }} from {harness:?}; export {{ cases, steps }} from {harness:?}; -const fixture = {{ Pending: rt.Pending, u64: {{ of: rt.u64Of }}, Log, Channel, Guard, sum, drain, blocks, watch, drops, futures }}; +const fixture = {{ Pending: rt.Pending, u64: {{ of: rt.u64Of }}, Log, Channel, Guard, sum, drain, blocks, watch, front, drops, futures }}; const script = harness(fixture); export const run = (input: rt.ByteSlice) => script(rt.byteSliceView(input)); "# diff --git a/ts/tests/task.ts b/ts/tests/task.ts index 2cc63d6e0..ca763fe4b 100644 --- a/ts/tests/task.ts +++ b/ts/tests/task.ts @@ -47,6 +47,7 @@ export interface Fixture { drain(rx: Consumer, depth: number): Future; blocks(rx: Consumer, guard: Guard, moves: boolean): Future; watch(rx: Consumer, guard: Guard): Future; + front(rx: Consumer, guard: Guard): Future; drops: { run(log: Log, id: number, arg: number): void; held(rx: Consumer, guard: Guard): Future; @@ -301,6 +302,13 @@ export const steps: [string, (r: Run, arg: number) => void][] = [ if (c !== undefined) r.exec.spawn(r.f.watch(r.f.Channel.consumer(r.channels[c]), guard(r))); }, ], + [ + "front", + (r, arg) => { + const c = pick(r.channels.length, arg); + if (c !== undefined) r.exec.spawn(r.f.front(r.f.Channel.consumer(r.channels[c]), guard(r))); + }, + ], ]; /** The script runner, as `harness.rs` runs it natively. */ @@ -371,6 +379,10 @@ export const cases: Uint8Array[] = [ script(["open", 0], ["watch", 0], ["run", 0], ["send", 3], ["run", 0], ["send", 4], ["run", 0], ["send", 7], ["run", 0], ["close", 0], ["run", 0]), script(["open", 0], ["watch", 0], ["run", 0], ["send", 1], ["run", 0], ["send", 2], ["run", 0], ["close", 0], ["run", 0]), script(["open", 0], ["watch", 0], ["watch", 0], ["run", 0], ["send", 6], ["step", 0], ["send", 8], ["drop", 1], ["run", 0], ["drop", 0]), + // moq's front: a listing filled in place and reset, then values in flight that a + // closure takes and refills each poll, read after it returns; and cancelled mid-wait. + script(["open", 0], ["front", 0], ["run", 0], ["send", 4], ["send", 3], ["send", 7], ["send", 9], ["send", 5], ["run", 0], ["send", 6], ["run", 0], ["send", 1], ["step", 0], ["close", 0], ["run", 0]), + script(["open", 0], ["front", 0], ["front", 0], ["run", 0], ["send", 2], ["run", 0], ["send", 8], ["step", 0], ["drop", 1], ["run", 0], ["drop", 0]), // Each scenario of values std holds that drop. ...Array.from({ length: 15 }, (_, arg) => script(["drops", arg])), // Each of a `Vec`'s edits, its, a tuple's, and a box's `clone`, and `Ord`'s defaults.