From d5427f9a0a078580b26ed5433b363094e4d3520c Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Mon, 2 Nov 2026 06:22:21 -0800 Subject: [PATCH 01/10] chore(quest): claim quest/m3/ts-deque-slices.md Quest-Claim: 04f3bbe59176fd21 From b33b14fa19ccb4bfd21beb16bf5743f728e3df24 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Mon, 2 Nov 2026 07:36:59 -0800 Subject: [PATCH 02/10] feat(ts): split a deque's slices where std's are, and translate their Debug Co-Authored-By: Claude Opus 5.5 --- quest/m3/README.md | 3 +- quest/m3/ts-constant-compares.md | 18 + quest/m3/ts-deque-slices.md | 29 - quest/m3/ts-vec-exact-capacity.md | 24 + ts/MIGRATE.md | 16 +- ts/README.md | 10 +- ts/fixtures/lang/caller.ts | 13 +- ts/fixtures/lang/expected/bounds.ts | 2 +- ts/fixtures/lang/expected/boxes.ts | 14 +- ts/fixtures/lang/expected/capacity.ts | 625 +++++----- ts/fixtures/lang/expected/clones.ts | 8 +- ts/fixtures/lang/expected/collections.ts | 66 +- ts/fixtures/lang/expected/cows.ts | 4 +- ts/fixtures/lang/expected/edits.ts | 28 +- ts/fixtures/lang/expected/fmt.ts | 17 +- ts/fixtures/lang/expected/harness.ts | 3 + ts/fixtures/lang/expected/hints.ts | 183 +-- ts/fixtures/lang/expected/joins.ts | 14 +- ts/fixtures/lang/expected/keys.ts | 14 +- ts/fixtures/lang/expected/nested.ts | 6 +- ts/fixtures/lang/expected/objects.ts | 5 +- ts/fixtures/lang/expected/orders.ts | 10 +- ts/fixtures/lang/expected/refs.ts | 4 +- ts/fixtures/lang/expected/rings.Big.ts | 30 + ts/fixtures/lang/expected/rings.ts | 1337 ++++++++++++++++++++++ ts/fixtures/lang/expected/tuples.ts | 20 +- ts/fixtures/lang/expected/wrappers.ts | 2 +- ts/fixtures/lang/src/capacity.rs | 76 +- ts/fixtures/lang/src/harness.rs | 3 +- ts/fixtures/lang/src/lib.rs | 1 + ts/fixtures/lang/src/rings.rs | 255 +++++ ts/runtime/rt/collections.ts | 538 +++++++-- ts/runtime/rt/iter.ts | 4 +- ts/src/lower/collections.rs | 85 +- ts/src/lower/drop.rs | 9 +- ts/src/lower/fmt.rs | 14 +- ts/src/lower/mir/call.rs | 6 +- 37 files changed, 2694 insertions(+), 802 deletions(-) create mode 100644 quest/m3/ts-constant-compares.md delete mode 100644 quest/m3/ts-deque-slices.md create mode 100644 quest/m3/ts-vec-exact-capacity.md create mode 100644 ts/fixtures/lang/expected/rings.Big.ts create mode 100644 ts/fixtures/lang/expected/rings.ts create mode 100644 ts/fixtures/lang/src/rings.rs diff --git a/quest/m3/README.md b/quest/m3/README.md index 5c3286027..c40c0a647 100644 --- a/quest/m3/README.md +++ b/quest/m3/README.md @@ -25,7 +25,8 @@ generic std gap is planned here even when moq never calls it. - [A slice's searches by a closure](/quest/m3/ts-binary-search-by.md) - `binary_search_by`, `binary_search_by_key`, and `partition_point` translate, probing as std's do - [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 +- [A comparison of two constants](/quest/m3/ts-constant-compares.md) - `size_of::() == 1` in a generic function translates to TypeScript `tsc` accepts +- [A vector's exact capacity as it shrinks](/quest/m3/ts-vec-exact-capacity.md) - a deque made from a `Vec` splits its slices where std's does - [Comparing places](/quest/m3/ts-place-compares.md) - `a.iter_mut().eq(&mut b)` and its orderings compare the values places lend - [std::iter::zip](/quest/m3/ts-iter-zip.md) - the free `zip` translates as `Iterator::zip` does - [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 diff --git a/quest/m3/ts-constant-compares.md b/quest/m3/ts-constant-compares.md new file mode 100644 index 000000000..7f3e67e24 --- /dev/null +++ b/quest/m3/ts-constant-compares.md @@ -0,0 +1,18 @@ +# [S] A comparison of two constants + +## Goal + +[rust2-ts](/ts/README.md) translates a comparison whose sides are both constants once a +generic function is monomorphized, such as `size_of::() == 1` in a function generic +over `T`, into TypeScript `tsc` accepts, proven by a fixture that runs it for a `T` of each +outcome against native Rust. + +## Plan + +Found writing the deque's slices fixture +([moq-dev/rust2#443](https://github.com/moq-dev/rust2/pull/443)): each instance writes +`12 === 1`, which `tsc` rejects as TS2367, two literal types with no overlap, so the +crate fails to translate. Fold the comparison to its value, or widen a side, where both are +literals. + +Public API: the translator's output. diff --git a/quest/m3/ts-deque-slices.md b/quest/m3/ts-deque-slices.md deleted file mode 100644 index 89405b040..000000000 --- a/quest/m3/ts-deque-slices.md +++ /dev/null @@ -1,29 +0,0 @@ -# [M] A deque's two slices - -## Goal - -[rust2-ts](/ts/README.md) translates `VecDeque::as_slices` and `as_mut_slices`, and `{:?}` -of `vec_deque::Iter`, `IterMut`, and `Drain`, writing the same text as std, proven by -differential tests against native Rust on wrapped deques. - -## Plan - -Left by [moq-dev/rust2#317](https://github.com/moq-dev/rust2/pull/317), which translated -the rest of std's iterators' `Debug`. - -- `Iter` and `IterMut` write the two slices of the ring buffer as `as_slices` splits it: - `Iter([3], [1, 2])`, each half as consumed so far, the second taking the first's place - once it empties (`vec_deque/iter.rs`). The split depends on the buffer's capacity and - where its head sits. -- The runtime's deque does not split where std's does: it grows to a power of two of at - least 4 and moves its head to 0, ignores `with_capacity`, and shifts items one at a time - in `insert` and `remove`. std keeps `RawVec`'s capacity, moves the shorter segment as it - grows (`handle_capacity_increase`), and moves the shorter side in `insert`, `remove`, and - the rest. Every function that places items must place them where std's does. -- Open: a deque holds only what std guarantees of its capacity, doubling as it grows - (decided 2026-11-01 to keep pushes cheap), so splitting where std's does needs its exact - capacity, at a cost to measure, or the maintainer's call to drop the split. -- `Drain` writes its counts, `Drain(drain_len, idx, tail_len, remaining)`, which the - runtime's drain does not keep. - -Public API: the translator's output. diff --git a/quest/m3/ts-vec-exact-capacity.md b/quest/m3/ts-vec-exact-capacity.md new file mode 100644 index 000000000..9b1477d8c --- /dev/null +++ b/quest/m3/ts-vec-exact-capacity.md @@ -0,0 +1,24 @@ +# [M] A vector's exact capacity as it shrinks + +## Goal + +[rust2-ts](/ts/README.md) holds a `Vec`'s exact capacity through every step, as it now +does a `VecDeque`'s, so a deque made from a `Vec` splits its slices where std's does, +proven by differential tests against native Rust. + +## Plan + +Found splitting a deque's slices where std's does +([moq-dev/rust2#443](https://github.com/moq-dev/rust2/pull/443)): a deque now holds std's +exact capacity, but one made from a `Vec`, by `From>` or by `collect`, takes the +capacity the runtime models for the `Vec`, which holds only std's guarantees (decided +2026-11-01) and so recomputes from its length after a pop, `truncate`, or `drain`. A +`Vec`'s `into_iter` also reads a view of its bytes, which leaves the capacity behind, +so `collect` into a deque cannot keep std's buffer and head. + +- Record the capacity where a step shrinks the length, and measure its cost on pops with + the codec's [TS benchmark](/ts/README.md#bench). +- Carry a `Vec`'s capacity into its `into_iter`. +- Needs the maintainer's call against the 2026-11-01 decision. + +Public API: the translator's output. diff --git a/ts/MIGRATE.md b/ts/MIGRATE.md index 439d9cade..9f90672ec 100644 --- a/ts/MIGRATE.md +++ b/ts/MIGRATE.md @@ -2,11 +2,17 @@ ## Unreleased -- `rt.vecCapacity`, `rt.vecReserve`, `rt.vecReserveExact`, and `rt.dequeReserve` are now - `Vec::capacity`, `reserve`, and `reserve_exact` and `VecDeque::reserve` of a vector, its - element size in bytes last, as in `rt.vecReserve(v, additional, 4)`, not the arithmetic - an extend reserved by; `rt.vecPush` and `rt.vecGrow` are gone. `rt.dequeClone` and - `rt.heapClone` take the element size after the clone function. +- `rt.vecCapacity`, `rt.vecReserve`, and `rt.vecReserveExact` are now `Vec::capacity`, + `reserve`, and `reserve_exact` of a vector, its element size in bytes last, as in + `rt.vecReserve(v, additional, 4)`, not the arithmetic an extend reserved by; + `rt.vecPush` and `rt.vecGrow` are gone. `rt.heapClone` takes the element size after the + clone function. +- An `rt.VecDeque` holds std's capacity as its buffer's length and its item size as `s`, + and a deque of bytes is a `Uint8Array`: `rt.dequeNew`, `rt.dequeWithCapacity`, and + `rt.dequeFromVec` take the item size and whether it holds bytes, as in + `rt.dequeNew(4)`, and `rt.dequeCapacity`, `rt.dequeReserve`, `rt.dequeReserveExact`, + `rt.dequeShrinkTo`, `rt.dequeClone`, `rt.dequeExtend`, and `rt.dequePart` no longer take + it. `rt.dequeIter` no longer takes a dropper: `rt.dequeIntoIter` is `into_iter`. - Every translation needs `tsc` 7.0 or later on `PATH`, not only one with bindings: it type-checks the output, and fails at the Rust span of each error, where it succeeded before. diff --git a/ts/README.md b/ts/README.md index cadf317f4..83e369e77 100644 --- a/ts/README.md +++ b/ts/README.md @@ -247,9 +247,9 @@ what each holds. `Debug` of a string or `char` escapes by std's Unicode tables, which the runtime carries, not the engine's. `Debug` of std's collections writes their items in the order each iterates, a hash map's or set's included, and of their iterators and `Chars` the items each has left, in std's wrapper; a deque's -`Iter` and `IterMut`, which write its buffer's two halves, and its `Drain`, which writes its -counts, are refused; a list's `Iter` and `IterMut` write what is left and its length, as -std's do. `Debug` of `Bound`, `Ordering`, `Reverse`, and `ControlFlow` is +`Iter` and `IterMut` write the two slices of its buffer they have left, swapped as std's +swap them, and its `Drain` its counts; a list's `Iter` and `IterMut` write what is left and +its length, as std's do. `Debug` of `Bound`, `Ordering`, `Reverse`, and `ControlFlow` is their derived one, whichever way each is held, and a guard of a cell or a lock, mapped or not, writes what it lends by its own `Debug` and `Display`. A caller prints a `printable` type as `to_string()` and `format!("{err:?}")` @@ -780,7 +780,9 @@ they need. with the maintainer on 2026-11-01). It holds one, as `cap`, only where an operation sets it or a removal reads it, so an insert never reads or writes one, and reading it doubles it from 3 while short of the length. `VecDeque` is a ring buffer over an array - whose length is a power of two. A `Vec`, `VecDeque`, and `BinaryHeap` hold what std + whose length is std's capacity, a `Uint8Array` of bytes, and each step places its items + where std's does, so `as_slices` splits them as std's; one made from a `Vec` takes the + capacity held for the `Vec`. A `Vec` and `BinaryHeap` hold what std guarantees of their capacity: at least their length and what `with_capacity`, `reserve`, and `reserve_exact` ask for, and std's exactly where its doubling fixes it, as through pushes. `clone_from` and `clone_into`, of which std guarantees only the diff --git a/ts/fixtures/lang/caller.ts b/ts/fixtures/lang/caller.ts index 5e12e45c1..a54738350 100644 --- a/ts/fixtures/lang/caller.ts +++ b/ts/fixtures/lang/caller.ts @@ -864,4 +864,15 @@ const capacityCases = [ ...Array.from({ length: 8 * 6 }, (_, i) => Uint8Array.of(...op("capacity::collects"), i % 8, [0, 1, 2, 5, 9, 23][Math.floor(i / 8)], 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)), ]; -export const cases: Uint8Array[] = [...loops, ...durations, ...ints(), ...utf8, ...floats, ...formats, ...parsed, ...singlesCases, ...singlesFormats, ...singlesParsed, ...dyns, ...cells, ...shared, ...locks, ...guards, ...maps, ...mappedLocks, ...relocks, ...tries, ...mutexMaps, ...printed, ...downgrades, ...leaks, ...rwlocks, ...onces, ...bounds, ...unsafeCells, ...edits, ...subslices, ...consumers, ...closures, ...elements, ...ranges, ...reducers, ...sliceEdits, ...drains, ...iters, ...hinted, ...peekedOthers, ...hints, ...reserves, ...setOps, ...zeros, ...writes, ...floatsMulAdds, ...singlesMulAdds, ...unlikeEqs, ...ownNes, ...rangeFroms, ...compares, ...unlikeCompares, ...rangeMethods, ...wraps(), ...refOrders, ...saturates(), ...methods(), ...separated, ...asciiCases, ...gets, ...capacityCases]; +/** + * `rings::slices` of each item type, from a deque made by `new`, `with_capacity` of 5, and + * from a `Vec` of 7: pushed at both ends and popped at the front to wrap it, past a few + * capacities, then each step by a few arguments, twice. + */ +const ringsCases = Array.from({ length: 5 * 3 * 4 * 24 * 3 }, (_, i) => { + const [kind, first, wraps, step, arg] = [i % 5, [0, 0x15, 0x1e][Math.floor(i / 5) % 3], [1, 3, 6, 10][Math.floor(i / 15) % 4], Math.floor(i / 60) % 24, [0, 0x5b, 0xe7][Math.floor(i / 1440)]]; + const wrap = Array.from({ length: wraps }, (_, j) => [j % 3 === 2 ? 4 : 0, j * 3, 6, 0, 4, j]).flat(); + return Uint8Array.of(...op("rings::slices"), kind, first, ...wrap, step, arg, step, arg ^ 0x25); +}); + +export const cases: Uint8Array[] = [...loops, ...durations, ...ints(), ...utf8, ...floats, ...formats, ...parsed, ...singlesCases, ...singlesFormats, ...singlesParsed, ...dyns, ...cells, ...shared, ...locks, ...guards, ...maps, ...mappedLocks, ...relocks, ...tries, ...mutexMaps, ...printed, ...downgrades, ...leaks, ...rwlocks, ...onces, ...bounds, ...unsafeCells, ...edits, ...subslices, ...consumers, ...closures, ...elements, ...ranges, ...reducers, ...sliceEdits, ...drains, ...iters, ...hinted, ...peekedOthers, ...hints, ...reserves, ...setOps, ...zeros, ...writes, ...floatsMulAdds, ...singlesMulAdds, ...unlikeEqs, ...ownNes, ...rangeFroms, ...compares, ...unlikeCompares, ...rangeMethods, ...wraps(), ...refOrders, ...saturates(), ...methods(), ...separated, ...asciiCases, ...gets, ...capacityCases, ...ringsCases]; diff --git a/ts/fixtures/lang/expected/bounds.ts b/ts/fixtures/lang/expected/bounds.ts index 11be217b4..5fc1955b0 100644 --- a/ts/fixtures/lang/expected/bounds.ts +++ b/ts/fixtures/lang/expected/bounds.ts @@ -179,7 +179,7 @@ export function bounds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { flush(out); rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes2)), undefined, true); } else if (_28 === 2) { - const queue: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const queue: rt.VecDeque = rt.dequeNew(1) as rt.VecDeque; const iter2: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 4)))); while (true) { const _104: [rt.usize, rt.u8] | rt.Done = iter2.next(); diff --git a/ts/fixtures/lang/expected/boxes.ts b/ts/fixtures/lang/expected/boxes.ts index b5de1b696..13e878307 100644 --- a/ts/fixtures/lang/expected/boxes.ts +++ b/ts/fixtures/lang/expected/boxes.ts @@ -9,7 +9,7 @@ import { then$0ea5h05 } from "./core/bool.ts"; import { unwrapOr$1iemzn8 as option_unwrapOr$1iemzn8, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, unwrapOr$1j4op5y as option_unwrapOr$1j4op5y, unwrapOr$11c0we2 as option_unwrapOr$11c0we2, mapOr$1e4a1e0 as option_mapOr$1e4a1e0, asDeref$0w8at8i as option_asDeref$0w8at8i, asDeref$0w2m0zn as option_asDeref$0w2m0zn, asDeref$0avuzwv as option_asDeref$0avuzwv, flatten$08boupk as option_flatten$08boupk } from "./core/option.ts"; import { map$0nfi04k as result_map$0nfi04k, asDeref$1fldd5d as result_asDeref$1fldd5d, asDeref$04i8i5u as result_asDeref$04i8i5u, unwrapOr$0e4foht as result_unwrapOr$0e4foht, copied$0bbq7yi as result_copied$0bbq7yi } from "./core/result.ts"; import { put as fmt_put } from "./fmt.ts"; -import { text } from "./strs.ts"; +import { text as strs_text } from "./strs.ts"; /** Puts what was logged since the last flush, after a marker. */ export function flush(log: rt.RefCell, out: rt.ByteVec): void { @@ -410,7 +410,7 @@ export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(_634[1]).reverse()), undefined, true); } } else { - const s: string = text(data2); + const s: string = strs_text(data2); const fromRef4: string = s; const fromString: string = s; const into2: string = s; @@ -855,11 +855,11 @@ export function impls(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(_113[1]).reverse()), undefined, true); } let s: string[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data2, 0, half))), (_222: rt.u8): string => { - return text(rt.byteSliceFrom(Uint8Array.of(_222))); + return strs_text(rt.byteSliceFrom(Uint8Array.of(_222))); }), undefined, 12, true); const t: string[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data2, half, rt.usizeMul(half, 2)))), (_223: rt.u8): string => { const x11: rt.u8 = _223; - return text(rt.byteSliceFrom(Uint8Array.of(x11, x11))); + return strs_text(rt.byteSliceFrom(Uint8Array.of(x11, x11))); }), undefined, 12, true); s = rt.boxSliceCloneFrom(s, t); const _138: rt.Place | undefined = rt.sliceFirstMut(s); @@ -910,7 +910,7 @@ export function impls(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.dropAll(m); flush(log.value, out); let t2: string = "ab"; - t2 = text(data2); + t2 = strs_text(data2); fmt_put(out, t2); } else if (_23 === 1) { let a2: rt.ByteSlice = rt.byteSliceFrom(rt.byteSliceToArray(data2)); @@ -942,7 +942,7 @@ export function impls(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const v3: rt.ByteVec = rt.byteSliceToByteVec(data2); rt.byteVecPush(v3, 102); bytes(rt.byteVecSlice(v3), out); - let s2: string = text(data2); + let s2: string = strs_text(data2); s2 = s2 + "#"; fmt_put(out, s2); const w2: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_28: rt.u8): rt.u16 => { @@ -1019,7 +1019,7 @@ export function impls(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { drop$Result_boxed_Box_array1_boxes_Logged_boxed_Box_slice_boxes_Logged(r2); flush(log.value, out); } else { - const s3: string = text(data2); + const s3: string = strs_text(data2); const a6: rt.ByteSlice = rt.stringAsBytes(s3); rt.byteSliceView(a6).reverse(); bytes(a6, out); diff --git a/ts/fixtures/lang/expected/capacity.ts b/ts/fixtures/lang/expected/capacity.ts index 3ea560670..ea6960531 100644 --- a/ts/fixtures/lang/expected/capacity.ts +++ b/ts/fixtures/lang/expected/capacity.ts @@ -840,104 +840,86 @@ export function dequeSteps$array160_u64(dataData: Uint8Array, dataStart: number, if ((first & 1) === 1) { q = rt.dequeWithCapacity(first >> 3 as rt.usize, 1280) as rt.VecDeque; } else { - q = rt.dequeNew() as rt.VecDeque; + q = rt.dequeNew(1280) as rt.VecDeque; } - const k: Known.Known = Known.new(rt.dequeCapacity(q, 1280)); - put(out, rt.dequeCapacity(q, 1280)); + put(out, rt.dequeCapacity(q)); const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); while (true) { - const _27: rt.ByteSlice | rt.Done = iter.next(); - if (_27 === rt.DONE) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { break; } - rt.idx(_27, 0); - const _33: [rt.u8, rt.u8] = [_27.data[_27.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_27, 1), 0)]; - const op: rt.u8 = _33[0]; - const arg: rt.u8 = _33[1]; - const _42: rt.u8 = rt.u8Rem(op, 21); - if (_42 === 0) { + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + const _39: rt.u8 = rt.u8Rem(op, 21); + if (_39 === 0) { rt.dequePushBack(q, copy$array_u64(make(arg))); - } else if (_42 === 1) { + } else if (_39 === 1) { rt.dequePushFront(q, copy$array_u64(make(arg))); - } else if (_42 === 2) { + } else if (_39 === 2) { rt.dequePopFront(q); - Known.loose(k); - } else if (_42 === 3 || _42 === 4) { + } else if (_39 === 3 || _39 === 4) { const additional: rt.usize = amount(arg, q.n, size); if (rt.u8Rem(op, 21) === 3) { - rt.dequeReserve(q, additional, 1280); + rt.dequeReserve(q, additional); } else { - rt.dequeReserveExact(q, additional, 1280); + rt.dequeReserveExact(q, additional); } - Known.reserved(k, q.n, additional); - } else if (_42 === 5) { - rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize, 1280); - Known.shrunk(k, q.n, rt.u8Rem(arg, 40) as rt.usize); - } else if (_42 === 6) { - rt.dequeShrinkTo(q, 0, 1280); - Known.shrunk(k, q.n, 0); - k.exact = true; - } else if (_42 === 7) { + } else if (_39 === 5) { + rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize); + } else if (_39 === 6) { + rt.dequeShrinkTo(q, 0); + } else if (_39 === 7) { rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); - Known.loose(k); - } else if (_42 === 8) { + } else if (_39 === 8) { rt.dequeInsert(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), copy$array_u64(make(arg))); - } else if (_42 === 9) { + } else if (_39 === 9) { rt.dequeRemove(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1))); - Known.loose(k); - } else if (_42 === 10) { + } else if (_39 === 10) { rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { return rt.u8Rem(i, 3) !== 0; - }), make), "next", 1280); - } else if (_42 === 11) { - rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 1280, true); - } else if (_42 === 12) { + }), make), "next"); + } else if (_39 === 11) { + rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, true); + } else if (_39 === 12) { rt.dequeClear(q); - Known.loose(k); - } else if (_42 === 13) { + } else if (_39 === 13) { const keep: () => boolean = alternate(); - rt.dequeRetain(q, (_28: rt.u64[]): boolean => { + rt.dequeRetain(q, (_25: rt.u64[]): boolean => { return keep(); }); - Known.loose(k); - } else if (_42 === 14) { - rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) }); - Known.loose(k); - } else if (_42 === 15) { - q = rt.dequeClone(q, copy$array_u64, 1280); - Known.remade(k, true); - } else if (_42 === 16) { - q = rt.dequeFromVec(rt.iterToArray(rt.dequeIter(q), undefined, 1280, true)) as rt.VecDeque; - Known.remade(k, false); - } else if (_42 === 17) { - q = rt.dequeFromVec(rt.iterToArray(rt.dequeIter(q), undefined, 1280, true)) as rt.VecDeque; - Known.remade(k, false); - } else if (_42 === 18) { + } else if (_39 === 14) { + rt.drop(rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) })); + } else if (_39 === 15) { + q = rt.dequeClone(q, copy$array_u64); + } else if (_39 === 16) { + q = rt.dequeFromIntoIter(rt.dequeIntoIter(q), 1280) as rt.VecDeque; + } else if (_39 === 17) { + q = rt.dequeFromVec(rt.iterToArray(rt.dequeIntoIter(q), undefined, 1280, true), 1280) as rt.VecDeque; + } else if (_39 === 18) { const keep2: () => boolean = alternate(); - q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_26: rt.u64[]): boolean => { + q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIntoIter(q), (_23: rt.u64[]): boolean => { return keep2(); - }), "next", 1280)) as rt.VecDeque; - Known.remade(k, true); - } else if (_42 === 19) { - const it: rt.Iter = rt.dequeIter(q); - const _173: rt.u8 = rt.u8Rem(arg, 4); + }), "next", 1280), 1280) as rt.VecDeque; + } else if (_39 === 19) { + const it: rt.Iter = rt.dequeIntoIter(q); + const _127: rt.u8 = rt.u8Rem(arg, 4); let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _173; + const iterEnd: rt.u8 = _127; while (iterStart++ < iterEnd) { rt.iterToOption(it.next()); } - q = rt.dequeFromVec(rt.iterToArray(it.clone({ v: copy$array_u64 }), undefined, 1280, true)) as rt.VecDeque; - Known.remade(k, false); - const rest: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(it, undefined, 1280, true)) as rt.VecDeque; - Known.put({ exact: false, floor: 0 }, out, rest.n, rt.dequeCapacity(rest, 1280)); + q = rt.dequeFromIntoIter(it.clone({ v: copy$array_u64 }), 1280) as rt.VecDeque; + const rest: rt.VecDeque = rt.dequeFromIntoIter(it, 1280) as rt.VecDeque; + put(out, rest.n); + put(out, rt.dequeCapacity(rest)); } else { - const _196: rt.u64[][] = [copy$array_u64(make(arg)), copy$array_u64(make(arg)), copy$array_u64(make(arg))]; - q = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_196), undefined, 1280, true); - Known.remade(k, false); + q = rt.dequeFromArray([copy$array_u64(make(arg)), copy$array_u64(make(arg)), copy$array_u64(make(arg))], 1280) as rt.VecDeque; } - const _204: rt.usize = q.n; - const _206: rt.usize = rt.dequeCapacity(q, 1280); - Known.put(k, out, _204, _206); + put(out, q.n); + put(out, rt.dequeCapacity(q)); } } @@ -952,104 +934,86 @@ export function dequeSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number if ((first & 1) === 1) { q = rt.dequeWithCapacity(first >> 3 as rt.usize, 16) as rt.VecDeque<[rt.u64, rt.u8]>; } else { - q = rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>; + q = rt.dequeNew(16) as rt.VecDeque<[rt.u64, rt.u8]>; } - const k: Known.Known = Known.new(rt.dequeCapacity(q, 16)); - put(out, rt.dequeCapacity(q, 16)); + put(out, rt.dequeCapacity(q)); const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); while (true) { - const _27: rt.ByteSlice | rt.Done = iter.next(); - if (_27 === rt.DONE) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { break; } - rt.idx(_27, 0); - const _33: [rt.u8, rt.u8] = [_27.data[_27.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_27, 1), 0)]; - const op: rt.u8 = _33[0]; - const arg: rt.u8 = _33[1]; - const _42: rt.u8 = rt.u8Rem(op, 21); - if (_42 === 0) { + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + const _39: rt.u8 = rt.u8Rem(op, 21); + if (_39 === 0) { rt.dequePushBack(q, copy$tuple2_u64_u8(make(arg))); - } else if (_42 === 1) { + } else if (_39 === 1) { rt.dequePushFront(q, copy$tuple2_u64_u8(make(arg))); - } else if (_42 === 2) { + } else if (_39 === 2) { rt.dequePopFront(q); - Known.loose(k); - } else if (_42 === 3 || _42 === 4) { + } else if (_39 === 3 || _39 === 4) { const additional: rt.usize = amount(arg, q.n, size); if (rt.u8Rem(op, 21) === 3) { - rt.dequeReserve(q, additional, 16); + rt.dequeReserve(q, additional); } else { - rt.dequeReserveExact(q, additional, 16); + rt.dequeReserveExact(q, additional); } - Known.reserved(k, q.n, additional); - } else if (_42 === 5) { - rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize, 16); - Known.shrunk(k, q.n, rt.u8Rem(arg, 40) as rt.usize); - } else if (_42 === 6) { - rt.dequeShrinkTo(q, 0, 16); - Known.shrunk(k, q.n, 0); - k.exact = true; - } else if (_42 === 7) { + } else if (_39 === 5) { + rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize); + } else if (_39 === 6) { + rt.dequeShrinkTo(q, 0); + } else if (_39 === 7) { rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); - Known.loose(k); - } else if (_42 === 8) { + } else if (_39 === 8) { rt.dequeInsert(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), copy$tuple2_u64_u8(make(arg))); - } else if (_42 === 9) { + } else if (_39 === 9) { rt.dequeRemove(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1))); - Known.loose(k); - } else if (_42 === 10) { + } else if (_39 === 10) { rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { return rt.u8Rem(i, 3) !== 0; - }), make), "next", 16); - } else if (_42 === 11) { - rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 16, true); - } else if (_42 === 12) { + }), make), "next"); + } else if (_39 === 11) { + rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, true); + } else if (_39 === 12) { rt.dequeClear(q); - Known.loose(k); - } else if (_42 === 13) { + } else if (_39 === 13) { const keep: () => boolean = alternate(); - rt.dequeRetain(q, (_28: [rt.u64, rt.u8]): boolean => { + rt.dequeRetain(q, (_25: [rt.u64, rt.u8]): boolean => { return keep(); }); - Known.loose(k); - } else if (_42 === 14) { - rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) }); - Known.loose(k); - } else if (_42 === 15) { - q = rt.dequeClone(q, copy$tuple2_u64_u8, 16); - Known.remade(k, true); - } else if (_42 === 16) { - q = rt.dequeFromVec(rt.iterToArray(rt.dequeIter(q), undefined, 16, true)) as rt.VecDeque<[rt.u64, rt.u8]>; - Known.remade(k, false); - } else if (_42 === 17) { - q = rt.dequeFromVec(rt.iterToArray(rt.dequeIter(q), undefined, 16, true)) as rt.VecDeque<[rt.u64, rt.u8]>; - Known.remade(k, false); - } else if (_42 === 18) { + } else if (_39 === 14) { + rt.drop(rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) })); + } else if (_39 === 15) { + q = rt.dequeClone(q, copy$tuple2_u64_u8); + } else if (_39 === 16) { + q = rt.dequeFromIntoIter(rt.dequeIntoIter(q), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + } else if (_39 === 17) { + q = rt.dequeFromVec(rt.iterToArray(rt.dequeIntoIter(q), undefined, 16, true), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + } else if (_39 === 18) { const keep2: () => boolean = alternate(); - q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_26: [rt.u64, rt.u8]): boolean => { + q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIntoIter(q), (_23: [rt.u64, rt.u8]): boolean => { return keep2(); - }), "next", 16)) as rt.VecDeque<[rt.u64, rt.u8]>; - Known.remade(k, true); - } else if (_42 === 19) { - const it: rt.Iter<[rt.u64, rt.u8]> = rt.dequeIter(q); - const _173: rt.u8 = rt.u8Rem(arg, 4); + }), "next", 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + } else if (_39 === 19) { + const it: rt.Iter<[rt.u64, rt.u8]> = rt.dequeIntoIter(q); + const _127: rt.u8 = rt.u8Rem(arg, 4); let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _173; + const iterEnd: rt.u8 = _127; while (iterStart++ < iterEnd) { rt.iterToOption(it.next()); } - q = rt.dequeFromVec(rt.iterToArray(it.clone({ v: copy$tuple2_u64_u8 }), undefined, 16, true)) as rt.VecDeque<[rt.u64, rt.u8]>; - Known.remade(k, false); - const rest: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.iterToArray(it, undefined, 16, true)) as rt.VecDeque<[rt.u64, rt.u8]>; - Known.put({ exact: false, floor: 0 }, out, rest.n, rt.dequeCapacity(rest, 16)); + q = rt.dequeFromIntoIter(it.clone({ v: copy$tuple2_u64_u8 }), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + const rest: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromIntoIter(it, 16) as rt.VecDeque<[rt.u64, rt.u8]>; + put(out, rest.n); + put(out, rt.dequeCapacity(rest)); } else { - const _196: [rt.u64, rt.u8][] = [copy$tuple2_u64_u8(make(arg)), copy$tuple2_u64_u8(make(arg)), copy$tuple2_u64_u8(make(arg))]; - q = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, rt.iterSlice(_196), undefined, 16, true); - Known.remade(k, false); + q = rt.dequeFromArray([copy$tuple2_u64_u8(make(arg)), copy$tuple2_u64_u8(make(arg)), copy$tuple2_u64_u8(make(arg))], 16) as rt.VecDeque<[rt.u64, rt.u8]>; } - const _204: rt.usize = q.n; - const _206: rt.usize = rt.dequeCapacity(q, 16); - Known.put(k, out, _204, _206); + put(out, q.n); + put(out, rt.dequeCapacity(q)); } } @@ -1064,104 +1028,86 @@ export function dequeSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: if ((first & 1) === 1) { q = rt.dequeWithCapacity(first >> 3 as rt.usize, 2) as rt.VecDeque; } else { - q = rt.dequeNew() as rt.VecDeque; + q = rt.dequeNew(2) as rt.VecDeque; } - const k: Known.Known = Known.new(rt.dequeCapacity(q, 2)); - put(out, rt.dequeCapacity(q, 2)); + put(out, rt.dequeCapacity(q)); const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); while (true) { - const _27: rt.ByteSlice | rt.Done = iter.next(); - if (_27 === rt.DONE) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { break; } - rt.idx(_27, 0); - const _33: [rt.u8, rt.u8] = [_27.data[_27.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_27, 1), 0)]; - const op: rt.u8 = _33[0]; - const arg: rt.u8 = _33[1]; - const _42: rt.u8 = rt.u8Rem(op, 21); - if (_42 === 0) { + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + const _39: rt.u8 = rt.u8Rem(op, 21); + if (_39 === 0) { rt.dequePushBack(q, make(arg)); - } else if (_42 === 1) { + } else if (_39 === 1) { rt.dequePushFront(q, make(arg)); - } else if (_42 === 2) { + } else if (_39 === 2) { rt.dequePopFront(q); - Known.loose(k); - } else if (_42 === 3 || _42 === 4) { + } else if (_39 === 3 || _39 === 4) { const additional: rt.usize = amount(arg, q.n, size); if (rt.u8Rem(op, 21) === 3) { - rt.dequeReserve(q, additional, 2); + rt.dequeReserve(q, additional); } else { - rt.dequeReserveExact(q, additional, 2); + rt.dequeReserveExact(q, additional); } - Known.reserved(k, q.n, additional); - } else if (_42 === 5) { - rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize, 2); - Known.shrunk(k, q.n, rt.u8Rem(arg, 40) as rt.usize); - } else if (_42 === 6) { - rt.dequeShrinkTo(q, 0, 2); - Known.shrunk(k, q.n, 0); - k.exact = true; - } else if (_42 === 7) { + } else if (_39 === 5) { + rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize); + } else if (_39 === 6) { + rt.dequeShrinkTo(q, 0); + } else if (_39 === 7) { rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); - Known.loose(k); - } else if (_42 === 8) { + } else if (_39 === 8) { rt.dequeInsert(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), make(arg)); - } else if (_42 === 9) { + } else if (_39 === 9) { rt.dequeRemove(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1))); - Known.loose(k); - } else if (_42 === 10) { + } else if (_39 === 10) { rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { return rt.u8Rem(i, 3) !== 0; - }), make), "next", 2); - } else if (_42 === 11) { - rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 2, true); - } else if (_42 === 12) { + }), make), "next"); + } else if (_39 === 11) { + rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, true); + } else if (_39 === 12) { rt.dequeClear(q); - Known.loose(k); - } else if (_42 === 13) { + } else if (_39 === 13) { const keep: () => boolean = alternate(); - rt.dequeRetain(q, (_28: rt.u16): boolean => { + rt.dequeRetain(q, (_25: rt.u16): boolean => { return keep(); }); - Known.loose(k); - } else if (_42 === 14) { - rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) }); - Known.loose(k); - } else if (_42 === 15) { - q = rt.dequeClone(q, undefined, 2); - Known.remade(k, true); - } else if (_42 === 16) { - q = rt.dequeFromVec(rt.iterToArray(rt.dequeIter(q), undefined, 2, true)) as rt.VecDeque; - Known.remade(k, false); - } else if (_42 === 17) { - q = rt.dequeFromVec(rt.iterToArray(rt.dequeIter(q), undefined, 2, true)) as rt.VecDeque; - Known.remade(k, false); - } else if (_42 === 18) { + } else if (_39 === 14) { + rt.drop(rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) })); + } else if (_39 === 15) { + q = rt.dequeClone(q); + } else if (_39 === 16) { + q = rt.dequeFromIntoIter(rt.dequeIntoIter(q), 2) as rt.VecDeque; + } else if (_39 === 17) { + q = rt.dequeFromVec(rt.iterToArray(rt.dequeIntoIter(q), undefined, 2, true), 2) as rt.VecDeque; + } else if (_39 === 18) { const keep2: () => boolean = alternate(); - q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_26: rt.u16): boolean => { + q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIntoIter(q), (_23: rt.u16): boolean => { return keep2(); - }), "next", 2)) as rt.VecDeque; - Known.remade(k, true); - } else if (_42 === 19) { - const it: rt.Iter = rt.dequeIter(q); - const _173: rt.u8 = rt.u8Rem(arg, 4); + }), "next", 2), 2) as rt.VecDeque; + } else if (_39 === 19) { + const it: rt.Iter = rt.dequeIntoIter(q); + const _127: rt.u8 = rt.u8Rem(arg, 4); let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _173; + const iterEnd: rt.u8 = _127; while (iterStart++ < iterEnd) { rt.iterToOption(it.next()); } - q = rt.dequeFromVec(rt.iterToArray(it.clone(), undefined, 2, true)) as rt.VecDeque; - Known.remade(k, false); - const rest: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(it, undefined, 2, true)) as rt.VecDeque; - Known.put({ exact: false, floor: 0 }, out, rest.n, rt.dequeCapacity(rest, 2)); + q = rt.dequeFromIntoIter(it.clone(), 2) as rt.VecDeque; + const rest: rt.VecDeque = rt.dequeFromIntoIter(it, 2) as rt.VecDeque; + put(out, rest.n); + put(out, rt.dequeCapacity(rest)); } else { - const _196: rt.u16[] = [make(arg), make(arg), make(arg)]; - q = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_196), undefined, 2, true); - Known.remade(k, false); + q = rt.dequeFromArray([make(arg), make(arg), make(arg)], 2) as rt.VecDeque; } - const _204: rt.usize = q.n; - const _206: rt.usize = rt.dequeCapacity(q, 2); - Known.put(k, out, _204, _206); + put(out, q.n); + put(out, rt.dequeCapacity(q)); } } @@ -1174,106 +1120,88 @@ export function dequeSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: }); const first: rt.u8 = _7[0]; if ((first & 1) === 1) { - q = rt.dequeWithCapacity(first >> 3 as rt.usize, 1) as rt.VecDeque; + q = rt.dequeWithCapacity(first >> 3 as rt.usize, 1, true) as rt.VecDeque; } else { - q = rt.dequeNew() as rt.VecDeque; + q = rt.dequeNew(1, true) as rt.VecDeque; } - const k: Known.Known = Known.new(rt.dequeCapacity(q, 1)); - put(out, rt.dequeCapacity(q, 1)); + put(out, rt.dequeCapacity(q)); const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); while (true) { - const _27: rt.ByteSlice | rt.Done = iter.next(); - if (_27 === rt.DONE) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { break; } - rt.idx(_27, 0); - const _33: [rt.u8, rt.u8] = [_27.data[_27.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_27, 1), 0)]; - const op: rt.u8 = _33[0]; - const arg: rt.u8 = _33[1]; - const _42: rt.u8 = rt.u8Rem(op, 21); - if (_42 === 0) { + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + const _39: rt.u8 = rt.u8Rem(op, 21); + if (_39 === 0) { rt.dequePushBack(q, make(arg)); - } else if (_42 === 1) { + } else if (_39 === 1) { rt.dequePushFront(q, make(arg)); - } else if (_42 === 2) { + } else if (_39 === 2) { rt.dequePopFront(q); - Known.loose(k); - } else if (_42 === 3 || _42 === 4) { + } else if (_39 === 3 || _39 === 4) { const additional: rt.usize = amount(arg, q.n, size); if (rt.u8Rem(op, 21) === 3) { - rt.dequeReserve(q, additional, 1); + rt.dequeReserve(q, additional); } else { - rt.dequeReserveExact(q, additional, 1); + rt.dequeReserveExact(q, additional); } - Known.reserved(k, q.n, additional); - } else if (_42 === 5) { - rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize, 1); - Known.shrunk(k, q.n, rt.u8Rem(arg, 40) as rt.usize); - } else if (_42 === 6) { - rt.dequeShrinkTo(q, 0, 1); - Known.shrunk(k, q.n, 0); - k.exact = true; - } else if (_42 === 7) { + } else if (_39 === 5) { + rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize); + } else if (_39 === 6) { + rt.dequeShrinkTo(q, 0); + } else if (_39 === 7) { rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); - Known.loose(k); - } else if (_42 === 8) { + } else if (_39 === 8) { rt.dequeInsert(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), make(arg)); - } else if (_42 === 9) { + } else if (_39 === 9) { rt.dequeRemove(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1))); - Known.loose(k); - } else if (_42 === 10) { + } else if (_39 === 10) { rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { return rt.u8Rem(i, 3) !== 0; - }), make), "next", 1); - } else if (_42 === 11) { - rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 1, true); - } else if (_42 === 12) { + }), make), "next"); + } else if (_39 === 11) { + rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, true); + } else if (_39 === 12) { rt.dequeClear(q); - Known.loose(k); - } else if (_42 === 13) { + } else if (_39 === 13) { const keep: () => boolean = alternate(); - rt.dequeRetain(q, (_28: rt.u8): boolean => { + rt.dequeRetain(q, (_25: rt.u8): boolean => { return keep(); }); - Known.loose(k); - } else if (_42 === 14) { - rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) }); - Known.loose(k); - } else if (_42 === 15) { - q = rt.dequeClone(q, undefined, 1); - Known.remade(k, true); - } else if (_42 === 16) { - q = rt.dequeFromVec(rt.iterToArray(rt.dequeIter(q), undefined, 1, true)) as rt.VecDeque; - Known.remade(k, false); - } else if (_42 === 17) { - q = rt.dequeFromVec(rt.byteVecToVec(rt.iterToByteVec(rt.dequeIter(q), undefined, true))) as rt.VecDeque; - Known.remade(k, false); - } else if (_42 === 18) { + } else if (_39 === 14) { + rt.drop(rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) })); + } else if (_39 === 15) { + q = rt.dequeClone(q); + } else if (_39 === 16) { + q = rt.dequeFromIntoIter(rt.dequeIntoIter(q), 1, true) as rt.VecDeque; + } else if (_39 === 17) { + q = rt.dequeFromVec(rt.byteVecToVec(rt.iterToByteVec(rt.dequeIntoIter(q), undefined, true)), 1, true) as rt.VecDeque; + } else if (_39 === 18) { const keep2: () => boolean = alternate(); - q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_26: rt.u8): boolean => { + q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIntoIter(q), (_23: rt.u8): boolean => { return keep2(); - }), "next", 1)) as rt.VecDeque; - Known.remade(k, true); - } else if (_42 === 19) { - const it: rt.Iter = rt.dequeIter(q); - const _173: rt.u8 = rt.u8Rem(arg, 4); + }), "next", 1), 1, true) as rt.VecDeque; + } else if (_39 === 19) { + const it: rt.Iter = rt.dequeIntoIter(q); + const _127: rt.u8 = rt.u8Rem(arg, 4); let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _173; + const iterEnd: rt.u8 = _127; while (iterStart++ < iterEnd) { rt.iterToOption(it.next()); } - q = rt.dequeFromVec(rt.iterToArray(it.clone(), undefined, 1, true)) as rt.VecDeque; - Known.remade(k, false); - const rest: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(it, undefined, 1, true)) as rt.VecDeque; - Known.put({ exact: false, floor: 0 }, out, rest.n, rt.dequeCapacity(rest, 1)); + q = rt.dequeFromIntoIter(it.clone(), 1, true) as rt.VecDeque; + const rest: rt.VecDeque = rt.dequeFromIntoIter(it, 1, true) as rt.VecDeque; + put(out, rest.n); + put(out, rt.dequeCapacity(rest)); } else { - const _196: Uint8Array = Uint8Array.of(make(arg), make(arg), make(arg)); - q = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_196), undefined, 1, true); - Known.remade(k, false); + q = rt.dequeFromArray(Uint8Array.of(make(arg), make(arg), make(arg)), 1, true) as rt.VecDeque; } - const _204: rt.usize = q.n; - const _206: rt.usize = rt.dequeCapacity(q, 1); - Known.put(k, out, _204, _206); + put(out, q.n); + put(out, rt.dequeCapacity(q)); } } @@ -1288,113 +1216,96 @@ export function dequeSteps$unit(dataData: Uint8Array, dataStart: number, dataLen if ((first & 1) === 1) { q = rt.dequeWithCapacity(first >> 3 as rt.usize, 0) as rt.VecDeque; } else { - q = rt.dequeNew() as rt.VecDeque; + q = rt.dequeNew(0) as rt.VecDeque; } - const k: Known.Known = Known.new(rt.dequeCapacity(q, 0)); - put(out, rt.dequeCapacity(q, 0)); + put(out, rt.dequeCapacity(q)); const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); while (true) { - const _27: rt.ByteSlice | rt.Done = iter.next(); - if (_27 === rt.DONE) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { break; } - rt.idx(_27, 0); - const _33: [rt.u8, rt.u8] = [_27.data[_27.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_27, 1), 0)]; - const op: rt.u8 = _33[0]; - const arg: rt.u8 = _33[1]; - const _42: rt.u8 = rt.u8Rem(op, 21); - if (_42 === 0) { - const _44: rt.VecDeque = q; + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + const _39: rt.u8 = rt.u8Rem(op, 21); + if (_39 === 0) { + const _41: rt.VecDeque = q; make(arg); - rt.dequePushBack(_44, undefined); - } else if (_42 === 1) { - const _46: rt.VecDeque = q; + rt.dequePushBack(_41, undefined); + } else if (_39 === 1) { + const _43: rt.VecDeque = q; make(arg); - rt.dequePushFront(_46, undefined); - } else if (_42 === 2) { + rt.dequePushFront(_43, undefined); + } else if (_39 === 2) { rt.dequePopFront(q, rt.None); - Known.loose(k); - } else if (_42 === 3 || _42 === 4) { + } else if (_39 === 3 || _39 === 4) { const additional: rt.usize = amount(arg, q.n, size); if (rt.u8Rem(op, 21) === 3) { - rt.dequeReserve(q, additional, 0); + rt.dequeReserve(q, additional); } else { - rt.dequeReserveExact(q, additional, 0); + rt.dequeReserveExact(q, additional); } - Known.reserved(k, q.n, additional); - } else if (_42 === 5) { - rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize, 0); - Known.shrunk(k, q.n, rt.u8Rem(arg, 40) as rt.usize); - } else if (_42 === 6) { - rt.dequeShrinkTo(q, 0, 0); - Known.shrunk(k, q.n, 0); - k.exact = true; - } else if (_42 === 7) { + } else if (_39 === 5) { + rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize); + } else if (_39 === 6) { + rt.dequeShrinkTo(q, 0); + } else if (_39 === 7) { rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); - Known.loose(k); - } else if (_42 === 8) { - const _90: rt.VecDeque = q; - const _91: rt.usize = rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)); + } else if (_39 === 8) { + const _63: rt.VecDeque = q; + const _64: rt.usize = rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)); make(arg); - rt.dequeInsert(_90, _91, undefined); - } else if (_42 === 9) { + rt.dequeInsert(_63, _64, undefined); + } else if (_39 === 9) { rt.dequeRemove(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), rt.None); - Known.loose(k); - } else if (_42 === 10) { + } else if (_39 === 10) { rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { return rt.u8Rem(i, 3) !== 0; - }), make), "next", 0); - } else if (_42 === 11) { - rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 0, true); - } else if (_42 === 12) { + }), make), "next"); + } else if (_39 === 11) { + rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, true); + } else if (_39 === 12) { rt.dequeClear(q); - Known.loose(k); - } else if (_42 === 13) { + } else if (_39 === 13) { const keep: () => boolean = alternate(); - rt.dequeRetain(q, (_28: undefined): boolean => { + rt.dequeRetain(q, (_25: undefined): boolean => { return keep(); }); - Known.loose(k); - } else if (_42 === 14) { - rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) }); - Known.loose(k); - } else if (_42 === 15) { - q = rt.dequeClone(q, undefined, 0); - Known.remade(k, true); - } else if (_42 === 16) { - q = rt.dequeFromVec(rt.iterToArray(rt.dequeIter(q), undefined, 0, true)) as rt.VecDeque; - Known.remade(k, false); - } else if (_42 === 17) { - q = rt.dequeFromVec(rt.iterToArray(rt.dequeIter(q), undefined, 0, true)) as rt.VecDeque; - Known.remade(k, false); - } else if (_42 === 18) { + } else if (_39 === 14) { + rt.drop(rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) })); + } else if (_39 === 15) { + q = rt.dequeClone(q); + } else if (_39 === 16) { + q = rt.dequeFromIntoIter(rt.dequeIntoIter(q), 0) as rt.VecDeque; + } else if (_39 === 17) { + q = rt.dequeFromVec(rt.iterToArray(rt.dequeIntoIter(q), undefined, 0, true), 0) as rt.VecDeque; + } else if (_39 === 18) { const keep2: () => boolean = alternate(); - q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_26: undefined): boolean => { + q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIntoIter(q), (_23: undefined): boolean => { return keep2(); - }), "next", 0)) as rt.VecDeque; - Known.remade(k, true); - } else if (_42 === 19) { - const it: rt.Iter = rt.dequeIter(q); - const _173: rt.u8 = rt.u8Rem(arg, 4); + }), "next", 0), 0) as rt.VecDeque; + } else if (_39 === 19) { + const it: rt.Iter = rt.dequeIntoIter(q); + const _127: rt.u8 = rt.u8Rem(arg, 4); let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _173; + const iterEnd: rt.u8 = _127; while (iterStart++ < iterEnd) { rt.iterToOption(it.next(), rt.None); } - q = rt.dequeFromVec(rt.iterToArray(it.clone(), undefined, 0, true)) as rt.VecDeque; - Known.remade(k, false); - const rest: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(it, undefined, 0, true)) as rt.VecDeque; - Known.put({ exact: false, floor: 0 }, out, rest.n, rt.dequeCapacity(rest, 0)); + q = rt.dequeFromIntoIter(it.clone(), 0) as rt.VecDeque; + const rest: rt.VecDeque = rt.dequeFromIntoIter(it, 0) as rt.VecDeque; + put(out, rest.n); + put(out, rt.dequeCapacity(rest)); } else { make(arg); make(arg); make(arg); - q = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice([undefined, undefined, undefined]), undefined, 0, true); - Known.remade(k, false); + q = rt.dequeFromArray([undefined, undefined, undefined], 0) as rt.VecDeque; } - const _204: rt.usize = q.n; - const _206: rt.usize = rt.dequeCapacity(q, 0); - Known.put(k, out, _204, _206); + put(out, q.n); + put(out, rt.dequeCapacity(q)); } } @@ -1903,14 +1814,14 @@ export function collects(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const _71: rt.Iter<[rt.u32, rt.u32]> = rt.iterCopied(rt.iterFilter(rt.iterSlice(pairs2), (_22: [rt.u32, rt.u32]): boolean => { return rt.u32Rem(_22[0], 2) === 0; }), copy$tuple2_u32_u32); - const _70: [rt.u32[], rt.VecDeque] = rt.tupleExtend([[], rt.dequeNew() as rt.VecDeque] as [rt.u32[], rt.VecDeque], _71, [rt.vecPart(4), rt.dequePart(4)]); + const _70: [rt.u32[], rt.VecDeque] = rt.tupleExtend([[], rt.dequeNew(4) as rt.VecDeque] as [rt.u32[], rt.VecDeque], _71, [rt.vecPart(4), rt.dequePart()]); const a: rt.u32[] = _70[0]; const b: rt.VecDeque = _70[1]; const _78: rt.usize = a.length; const _80: rt.usize = rt.vecCapacity(a, 4); Known.put(exact, out, _78, _80); const _84: rt.usize = b.n; - const _86: rt.usize = rt.dequeCapacity(b, 4); + const _86: rt.usize = rt.dequeCapacity(b); Known.put(exact, out, _84, _86); const _91: rt.Iter<[rt.u8, rt.u32]> = rt.iterMap(rt.iterSlice(pairs2), (_26: [rt.u32, rt.u32]): [rt.u8, rt.u32] => { return [_26[0] & 0xff, _26[1]] as [rt.u8, rt.u32]; @@ -1934,14 +1845,14 @@ export function collects(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } else if (_20 === 4) { put(out, rt.vecCapacity(rt.vecWithCapacity(rt.usizeSub(4294967295, n), 8), 8)); } else if (_20 === 5) { - put(out, rt.dequeCapacity(rt.dequeWithCapacity(rt.usizeAdd(268435456, n), 16) as rt.VecDeque<[rt.u64, rt.u64]>, 16)); + put(out, rt.dequeCapacity(rt.dequeWithCapacity(rt.usizeAdd(268435456, n), 16) as rt.VecDeque<[rt.u64, rt.u64]>)); } else if (_20 === 6) { const bytes2: rt.ByteVec = rt.byteVecWithCapacity(rt.usizeAdd(n, 5)); const _138: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(n, data.length)); rt.byteVecExtendFromSlice(bytes2, _138); - const q2: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecFrom(rt.byteVecView(bytes2)))) as rt.VecDeque; + const q2: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecFrom(rt.byteVecView(bytes2))), 1, true) as rt.VecDeque; const _147: rt.usize = q2.n; - const _149: rt.usize = rt.dequeCapacity(q2, 1); + const _149: rt.usize = rt.dequeCapacity(q2); Known.put(loose, out, _147, _149); const heap: rt.BinaryHeap = rt.heapFrom(rt.byteVecToVec(bytes2), rt.le, rt.ge, rt.lt); const _155: rt.usize = heap.d.length; diff --git a/ts/fixtures/lang/expected/clones.ts b/ts/fixtures/lang/expected/clones.ts index 63df0a599..8751363a6 100644 --- a/ts/fixtures/lang/expected/clones.ts +++ b/ts/fixtures/lang/expected/clones.ts @@ -7145,7 +7145,7 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { unordered$iter_Copied_collections_hash_set_Difference_u8_hash_RandomState(rt.hashDifference(a4, b5), plan, out); unordered$iter_Copied_collections_hash_set_SymmetricDifference_u8_hash_RandomState(rt.hashSymmetricDifference(a4, b5), plan, out); } else if (_9 === 12) { - const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const q: rt.VecDeque = rt.dequeNew(1, true) as rt.VecDeque; for (const b6 of rt.byteSliceView(data)) { if (rt.u8Rem(b6, 2) === 0) { rt.dequePushFront(q, b6); @@ -7158,7 +7158,7 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }, plan, (x10: rt.u8): rt.u8 => { return x10; }, out); - turns$collections_vec_deque_IntoIter_u8_clones_iters_closure139_clones_iters_closure140(rt.dequeIter(rt.dequeClone(q, undefined, 1)), (it8: rt.Iter): rt.u8 | undefined => { + turns$collections_vec_deque_IntoIter_u8_clones_iters_closure139_clones_iters_closure140(rt.dequeIntoIter(rt.dequeClone(q)), (it8: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it8.nextBack()); }, plan, (x11: rt.u8): rt.u8 => { return x11; @@ -7409,9 +7409,9 @@ export function owned(data: rt.ByteSlice, plan: Plan.Plan, out: rt.ByteVec): voi return _04; }, out); flush(log.value, out); - turns$collections_vec_deque_IntoIter_clones_Logged_clones_owned_closure5_clones_owned_closure6(rt.dequeIter(rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 4), (_22: rt.u8): clones_Logged.Logged => { + turns$collections_vec_deque_IntoIter_clones_Logged_clones_owned_closure5_clones_owned_closure6(rt.dequeIntoIter(rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 4), (_22: rt.u8): clones_Logged.Logged => { return logged(_22 & 112); - }), undefined, 8, true)) as rt.VecDeque, rt.drop), (it7: rt.Iter): clones_Logged.Logged | undefined => { + }), undefined, 8, true), 8) as rt.VecDeque, rt.drop), (it7: rt.Iter): clones_Logged.Logged | undefined => { return rt.iterToOption(it7.nextBack()); }, plan, (x2: clones_Logged.Logged): rt.u8 => { const _07: rt.u8 = clones_Logged.id(x2); diff --git a/ts/fixtures/lang/expected/collections.ts b/ts/fixtures/lang/expected/collections.ts index a32b5ee7c..f44ce1bfe 100644 --- a/ts/fixtures/lang/expected/collections.ts +++ b/ts/fixtures/lang/expected/collections.ts @@ -929,7 +929,7 @@ export function touch(q: rt.VecDeque): rt.VecDeque { /** `VecDeque`: a ring buffer, pushed and popped at both ends past its capacity. */ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { let drained2!: rt.ByteVec; - const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const q: rt.VecDeque = rt.dequeNew(1, true) as rt.VecDeque; const pairs: rt.VecDeque<[rt.u8, rt.u8]> = rt.dequeWithCapacity(2, 2) as rt.VecDeque<[rt.u8, rt.u8]>; for (const b of rt.byteSliceView(data)) { const _12: rt.u8 = rt.u8Rem(b, 7); @@ -957,8 +957,8 @@ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { }); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.dequeSwapRemove(q, at, true), 232)); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.dequeSwapRemove(q, at), 231)); - rt.dequeShrinkTo(touch(q), 0, 1); - rt.dequeReserve(touch(q), 1, 1); + rt.dequeShrinkTo(touch(q), 0); + rt.dequeReserve(touch(q), 1); rt.byteVecPush(out, q.n & 0xff); rt.iterExtendBytes(out, rt.iterRev(rt.dequeIter(q)), undefined, true); if (!((q.n === 0))) { @@ -980,8 +980,8 @@ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, q.n === 0 ? 1 : 0); const tallies: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): collections_Tally.Tally => { return { n: _25 as rt.u16 }; - }), undefined, 2, true)) as rt.VecDeque; - const copy: rt.VecDeque = rt.dequeClone(tallies, copy$collections_Tally, 2); + }), undefined, 2, true), 2) as rt.VecDeque; + const copy: rt.VecDeque = rt.dequeClone(tallies, copy$collections_Tally); const _115: collections_Tally.Tally | undefined = rt.dequeEnd(copy); if (_115 !== undefined) { _115.n = _115.n ^ 255; @@ -993,7 +993,7 @@ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { return t3.n & 0xff; }), undefined, true); const _129: rt.Iter = rt.dequeIter(tallies); - rt.dequeExtend(copy, rt.iterMap(_129, copy$collections_Tally), undefined, 2, true); + rt.dequeExtend(copy, rt.iterMap(_129, copy$collections_Tally), undefined, true); const _131: collections_Tally.Tally | undefined = rt.dequeEnd(copy, true); if (_131 !== undefined) { _131.n = _131.n ^ 255; @@ -1018,7 +1018,7 @@ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { return t7.n & 0xff; }), undefined, true); const _162: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - rt.dequeExtend(q, _162, undefined, 1, true); + rt.dequeExtend(q, _162, undefined, true); rt.dequeInsert(q, rt.usizeDiv(q.n, 2), 66); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.dequeRemove(q, 1), 233)); rt.dequeTruncate(q, 5); @@ -1026,7 +1026,7 @@ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterRev(rt.dequeIter(q)), undefined, true); const a: rt.usize = rt.usizeRem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0) as rt.usize, 8); const b2: rt.usize = rt.usizeRem(option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0) as rt.usize, 8); - const q2: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterSlice(rt.byteSliceView(data)), undefined, 1, true)) as rt.VecDeque; + const q2: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterSlice(rt.byteSliceView(data)), undefined, 1, true), 1, true) as rt.VecDeque; const _201: rt.usize = rt.usizeRem(a, 4); if (_201 === 0) { drained2 = rt.iterToByteVec(rt.dequeDrain(q2, new rt.Range(a, b2)), "next"); @@ -1202,7 +1202,7 @@ export function stores(data: rt.ByteSlice, out: rt.ByteVec): void { }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(changed[0], changed[1], old[0], old[1]))); const tally: collections_Tally.Tally = { n: a as rt.u16 }; - const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const q: rt.VecDeque = rt.dequeNew(2) as rt.VecDeque; rt.dequePushBack(q, copy$collections_Tally(tally)); rt.dequePushFront(q, copy$collections_Tally(tally)); rt.dequeInsert(q, 1, copy$collections_Tally(tally)); @@ -3695,7 +3695,7 @@ export function unlikeEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi }), undefined, 2, true)), undefined, 4, true); putEq(rt.eqSeq(Odd.eq$cmp_PartialEq_ref_collections_Right_ref)(_210, refs), log, out); const half: rt.usize = rt.usizeDiv(data.length, 2); - const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const q: rt.VecDeque = rt.dequeNew(8) as rt.VecDeque; const iter: rt.Iter = rt.iterRev(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 0, half)))); while (true) { const _226: rt.u8 | rt.Done = iter.next(); @@ -3736,7 +3736,7 @@ export function unlikeEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi putEq(rt.eqSeq((a32: Left.Left, b30: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a32, b30); })(q, _295), log, out); - const bytes: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const bytes: rt.VecDeque = rt.dequeNew(1, true) as rt.VecDeque; const iter3: rt.Iter = rt.iterRev(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 0, half)))); while (true) { const _305: rt.u8 | rt.Done = iter3.next(); @@ -3746,7 +3746,7 @@ export function unlikeEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi rt.dequePushFront(bytes, _305); } const _313: rt.ByteSlice = rt.byteSliceRange(data, half); - rt.dequeExtend(bytes, rt.iterSlice(rt.byteSliceView(_313)), undefined, 1, true); + rt.dequeExtend(bytes, rt.iterSlice(rt.byteSliceView(_313)), undefined, true); const stepped: rt.ByteVec = rt.iterToByteVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), (_27: [rt.usize, rt.u8]): rt.u8 => { return _27[1] ^ (_27[0] === byEq ? 1 : 0); }), undefined, true); @@ -3756,8 +3756,8 @@ export function unlikeEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi putEq(rt.eqSeq(rt.same)(bytes, _334), log, out); const wide: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.dequeIter(bytes), (_28: rt.u8): rt.u16 => { return _28 as rt.u16; - }), undefined, 2, true)) as rt.VecDeque; - const wrapped: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + }), undefined, 2, true), 2) as rt.VecDeque; + const wrapped: rt.VecDeque = rt.dequeNew(2) as rt.VecDeque; const iter4: rt.Iter = rt.iterRev(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(stepped)))); while (true) { const _351: rt.u8 | rt.Done = iter4.next(); @@ -3767,7 +3767,7 @@ export function unlikeEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi rt.dequePushFront(wrapped, _351 as rt.u16); } putEq(rt.eqSeq(rt.same)(wide, wrapped), log, out); - const _366: rt.VecDeque[] = [rt.dequeClone(wide, undefined, 2)]; + const _366: rt.VecDeque[] = [rt.dequeClone(wide)]; const _371: rt.VecDeque[] = [wrapped]; putEq(rt.eqSlice(rt.eqSeq(rt.same))(_366, _371), log, out); const it: rt.Peekable = rt.iterPeekable(rt.iterSlice([lefts(), lefts(), lefts()])); @@ -3791,7 +3791,7 @@ export function unlikeEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi })(a035, a135); }) !== undefined, log, out); rt.byteVecPush(out, rt.iterCount(it) & 0xff); - const it2: rt.Peekable> = rt.iterPeekable(rt.iterSlice([rt.dequeClone(bytes, undefined, 1), bytes])); + const it2: rt.Peekable> = rt.iterPeekable(rt.iterSlice([rt.dequeClone(bytes), bytes])); const _430: rt.ByteVec = rt.byteSliceToByteVec(data); putEq(rt.peekableNextIfEq(it2, _430, (a037: rt.VecDeque, a137: rt.ByteVec): boolean => { return rt.eqSeq(rt.same)(a037, a137); @@ -3808,7 +3808,7 @@ export function unlikeEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi */ export function wrapped$collections_Picky(v: collections_Picky.Picky[]): rt.VecDeque { const half: rt.usize = rt.usizeDiv(v.length, 2); - const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const q: rt.VecDeque = rt.dequeNew(8) as rt.VecDeque; const iter: rt.Iter = rt.iterRev(rt.iterSlice(rt.sliceRange(v, 0, half))); while (true) { const _12: collections_Picky.Picky | rt.Done = iter.next(); @@ -3819,7 +3819,7 @@ export function wrapped$collections_Picky(v: collections_Picky.Picky[]): rt.VecD rt.dequePushFront(q, _18); } const _21: rt.Iter = rt.iterMap(rt.iterSlice(rt.sliceRange(v, half)), collections_Picky.clone$Clone); - rt.dequeExtend(q, _21, undefined, 8, true); + rt.dequeExtend(q, _21, undefined, true); return q; } @@ -4736,10 +4736,8 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_147, _152, !rt.eqSlice(ByRef.eq$cmp_PartialEq_ref)(_161, _164)], (a022: boolean): rt.u8 => { return a022 ? 1 : 0; })), undefined, true); - const _171: ByRef.ByRef[] = [a, b]; - const _170: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_171), undefined, 4, true); - const _174: ByRef.ByRef[] = [b, a]; - const _173: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_174), undefined, 4, true); + const _170: rt.VecDeque = rt.dequeFromArray([a, b], 4) as rt.VecDeque; + const _173: rt.VecDeque = rt.dequeFromArray([b, a], 4) as rt.VecDeque; rt.byteVecPush(out, rt.eqSeq(ByRef.eq$cmp_PartialEq_ref)(_170, _173) ? 1 : 0); const _180: ByRef.ByRef = a; const _182: ByRef.ByRef = b; @@ -4860,10 +4858,8 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_458, _463, !rt.eqSlice(ByRef.eq$cmp_PartialEq_ref)(_472, _475)], (a067: boolean): rt.u8 => { return a067 ? 1 : 0; })), undefined, true); - const _482: ByRef.ByRef[] = [a2, b2]; - const _481: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_482), undefined, 4, true); - const _485: ByRef.ByRef[] = [b2, a2]; - const _484: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_485), undefined, 4, true); + const _481: rt.VecDeque = rt.dequeFromArray([a2, b2], 4) as rt.VecDeque; + const _484: rt.VecDeque = rt.dequeFromArray([b2, a2], 4) as rt.VecDeque; rt.byteVecPush(out, rt.eqSeq(ByRef.eq$cmp_PartialEq_ref)(_481, _484) ? 1 : 0); const _491: ByRef.ByRef = a2; const _493: ByRef.ByRef = b2; @@ -4984,10 +4980,8 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_761, _766, !rt.eqSlice(ByVal.eq$cmp_PartialEq)(_775, _778)], (a0112: boolean): rt.u8 => { return a0112 ? 1 : 0; })), undefined, true); - const _785: ByVal.ByVal[] = [a3, b3]; - const _784: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_785), undefined, 4, true); - const _788: ByVal.ByVal[] = [b3, a3]; - const _787: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_788), undefined, 4, true); + const _784: rt.VecDeque = rt.dequeFromArray([a3, b3], 4) as rt.VecDeque; + const _787: rt.VecDeque = rt.dequeFromArray([b3, a3], 4) as rt.VecDeque; rt.byteVecPush(out, rt.eqSeq(ByVal.eq$cmp_PartialEq)(_784, _787) ? 1 : 0); const _794: ByVal.ByVal = a3; const _796: ByVal.ByVal = b3; @@ -5108,10 +5102,8 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_1068, _1073, !rt.eqSlice(ByVal.eq$cmp_PartialEq)(_1082, _1085)], (a0157: boolean): rt.u8 => { return a0157 ? 1 : 0; })), undefined, true); - const _1092: ByVal.ByVal[] = [a4, b4]; - const _1091: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_1092), undefined, 4, true); - const _1095: ByVal.ByVal[] = [b4, a4]; - const _1094: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_1095), undefined, 4, true); + const _1091: rt.VecDeque = rt.dequeFromArray([a4, b4], 4) as rt.VecDeque; + const _1094: rt.VecDeque = rt.dequeFromArray([b4, a4], 4) as rt.VecDeque; rt.byteVecPush(out, rt.eqSeq(ByVal.eq$cmp_PartialEq)(_1091, _1094) ? 1 : 0); const _1101: ByVal.ByVal = a4; const _1103: ByVal.ByVal = b4; @@ -5281,7 +5273,7 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo return rt.sliceContains(rt.sliceRange(xs, 1), first, ByRef.eq$cmp_PartialEq_ref) ? 1 : 0; })), undefined, true); rt.byteVecPush(out, rt.sliceIsSorted(xs, rt.cmpLe(ByRef.partialCmp$cmp_PartialOrd_ref)) ? 1 : 0); - rt.byteVecPush(out, rt.dequeContains(rt.dequeFromVec(rt.vecExact(xs.slice(), 4)) as rt.VecDeque, xs[rt.idx(xs, rt.usizeDiv(xs.length, 2))], ByRef.eq$cmp_PartialEq_ref) ? 1 : 0); + rt.byteVecPush(out, rt.dequeContains(rt.dequeFromVec(rt.vecExact(xs.slice(), 4), 4) as rt.VecDeque, xs[rt.idx(xs, rt.usizeDiv(xs.length, 2))], ByRef.eq$cmp_PartialEq_ref) ? 1 : 0); const _1541: [ByVal.ByVal[], rt.ByteVec] = [rt.iterToArray(rt.iterSlice(byVal), undefined, 4, true), out]; const xs2: ByVal.ByVal[] = _1541[0]; const sorted2: ByVal.ByVal[] = rt.vecExact(xs2.slice(), 4); @@ -5330,7 +5322,7 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo return rt.sliceContains(rt.sliceRange(xs2, 1), first2, ByVal.eq$cmp_PartialEq) ? 1 : 0; })), undefined, true); rt.byteVecPush(out, rt.sliceIsSorted(xs2, rt.cmpLe(ByVal.partialCmp$cmp_PartialOrd)) ? 1 : 0); - rt.byteVecPush(out, rt.dequeContains(rt.dequeFromVec(rt.vecExact(xs2.slice(), 4)) as rt.VecDeque, xs2[rt.idx(xs2, rt.usizeDiv(xs2.length, 2))], ByVal.eq$cmp_PartialEq) ? 1 : 0); + rt.byteVecPush(out, rt.dequeContains(rt.dequeFromVec(rt.vecExact(xs2.slice(), 4), 4) as rt.VecDeque, xs2[rt.idx(xs2, rt.usizeDiv(xs2.length, 2))], ByVal.eq$cmp_PartialEq) ? 1 : 0); const _1651: [Mixed.Mixed[], rt.ByteVec] = [rt.iterToArray(rt.iterSlice(mixed), undefined, 4, true), out]; const xs3: Mixed.Mixed[] = _1651[0]; const sorted3: Mixed.Mixed[] = rt.vecExact(xs3.slice(), 4); @@ -5379,7 +5371,7 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo return rt.sliceContains(rt.sliceRange(xs3, 1), first3, Mixed.eq$cmp_PartialEq) ? 1 : 0; })), undefined, true); rt.byteVecPush(out, rt.sliceIsSorted(xs3, rt.cmpLe(Mixed.partialCmp$cmp_PartialOrd)) ? 1 : 0); - rt.byteVecPush(out, rt.dequeContains(rt.dequeFromVec(rt.vecExact(xs3.slice(), 4)) as rt.VecDeque, xs3[rt.idx(xs3, rt.usizeDiv(xs3.length, 2))], Mixed.eq$cmp_PartialEq) ? 1 : 0); + rt.byteVecPush(out, rt.dequeContains(rt.dequeFromVec(rt.vecExact(xs3.slice(), 4), 4) as rt.VecDeque, xs3[rt.idx(xs3, rt.usizeDiv(xs3.length, 2))], Mixed.eq$cmp_PartialEq) ? 1 : 0); } export function hashed$ref_orders_Option_ref_collections_ByRef(value: ByRef.ByRef | undefined): Uint8Array { diff --git a/ts/fixtures/lang/expected/cows.ts b/ts/fixtures/lang/expected/cows.ts index e16d42932..fc60966f1 100644 --- a/ts/fixtures/lang/expected/cows.ts +++ b/ts/fixtures/lang/expected/cows.ts @@ -6,7 +6,7 @@ import * as cows_Named from "./cows.Named.ts"; import * as cows_Run from "./cows.Run.ts"; import * as cows_Tally from "./cows.Tally.ts"; import { put as fmt_put } from "./fmt.ts"; -import { text } from "./strs.ts"; +import { text as strs_text } from "./strs.ts"; /** `to_mut` of a `Result`'s payload, which the store rebuilds the `Result` around. */ export function exclaimed(r: rt.Result): rt.Result { @@ -25,7 +25,7 @@ export function cow(s: string, owned: boolean): string { export function cows(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let r!: rt.Result; - const s: string = text(data); + const s: string = strs_text(data); const owned: boolean = (kind & 128) !== 0; const first: string = option_unwrapOr$1iemzn8(rt.iterToOption(rt.strSplit(s, "/").next()), ""); const _14: rt.u8 = rt.u8Rem(kind, 6); diff --git a/ts/fixtures/lang/expected/edits.ts b/ts/fixtures/lang/expected/edits.ts index 090c62c6a..8725dc67a 100644 --- a/ts/fixtures/lang/expected/edits.ts +++ b/ts/fixtures/lang/expected/edits.ts @@ -8,7 +8,7 @@ import * as edits_Named from "./edits.Named.ts"; import * as Stamp from "./edits.Stamp.ts"; import * as edits_Tally from "./edits.Tally.ts"; import { put as fmt_put } from "./fmt.ts"; -import { text } from "./strs.ts"; +import { text as strs_text } from "./strs.ts"; /** Into an `Option`, as a parameter that takes either. */ export function optional$Option_edits_Named(n: edits_Named.Named | undefined): edits_Named.Named | undefined { @@ -29,10 +29,10 @@ export function putU16s(out: rt.ByteVec, v: rt.u16[]): void { export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _104: (a0: rt.u16) => edits_Named.Named = (w: rt.u16): edits_Named.Named => { - return { id: w, name: text(rt.byteSliceFrom(Uint8Array.of(rt.u8Div(w & 0xff, 16)))) }; + return { id: w, name: strs_text(rt.byteSliceFrom(Uint8Array.of(rt.u8Div(w & 0xff, 16)))) }; }; const _604: (a0: rt.u16) => edits_Named.Named = (w2: rt.u16): edits_Named.Named => { - return { id: w2, name: text(rt.byteSliceFrom(Uint8Array.of(w2 & 0xff))) }; + return { id: w2, name: strs_text(rt.byteSliceFrom(Uint8Array.of(w2 & 0xff))) }; }; const _605: (a0: edits_Named.Named[]) => rt.u16[] = (v8: edits_Named.Named[]): rt.u16[] => { return rt.iterToArray(rt.iterMap(rt.iterSlice(v8), (n: edits_Named.Named): rt.u16 => { @@ -67,7 +67,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { putU16s(out, [_33[0], _33[1]]); } const names: string[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_233: rt.u8): string => { - return text(rt.byteSliceFrom(Uint8Array.of(_233))); + return strs_text(rt.byteSliceFrom(Uint8Array.of(_233))); }), undefined, 12, true); rt.vecRetain(names, (s3: string): boolean => { return rt.stringLen(s3) > 1; @@ -141,7 +141,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, _144.name); } const names2: string[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_226: rt.u8): string => { - return text(rt.byteSliceFrom(Uint8Array.of(rt.u8Rem(_226, 3)))); + return strs_text(rt.byteSliceFrom(Uint8Array.of(rt.u8Rem(_226, 3)))); }), undefined, 12, true); rt.vecDedupBy(names2, rt.same); rt.byteVecPush(out, names2.length & 0xff); @@ -192,7 +192,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const names3: string[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_221: rt.u8): string => { const b8: rt.u8 = _221; - return text(rt.byteSliceFrom(Uint8Array.of(b8, rt.u8Div(b8, 16)))); + return strs_text(rt.byteSliceFrom(Uint8Array.of(b8, rt.u8Div(b8, 16)))); }), undefined, 12, true); rt.sliceSort(names3, rt.cmpLt(rt.cmpStr)); for (const _263 of names3) { @@ -219,9 +219,9 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { putU16s(out, v6); const named: edits_Named.Named[] = rt.iterToArray(rt.iterMap(rt.iterSlice(words), (_212: rt.u16): edits_Named.Named => { const w6: rt.u16 = _212; - return { id: w6, name: text(rt.byteSliceFrom(Uint8Array.of(w6 & 0xff))) }; + return { id: w6, name: strs_text(rt.byteSliceFrom(Uint8Array.of(w6 & 0xff))) }; }), undefined, 16, true); - const probe: edits_Named.Named = { id: rt.u16Mul(at(1) as rt.u16, 3), name: text(rt.byteSliceFrom(Uint8Array.of(rt.u8WrappingMul(at(1), 3)))) }; + const probe: edits_Named.Named = { id: rt.u16Mul(at(1) as rt.u16, 3), name: strs_text(rt.byteSliceFrom(Uint8Array.of(rt.u8WrappingMul(at(1), 3)))) }; rt.byteVecPush(out, rt.sliceContains(named, probe, edits_Named.eq$cmp_PartialEq) ? 1 : 0); rt.byteVecPush(out, rt.sliceContains(words, rt.u16Mul(at(2) as rt.u16, 3), rt.same) ? 1 : 0); const _361: rt.u8 = at(3); @@ -237,7 +237,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_8 === 4) { const named2: edits_Named.Named[] = rt.iterToArray(rt.iterMap(rt.iterSlice(words), (_28: rt.u16): edits_Named.Named => { const w4: rt.u16 = _28; - return { id: w4, name: text(rt.byteSliceFrom(Uint8Array.of(w4 & 0xff))) }; + return { id: w4, name: strs_text(rt.byteSliceFrom(Uint8Array.of(w4 & 0xff))) }; }), undefined, 16, true); const cloned: edits_Named.Named[] = rt.vecExact(named2.map(edits_Named.clone$Clone), 16); rt.byteVecPush(out, rt.eqSlice(edits_Named.eq$cmp_PartialEq)(cloned, named2) ? 1 : 0); @@ -262,7 +262,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.vecExact(a027.slice(), 2); }), 12); rt.byteVecPush(out, rt.eqSlice(rt.eqSlice(rt.same))(_453, nested) ? 1 : 0); - const pair: [string, rt.u8] = [text(data), at(0)]; + const pair: [string, rt.u8] = [strs_text(data), at(0)]; const copy: [string, rt.u8] = rt.tupleClone(pair, [undefined, undefined]); fmt_put(out, copy[0]); const _470: [rt.u8, string] = [copy[1], copy[0]]; @@ -275,15 +275,15 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.vecExtendFromSlice(grown, words); putU16s(out, grown); } else if (_8 === 5) { - let tally: edits_Tally.Tally = { n: at(0), names: [text(data)] }; + let tally: edits_Tally.Tally = { n: at(0), names: [strs_text(data)] }; const default_ = edits_Tally.default$Default(); const taken3 = tally; tally = default_; rt.byteVecPush(out, taken3.n); rt.byteVecPush(out, tally.n); fmt_put(out, tally.names[rt.idx(tally.names, 0)]); - let queue: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterSlice(words), undefined, 2, true)) as rt.VecDeque; - const default_2 = rt.dequeNew() as rt.VecDeque; + let queue: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterSlice(words), undefined, 2, true), 2) as rt.VecDeque; + const default_2 = rt.dequeNew(2) as rt.VecDeque; const taken4 = queue; queue = default_2; rt.byteVecPush(out, taken4.n & 0xff); @@ -370,7 +370,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, 6 & 0xff); rt.byteVecPush(out, rt.u8Mul(4 & 0xff, 1 & 0xff)); } else { - const s2: string = text(data); + const s2: string = strs_text(data); const sep: rt.char[] = [47, 97]; rt.byteVecPush(out, rt.strContains(s2, rt.patternChars(sep)) ? 1 : 0); rt.byteVecPush(out, rt.strContains(s2, rt.patternChars(rt.sliceRange(sep, 0))) ? 1 : 0); diff --git a/ts/fixtures/lang/expected/fmt.ts b/ts/fixtures/lang/expected/fmt.ts index db283be35..9f5db53d7 100644 --- a/ts/fixtures/lang/expected/fmt.ts +++ b/ts/fixtures/lang/expected/fmt.ts @@ -749,7 +749,7 @@ export function collections(data: rt.ByteSlice, out: rt.ByteVec): void { const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.dequeIter(q), f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug))]; put(out, rt.fmtFormat([args2[0], "|", rt.fmtSpec({ alternate: true }, args2[0]), "|", rt.fmtSpec({ debugHex: "x" }, args2[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args2[0])])); const wrapped: rt.VecDeque = rt.dequeWithCapacity(4, 4) as rt.VecDeque; - rt.dequeExtend(wrapped, rt.iterSlice([{ _0: 1 }, { _0: 2 }]), undefined, 4, true); + rt.dequeExtend(wrapped, rt.iterSlice([{ _0: 1 }, { _0: 2 }]), undefined, true); const _48: Hex.Hex = { _0: rt.u32Mul(at(0) as rt.u32, 4097) }; rt.dequePushFront(wrapped, _48); const _57: Hex.Hex = { _0: at(1) as rt.u32 }; @@ -760,14 +760,11 @@ export function collections(data: rt.ByteSlice, out: rt.ByteVec): void { rt.dequePopBack(wrapped); const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, mid), (f: rt.Formatter) => rt.fmtList(rt.dequeIter(wrapped), f, (value: Hex.Hex, f: rt.Formatter) => Hex.fmt$fmt_Debug(value, f))]; put(out, rt.fmtFormat([args6[0], "|", args6[1], "|", rt.fmtSpec({ alternate: true }, args6[1]), "|", rt.fmtSpec({ width: 6 }, args6[1])])); - const empty: rt.VecDeque = rt.dequeNew() as rt.VecDeque; - const units: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(new rt.Range(0, rt.u8Rem(at(2), 3)), (_2: rt.u8): undefined => {}), undefined, 0, true)) as rt.VecDeque; + const empty: rt.VecDeque = rt.dequeNew(1, true) as rt.VecDeque; + const units: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(new rt.Range(0, rt.u8Rem(at(2), 3)), (_2: rt.u8): undefined => {}), undefined, 0, true), 0) as rt.VecDeque; const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.dequeIter(empty), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.dequeIter(units), f, rt.fmtUnit)]; put(out, rt.fmtFormat([args8[0], "|", rt.fmtSpec({ alternate: true }, args8[0]), "|", args8[1]])); - const _114: rt.VecDeque = rt.dequeNew() as rt.VecDeque; - const _116: fmt_Pair.Pair[] = [{ _0: at(3), _1: -1 }, { _0: 2, _1: 3 }]; - const _113: rt.VecDeque[] = [_114, rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_116), undefined, 16, true)]; - const part = rt.dequeExtend(rt.dequeNew() as rt.VecDeque>, rt.iterSlice(_113), undefined, 16, true); + const part = rt.dequeFromArray([rt.dequeNew(16) as rt.VecDeque, rt.dequeFromArray([{ _0: at(3), _1: -1 }, { _0: 2, _1: 3 }], 16) as rt.VecDeque], 16) as rt.VecDeque>; const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.dequeIter(part), f, (value: rt.VecDeque, f: rt.Formatter) => rt.fmtList(rt.dequeIter(value), f, (value: fmt_Pair.Pair, f: rt.Formatter) => fmt_Pair.fmt$fmt_Debug(value, f)))]; put(out, rt.fmtFormat([args10[0], "|", rt.fmtSpec({ alternate: true }, args10[0])])); const _135: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): rt.u8 | undefined => { @@ -786,7 +783,7 @@ export function collections(data: rt.ByteSlice, out: rt.ByteVec): void { } const b2: rt.u8 = _154; rt.dequePushFront(rt.entryOrInsertWith(rt.entry(map, rt.u8Rem(b2, 4)), (): rt.VecDeque => { - return rt.dequeNew() as rt.VecDeque; + return rt.dequeNew(16) as rt.VecDeque; }), { _0: b2, _1: rt.i64Neg(b2 as rt.i64) }); } const _176: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; @@ -1054,10 +1051,10 @@ export function iters(data: rt.ByteSlice, out: rt.ByteVec): void { const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(it8, f, rt.u8Debug, [["Drain", "iter"], "Drain"])]; put(out, rt.fmtFormat([args24[0], "|", rt.fmtSpec({ alternate: true }, args24[0])])); rt.drop(it8); - const part9 = ends$iters_collections_vec_deque_IntoIter_Option_u8(rt.dequeIter(rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_27: rt.u8): rt.u8 | undefined => { + const part9 = ends$iters_collections_vec_deque_IntoIter_Option_u8(rt.dequeIntoIter(rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_27: rt.u8): rt.u8 | undefined => { const b4: rt.u8 = _27; return thenSome$0d5am30(rt.u8Rem(b4, 3) !== 0, b4); - }), undefined, 2, true)) as rt.VecDeque), front, back); + }), undefined, 2, true), 2) as rt.VecDeque), front, back); const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part9, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), ["IntoIter"])]; put(out, rt.fmtFormat([args26[0], "|", rt.fmtSpec({ alternate: true }, args26[0])])); const text: string = rt.stringExtendChars("", rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_28: rt.u8): rt.char => { diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index a4b115d32..5bb864e22 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -49,6 +49,7 @@ import { lists as pointers_lists, shared as pointers_shared, places as pointers_ import { refs, toRefs, adapted as refs_adapted } from "./refs.ts"; import { results as results_results } from "./results.ts"; import { returns } from "./returns.ts"; +import { slices as rings_slices } from "./rings.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"; import { copies as shapes_copies, order as shapes_order, discriminants, loops, patterns, uninhabited, closures as shapes_closures, library, flows } from "./shapes.ts"; @@ -280,6 +281,8 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) downgraded(data97, out98); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["borrows::leaks", (_2198: rt.u8, data98: rt.ByteSlice, out99: rt.ByteVec): undefined => { leaks(data98, out99); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["rings::slices", (a0159: rt.u8, a1159: rt.ByteSlice, a2159: rt.ByteVec): undefined => { + rings_slices(a0159, a1159.data, a1159.start, a1159.length, a2159); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; } diff --git a/ts/fixtures/lang/expected/hints.ts b/ts/fixtures/lang/expected/hints.ts index 49b695820..41c5e8df9 100644 --- a/ts/fixtures/lang/expected/hints.ts +++ b/ts/fixtures/lang/expected/hints.ts @@ -162,6 +162,7 @@ export function walk$collections_vec_deque_Drain_u8(it: rt.Iter, steps: r } put(out, it.sizeHint()); } + rt.drop(it); } /** @@ -2081,7 +2082,7 @@ export function hints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { walk$collections_btree_map_Values_u8_u8(rt.btreeValues(map2), steps, out); } } else if (_37 === 20) { - const deque: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterSlice(rt.byteSliceView(bytes)), undefined, 1, true)) as rt.VecDeque; + const deque: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterSlice(rt.byteSliceView(bytes)), undefined, 1, true), 1, true) as rt.VecDeque; const v: rt.ByteVec = rt.byteSliceToByteVec(bytes); const heap: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterSlice(rt.byteSliceView(bytes)), undefined, 1, true), rt.le, rt.ge, rt.lt); const half2: rt.usize = rt.usizeDiv(bytes.length, 2); @@ -2623,10 +2624,10 @@ export function fill$array275_u32_iter_Filter_iter_Map_ops_RangeInclusive_u32_hi rt.iterExtend(v2, items, "next", 1100); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100), 1100) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32)) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 1100); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32), 1100) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).d.length; @@ -2693,10 +2694,10 @@ export function fill$array275_u32_iter_Map_iter_Flatten_array_IntoIter_ops_Range rt.iterExtend(v2, items, "next", 1100); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100), 1100) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32)) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 1100); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32), 1100) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).d.length; @@ -2763,10 +2764,10 @@ export function fill$array275_u32_iter_Map_iter_Flatten_array_IntoIter_ops_Range rt.iterExtend(v2, items, "next", 1100); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100), 1100) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32)) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 1100); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32), 1100) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).d.length; @@ -2833,10 +2834,10 @@ export function fill$array275_u32_iter_Map_ops_RangeInclusive_u32_hints_typed_cl rt.iterExtend(v2, items, undefined, 1100, true); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 1100, true)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 1100, true), 1100) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32)) as rt.VecDeque; - rt.dequeExtend(q, items, undefined, 1100, true); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32), 1100) as rt.VecDeque; + rt.dequeExtend(q, items, undefined, true); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, undefined, 1100, true), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).d.length; @@ -2903,10 +2904,10 @@ export function fill$array275_u32_iter_Skip_iter_Map_ops_RangeInclusive_u32_hint rt.iterExtend(v2, items, "next", 1100); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100), 1100) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32)) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 1100); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32), 1100) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).d.length; @@ -2972,10 +2973,10 @@ export function fill$hints_Unit_iter_Filter_iter_Map_ops_RangeInclusive_u32_hint rt.iterExtend(v2, items, "next", 0); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0), 0) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone)) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 0); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone), 0) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 0), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)).d.length; @@ -3041,10 +3042,10 @@ export function fill$hints_Unit_iter_Map_iter_Flatten_array_IntoIter_ops_RangeIn rt.iterExtend(v2, items, "next", 0); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0), 0) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone)) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 0); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone), 0) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 0), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)).d.length; @@ -3110,10 +3111,10 @@ export function fill$hints_Unit_iter_Map_iter_Flatten_array_IntoIter_ops_RangeIn rt.iterExtend(v2, items, "next", 0); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0), 0) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone)) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 0); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone), 0) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 0), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)).d.length; @@ -3179,10 +3180,10 @@ export function fill$hints_Unit_iter_Map_ops_RangeInclusive_u32_hints_typed_clos rt.iterExtend(v2, items, undefined, 0, true); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 0, true)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 0, true), 0) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone)) as rt.VecDeque; - rt.dequeExtend(q, items, undefined, 0, true); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone), 0) as rt.VecDeque; + rt.dequeExtend(q, items, undefined, true); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, undefined, 0, true), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)).d.length; @@ -3248,10 +3249,10 @@ export function fill$hints_Unit_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_ rt.iterExtend(v2, items, "next", 0); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0), 0) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone)) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 0); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone), 0) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 0), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)).d.length; @@ -3318,10 +3319,10 @@ export function fill$tuple2_u64_u8_iter_Filter_iter_Map_ops_RangeInclusive_u32_h rt.iterExtend(v2, items, "next", 16); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16)) as rt.VecDeque<[rt.u64, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8)) as rt.VecDeque<[rt.u64, rt.u8]>; - rt.dequeExtend(q, items, "next", 16); + const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 16), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))).d.length; @@ -3388,10 +3389,10 @@ export function fill$tuple2_u64_u8_iter_Map_iter_Flatten_array_IntoIter_ops_Rang rt.iterExtend(v2, items, "next", 16); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16)) as rt.VecDeque<[rt.u64, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8)) as rt.VecDeque<[rt.u64, rt.u8]>; - rt.dequeExtend(q, items, "next", 16); + const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 16), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))).d.length; @@ -3458,10 +3459,10 @@ export function fill$tuple2_u64_u8_iter_Map_iter_Flatten_array_IntoIter_ops_Rang rt.iterExtend(v2, items, "next", 16); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16)) as rt.VecDeque<[rt.u64, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8)) as rt.VecDeque<[rt.u64, rt.u8]>; - rt.dequeExtend(q, items, "next", 16); + const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 16), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))).d.length; @@ -3528,10 +3529,10 @@ export function fill$tuple2_u64_u8_iter_Map_ops_RangeInclusive_u32_hints_typed_c rt.iterExtend(v2, items, undefined, 16, true); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 16, true)) as rt.VecDeque<[rt.u64, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 16, true), 16) as rt.VecDeque<[rt.u64, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8)) as rt.VecDeque<[rt.u64, rt.u8]>; - rt.dequeExtend(q, items, undefined, 16, true); + const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + rt.dequeExtend(q, items, undefined, true); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, undefined, 16, true), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))).d.length; @@ -3598,10 +3599,10 @@ export function fill$tuple2_u64_u8_iter_Skip_iter_Map_ops_RangeInclusive_u32_hin rt.iterExtend(v2, items, "next", 16); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16)) as rt.VecDeque<[rt.u64, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8)) as rt.VecDeque<[rt.u64, rt.u8]>; - rt.dequeExtend(q, items, "next", 16); + const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 16), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))).d.length; @@ -3667,10 +3668,10 @@ export function fill$tuple3_u8_u8_u8_iter_Filter_iter_Map_ops_RangeInclusive_u32 rt.iterExtend(v2, items, "next", 3); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; - rt.dequeExtend(q, items, "next", 3); + const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))).d.length; @@ -3736,10 +3737,10 @@ export function fill$tuple3_u8_u8_u8_iter_Map_iter_Flatten_array_IntoIter_ops_Ra rt.iterExtend(v2, items, "next", 3); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; - rt.dequeExtend(q, items, "next", 3); + const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))).d.length; @@ -3805,10 +3806,10 @@ export function fill$tuple3_u8_u8_u8_iter_Map_iter_Flatten_array_IntoIter_ops_Ra rt.iterExtend(v2, items, "next", 3); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; - rt.dequeExtend(q, items, "next", 3); + const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))).d.length; @@ -3874,10 +3875,10 @@ export function fill$tuple3_u8_u8_u8_iter_Map_ops_RangeInclusive_u32_hints_typed rt.iterExtend(v2, items, undefined, 3, true); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 3, true)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 3, true), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; - rt.dequeExtend(q, items, undefined, 3, true); + const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; + rt.dequeExtend(q, items, undefined, true); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, undefined, 3, true), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))).d.length; @@ -3943,10 +3944,10 @@ export function fill$tuple3_u8_u8_u8_iter_Skip_iter_Map_ops_RangeInclusive_u32_h rt.iterExtend(v2, items, "next", 3); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; - rt.dequeExtend(q, items, "next", 3); + const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))).d.length; @@ -4012,10 +4013,10 @@ export function fill$u32_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed rt.iterExtend(v2, items, "next", 4); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4), 4) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined)) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 4); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 4) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 4), rt.le, rt.ge, rt.lt).d.length; @@ -4081,10 +4082,10 @@ export function fill$u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive rt.iterExtend(v2, items, "next", 4); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4), 4) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined)) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 4); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 4) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 4), rt.le, rt.ge, rt.lt).d.length; @@ -4150,10 +4151,10 @@ export function fill$u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive rt.iterExtend(v2, items, "next", 4); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4), 4) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined)) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 4); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 4) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 4), rt.le, rt.ge, rt.lt).d.length; @@ -4219,10 +4220,10 @@ export function fill$u32_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u3 rt.iterExtend(v2, items, undefined, 4, true); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 4, true)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 4, true), 4) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined)) as rt.VecDeque; - rt.dequeExtend(q, items, undefined, 4, true); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 4) as rt.VecDeque; + rt.dequeExtend(q, items, undefined, true); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, undefined, 4, true), rt.le, rt.ge, rt.lt).d.length; @@ -4288,10 +4289,10 @@ export function fill$u32_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_c rt.iterExtend(v2, items, "next", 4); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4), 4) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined)) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 4); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 4) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 4), rt.le, rt.ge, rt.lt).d.length; @@ -4357,10 +4358,10 @@ export function fill$u8_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_ rt.iterExtendBytes(v2, items, "next"); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1), 1, true) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2))) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 1); + const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2)), 1, true) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 1), rt.le, rt.ge, rt.lt).d.length; @@ -4426,10 +4427,10 @@ export function fill$u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_ rt.iterExtendBytes(v2, items, "next"); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1), 1, true) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2))) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 1); + const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2)), 1, true) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 1), rt.le, rt.ge, rt.lt).d.length; @@ -4495,10 +4496,10 @@ export function fill$u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_ rt.iterExtendBytes(v2, items, "next"); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1), 1, true) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2))) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 1); + const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2)), 1, true) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 1), rt.le, rt.ge, rt.lt).d.length; @@ -4564,10 +4565,10 @@ export function fill$u8_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u8_ rt.iterExtendBytes(v2, items, undefined, true); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 1, true)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 1, true), 1, true) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2))) as rt.VecDeque; - rt.dequeExtend(q, items, undefined, 1, true); + const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2)), 1, true) as rt.VecDeque; + rt.dequeExtend(q, items, undefined, true); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, undefined, 1, true), rt.le, rt.ge, rt.lt).d.length; @@ -4633,10 +4634,10 @@ export function fill$u8_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_cl rt.iterExtendBytes(v2, items, "next"); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1), 1, true) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2))) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 1); + const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2)), 1, true) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 1), rt.le, rt.ge, rt.lt).d.length; diff --git a/ts/fixtures/lang/expected/joins.ts b/ts/fixtures/lang/expected/joins.ts index 3c10edf32..5d1391760 100644 --- a/ts/fixtures/lang/expected/joins.ts +++ b/ts/fixtures/lang/expected/joins.ts @@ -6,7 +6,7 @@ import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, unwrapOr$1j4op5y as option import { put as fmt_put } from "./fmt.ts"; import * as joins_Logged from "./joins.Logged.ts"; import * as Sentinel from "./joins.Sentinel.ts"; -import { text } from "./strs.ts"; +import { text as strs_text } from "./strs.ts"; /** Puts what was logged since the last flush, after a marker. */ export function flush(log: rt.RefCell, out: rt.ByteVec): void { @@ -187,9 +187,9 @@ export function joins(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { log[Symbol.dispose](); } else if (_26 === 4) { const owned2: string[] = rt.iterToArray(rt.iterMap(rt.iterSlice(parts), (p3: rt.ByteSlice): string => { - return text(p3); + return strs_text(p3); }), undefined, 12, true); - const sep4: string = text(seps); + const sep4: string = strs_text(seps); fmt_put(out, rt.strsJoin(owned2, "")); fmt_put(out, rt.strsJoin(owned2, sep4)); const borrowed: string[] = rt.iterToArray(rt.iterMap(rt.iterSlice(owned2), (a02: string): string => { @@ -229,14 +229,14 @@ export function joins(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (rt.usizeRem(_214[0], 2) === 0) { return "ab"; } - return text(_214[1]); + return strs_text(_214[1]); }), undefined, 12, true); fmt_put(out, rt.strsJoin(texts, "")); fmt_put(out, rt.strsJoin(texts, "--")); } else { const big: rt.ByteVec = rt.byteVecOf(1, 1 << 16); const wide4: rt.u16[] = rt.vecFromElem(1, 1 << 16, undefined); - const text_: string = text(rt.byteVecSlice(big)); + const text: string = strs_text(rt.byteVecSlice(big)); const refs: (a0: rt.usize) => rt.ByteSlice[] = (n: rt.usize): rt.ByteSlice[] => { return rt.vecFromElem(rt.byteSliceRange(rt.byteVecSlice(big), 0), n, undefined); }; @@ -250,9 +250,9 @@ export function joins(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_512 === 3) { wides(rt.slicesJoin(rt.vecFromElem(rt.sliceRange(wide4, 0), rt.usizeAdd(1 << 14, 1), undefined), 2), out); } else if (_512 === 4) { - fmt_put(out, rt.strsJoin(rt.vecFromElem(text_, rt.usizeAdd(1 << 15, 1), undefined), "")); + fmt_put(out, rt.strsJoin(rt.vecFromElem(text, rt.usizeAdd(1 << 15, 1), undefined), "")); } else if (_512 === 5) { - fmt_put(out, rt.strsJoin(rt.vecFromElem(text_, rt.usizeAdd(1 << 16, 1), undefined), "")); + fmt_put(out, rt.strsJoin(rt.vecFromElem(text, rt.usizeAdd(1 << 16, 1), undefined), "")); } else { const sep5: Sentinel.Sentinel[] = rt.iterToArray(rt.iterMap(new rt.Range(0, 1 << 16), (i: rt.i32): Sentinel.Sentinel => { return { _0: (i & 0xff) ^ 90 }; diff --git a/ts/fixtures/lang/expected/keys.ts b/ts/fixtures/lang/expected/keys.ts index acc506612..65a8e47df 100644 --- a/ts/fixtures/lang/expected/keys.ts +++ b/ts/fixtures/lang/expected/keys.ts @@ -1431,7 +1431,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void export function lentValues(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const map: rt.HashMap = rt.hashNew() as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - const deque: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const deque: rt.VecDeque = rt.dequeNew(2) as rt.VecDeque; const heap: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; const iter: rt.Iter = rt.byteSliceWindows(data, 2); while (true) { @@ -3972,9 +3972,9 @@ export function taken$0_keys_byte_refs_closure1(data: rt.ByteSlice, make: (a0: r const pairs: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceWindows(data, 2), make), undefined, 0, true); const vec: Uint8Array[] = []; rt.iterExtend(vec, rt.iterMap(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 0, true); - const deque: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const deque: rt.VecDeque = rt.dequeNew(0) as rt.VecDeque; const _14: rt.Iter = rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom); - rt.dequeExtend(deque, rt.iterMap(_14, rt.byteSliceToArray), undefined, 0, true); + rt.dequeExtend(deque, rt.iterMap(_14, rt.byteSliceToArray), undefined, true); const heap: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; rt.heapExtend(heap, rt.iterMap(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray), rt.cmpLe(rt.cmpBytes), rt.cmpGe(rt.cmpBytes), rt.cmpLt(rt.cmpBytes), undefined, 0, true); const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet; @@ -4089,7 +4089,7 @@ export function taken$0_keys_byte_refs_closure1(data: rt.ByteSlice, make: (a0: r return _22 < 2; }); }, (f4) => (held6) => f4(rt.byteSliceFrom(held6)))), "next", 0)), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 0), undefined, true); - const rest: rt.Peekable = rt.iterPeekable(rt.iterSkipWhile(rt.dequeIter(rt.dequeClone(deque, copy$array_u8, 0)), rt.lending((p4: rt.ByteSlice): boolean => { + const rest: rt.Peekable = rt.iterPeekable(rt.iterSkipWhile(rt.dequeIntoIter(rt.dequeClone(deque, copy$array_u8)), rt.lending((p4: rt.ByteSlice): boolean => { return rt.byteSliceFirst(p4) === 64; }, (f6) => (held7) => f6(rt.byteSliceFrom(held7))))); const _214: rt.ByteSlice | undefined = rt.optionMap(rt.peekablePeek(rest), rt.byteSliceFrom); @@ -4273,9 +4273,9 @@ export function taken$2_keys_byte_refs_closure0(data: rt.ByteSlice, make: (a0: r const pairs: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceWindows(data, 2), make), undefined, 2, true); const vec: Uint8Array[] = []; rt.iterExtend(vec, rt.iterMap(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 2, true); - const deque: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const deque: rt.VecDeque = rt.dequeNew(2) as rt.VecDeque; const _14: rt.Iter = rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom); - rt.dequeExtend(deque, rt.iterMap(_14, rt.byteSliceToArray), undefined, 2, true); + rt.dequeExtend(deque, rt.iterMap(_14, rt.byteSliceToArray), undefined, true); const heap: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; rt.heapExtend(heap, rt.iterMap(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray), rt.cmpLe(rt.cmpBytes), rt.cmpGe(rt.cmpBytes), rt.cmpLt(rt.cmpBytes), undefined, 2, true); const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet; @@ -4390,7 +4390,7 @@ export function taken$2_keys_byte_refs_closure0(data: rt.ByteSlice, make: (a0: r return _22 < 2; }); }, (f4) => (held6) => f4(rt.byteSliceFrom(held6)))), "next", 2)), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 2), undefined, true); - const rest: rt.Peekable = rt.iterPeekable(rt.iterSkipWhile(rt.dequeIter(rt.dequeClone(deque, copy$array_u8, 2)), rt.lending((p4: rt.ByteSlice): boolean => { + const rest: rt.Peekable = rt.iterPeekable(rt.iterSkipWhile(rt.dequeIntoIter(rt.dequeClone(deque, copy$array_u8)), rt.lending((p4: rt.ByteSlice): boolean => { return rt.byteSliceFirst(p4) === 64; }, (f6) => (held7) => f6(rt.byteSliceFrom(held7))))); const _214: rt.ByteSlice | undefined = rt.optionMap(rt.peekablePeek(rest), rt.byteSliceFrom); diff --git a/ts/fixtures/lang/expected/nested.ts b/ts/fixtures/lang/expected/nested.ts index ff178e363..cfc1d2a74 100644 --- a/ts/fixtures/lang/expected/nested.ts +++ b/ts/fixtures/lang/expected/nested.ts @@ -547,7 +547,7 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { popped = rt.u8Add(popped, 1); } rt.byteVecPush(out, popped); - const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const q: rt.VecDeque = rt.dequeNew(2) as rt.VecDeque; const iter2: rt.Iter<[rt.usize, rt.u8 | undefined]> = rt.iterEnumerate(rt.iterSlice(items)); while (true) { const _167: [rt.usize, rt.u8 | undefined] | rt.Done = iter2.next(); @@ -593,7 +593,7 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { } } rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.dequePopFront(q, rt.None)), code(rt.dequePopBack(q, rt.None)), code(rt.dequeEnd(q, false, rt.None)), code(rt.dequeRemove(q, 0, rt.None)), code(rt.dequeSwapRemove(q, 0, true, rt.None)), code(rt.dequeSwapRemove(q, 0, false, rt.None)))), undefined, true); - const unitQ: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(undefined, rt.usizeMul(data.length, 2), undefined)) as rt.VecDeque; + const unitQ: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(undefined, rt.usizeMul(data.length, 2), undefined), 0) as rt.VecDeque; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.dequeEnd(unitQ, false, rt.None) !== rt.None ? 1 : 0, rt.dequeEnd(unitQ, true, rt.None) !== rt.None ? 1 : 0, rt.dequeGet(unitQ, at, rt.None) !== rt.None ? 1 : 0)), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.dequePopBack(unitQ, rt.None) !== rt.None ? 1 : 0, rt.dequeRemove(unitQ, at, rt.None) !== rt.None ? 1 : 0, rt.dequeSwapRemove(unitQ, at, true, rt.None) !== rt.None ? 1 : 0, rt.dequeSwapRemove(unitQ, at, false, rt.None) !== rt.None ? 1 : 0, rt.dequePopFront(unitQ, rt.None) !== rt.None ? 1 : 0, unitQ.n & 0xff)), undefined, true); const heap: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterSlice(items), undefined, 2, true), rt.cmpLe(rt.cmpOption(rt.cmp)), rt.cmpGe(rt.cmpOption(rt.cmp)), rt.cmpLt(rt.cmpOption(rt.cmp))); @@ -746,7 +746,7 @@ export function madeAll$nested_Unit(m: nested_Unit.Unit, data: rt.ByteSlice): un export function units(data: rt.ByteSlice, out: rt.ByteVec): void { let f!: (a0: rt.u8) => undefined; const units: undefined[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): undefined => {}), undefined, 0, true); - const q: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), (_22: rt.u8): undefined => {}), undefined, 0, true)) as rt.VecDeque; + const q: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), (_22: rt.u8): undefined => {}), undefined, 0, true), 0) as rt.VecDeque; const named: undefined[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), ignore as (a0: rt.u8) => undefined), undefined, 0, true); const _15: rt.u8 | undefined = rt.byteSliceFirst(data); b0: { diff --git a/ts/fixtures/lang/expected/objects.ts b/ts/fixtures/lang/expected/objects.ts index ab7b20790..c44de07ba 100644 --- a/ts/fixtures/lang/expected/objects.ts +++ b/ts/fixtures/lang/expected/objects.ts @@ -187,7 +187,7 @@ export function refill(v: rt.Arc[], bytes: rt.ByteVec, with_: rt.Arc, map: rt.HashMap, n: rt.u8): rt.usize { - const old: rt.VecDeque = rt.replaceIn(q, rt.dequeFromVec(rt.iterToArray(new rt.Range(0, rt.u8Rem(n, 5)), undefined, 1, true)) as rt.VecDeque); + const old: rt.VecDeque = rt.replaceIn(q, rt.dequeFromVec(rt.iterToArray(new rt.Range(0, rt.u8Rem(n, 5)), undefined, 1, true), 1, true) as rt.VecDeque); Object.assign(map, rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice([[n, n] as [rt.u8, rt.u8]]), undefined, undefined, undefined, 469762048)); return old.n; } @@ -442,8 +442,7 @@ export function objects(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteVecSlice(bytes)); counts(out, [one, two], w.held); counts(out, [one, two], other); - const _515: Uint8Array = Uint8Array.of(by); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_515), undefined, 1, true); + const q: rt.VecDeque = rt.dequeFromArray(Uint8Array.of(by), 1, true) as rt.VecDeque; const map: rt.HashMap = rt.hashNew() as rt.HashMap; for (const _519 of rt.byteSliceView(data)) { rt.byteVecPush(out, requeue(q, map, _519) & 0xff); diff --git a/ts/fixtures/lang/expected/orders.ts b/ts/fixtures/lang/expected/orders.ts index 0c9a4a0b7..8be90efc1 100644 --- a/ts/fixtures/lang/expected/orders.ts +++ b/ts/fixtures/lang/expected/orders.ts @@ -751,7 +751,7 @@ export function deque$orders_Part_orders_held_closure3(sData: Uint8Array, sStart const _17: rt.usize = at; const d: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rt.usize, rt.u8]): Part.Part => { return f(rt.usizeAdd(_2[0], _17), _2[1]); - }), undefined, 2, true)) as rt.VecDeque; + }), undefined, 2, true), 2) as rt.VecDeque; const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart, mid))))); while (true) { const _23: [rt.usize, rt.u8] | rt.Done = iter.next(); @@ -781,7 +781,7 @@ export function deque$orders_Part_orders_part(sData: Uint8Array, sStart: number, const _17: rt.usize = at; const d: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rt.usize, rt.u8]): Part.Part => { return part(rt.usizeAdd(_2[0], _17), _2[1]); - }), undefined, 2, true)) as rt.VecDeque; + }), undefined, 2, true), 2) as rt.VecDeque; const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart, mid))))); while (true) { const _23: [rt.usize, rt.u8] | rt.Done = iter.next(); @@ -811,7 +811,7 @@ export function deque$u8_orders_held_closure11(sData: Uint8Array, sStart: number const _17: rt.usize = at; const d: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rt.usize, rt.u8]): rt.u8 => { return f(rt.usizeAdd(_2[0], _17), _2[1]); - }), undefined, 1, true)) as rt.VecDeque; + }), undefined, 1, true), 1, true) as rt.VecDeque; const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart, mid))))); while (true) { const _23: [rt.usize, rt.u8] | rt.Done = iter.next(); @@ -841,7 +841,7 @@ export function deque$u8_orders_held_closure8(sData: Uint8Array, sStart: number, const _17: rt.usize = at; const d: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rt.usize, rt.u8]): rt.u8 => { return f(rt.usizeAdd(_2[0], _17), _2[1]); - }), undefined, 1, true)) as rt.VecDeque; + }), undefined, 1, true), 1, true) as rt.VecDeque; const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart, mid))))); while (true) { const _23: [rt.usize, rt.u8] | rt.Done = iter.next(); @@ -892,7 +892,7 @@ export function held(data: rt.ByteSlice, out: rt.ByteVec): void { return p2.key as rt.f64; } return NaN; - }), undefined, 8, true)) as rt.VecDeque; + }), undefined, 8, true), 8) as rt.VecDeque; }; const iter: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.byteSliceWindows(data, 2)); while (true) { diff --git a/ts/fixtures/lang/expected/refs.ts b/ts/fixtures/lang/expected/refs.ts index 028122014..1c367ecac 100644 --- a/ts/fixtures/lang/expected/refs.ts +++ b/ts/fixtures/lang/expected/refs.ts @@ -753,7 +753,7 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { } const hash: rt.HashMap = rt.hashNew() as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - const queue: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const queue: rt.VecDeque = rt.dequeNew(4) as rt.VecDeque; for (const b2 of rt.byteSliceView(data)) { rt.entryOrInsert(rt.entryAndModify(rt.entry(hash, rt.u8Rem(b2, 5)), (x9: [rt.u8, rt.u8]): undefined => { x9[1] = rt.u8WrappingAdd(x9[1], b2); @@ -1041,7 +1041,7 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, k3); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(x5))); } - const iter36: rt.Iter = rt.dequeIter(queue); + const iter36: rt.Iter = rt.dequeIntoIter(queue); while (true) { const _590: rt.u32 | rt.Done = iter36.next(); if (_590 === rt.DONE) { diff --git a/ts/fixtures/lang/expected/rings.Big.ts b/ts/fixtures/lang/expected/rings.Big.ts new file mode 100644 index 000000000..50f04acf6 --- /dev/null +++ b/ts/fixtures/lang/expected/rings.Big.ts @@ -0,0 +1,30 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; + +export function clone$Clone(self: Big): Big { + return { id: self.id, pad: rt.byteSliceToArray(rt.byteSliceFrom(self.pad)) }; +} + +/** Past 1 KiB, which std's grows from one slot rather than four. */ +export interface Big { + id: rt.u8; + pad: Uint8Array; +} + +export function fmt$fmt_Debug(self: Big, f: rt.Formatter): rt.Result { + const part = self.pad[1099]; + const arg = self.id; + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg, f), (f: rt.Formatter) => rt.u8Display(part, f)]; + return rt.fmtWriteFmt(f, ["B", args2[0], ".", args2[1]]); +} + +export function make$rings_Item(b: rt.u8): Big { + return { id: b, pad: rt.bytes(1100).fill(b) }; +} + +export function bump$rings_Item(self: Big): void { + self.id = rt.u8WrappingAdd(self.id, 1); +} + +//# sourceMappingURL=rings.Big.ts.map diff --git a/ts/fixtures/lang/expected/rings.ts b/ts/fixtures/lang/expected/rings.ts new file mode 100644 index 000000000..899fa149c --- /dev/null +++ b/ts/fixtures/lang/expected/rings.ts @@ -0,0 +1,1337 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$1ttssgs as option_mapOr$1ttssgs } from "./core/option.ts"; +import * as Big from "./rings.Big.ts"; + +export function make$rings_Item_u8(b: rt.u8): rt.u8 { + return b; +} + +export function bump$rings_Item_u8(self: rt.Place): void { + self.v = rt.u8WrappingAdd(self.v, 1); +} + +export function make$rings_Item_u32(b: rt.u8): rt.u32 { + return (((b as rt.u32)) << 12) >>> 0; +} + +export function bump$rings_Item_u32(self: rt.Place): void { + self.v = rt.u32Add(self.v, 1); +} + +export function make$rings_Item_String(b: rt.u8): string { + const part = rt.u8Rem(b, 16); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(part, f)]; + return rt.fmtFormat(["s", args2[0]]); +} + +export function bump$rings_Item_String(self: rt.Place): void { + self.v = self.v + "!"; +} + +export function make$rings_Item_unit(_1: rt.u8): void { +} + +export function bump$rings_Item_unit(_self: rt.Place): void { +} + +/** Steps a deque of the item type `kind` picks through `data`. */ +export function slices(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const _4: rt.u8 = rt.u8Rem(kind, 5); + if (_4 === 0) { + steps$u8(dataData, dataStart, dataLen, out); + } else if (_4 === 1) { + steps$u32(dataData, dataStart, dataLen, out); + } else if (_4 === 2) { + steps$String(dataData, dataStart, dataLen, out); + } else if (_4 === 3) { + steps$unit(dataData, dataStart, dataLen, out); + } else { + steps$rings_Big(dataData, dataStart, dataLen, out); + } +} + +/** A length or capacity, as four bytes. */ +export function put(out: rt.ByteVec, n: rt.usize): void { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(n as rt.u32).reverse())); +} + +/** What `{:?}` writes of `value`. */ +export function text$Option_ref_String(out: rt.ByteVec, value: string | undefined): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(value, f, rt.fmtStr)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$Option_ref_rings_Big(out: rt.ByteVec, value: Big.Big | undefined): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(value, f, (value: Big.Big, f: rt.Formatter) => Big.fmt$fmt_Debug(value, f))]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$Option_ref_u32(out: rt.ByteVec, value: rt.u32 | undefined): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$Option_ref_u8(out: rt.ByteVec, value: rt.u8 | undefined): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$Option_ref_unit(out: rt.ByteVec, value: undefined | rt.None): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(value, f, rt.fmtUnit, rt.None)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_Drain_String(out: rt.ByteVec, value: rt.Iter): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeDrain(value, f, rt.usizeDebug)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_Drain_rings_Big(out: rt.ByteVec, value: rt.Iter): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeDrain(value, f, rt.usizeDebug)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_Drain_u32(out: rt.ByteVec, value: rt.Iter): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeDrain(value, f, rt.usizeDebug)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_Drain_u8(out: rt.ByteVec, value: rt.Iter): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeDrain(value, f, rt.usizeDebug)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_Drain_unit(out: rt.ByteVec, value: rt.Iter): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeDrain(value, f, rt.usizeDebug)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_IterMut_String(out: rt.ByteVec, value: rt.Iter>): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, rt.fmtStr, "IterMut")]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_IterMut_rings_Big(out: rt.ByteVec, value: rt.Iter): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, (value: Big.Big, f: rt.Formatter) => Big.fmt$fmt_Debug(value, f), "IterMut")]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_IterMut_u32(out: rt.ByteVec, value: rt.Iter>): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, rt.u32Debug, "IterMut")]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_IterMut_u8(out: rt.ByteVec, value: rt.Iter>): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, rt.u8Debug, "IterMut")]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_IterMut_unit(out: rt.ByteVec, value: rt.Iter>): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, rt.fmtUnit, "IterMut")]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_Iter_String(out: rt.ByteVec, value: rt.Iter): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, rt.fmtStr, "Iter")]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_Iter_rings_Big(out: rt.ByteVec, value: rt.Iter): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, (value: Big.Big, f: rt.Formatter) => Big.fmt$fmt_Debug(value, f), "Iter")]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_Iter_u32(out: rt.ByteVec, value: rt.Iter): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, rt.u32Debug, "Iter")]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_Iter_u8(out: rt.ByteVec, value: rt.Iter): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, rt.u8Debug, "Iter")]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_Iter_unit(out: rt.ByteVec, value: rt.Iter): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, rt.fmtUnit, "Iter")]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$tuple2_ref_slice_String_ref_slice_String(out: rt.ByteVec, value: [string[], string[]]): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtList(value[0], f, rt.fmtStr), (f: rt.Formatter) => rt.fmtList(value[1], f, rt.fmtStr)], f)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$tuple2_ref_slice_rings_Big_ref_slice_rings_Big(out: rt.ByteVec, value: [Big.Big[], Big.Big[]]): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtList(value[0], f, (value: Big.Big, f: rt.Formatter) => Big.fmt$fmt_Debug(value, f)), (f: rt.Formatter) => rt.fmtList(value[1], f, (value: Big.Big, f: rt.Formatter) => Big.fmt$fmt_Debug(value, f))], f)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$tuple2_ref_slice_u32_ref_slice_u32(out: rt.ByteVec, value: [rt.u32[], rt.u32[]]): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtList(value[0], f, rt.u32Debug), (f: rt.Formatter) => rt.fmtList(value[1], f, rt.u32Debug)], f)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$tuple2_ref_slice_u8_ref_slice_u8(out: rt.ByteVec, value: [rt.ByteSlice, rt.ByteSlice]): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value[0]), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value[1]), f, rt.u8Debug)], f)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$tuple2_ref_slice_unit_ref_slice_unit(out: rt.ByteVec, value: [undefined[], undefined[]]): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtList(value[0], f, rt.fmtUnit), (f: rt.Formatter) => rt.fmtList(value[1], f, rt.fmtUnit)], f)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** + * A deque the first byte makes, new, with room for a few, or from a `Vec` of a few, and + * each pair after it steps: after each, its length, capacity, and two slices. + */ +export function steps$String(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + let q!: rt.VecDeque; + const _7: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; + const _5: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _7, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; + }); + const first: rt.u8 = _5[0]; + const n: rt.usize = rt.usizeRem(first >> 2 as rt.usize, 12); + const _17: rt.u8 = rt.u8Rem(first, 3); + if (_17 === 0) { + q = rt.dequeNew(12) as rt.VecDeque; + } else if (_17 === 1) { + q = rt.dequeWithCapacity(n, 12) as rt.VecDeque; + } else { + q = rt.dequeFromVec(rt.vecFromElem(make$rings_Item_String(first), n, undefined), 12) as rt.VecDeque; + } + const iter: rt.Iter = rt.byteSliceChunks(_5[1], 2); + while (true) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { + break; + } + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + const at: rt.usize = rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)); + b3: { + const _46: rt.u8 = rt.u8Rem(op, 24); + if (0 <= _46) { + if (_46 <= 3) { + rt.dequePushBack(q, make$rings_Item_String(arg)); + break b3; + } + } + if (_46 === 4 || _46 === 5) { + rt.dequePushFront(q, make$rings_Item_String(arg)); + } else if (_46 === 6) { + rt.dequePopFront(q); + } else if (_46 === 7) { + rt.dequePopBack(q); + } else if (_46 === 8) { + rt.dequeInsert(q, at, make$rings_Item_String(arg)); + } else if (_46 === 9) { + rt.dequeRemove(q, at); + } else if (_46 === 10) { + rt.dequeSwapRemove(q, at); + } else if (_46 === 11) { + rt.dequeSwapRemove(q, at, true); + } else if (_46 === 12) { + rt.dequeTruncate(q, rt.usizeRem(arg as rt.usize, 8)); + } else if (_46 === 13) { + let kept: rt.u8 = arg; + rt.dequeRetain(q, (_23: string): boolean => { + kept = rt.intRotateLeft(kept, 1, 8, false); + return (kept & 1) === 1; + }); + } else if (_46 === 14) { + drained$String(q, arg, out); + } else if (_46 === 15) { + rt.dequeReserve(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 16) { + rt.dequeReserveExact(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 17) { + rt.dequeShrinkTo(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 18) { + rt.dequeShrinkTo(q, 0); + } else if (_46 === 19) { + rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 8)), (i: rt.u8): boolean => { + return rt.u8Rem(i, 3) !== 0; + }), make$rings_Item_String), "next"); + } else if (_46 === 20) { + rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 8)), make$rings_Item_String), undefined, true); + } else if (_46 === 21) { + rt.dequeClear(q); + } else if (_46 === 22) { + q = remade$String(q, arg); + } else { + mutated$String(q, arg, out); + } + } + put(out, q.n); + put(out, rt.dequeCapacity(q)); + text$tuple2_ref_slice_String_ref_slice_String(out, rt.dequeAsSlices(q)); + iterated$String(q, arg, out); + } +} + +/** + * A deque the first byte makes, new, with room for a few, or from a `Vec` of a few, and + * each pair after it steps: after each, its length, capacity, and two slices. + */ +export function steps$rings_Big(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + let q!: rt.VecDeque; + const _7: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; + const _5: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _7, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; + }); + const first: rt.u8 = _5[0]; + const n: rt.usize = rt.usizeRem(first >> 2 as rt.usize, 12); + const _17: rt.u8 = rt.u8Rem(first, 3); + if (_17 === 0) { + q = rt.dequeNew(1101) as rt.VecDeque; + } else if (_17 === 1) { + q = rt.dequeWithCapacity(n, 1101) as rt.VecDeque; + } else { + q = rt.dequeFromVec(rt.vecFromElem(Big.make$rings_Item(first), n, Big.clone$Clone), 1101) as rt.VecDeque; + } + const iter: rt.Iter = rt.byteSliceChunks(_5[1], 2); + while (true) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { + break; + } + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + const at: rt.usize = rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)); + b3: { + const _46: rt.u8 = rt.u8Rem(op, 24); + if (0 <= _46) { + if (_46 <= 3) { + rt.dequePushBack(q, Big.make$rings_Item(arg)); + break b3; + } + } + if (_46 === 4 || _46 === 5) { + rt.dequePushFront(q, Big.make$rings_Item(arg)); + } else if (_46 === 6) { + rt.dequePopFront(q); + } else if (_46 === 7) { + rt.dequePopBack(q); + } else if (_46 === 8) { + rt.dequeInsert(q, at, Big.make$rings_Item(arg)); + } else if (_46 === 9) { + rt.dequeRemove(q, at); + } else if (_46 === 10) { + rt.dequeSwapRemove(q, at); + } else if (_46 === 11) { + rt.dequeSwapRemove(q, at, true); + } else if (_46 === 12) { + rt.dequeTruncate(q, rt.usizeRem(arg as rt.usize, 8)); + } else if (_46 === 13) { + let kept: rt.u8 = arg; + rt.dequeRetain(q, (_23: Big.Big): boolean => { + kept = rt.intRotateLeft(kept, 1, 8, false); + return (kept & 1) === 1; + }); + } else if (_46 === 14) { + drained$rings_Big(q, arg, out); + } else if (_46 === 15) { + rt.dequeReserve(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 16) { + rt.dequeReserveExact(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 17) { + rt.dequeShrinkTo(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 18) { + rt.dequeShrinkTo(q, 0); + } else if (_46 === 19) { + rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 8)), (i: rt.u8): boolean => { + return rt.u8Rem(i, 3) !== 0; + }), Big.make$rings_Item), "next"); + } else if (_46 === 20) { + rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 8)), Big.make$rings_Item), undefined, true); + } else if (_46 === 21) { + rt.dequeClear(q); + } else if (_46 === 22) { + q = remade$rings_Big(q, arg); + } else { + mutated$rings_Big(q, arg, out); + } + } + put(out, q.n); + put(out, rt.dequeCapacity(q)); + text$tuple2_ref_slice_rings_Big_ref_slice_rings_Big(out, rt.dequeAsSlices(q)); + iterated$rings_Big(q, arg, out); + } +} + +/** + * A deque the first byte makes, new, with room for a few, or from a `Vec` of a few, and + * each pair after it steps: after each, its length, capacity, and two slices. + */ +export function steps$u32(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + let q!: rt.VecDeque; + const _7: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; + const _5: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _7, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; + }); + const first: rt.u8 = _5[0]; + const n: rt.usize = rt.usizeRem(first >> 2 as rt.usize, 12); + const _17: rt.u8 = rt.u8Rem(first, 3); + if (_17 === 0) { + q = rt.dequeNew(4) as rt.VecDeque; + } else if (_17 === 1) { + q = rt.dequeWithCapacity(n, 4) as rt.VecDeque; + } else { + q = rt.dequeFromVec(rt.vecFromElem(make$rings_Item_u32(first), n, undefined), 4) as rt.VecDeque; + } + const iter: rt.Iter = rt.byteSliceChunks(_5[1], 2); + while (true) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { + break; + } + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + const at: rt.usize = rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)); + b3: { + const _46: rt.u8 = rt.u8Rem(op, 24); + if (0 <= _46) { + if (_46 <= 3) { + rt.dequePushBack(q, make$rings_Item_u32(arg)); + break b3; + } + } + if (_46 === 4 || _46 === 5) { + rt.dequePushFront(q, make$rings_Item_u32(arg)); + } else if (_46 === 6) { + rt.dequePopFront(q); + } else if (_46 === 7) { + rt.dequePopBack(q); + } else if (_46 === 8) { + rt.dequeInsert(q, at, make$rings_Item_u32(arg)); + } else if (_46 === 9) { + rt.dequeRemove(q, at); + } else if (_46 === 10) { + rt.dequeSwapRemove(q, at); + } else if (_46 === 11) { + rt.dequeSwapRemove(q, at, true); + } else if (_46 === 12) { + rt.dequeTruncate(q, rt.usizeRem(arg as rt.usize, 8)); + } else if (_46 === 13) { + let kept: rt.u8 = arg; + rt.dequeRetain(q, (_23: rt.u32): boolean => { + kept = rt.intRotateLeft(kept, 1, 8, false); + return (kept & 1) === 1; + }); + } else if (_46 === 14) { + drained$u32(q, arg, out); + } else if (_46 === 15) { + rt.dequeReserve(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 16) { + rt.dequeReserveExact(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 17) { + rt.dequeShrinkTo(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 18) { + rt.dequeShrinkTo(q, 0); + } else if (_46 === 19) { + rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 8)), (i: rt.u8): boolean => { + return rt.u8Rem(i, 3) !== 0; + }), make$rings_Item_u32), "next"); + } else if (_46 === 20) { + rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 8)), make$rings_Item_u32), undefined, true); + } else if (_46 === 21) { + rt.dequeClear(q); + } else if (_46 === 22) { + q = remade$u32(q, arg); + } else { + mutated$u32(q, arg, out); + } + } + put(out, q.n); + put(out, rt.dequeCapacity(q)); + text$tuple2_ref_slice_u32_ref_slice_u32(out, rt.dequeAsSlices(q)); + iterated$u32(q, arg, out); + } +} + +/** + * A deque the first byte makes, new, with room for a few, or from a `Vec` of a few, and + * each pair after it steps: after each, its length, capacity, and two slices. + */ +export function steps$u8(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + let q!: rt.VecDeque; + const _7: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; + const _5: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _7, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; + }); + const first: rt.u8 = _5[0]; + const n: rt.usize = rt.usizeRem(first >> 2 as rt.usize, 12); + const _17: rt.u8 = rt.u8Rem(first, 3); + if (_17 === 0) { + q = rt.dequeNew(1, true) as rt.VecDeque; + } else if (_17 === 1) { + q = rt.dequeWithCapacity(n, 1, true) as rt.VecDeque; + } else { + q = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(make$rings_Item_u8(first), n)), 1, true) as rt.VecDeque; + } + const iter: rt.Iter = rt.byteSliceChunks(_5[1], 2); + while (true) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { + break; + } + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + const at: rt.usize = rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)); + b3: { + const _46: rt.u8 = rt.u8Rem(op, 24); + if (0 <= _46) { + if (_46 <= 3) { + rt.dequePushBack(q, make$rings_Item_u8(arg)); + break b3; + } + } + if (_46 === 4 || _46 === 5) { + rt.dequePushFront(q, make$rings_Item_u8(arg)); + } else if (_46 === 6) { + rt.dequePopFront(q); + } else if (_46 === 7) { + rt.dequePopBack(q); + } else if (_46 === 8) { + rt.dequeInsert(q, at, make$rings_Item_u8(arg)); + } else if (_46 === 9) { + rt.dequeRemove(q, at); + } else if (_46 === 10) { + rt.dequeSwapRemove(q, at); + } else if (_46 === 11) { + rt.dequeSwapRemove(q, at, true); + } else if (_46 === 12) { + rt.dequeTruncate(q, rt.usizeRem(arg as rt.usize, 8)); + } else if (_46 === 13) { + let kept: rt.u8 = arg; + rt.dequeRetain(q, (_23: rt.u8): boolean => { + kept = rt.intRotateLeft(kept, 1, 8, false); + return (kept & 1) === 1; + }); + } else if (_46 === 14) { + drained$u8(q, arg, out); + } else if (_46 === 15) { + rt.dequeReserve(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 16) { + rt.dequeReserveExact(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 17) { + rt.dequeShrinkTo(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 18) { + rt.dequeShrinkTo(q, 0); + } else if (_46 === 19) { + rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 8)), (i: rt.u8): boolean => { + return rt.u8Rem(i, 3) !== 0; + }), make$rings_Item_u8), "next"); + } else if (_46 === 20) { + rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 8)), make$rings_Item_u8), undefined, true); + } else if (_46 === 21) { + rt.dequeClear(q); + } else if (_46 === 22) { + q = remade$u8(q, arg); + } else { + mutated$u8(q, arg, out); + } + } + put(out, q.n); + put(out, rt.dequeCapacity(q)); + text$tuple2_ref_slice_u8_ref_slice_u8(out, rt.dequeByteSlices(q)); + iterated$u8(q, arg, out); + } +} + +/** + * A deque the first byte makes, new, with room for a few, or from a `Vec` of a few, and + * each pair after it steps: after each, its length, capacity, and two slices. + */ +export function steps$unit(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + let q!: rt.VecDeque; + const _7: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; + const _5: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _7, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; + }); + const first: rt.u8 = _5[0]; + const n: rt.usize = rt.usizeRem(first >> 2 as rt.usize, 12); + const _17: rt.u8 = rt.u8Rem(first, 3); + if (_17 === 0) { + q = rt.dequeNew(0) as rt.VecDeque; + } else if (_17 === 1) { + q = rt.dequeWithCapacity(n, 0) as rt.VecDeque; + } else { + make$rings_Item_unit(first); + q = rt.dequeFromVec(rt.vecFromElem(undefined, n, undefined), 0) as rt.VecDeque; + } + const iter: rt.Iter = rt.byteSliceChunks(_5[1], 2); + while (true) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { + break; + } + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + const at: rt.usize = rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)); + b3: { + const _46: rt.u8 = rt.u8Rem(op, 24); + if (0 <= _46) { + if (_46 <= 3) { + const _50: rt.VecDeque = q; + make$rings_Item_unit(arg); + rt.dequePushBack(_50, undefined); + break b3; + } + } + if (_46 === 4 || _46 === 5) { + const _52: rt.VecDeque = q; + make$rings_Item_unit(arg); + rt.dequePushFront(_52, undefined); + } else if (_46 === 6) { + rt.dequePopFront(q, rt.None); + } else if (_46 === 7) { + rt.dequePopBack(q, rt.None); + } else if (_46 === 8) { + const _58: rt.VecDeque = q; + make$rings_Item_unit(arg); + rt.dequeInsert(_58, at, undefined); + } else if (_46 === 9) { + rt.dequeRemove(q, at, rt.None); + } else if (_46 === 10) { + rt.dequeSwapRemove(q, at, false, rt.None); + } else if (_46 === 11) { + rt.dequeSwapRemove(q, at, true, rt.None); + } else if (_46 === 12) { + rt.dequeTruncate(q, rt.usizeRem(arg as rt.usize, 8)); + } else if (_46 === 13) { + let kept: rt.u8 = arg; + rt.dequeRetain(q, (_23: undefined): boolean => { + kept = rt.intRotateLeft(kept, 1, 8, false); + return (kept & 1) === 1; + }); + } else if (_46 === 14) { + drained$unit(q, arg, out); + } else if (_46 === 15) { + rt.dequeReserve(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 16) { + rt.dequeReserveExact(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 17) { + rt.dequeShrinkTo(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 18) { + rt.dequeShrinkTo(q, 0); + } else if (_46 === 19) { + rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 8)), (i: rt.u8): boolean => { + return rt.u8Rem(i, 3) !== 0; + }), make$rings_Item_unit as (a0: rt.u8) => undefined), "next"); + } else if (_46 === 20) { + rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 8)), make$rings_Item_unit as (a0: rt.u8) => undefined), undefined, true); + } else if (_46 === 21) { + rt.dequeClear(q); + } else if (_46 === 22) { + q = remade$unit(q, arg); + } else { + mutated$unit(q, arg, out); + } + } + put(out, q.n); + put(out, rt.dequeCapacity(q)); + text$tuple2_ref_slice_unit_ref_slice_unit(out, rt.dequeAsSlices(q)); + iterated$unit(q, arg, out); + } +} + +/** + * A deque made anew from `q`: a clone, or one with room of its own cloned from it, + * collected from its own `into_iter` or a `Vec`'s read in part, whose buffers std's takes + * as they are, or from a `Vec` it collects. + */ +export function remade$String(q: rt.VecDeque, arg: rt.u8): rt.VecDeque { + const skip: rt.usize = rt.usizeRem(rt.u8Div(arg, 5) as rt.usize, 4); + const _8: rt.u8 = rt.u8Rem(arg, 5); + if (_8 === 0) { + if (!((arg & 32) === 0)) { + const own: rt.VecDeque = rt.dequeWithCapacity(rt.usizeMul(skip, 3), 12) as rt.VecDeque; + const _18: string = make$rings_Item_String(arg); + rt.dequePushFront(own, _18); + rt.dequeCloneFrom(own, q, undefined); + return own; + } + return rt.dequeClone(q); + } + if (_8 === 1) { + const it: rt.Iter = rt.dequeIntoIter(q); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = skip; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + rt.iterToOption(it.nextBack()); + return rt.dequeFromIntoIter(it, 12) as rt.VecDeque; + } + if (_8 === 2) { + const it2: rt.Iter = rt.dequeIntoIter(q); + rt.iterNth(it2, skip); + return rt.dequeFromIntoIter(it2, 12) as rt.VecDeque; + } + if (_8 === 3) { + return rt.dequeFromVec(rt.iterToArray(rt.dequeIntoIter(q), undefined, 12, true), 12) as rt.VecDeque; + } + if (true) { + const v: string[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 12, true); + rt.vecReserve(v, skip, 12); + const it3: rt.Iter = rt.iterSlice(v); + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = skip; + while (iterStart2++ < iterEnd2) { + rt.iterToOption(it3.next()); + } + return rt.dequeFromIntoIter(it3, 12) as rt.VecDeque; + } + return q; +} + +/** + * A deque made anew from `q`: a clone, or one with room of its own cloned from it, + * collected from its own `into_iter` or a `Vec`'s read in part, whose buffers std's takes + * as they are, or from a `Vec` it collects. + */ +export function remade$rings_Big(q: rt.VecDeque, arg: rt.u8): rt.VecDeque { + const skip: rt.usize = rt.usizeRem(rt.u8Div(arg, 5) as rt.usize, 4); + const _8: rt.u8 = rt.u8Rem(arg, 5); + if (_8 === 0) { + if (!((arg & 32) === 0)) { + const own: rt.VecDeque = rt.dequeWithCapacity(rt.usizeMul(skip, 3), 1101) as rt.VecDeque; + const _18: Big.Big = Big.make$rings_Item(arg); + rt.dequePushFront(own, _18); + rt.dequeCloneFrom(own, q, Big.clone$Clone); + return own; + } + return rt.dequeClone(q, Big.clone$Clone); + } + if (_8 === 1) { + const it: rt.Iter = rt.dequeIntoIter(q); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = skip; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + rt.iterToOption(it.nextBack()); + return rt.dequeFromIntoIter(it, 1101) as rt.VecDeque; + } + if (_8 === 2) { + const it2: rt.Iter = rt.dequeIntoIter(q); + rt.iterNth(it2, skip); + return rt.dequeFromIntoIter(it2, 1101) as rt.VecDeque; + } + if (_8 === 3) { + return rt.dequeFromVec(rt.iterToArray(rt.dequeIntoIter(q), undefined, 1101, true), 1101) as rt.VecDeque; + } + if (true) { + const v: Big.Big[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 1101, true); + rt.vecReserve(v, skip, 1101); + const it3: rt.Iter = rt.iterSlice(v); + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = skip; + while (iterStart2++ < iterEnd2) { + rt.iterToOption(it3.next()); + } + return rt.dequeFromIntoIter(it3, 1101) as rt.VecDeque; + } + return q; +} + +/** + * A deque made anew from `q`: a clone, or one with room of its own cloned from it, + * collected from its own `into_iter` or a `Vec`'s read in part, whose buffers std's takes + * as they are, or from a `Vec` it collects. + */ +export function remade$u32(q: rt.VecDeque, arg: rt.u8): rt.VecDeque { + const skip: rt.usize = rt.usizeRem(rt.u8Div(arg, 5) as rt.usize, 4); + const _8: rt.u8 = rt.u8Rem(arg, 5); + if (_8 === 0) { + if (!((arg & 32) === 0)) { + const own: rt.VecDeque = rt.dequeWithCapacity(rt.usizeMul(skip, 3), 4) as rt.VecDeque; + const _18: rt.u32 = make$rings_Item_u32(arg); + rt.dequePushFront(own, _18); + rt.dequeCloneFrom(own, q, undefined); + return own; + } + return rt.dequeClone(q); + } + if (_8 === 1) { + const it: rt.Iter = rt.dequeIntoIter(q); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = skip; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + rt.iterToOption(it.nextBack()); + return rt.dequeFromIntoIter(it, 4) as rt.VecDeque; + } + if (_8 === 2) { + const it2: rt.Iter = rt.dequeIntoIter(q); + rt.iterNth(it2, skip); + return rt.dequeFromIntoIter(it2, 4) as rt.VecDeque; + } + if (_8 === 3) { + return rt.dequeFromVec(rt.iterToArray(rt.dequeIntoIter(q), undefined, 4, true), 4) as rt.VecDeque; + } + if (true) { + const v: rt.u32[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 4, true); + rt.vecReserve(v, skip, 4); + const it3: rt.Iter = rt.iterSlice(v); + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = skip; + while (iterStart2++ < iterEnd2) { + rt.iterToOption(it3.next()); + } + return rt.dequeFromIntoIter(it3, 4) as rt.VecDeque; + } + return q; +} + +/** + * A deque made anew from `q`: a clone, or one with room of its own cloned from it, + * collected from its own `into_iter` or a `Vec`'s read in part, whose buffers std's takes + * as they are, or from a `Vec` it collects. + */ +export function remade$u8(q: rt.VecDeque, arg: rt.u8): rt.VecDeque { + const skip: rt.usize = rt.usizeRem(rt.u8Div(arg, 5) as rt.usize, 4); + const _8: rt.u8 = rt.u8Rem(arg, 5); + if (_8 === 0) { + if (!((arg & 32) === 0)) { + const own: rt.VecDeque = rt.dequeWithCapacity(rt.usizeMul(skip, 3), 1, true) as rt.VecDeque; + const _18: rt.u8 = make$rings_Item_u8(arg); + rt.dequePushFront(own, _18); + rt.dequeCloneFrom(own, q, undefined); + return own; + } + return rt.dequeClone(q); + } + if (_8 === 1) { + const it: rt.Iter = rt.dequeIntoIter(q); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = skip; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + rt.iterToOption(it.nextBack()); + return rt.dequeFromIntoIter(it, 1, true) as rt.VecDeque; + } + if (_8 === 2) { + const it2: rt.Iter = rt.dequeIntoIter(q); + rt.iterNth(it2, skip); + return rt.dequeFromIntoIter(it2, 1, true) as rt.VecDeque; + } + if (_8 === 3) { + return rt.dequeFromVec(rt.byteVecToVec(rt.iterToByteVec(rt.dequeIntoIter(q), undefined, true)), 1, true) as rt.VecDeque; + } + if (false) { + const v: rt.ByteVec = rt.iterToByteVec(rt.dequeIntoIter(q), undefined, true); + rt.byteVecReserve(v, skip); + const it3: rt.Iter = rt.iterSlice(rt.byteVecView(v)); + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = skip; + while (iterStart2++ < iterEnd2) { + rt.iterToOption(it3.next()); + } + return rt.dequeFromVec(rt.iterToArray(it3, "next", 1, true), 1, true) as rt.VecDeque; + } + return q; +} + +/** + * A deque made anew from `q`: a clone, or one with room of its own cloned from it, + * collected from its own `into_iter` or a `Vec`'s read in part, whose buffers std's takes + * as they are, or from a `Vec` it collects. + */ +export function remade$unit(q: rt.VecDeque, arg: rt.u8): rt.VecDeque { + const skip: rt.usize = rt.usizeRem(rt.u8Div(arg, 5) as rt.usize, 4); + const _8: rt.u8 = rt.u8Rem(arg, 5); + if (_8 === 0) { + if (!((arg & 32) === 0)) { + const own: rt.VecDeque = rt.dequeWithCapacity(rt.usizeMul(skip, 3), 0) as rt.VecDeque; + make$rings_Item_unit(arg); + rt.dequePushFront(own, undefined); + rt.dequeCloneFrom(own, q, undefined); + return own; + } + return rt.dequeClone(q); + } + if (_8 === 1) { + const it: rt.Iter = rt.dequeIntoIter(q); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = skip; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next(), rt.None); + } + rt.iterToOption(it.nextBack(), rt.None); + return rt.dequeFromIntoIter(it, 0) as rt.VecDeque; + } + if (_8 === 2) { + const it2: rt.Iter = rt.dequeIntoIter(q); + rt.iterNth(it2, skip, undefined, rt.None); + return rt.dequeFromIntoIter(it2, 0) as rt.VecDeque; + } + if (_8 === 3) { + return rt.dequeFromVec(rt.iterToArray(rt.dequeIntoIter(q), undefined, 0, true), 0) as rt.VecDeque; + } + if (true) { + const v: undefined[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 0, true); + rt.vecReserve(v, skip, 0); + const it3: rt.Iter = rt.iterSlice(v); + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = skip; + while (iterStart2++ < iterEnd2) { + rt.iterToOption(it3.next(), rt.None); + } + return rt.dequeFromIntoIter(it3, 0) as rt.VecDeque; + } + return q; +} + +/** A drain of a range `arg` picks, written as it is read from either end and then dropped. */ +export function drained$String(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + const len: rt.usize = q.n; + const start: rt.usize = rt.usizeRem((arg & 7) as rt.usize, rt.usizeAdd(len, 1)); + const d: rt.Iter = rt.dequeDrain(q, new rt.Range(start, rt.usizeAdd(start, rt.usizeRem(((arg >> 3) & 7) as rt.usize, rt.usizeAdd(rt.usizeSub(len, start), 1))))); + text$collections_vec_deque_Drain_String(out, d); + if ((arg & 64) !== 0) { + rt.iterToOption(d.next()); + } + if ((arg & 128) !== 0) { + rt.iterToOption(d.nextBack()); + } + text$collections_vec_deque_Drain_String(out, d); + rt.drop(d); +} + +/** A drain of a range `arg` picks, written as it is read from either end and then dropped. */ +export function drained$rings_Big(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + const len: rt.usize = q.n; + const start: rt.usize = rt.usizeRem((arg & 7) as rt.usize, rt.usizeAdd(len, 1)); + const d: rt.Iter = rt.dequeDrain(q, new rt.Range(start, rt.usizeAdd(start, rt.usizeRem(((arg >> 3) & 7) as rt.usize, rt.usizeAdd(rt.usizeSub(len, start), 1))))); + text$collections_vec_deque_Drain_rings_Big(out, d); + if ((arg & 64) !== 0) { + rt.iterToOption(d.next()); + } + if ((arg & 128) !== 0) { + rt.iterToOption(d.nextBack()); + } + text$collections_vec_deque_Drain_rings_Big(out, d); + rt.drop(d); +} + +/** A drain of a range `arg` picks, written as it is read from either end and then dropped. */ +export function drained$u32(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + const len: rt.usize = q.n; + const start: rt.usize = rt.usizeRem((arg & 7) as rt.usize, rt.usizeAdd(len, 1)); + const d: rt.Iter = rt.dequeDrain(q, new rt.Range(start, rt.usizeAdd(start, rt.usizeRem(((arg >> 3) & 7) as rt.usize, rt.usizeAdd(rt.usizeSub(len, start), 1))))); + text$collections_vec_deque_Drain_u32(out, d); + if ((arg & 64) !== 0) { + rt.iterToOption(d.next()); + } + if ((arg & 128) !== 0) { + rt.iterToOption(d.nextBack()); + } + text$collections_vec_deque_Drain_u32(out, d); + rt.drop(d); +} + +/** A drain of a range `arg` picks, written as it is read from either end and then dropped. */ +export function drained$u8(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + const len: rt.usize = q.n; + const start: rt.usize = rt.usizeRem((arg & 7) as rt.usize, rt.usizeAdd(len, 1)); + const d: rt.Iter = rt.dequeDrain(q, new rt.Range(start, rt.usizeAdd(start, rt.usizeRem(((arg >> 3) & 7) as rt.usize, rt.usizeAdd(rt.usizeSub(len, start), 1))))); + text$collections_vec_deque_Drain_u8(out, d); + if ((arg & 64) !== 0) { + rt.iterToOption(d.next()); + } + if ((arg & 128) !== 0) { + rt.iterToOption(d.nextBack()); + } + text$collections_vec_deque_Drain_u8(out, d); + rt.drop(d); +} + +/** A drain of a range `arg` picks, written as it is read from either end and then dropped. */ +export function drained$unit(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + const len: rt.usize = q.n; + const start: rt.usize = rt.usizeRem((arg & 7) as rt.usize, rt.usizeAdd(len, 1)); + const d: rt.Iter = rt.dequeDrain(q, new rt.Range(start, rt.usizeAdd(start, rt.usizeRem(((arg >> 3) & 7) as rt.usize, rt.usizeAdd(rt.usizeSub(len, start), 1))))); + text$collections_vec_deque_Drain_unit(out, d); + if ((arg & 64) !== 0) { + rt.iterToOption(d.next(), rt.None); + } + if ((arg & 128) !== 0) { + rt.iterToOption(d.nextBack(), rt.None); + } + text$collections_vec_deque_Drain_unit(out, d); + rt.drop(d); +} + +/** Items bumped through `as_mut_slices`, then through `iter_mut` read in part, written. */ +export function mutated$String(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + const _6: [string[], string[]] = rt.dequeAsSlices(q, true); + const _7: rt.Place | undefined = rt.sliceFirstMut(_6[0]); + if (_7 !== undefined) { + bump$rings_Item_String(_7); + } + const _11: rt.Place | undefined = rt.sliceLastMut(_6[1]); + if (_11 !== undefined) { + bump$rings_Item_String(_11); + } + const it: rt.Iter> = rt.dequeIterMut(q); + const _18: rt.u8 = rt.u8Rem(arg, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _18; + while (iterStart++ < iterEnd) { + const _24: rt.Place | rt.Done = it.next(); + if (_24 !== rt.DONE) { + bump$rings_Item_String(_24); + } + } + const _29: rt.Place | undefined = rt.iterToOption(it.nextBack()); + if (_29 !== undefined) { + bump$rings_Item_String(_29); + } + text$collections_vec_deque_IterMut_String(out, it); +} + +/** Items bumped through `as_mut_slices`, then through `iter_mut` read in part, written. */ +export function mutated$rings_Big(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + const _6: [Big.Big[], Big.Big[]] = rt.dequeAsSlices(q, true); + const _7: Big.Big | undefined = rt.sliceFirst(_6[0]); + if (_7 !== undefined) { + Big.bump$rings_Item(_7); + } + const _11: Big.Big | undefined = rt.sliceLast(_6[1]); + if (_11 !== undefined) { + Big.bump$rings_Item(_11); + } + const it: rt.Iter = rt.dequeIter(q); + const _18: rt.u8 = rt.u8Rem(arg, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _18; + while (iterStart++ < iterEnd) { + const _24: Big.Big | rt.Done = it.next(); + if (_24 !== rt.DONE) { + Big.bump$rings_Item(_24); + } + } + const _29: Big.Big | undefined = rt.iterToOption(it.nextBack()); + if (_29 !== undefined) { + Big.bump$rings_Item(_29); + } + text$collections_vec_deque_IterMut_rings_Big(out, it); +} + +/** Items bumped through `as_mut_slices`, then through `iter_mut` read in part, written. */ +export function mutated$u32(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + const _6: [rt.u32[], rt.u32[]] = rt.dequeAsSlices(q, true); + const _7: rt.Place | undefined = rt.sliceFirstMut(_6[0]); + if (_7 !== undefined) { + bump$rings_Item_u32(_7); + } + const _11: rt.Place | undefined = rt.sliceLastMut(_6[1]); + if (_11 !== undefined) { + bump$rings_Item_u32(_11); + } + const it: rt.Iter> = rt.dequeIterMut(q); + const _18: rt.u8 = rt.u8Rem(arg, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _18; + while (iterStart++ < iterEnd) { + const _24: rt.Place | rt.Done = it.next(); + if (_24 !== rt.DONE) { + bump$rings_Item_u32(_24); + } + } + const _29: rt.Place | undefined = rt.iterToOption(it.nextBack()); + if (_29 !== undefined) { + bump$rings_Item_u32(_29); + } + text$collections_vec_deque_IterMut_u32(out, it); +} + +/** Items bumped through `as_mut_slices`, then through `iter_mut` read in part, written. */ +export function mutated$u8(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + const _6: [rt.ByteSlice, rt.ByteSlice] = rt.dequeByteSlices(q); + const _7: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(_6[0])); + if (_7 !== undefined) { + bump$rings_Item_u8(_7); + } + const _11: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(_6[1])); + if (_11 !== undefined) { + bump$rings_Item_u8(_11); + } + const it: rt.Iter> = rt.dequeIterMut(q); + const _18: rt.u8 = rt.u8Rem(arg, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _18; + while (iterStart++ < iterEnd) { + const _24: rt.Place | rt.Done = it.next(); + if (_24 !== rt.DONE) { + bump$rings_Item_u8(_24); + } + } + const _29: rt.Place | undefined = rt.iterToOption(it.nextBack()); + if (_29 !== undefined) { + bump$rings_Item_u8(_29); + } + text$collections_vec_deque_IterMut_u8(out, it); +} + +/** Items bumped through `as_mut_slices`, then through `iter_mut` read in part, written. */ +export function mutated$unit(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + const _6: [undefined[], undefined[]] = rt.dequeAsSlices(q, true); + const _7: rt.Place | undefined = rt.sliceFirstMut(_6[0]); + if (_7 !== undefined) { + bump$rings_Item_unit(_7); + } + const _11: rt.Place | undefined = rt.sliceLastMut(_6[1]); + if (_11 !== undefined) { + bump$rings_Item_unit(_11); + } + const it: rt.Iter> = rt.dequeIterMut(q); + const _18: rt.u8 = rt.u8Rem(arg, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _18; + while (iterStart++ < iterEnd) { + const _24: rt.Place | rt.Done = it.next(); + if (_24 !== rt.DONE) { + bump$rings_Item_unit(_24); + } + } + const _29: rt.Place | undefined = rt.iterToOption(it.nextBack()); + if (_29 !== undefined) { + bump$rings_Item_unit(_29); + } + text$collections_vec_deque_IterMut_unit(out, it); +} + +/** `q`'s `Iter`, written before and after each of three reads `arg` picks. */ +export function iterated$String(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + let _10!: rt.u32; + let read!: string | undefined; + const it: rt.Iter = rt.dequeIter(q); + text$collections_vec_deque_Iter_String(out, it); + let iterStart: rt.u32 = 0; + const iterEnd: rt.u32 = 3; + while ((_10 = iterStart++) < iterEnd) { + const pick: rt.u8 = rt.intRotateLeft(arg, rt.u32Mul(3, _10), 8, false); + let count: rt.u8 = (pick >> 3) & 3; + const _22: rt.u8 = rt.u8Rem(pick, 7); + if (_22 === 0) { + read = rt.iterToOption(it.next()); + } else if (_22 === 1) { + read = rt.iterToOption(it.nextBack()); + } else if (_22 === 2) { + read = rt.iterNth(it, count as rt.usize); + } else if (_22 === 3) { + read = rt.iterNthBack(it, count as rt.usize); + } else if (_22 === 4) { + read = rt.iterFind(it, (_24: string): boolean => { + count = rt.u8SaturatingSub(count, 1); + return count === 0; + }); + } else if (_22 === 5) { + read = rt.iterRfind(it, (_2: string): boolean => { + count = rt.u8SaturatingSub(count, 1); + return count === 0; + }); + } else { + read = rt.iterToOption(it.clone().next()); + } + text$Option_ref_String(out, read); + text$collections_vec_deque_Iter_String(out, it); + } +} + +/** `q`'s `Iter`, written before and after each of three reads `arg` picks. */ +export function iterated$rings_Big(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + let _10!: rt.u32; + let read!: Big.Big | undefined; + const it: rt.Iter = rt.dequeIter(q); + text$collections_vec_deque_Iter_rings_Big(out, it); + let iterStart: rt.u32 = 0; + const iterEnd: rt.u32 = 3; + while ((_10 = iterStart++) < iterEnd) { + const pick: rt.u8 = rt.intRotateLeft(arg, rt.u32Mul(3, _10), 8, false); + let count: rt.u8 = (pick >> 3) & 3; + const _22: rt.u8 = rt.u8Rem(pick, 7); + if (_22 === 0) { + read = rt.iterToOption(it.next()); + } else if (_22 === 1) { + read = rt.iterToOption(it.nextBack()); + } else if (_22 === 2) { + read = rt.iterNth(it, count as rt.usize); + } else if (_22 === 3) { + read = rt.iterNthBack(it, count as rt.usize); + } else if (_22 === 4) { + read = rt.iterFind(it, (_24: Big.Big): boolean => { + count = rt.u8SaturatingSub(count, 1); + return count === 0; + }); + } else if (_22 === 5) { + read = rt.iterRfind(it, (_2: Big.Big): boolean => { + count = rt.u8SaturatingSub(count, 1); + return count === 0; + }); + } else { + read = rt.iterToOption(it.clone().next()); + } + text$Option_ref_rings_Big(out, read); + text$collections_vec_deque_Iter_rings_Big(out, it); + } +} + +/** `q`'s `Iter`, written before and after each of three reads `arg` picks. */ +export function iterated$u32(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + let _10!: rt.u32; + let read!: rt.u32 | undefined; + const it: rt.Iter = rt.dequeIter(q); + text$collections_vec_deque_Iter_u32(out, it); + let iterStart: rt.u32 = 0; + const iterEnd: rt.u32 = 3; + while ((_10 = iterStart++) < iterEnd) { + const pick: rt.u8 = rt.intRotateLeft(arg, rt.u32Mul(3, _10), 8, false); + let count: rt.u8 = (pick >> 3) & 3; + const _22: rt.u8 = rt.u8Rem(pick, 7); + if (_22 === 0) { + read = rt.iterToOption(it.next()); + } else if (_22 === 1) { + read = rt.iterToOption(it.nextBack()); + } else if (_22 === 2) { + read = rt.iterNth(it, count as rt.usize); + } else if (_22 === 3) { + read = rt.iterNthBack(it, count as rt.usize); + } else if (_22 === 4) { + read = rt.iterFind(it, (_24: rt.u32): boolean => { + count = rt.u8SaturatingSub(count, 1); + return count === 0; + }); + } else if (_22 === 5) { + read = rt.iterRfind(it, (_2: rt.u32): boolean => { + count = rt.u8SaturatingSub(count, 1); + return count === 0; + }); + } else { + read = rt.iterToOption(it.clone().next()); + } + text$Option_ref_u32(out, read); + text$collections_vec_deque_Iter_u32(out, it); + } +} + +/** `q`'s `Iter`, written before and after each of three reads `arg` picks. */ +export function iterated$u8(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + let _10!: rt.u32; + let read!: rt.u8 | undefined; + const it: rt.Iter = rt.dequeIter(q); + text$collections_vec_deque_Iter_u8(out, it); + let iterStart: rt.u32 = 0; + const iterEnd: rt.u32 = 3; + while ((_10 = iterStart++) < iterEnd) { + const pick: rt.u8 = rt.intRotateLeft(arg, rt.u32Mul(3, _10), 8, false); + let count: rt.u8 = (pick >> 3) & 3; + const _22: rt.u8 = rt.u8Rem(pick, 7); + if (_22 === 0) { + read = rt.iterToOption(it.next()); + } else if (_22 === 1) { + read = rt.iterToOption(it.nextBack()); + } else if (_22 === 2) { + read = rt.iterNth(it, count as rt.usize); + } else if (_22 === 3) { + read = rt.iterNthBack(it, count as rt.usize); + } else if (_22 === 4) { + read = rt.iterFind(it, (_24: rt.u8): boolean => { + count = rt.u8SaturatingSub(count, 1); + return count === 0; + }); + } else if (_22 === 5) { + read = rt.iterRfind(it, (_2: rt.u8): boolean => { + count = rt.u8SaturatingSub(count, 1); + return count === 0; + }); + } else { + read = rt.iterToOption(it.clone().next()); + } + text$Option_ref_u8(out, read); + text$collections_vec_deque_Iter_u8(out, it); + } +} + +/** `q`'s `Iter`, written before and after each of three reads `arg` picks. */ +export function iterated$unit(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + let _10!: rt.u32; + let read!: undefined | rt.None; + const it: rt.Iter = rt.dequeIter(q); + text$collections_vec_deque_Iter_unit(out, it); + let iterStart: rt.u32 = 0; + const iterEnd: rt.u32 = 3; + while ((_10 = iterStart++) < iterEnd) { + const pick: rt.u8 = rt.intRotateLeft(arg, rt.u32Mul(3, _10), 8, false); + let count: rt.u8 = (pick >> 3) & 3; + const _22: rt.u8 = rt.u8Rem(pick, 7); + if (_22 === 0) { + read = rt.iterToOption(it.next(), rt.None); + } else if (_22 === 1) { + read = rt.iterToOption(it.nextBack(), rt.None); + } else if (_22 === 2) { + read = rt.iterNth(it, count as rt.usize, undefined, rt.None); + } else if (_22 === 3) { + read = rt.iterNthBack(it, count as rt.usize, undefined, rt.None); + } else if (_22 === 4) { + read = rt.iterFind(it, (_24: undefined): boolean => { + count = rt.u8SaturatingSub(count, 1); + return count === 0; + }, undefined, rt.None); + } else if (_22 === 5) { + read = rt.iterRfind(it, (_2: undefined): boolean => { + count = rt.u8SaturatingSub(count, 1); + return count === 0; + }, undefined, rt.None); + } else { + read = rt.iterToOption(it.clone().next(), rt.None); + } + text$Option_ref_unit(out, read); + text$collections_vec_deque_Iter_unit(out, it); + } +} + +//# sourceMappingURL=rings.ts.map diff --git a/ts/fixtures/lang/expected/tuples.ts b/ts/fixtures/lang/expected/tuples.ts index 54e14d022..e7085ece5 100644 --- a/ts/fixtures/lang/expected/tuples.ts +++ b/ts/fixtures/lang/expected/tuples.ts @@ -88,7 +88,7 @@ export function ones(data: rt.ByteSlice, out: rt.ByteVec): void { }), (_211: rt.u8): [rt.u8] => { return [_211] as [rt.u8]; }); - rt.iterExtendBytes(out, rt.dequeIter(rt.tupleExtendOne([rt.dequeNew() as rt.VecDeque] as [rt.VecDeque], _28, (c4, items4) => rt.dequeExtend(c4, items4, "next", 1))[0]), undefined, true); + rt.iterExtendBytes(out, rt.dequeIntoIter(rt.tupleExtendOne([rt.dequeNew(1, true) as rt.VecDeque] as [rt.VecDeque], _28, (c4, items4) => rt.dequeExtend(c4, items4, "next"))[0]), undefined, true); const _34: rt.Iter<[rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_212: rt.u8): [rt.u8] => { return [rt.u8Rem(_212, 16)] as [rt.u8]; }); @@ -157,7 +157,7 @@ export function pairs(data: rt.ByteSlice, out: rt.ByteVec): void { const b3: rt.u8 = _27; return [b3, rt.u16Mul(b3 as rt.u16, 3)] as [rt.u8, rt.u16]; }); - const _22: [rt.BinaryHeap, rt.VecDeque] = rt.tupleExtend([rt.heapNew() as rt.BinaryHeap, rt.dequeNew() as rt.VecDeque] as [rt.BinaryHeap, rt.VecDeque], _23, [rt.heapPart(rt.le, 1), rt.dequePart(2)]); + const _22: [rt.BinaryHeap, rt.VecDeque] = rt.tupleExtend([rt.heapNew() as rt.BinaryHeap, rt.dequeNew(2) as rt.VecDeque] as [rt.BinaryHeap, rt.VecDeque], _23, [rt.heapPart(rt.le, 1), rt.dequePart()]); const heap: rt.BinaryHeap = _22[0]; const q: rt.VecDeque = _22[1]; rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFromVec(heap.d))), undefined, true); @@ -174,13 +174,13 @@ export function pairs(data: rt.ByteSlice, out: rt.ByteVec): void { const b6: rt.u8 = _212; return [b6 as rt.u16, b6] as [rt.u16, rt.u8]; }); - const _38: [rt.u16[], rt.VecDeque] = rt.tupleExtend([[], rt.dequeNew() as rt.VecDeque] as [rt.u16[], rt.VecDeque], _39, [rt.vecPart(2), rt.dequePart(1)]); + const _38: [rt.u16[], rt.VecDeque] = rt.tupleExtend([[], rt.dequeNew(1, true) as rt.VecDeque] as [rt.u16[], rt.VecDeque], _39, [rt.vecPart(2), rt.dequePart()]); const v4: rt.u16[] = _38[0]; const q2: rt.VecDeque = _38[1]; rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(v4), (n2: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n2).reverse(); }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); - rt.iterExtendBytes(out, rt.dequeIter(q2), undefined, true); + rt.iterExtendBytes(out, rt.dequeIntoIter(q2), undefined, true); } /** Triples, of mixed collections, and tuples of collections within one. */ @@ -189,7 +189,7 @@ export function triples(data: rt.ByteSlice, out: rt.ByteVec): void { const b: rt.u8 = _2; return [b, (((b as rt.u16)) << 8) & 0xffff, rt.u8Add(97, rt.u8Rem(b, 26)) as rt.char] as [rt.u8, rt.u16, rt.char]; }); - const _6: [rt.ByteVec, rt.VecDeque, string] = rt.tupleExtend([new rt.ByteVec(), rt.dequeNew() as rt.VecDeque, ""] as [rt.ByteVec, rt.VecDeque, string], _7, [rt.byteVecPart(), rt.dequePart(2), rt.STRING_CHARS_PART]); + const _6: [rt.ByteVec, rt.VecDeque, string] = rt.tupleExtend([new rt.ByteVec(), rt.dequeNew(2) as rt.VecDeque, ""] as [rt.ByteVec, rt.VecDeque, string], _7, [rt.byteVecPart(), rt.dequePart(), rt.STRING_CHARS_PART]); const v: rt.ByteVec = _6[0]; const q: rt.VecDeque = _6[1]; const s: string = _6[2]; @@ -254,7 +254,7 @@ export function twelves(data: rt.ByteSlice, out: rt.ByteVec): void { const _28: [rt.u8, [rt.char]] = [b ^ 51, [rt.u8Add(65, rt.u8Rem(b, 26)) as rt.char] as [rt.char]]; return [b, _12, _152, _5[_8], _162, b, _172, _202, _222, _262, undefined, _28] as [rt.u8, rt.u16, rt.char, string, rt.u8, rt.u8, [rt.u8, rt.u8], rt.u8, [rt.u8, rt.u16], rt.u8, undefined, [rt.u8, [rt.char]]]; }); - const _15: [rt.ByteVec, rt.u16[], string, string, rt.VecDeque, rt.BinaryHeap, rt.HashMap, rt.HashSet, rt.BTreeMap, rt.BTreeSet, undefined, [rt.ByteVec, [string]]] = rt.tupleExtend([new rt.ByteVec(), [], "", "", rt.dequeNew() as rt.VecDeque, rt.heapNew() as rt.BinaryHeap, rt.hashNew() as rt.HashMap, rt.hashNew() as rt.HashSet, rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.btreeNew(rt.cmp) as rt.BTreeSet, undefined, [new rt.ByteVec(), [""]]] as [rt.ByteVec, rt.u16[], string, string, rt.VecDeque, rt.BinaryHeap, rt.HashMap, rt.HashSet, rt.BTreeMap, rt.BTreeSet, undefined, [rt.ByteVec, [string]]], _16, [rt.byteVecPart(), rt.vecPart(2), rt.STRING_CHARS_PART, rt.STRING_PART, rt.dequePart(1), rt.heapPart(rt.le, 1), rt.hashPart(undefined, undefined, 469762048), rt.hashKeysPart(undefined, 469762048), rt.btreePart(), rt.btreeKeysPart(), rt.UNIT_PART, rt.tuplePart([rt.byteVecPart(), rt.tuplePart([rt.STRING_CHARS_PART])])]); + const _15: [rt.ByteVec, rt.u16[], string, string, rt.VecDeque, rt.BinaryHeap, rt.HashMap, rt.HashSet, rt.BTreeMap, rt.BTreeSet, undefined, [rt.ByteVec, [string]]] = rt.tupleExtend([new rt.ByteVec(), [], "", "", rt.dequeNew(1, true) as rt.VecDeque, rt.heapNew() as rt.BinaryHeap, rt.hashNew() as rt.HashMap, rt.hashNew() as rt.HashSet, rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.btreeNew(rt.cmp) as rt.BTreeSet, undefined, [new rt.ByteVec(), [""]]] as [rt.ByteVec, rt.u16[], string, string, rt.VecDeque, rt.BinaryHeap, rt.HashMap, rt.HashSet, rt.BTreeMap, rt.BTreeSet, undefined, [rt.ByteVec, [string]]], _16, [rt.byteVecPart(), rt.vecPart(2), rt.STRING_CHARS_PART, rt.STRING_PART, rt.dequePart(), rt.heapPart(rt.le, 1), rt.hashPart(undefined, undefined, 469762048), rt.hashKeysPart(undefined, 469762048), rt.btreePart(), rt.btreeKeysPart(), rt.UNIT_PART, rt.tuplePart([rt.byteVecPart(), rt.tuplePart([rt.STRING_CHARS_PART])])]); const bytes: rt.ByteVec = _15[0]; const wide: rt.u16[] = _15[1]; const chars: string = _15[2]; @@ -273,7 +273,7 @@ export function twelves(data: rt.ByteSlice, out: rt.ByteVec): void { }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); rt.iterExtendBytes(out, rt.strBytes(chars), undefined, true); rt.iterExtendBytes(out, rt.strBytes(texts), undefined, true); - rt.iterExtendBytes(out, rt.dequeIter(q), undefined, true); + rt.iterExtendBytes(out, rt.dequeIntoIter(q), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFromVec(heap.d))), undefined, true); entries(map, out); sorted(set, out); @@ -293,12 +293,12 @@ export function twelves(data: rt.ByteSlice, out: rt.ByteVec): void { * and a map or set keeps an equal key already there. */ export function extended(data: rt.ByteSlice, out: rt.ByteVec): void { - const t: [rt.ByteVec, string, rt.BTreeMap, rt.VecDeque, rt.HashSet] = [rt.byteVecFrom(Uint8Array.of(9, 8)), "pre", rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterSlice([[3, 30] as [rt.u8, rt.u16]]), true, undefined, undefined, undefined, 4, true), rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice([1]), undefined, 2, true), rt.hashExtendKeys(rt.hashNew() as rt.HashSet, rt.iterSlice(Uint8Array.of(5)), undefined, undefined, 469762048)]; + const t: [rt.ByteVec, string, rt.BTreeMap, rt.VecDeque, rt.HashSet] = [rt.byteVecFrom(Uint8Array.of(9, 8)), "pre", rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterSlice([[3, 30] as [rt.u8, rt.u16]]), true, undefined, undefined, undefined, 4, true), rt.dequeFromArray([1], 2) as rt.VecDeque, rt.hashExtendKeys(rt.hashNew() as rt.HashSet, rt.iterSlice(Uint8Array.of(5)), undefined, undefined, 469762048)]; const _16: rt.Iter<[rt.u8, rt.char, [rt.u8, rt.u16], rt.u16, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): [rt.u8, rt.char, [rt.u8, rt.u16], rt.u16, rt.u8] => { const b: rt.u8 = _2; return [b, b as rt.char, [rt.u8Rem(b, 8), b as rt.u16] as [rt.u8, rt.u16], b as rt.u16, rt.u8Rem(b, 16)] as [rt.u8, rt.char, [rt.u8, rt.u16], rt.u16, rt.u8]; }); - rt.tupleExtend(t, _16, [rt.byteVecPart(), rt.STRING_CHARS_PART, rt.btreePart(), rt.dequePart(2), rt.hashKeysPart(undefined, 469762048)]); + rt.tupleExtend(t, _16, [rt.byteVecPart(), rt.STRING_CHARS_PART, rt.btreePart(), rt.dequePart(), rt.hashKeysPart(undefined, 469762048)]); const v: rt.ByteVec = t[0]; const s: string = t[1]; const tree: rt.BTreeMap = t[2]; @@ -501,7 +501,7 @@ export function reserved(data: rt.ByteSlice, out: rt.ByteVec): void { const _55: rt.Iter<[rt.u8, rt.u16]> = rt.iterMap(items, (i2: rt.u32): [rt.u8, rt.u16] => { return [i2 & 0xff, i2 & 0xffff] as [rt.u8, rt.u16]; }); - const _54: [rt.BTreeSet, rt.VecDeque] = rt.tupleExtend([rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.dequeNew() as rt.VecDeque] as [rt.BTreeSet, rt.VecDeque], _55, [rt.btreeKeysPart(), rt.dequePart(2)]); + const _54: [rt.BTreeSet, rt.VecDeque] = rt.tupleExtend([rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.dequeNew(2) as rt.VecDeque] as [rt.BTreeSet, rt.VecDeque], _55, [rt.btreeKeysPart(), rt.dequePart()]); const tree: rt.BTreeSet = _54[0]; const q: rt.VecDeque = _54[1]; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeLen(tree) & 0xff, q.n & 0xff)), undefined, true); diff --git a/ts/fixtures/lang/expected/wrappers.ts b/ts/fixtures/lang/expected/wrappers.ts index 1902bd177..a2ee895e4 100644 --- a/ts/fixtures/lang/expected/wrappers.ts +++ b/ts/fixtures/lang/expected/wrappers.ts @@ -342,7 +342,7 @@ export function wrappers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void rt.byteVecPush(out, rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.iterBorrow(_166), true, undefined, undefined, 8, true)) & 0xff); bounds$ops_RangeInclusive_u64(out, keyed); const queued: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u64Step); - rt.byteVecPush(out, ((rt.dequeFromVec(rt.iterToArray(rt.iterBorrow(queued), undefined, 8, true)) as rt.VecDeque)).n & 0xff); + rt.byteVecPush(out, ((rt.dequeFromVec(rt.iterToArray(rt.iterBorrow(queued), undefined, 8, true), 8) as rt.VecDeque)).n & 0xff); bounds$ops_RangeInclusive_u64(out, queued); const hashed: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u64Step); const _186: rt.RangeInclusive = hashed; diff --git a/ts/fixtures/lang/src/capacity.rs b/ts/fixtures/lang/src/capacity.rs index 96a12837a..11e6b34ce 100644 --- a/ts/fixtures/lang/src/capacity.rs +++ b/ts/fixtures/lang/src/capacity.rs @@ -1,9 +1,10 @@ //! The capacity std's `Vec`, `VecDeque`, and `BinaryHeap` hold as each step of a case //! grows, shrinks, remakes, or reads one, of elements of each size its growth tells apart: -//! a byte, at most 1 KiB, past it, and none. std fixes it exactly only through steps its -//! doubling decides, such as pushes, `with_capacity`, `reserve`, and `shrink_to`; past -//! any other step, a case checks only what std guarantees. A `HashMap`'s and a -//! `HashSet`'s it checks only by std's guarantees. +//! a byte, at most 1 KiB, past it, and none. std fixes a `Vec`'s and a `BinaryHeap`'s +//! exactly only through steps its doubling decides, such as pushes, `with_capacity`, +//! `reserve`, and `shrink_to`; past any other step, a case checks only what std +//! guarantees. A `VecDeque`'s it checks exactly past every step, as where its slices split +//! depends on it. A `HashMap`'s and a `HashSet`'s it checks only by std's guarantees. use std::collections::{BinaryHeap, HashMap, HashSet, VecDeque}; use std::mem; @@ -229,75 +230,40 @@ fn deque_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec 1 => VecDeque::with_capacity(usize::from(first >> 3)), _ => VecDeque::new(), }; - let mut k = Known::new(q.capacity()); put(out, q.capacity()); for step in steps.chunks(2) { let (op, arg) = (step[0], step.get(1).copied().unwrap_or(0)); match op % 21 { 0 => q.push_back(make(arg)), 1 => q.push_front(make(arg)), - 2 => { - drop(q.pop_front()); - k.loose(); - } + 2 => drop(q.pop_front()), 3 | 4 => { let additional = amount(arg, q.len(), size); match op % 21 { 3 => q.reserve(additional), _ => q.reserve_exact(additional), } - k.reserved(q.len(), additional); - } - 5 => { - q.shrink_to(usize::from(arg % 40)); - k.shrunk(q.len(), usize::from(arg % 40)); - } - 6 => { - q.shrink_to_fit(); - k.shrunk(q.len(), 0); - k.exact = true; - } - 7 => { - q.truncate(usize::from(arg % 8)); - k.loose(); } + 5 => q.shrink_to(usize::from(arg % 40)), + 6 => q.shrink_to_fit(), + 7 => q.truncate(usize::from(arg % 8)), 8 => q.insert(usize::from(arg) % (q.len() + 1), make(arg)), - 9 => { - drop(q.remove(usize::from(arg) % (q.len() + 1))); - k.loose(); - } + 9 => drop(q.remove(usize::from(arg) % (q.len() + 1))), 10 => q.extend((0..arg % 24).filter(|i| i % 3 != 0).map(make)), 11 => q.extend((0..arg % 24).map(make)), - 12 => { - q.clear(); - k.loose(); - } + 12 => q.clear(), 13 => { let mut keep = alternate(); q.retain(|_| keep()); - k.loose(); - } - 14 => { - drop(q.drain(..q.len().min(usize::from(arg % 4)))); - k.loose(); - } - 15 => { - q = q.clone(); - k.remade(true); } + 14 => drop(q.drain(..q.len().min(usize::from(arg % 4)))), + 15 => q = q.clone(), // Its own, and a `Vec`'s in place of one, and one it collects first. - 16 => { - q = q.into_iter().collect(); - k.remade(false); - } - 17 => { - q = VecDeque::from(q.into_iter().collect::>()); - k.remade(false); - } + 16 => q = q.into_iter().collect(), + 17 => q = VecDeque::from(q.into_iter().collect::>()), 18 => { let mut keep = alternate(); q = q.into_iter().filter(|_| keep()).collect(); - k.remade(true); } 19 => { let mut it = q.into_iter(); @@ -305,16 +271,14 @@ fn deque_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec drop(it.next()); } q = it.clone().collect(); - k.remade(false); let rest = it.collect::>(); - Known { exact: false, floor: 0 }.put(out, rest.len(), rest.capacity()); - } - _ => { - q = VecDeque::from([make(arg), make(arg), make(arg)]); - k.remade(false); + put(out, rest.len()); + put(out, rest.capacity()); } + _ => q = VecDeque::from([make(arg), make(arg), make(arg)]), } - k.put(out, q.len(), q.capacity()); + put(out, q.len()); + put(out, q.capacity()); } } diff --git a/ts/fixtures/lang/src/harness.rs b/ts/fixtures/lang/src/harness.rs index 0a4253ba2..38dc994dc 100644 --- a/ts/fixtures/lang/src/harness.rs +++ b/ts/fixtures/lang/src/harness.rs @@ -5,7 +5,7 @@ use crate::{ args, arrays, ascii, atomics, borrows, bounds, boxes, capacity, captures, cells, chars, chunks, clones, collections, combinators, conversions, counts, cows, cycles, defaults, durations, dyns, edits, errors, fields, floats, fmt, folds, generics, hashes, hints, holds, ints, iters, joins, keys, lengths, lists, locals, locks, - methods, nested, objects, orders, pointers, refs, results, returns, saturates, separated, shapes, singles, slices, + methods, nested, objects, orders, pointers, refs, results, returns, rings, saturates, separated, shapes, singles, slices, splits, statics, strs, tuples, utf8, wrappers, wraps, zeros, }; @@ -288,6 +288,7 @@ fn cases() -> Vec<(&'static str, Case)> { ("capacity::maps", capacity::maps), ("locks::downgraded", |_, data, out| locks::downgraded(data, out)), ("borrows::leaks", |_, data, out| borrows::leaks(data, out)), + ("rings::slices", rings::slices), ] } diff --git a/ts/fixtures/lang/src/lib.rs b/ts/fixtures/lang/src/lib.rs index a5f78962a..7d1033a6f 100644 --- a/ts/fixtures/lang/src/lib.rs +++ b/ts/fixtures/lang/src/lib.rs @@ -87,6 +87,7 @@ mod pointers; mod refs; mod results; mod returns; +mod rings; mod saturates; mod separated; mod shapes; diff --git a/ts/fixtures/lang/src/rings.rs b/ts/fixtures/lang/src/rings.rs new file mode 100644 index 000000000..c7efc8719 --- /dev/null +++ b/ts/fixtures/lang/src/rings.rs @@ -0,0 +1,255 @@ +//! `VecDeque`'s ring buffer, as std places its items: each step that moves them, then +//! where `as_slices` splits them, and `{:?}` of its `Iter`, `IterMut`, and `Drain` read in +//! part, from either end, by `nth`, and by `try_fold`. Run for items of each size std's +//! growth tells apart, bytes, which its slices view, zero-sized ones, and ones that drop. + +use std::collections::VecDeque; +use std::fmt::Debug; + +/// An item a byte makes, which a write through a `&mut` changes. +trait Item: Clone + Debug { + /// Whether it is a byte, which a deque holds in a `Uint8Array`. + const BYTE: bool = false; + + fn make(b: u8) -> Self; + + fn bump(&mut self); +} + +impl Item for u8 { + const BYTE: bool = true; + + fn make(b: u8) -> Self { + b + } + + fn bump(&mut self) { + *self = self.wrapping_add(1); + } +} + +impl Item for u32 { + fn make(b: u8) -> Self { + u32::from(b) << 12 + } + + fn bump(&mut self) { + *self += 1; + } +} + +impl Item for String { + fn make(b: u8) -> Self { + format!("s{}", b % 16) + } + + fn bump(&mut self) { + self.push('!'); + } +} + +impl Item for () { + fn make(_: u8) -> Self {} + + fn bump(&mut self) {} +} + +/// Past 1 KiB, which std's grows from one slot rather than four. +#[derive(Clone)] +struct Big { + id: u8, + pad: [u8; 1100], +} + +impl Debug for Big { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "B{}.{}", self.id, self.pad[1099]) + } +} + +impl Item for Big { + fn make(b: u8) -> Self { + Big { id: b, pad: [b; 1100] } + } + + fn bump(&mut self) { + self.id = self.id.wrapping_add(1); + } +} + +/// Steps a deque of the item type `kind` picks through `data`. +pub fn slices(kind: u8, data: &[u8], out: &mut Vec) { + match kind % 5 { + 0 => steps::(data, out), + 1 => steps::(data, out), + 2 => steps::(data, out), + 3 => steps::<()>(data, out), + _ => steps::(data, out), + } +} + +/// A length or capacity, as four bytes. +fn put(out: &mut Vec, n: usize) { + out.extend_from_slice(&(n as u32).to_le_bytes()); +} + +/// What `{:?}` writes of `value`. +fn text(out: &mut Vec, value: &impl Debug) { + out.extend_from_slice(format!("{value:?}").as_bytes()); +} + +/// A deque the first byte makes, new, with room for a few, or from a `Vec` of a few, and +/// each pair after it steps: after each, its length, capacity, and two slices. +fn steps(data: &[u8], out: &mut Vec) { + let (first, rest) = data.split_first().map_or((0, &[][..]), |(&b, rest)| (b, rest)); + let n = usize::from(first >> 2) % 12; + let mut q: VecDeque = match first % 3 { + 0 => VecDeque::new(), + 1 => VecDeque::with_capacity(n), + _ => VecDeque::from(vec![T::make(first); n]), + }; + for step in rest.chunks(2) { + let (op, arg) = (step[0], step.get(1).copied().unwrap_or(0)); + let at = usize::from(arg) % (q.len() + 1); + match op % 24 { + 0..=3 => q.push_back(T::make(arg)), + 4 | 5 => q.push_front(T::make(arg)), + 6 => drop(q.pop_front()), + 7 => drop(q.pop_back()), + 8 => q.insert(at, T::make(arg)), + 9 => drop(q.remove(at)), + 10 => drop(q.swap_remove_front(at)), + 11 => drop(q.swap_remove_back(at)), + 12 => q.truncate(usize::from(arg) % 8), + 13 => { + let mut kept = arg; + q.retain(|_| { + kept = kept.rotate_left(1); + kept & 1 == 1 + }); + } + 14 => drained(&mut q, arg, out), + 15 => q.reserve(usize::from(arg) % 12), + 16 => q.reserve_exact(usize::from(arg) % 12), + 17 => q.shrink_to(usize::from(arg) % 12), + 18 => q.shrink_to_fit(), + // Not `TrustedLen`, so it reserves once full, and a `TrustedLen` one. + 19 => q.extend((0..arg % 8).filter(|i| i % 3 != 0).map(T::make)), + 20 => q.extend((0..arg % 8).map(T::make)), + 21 => q.clear(), + 22 => q = remade(q, arg), + _ => mutated(&mut q, arg, out), + } + put(out, q.len()); + put(out, q.capacity()); + text(out, &q.as_slices()); + iterated(&q, arg, out); + } +} + +/// A deque made anew from `q`: a clone, or one with room of its own cloned from it, +/// collected from its own `into_iter` or a `Vec`'s read in part, whose buffers std's takes +/// as they are, or from a `Vec` it collects. +fn remade(q: VecDeque, arg: u8) -> VecDeque { + let skip = usize::from(arg / 5) % 4; + match arg % 5 { + 0 if arg & 0x20 == 0 => q.clone(), + 0 => { + let mut own = VecDeque::with_capacity(skip * 3); + own.push_front(T::make(arg)); + own.clone_from(&q); + own + } + 1 => { + let mut it = q.into_iter(); + for _ in 0..skip { + drop(it.next()); + } + drop(it.next_back()); + it.collect() + } + // By `advance_by`, which drains the front or clears it all. + 2 => { + let mut it = q.into_iter(); + drop(it.nth(skip)); + it.collect() + } + 3 => VecDeque::from(q.into_iter().collect::>()), + // A `Vec`'s iterator reads a view of its bytes, which leaves its capacity behind. + _ if T::BYTE => q, + _ => { + let mut v: Vec = q.into_iter().collect(); + v.reserve(skip); + let mut it = v.into_iter(); + for _ in 0..skip { + drop(it.next()); + } + it.collect() + } + } +} + +/// A drain of a range `arg` picks, written as it is read from either end and then dropped. +fn drained(q: &mut VecDeque, arg: u8, out: &mut Vec) { + let len = q.len(); + let start = usize::from(arg & 7) % (len + 1); + let end = start + usize::from(arg >> 3 & 7) % (len - start + 1); + let mut d = q.drain(start..end); + text(out, &d); + if arg & 0x40 != 0 { + drop(d.next()); + } + if arg & 0x80 != 0 { + drop(d.next_back()); + } + text(out, &d); +} + +/// Items bumped through `as_mut_slices`, then through `iter_mut` read in part, written. +fn mutated(q: &mut VecDeque, arg: u8, out: &mut Vec) { + let (a, b) = q.as_mut_slices(); + if let Some(x) = a.first_mut() { + x.bump(); + } + if let Some(x) = b.last_mut() { + x.bump(); + } + let mut it = q.iter_mut(); + for _ in 0..arg % 4 { + if let Some(x) = it.next() { + x.bump(); + } + } + if let Some(x) = it.next_back() { + x.bump(); + } + text(out, &it); +} + +/// `q`'s `Iter`, written before and after each of three reads `arg` picks. +fn iterated(q: &VecDeque, arg: u8, out: &mut Vec) { + let mut it = q.iter(); + text(out, &it); + for k in 0..3 { + let pick = arg.rotate_left(3 * k); + let mut count = pick >> 3 & 3; + let read = match pick % 7 { + 0 => it.next(), + 1 => it.next_back(), + 2 => it.nth(usize::from(count)), + 3 => it.nth_back(usize::from(count)), + // By `try_fold`, which reads the first slice and then the second, swapping neither. + 4 => it.find(|_| { + count = count.saturating_sub(1); + count == 0 + }), + 5 => it.rfind(|_| { + count = count.saturating_sub(1); + count == 0 + }), + _ => it.clone().next(), + }; + text(out, &read); + text(out, &it); + } +} diff --git a/ts/runtime/rt/collections.ts b/ts/runtime/rt/collections.ts index cc891e3d0..3317d4afa 100644 --- a/ts/runtime/rt/collections.ts +++ b/ts/runtime/rt/collections.ts @@ -15,14 +15,15 @@ // A function that may drop a key, value, or item std's would, rather than return or keep // it, takes what drops each that does, as `k`, `v`, or `f`, and drops it where std's does. -import { ByteSlice, ByteVec, byteVecPush, byteVecReserve, type Capped, capHold, capOf, capReserve, capReserveExact, capSet, capShrink, Err, type None, Ok, type Place, panic, type RangeBound, type Result, rangeCheck, sliceSort, vecExact, vecMax, vecReserve, vecWithCapacity } from "../rt.ts"; +import { ByteSlice, ByteVec, byteVecPush, byteVecReserve, type Capped, capOf, capReserve, capReserveExact, capSet, type Debug, Err, type FmtResult, type Formatter, fmtDebugTupleFields, fmtList, type None, Ok, type Place, panic, type RangeBound, type Result, rangeCheck, sliceSort, sliceView, vecExact, vecMax, vecReserve, vecWithCapacity } from "../rt.ts"; import type { Hashing } from "./hash.ts"; -import { type Limbs, lt, type u64 } from "./int.ts"; +import { type Limbs, lt, type u64, type usize } from "./int.ts"; import { type Clones, DONE, type Done, exactHint, + Folded, Iter, iterChain, iterEmpty, @@ -34,6 +35,7 @@ import { rangeInclusiveEndBound, rangeInclusiveStartBound, type SizeHint, + satAdd, type Take, capNext, trustedUpper, @@ -967,11 +969,11 @@ function extending(c: C, items: Iter, add: (item: T) => void, take?: Ta } /** - * `extending` a `Vec` or `VecDeque` holding `len`, which with elements `size` bytes each - * reserves as `iterExtend` does, into the capacity `at` holds: a `trusted` iterator up - * front, and any other by `next`, a `deque`'s at its first item too. + * `extending` a `Vec` holding `len`, which with elements `size` bytes each reserves as + * `iterExtend` does, into the capacity `at` holds: a `trusted` iterator up front, and any + * other by `next`. */ -function vecExtending(c: C, len: number, items: Iter, add: (item: T) => void, take?: Take, size?: number, trusted = false, at: object & Capped = {}, deque = false): C { +function vecExtending(c: C, len: number, items: Iter, add: (item: T) => void, take?: Take, size?: number, trusted = false, at: object & Capped = {}): C { if (size === undefined) return extending(c, items, add, take); let cap = capOf(len, at.cap, size); if (trusted) { @@ -979,8 +981,7 @@ function vecExtending(c: C, len: number, items: Iter, add: (item: T) => return extending(c, items, add, take); } for (let item = items.next(); item !== DONE; item = items.next()) { - if (deque || len === cap) cap = capNext(items, len, cap, size); - deque = false; + if (len === cap) cap = capNext(items, len, cap, size); add(item); len++; } @@ -2572,69 +2573,140 @@ export function btreeFirstEntry(m: BTreeMap, last = false): Entry`: a ring buffer of `b.length` slots, a power of two, holding `n` items - * from `h` on, wrapping past the end, and the capacity an operation set, as a `Vec`'s. + * `VecDeque`: a ring buffer of `b.length` slots, std's capacity, holding `n` items of + * `s` bytes each from `h` on, wrapping past the end. Each step places them where std's + * does, which `as_slices` shows: a deque of bytes is a `Uint8Array`, which its slices view, + * and one of zero-sized items has `usize::MAX` slots, as std's. */ -export interface VecDeque extends Capped { +export interface VecDeque { b: (T | undefined)[]; h: number; n: number; + s: number; +} + +/** `cap` empty slots, bytes if `bytes`. */ +function slots(cap: number, bytes: boolean): (T | undefined)[] { + return bytes ? (new Uint8Array(cap) as unknown as T[]) : new Array(cap); +} + +/** Whether `q` holds bytes in a `Uint8Array`. */ +function holdsBytes(q: VecDeque): boolean { + return q.b instanceof Uint8Array; } -/** `VecDeque::new`. */ -export function dequeNew(): VecDeque { - return { b: [], h: 0, n: 0 }; +/** `VecDeque::new` of `size`-byte items, held as bytes if `bytes`. */ +export function dequeNew(size: number, bytes = false): VecDeque { + return { b: slots(size === 0 ? USIZE_MAX : 0, bytes), h: 0, n: 0, s: size }; } /** `VecDeque::with_capacity` of `size`-byte items, which panics past what it may hold. */ -export function dequeWithCapacity(n: number, size: number): VecDeque { +export function dequeWithCapacity(n: number, size: number, bytes = false): VecDeque { if (n > vecMax(size)) panic("capacity overflow"); - const q = dequeNew(); - capSet(q, 0, n, size); + const q = dequeNew(size, bytes); + if (size !== 0) q.b = slots(n, bytes); return q; } /** A deque of `v`'s items, with its capacity, as std's `From>` keeps it. */ -export function dequeFromVec(v: T[] & Capped): VecDeque { - const q = dequeNew(); - for (const item of v) dequePushBack(q, item); - if (v.cap !== undefined) q.cap = v.cap; +export function dequeFromVec(v: T[] & Capped, size: number, bytes = false): VecDeque { + const q = dequeWithCapacity(capOf(v.length, v.cap, size), size, bytes); + for (let i = 0; i < v.length; i++) q.b[i] = v[i]; + q.n = v.length; return q; } -/** `VecDeque::capacity` of `size`-byte items. */ -export function dequeCapacity(q: VecDeque, size: number): number { - return capOf(q.n, q.cap, size); +/** A deque of `a`'s items, with room for exactly them, as std's `From<[T; N]>` makes it. */ +export function dequeFromArray(a: ArrayLike, size: number, bytes = false): VecDeque { + const q = dequeWithCapacity(a.length, size, bytes); + for (let i = 0; i < a.length; i++) q.b[i] = a[i]; + q.n = a.length; + return q; +} + +/** `VecDeque::capacity`. */ +export function dequeCapacity(q: VecDeque): number { + return q.b.length; +} + +/** `VecDeque::reserve`. */ +export function dequeReserve(q: VecDeque, additional: number): void { + regrow(q, capReserve(q.n, q.b.length, additional, q.s)); } -/** `VecDeque::reserve` of `size`-byte items. */ -export function dequeReserve(q: VecDeque, additional: number, size: number): void { - capHold(q, capReserve(q.n, dequeCapacity(q, size), additional, size), size); +/** `VecDeque::reserve_exact`. */ +export function dequeReserveExact(q: VecDeque, additional: number): void { + regrow(q, capReserveExact(q.n, q.b.length, additional, q.s)); } -/** `VecDeque::reserve_exact` of `size`-byte items. */ -export function dequeReserveExact(q: VecDeque, additional: number, size: number): void { - capHold(q, capReserveExact(q.n, dequeCapacity(q, size), additional, size), size); +/** + * `VecDeque::shrink_to`, and `shrink_to_fit` of 0: the items moved within the slots kept + * as std's moves them, the head to the front if the tail is past them, or else the part + * past them to the front, or the wrapped head to their end. + */ +export function dequeShrinkTo(q: VecDeque, min: number): void { + const cap = q.b.length; + const target = Math.max(min, q.n); + if (q.s === 0 || cap <= target) return; + const end = q.h + q.n; + const tailOutside = end > target && end <= cap; + let h = q.h; + if (q.n === 0 || (q.h >= target && tailOutside)) h = 0; + else if (!tailOutside && q.h > cap - q.n) h = target - (cap - q.h); + place(q, target, h); } -/** `VecDeque::shrink_to` of `size`-byte items, and `shrink_to_fit` of 0. */ -export function dequeShrinkTo(q: VecDeque, min: number, size: number): void { - capSet(q, q.n, capShrink(q.n, dequeCapacity(q, size), min), size); +/** + * The slot `n` past slot `j`, as std's `wrap_index` of a `usize` sum: past `usize::MAX`, + * which only zero-sized items' `usize::MAX` slots reach, it wraps first. + */ +function wrap(q: VecDeque, j: number): number { + if (j < q.b.length) return j; + return j > USIZE_MAX ? j - USIZE_MAX - 1 : j - q.b.length; } /** The slot of item `i`. */ function at(q: VecDeque, i: number): number { - return (q.h + i) & (q.b.length - 1); + return wrap(q, q.h + i); } -/** Room for one more item. */ -function grow(q: VecDeque): void { - if (q.n < q.b.length) return; - const b = new Array(Math.max(4, q.b.length * 2)); - for (let i = 0; i < q.n; i++) b[i] = q.b[at(q, i)]; +/** The slot before `q`'s head, as std's `wrap_sub` finds it. */ +function before(q: VecDeque): number { + return wrap(q, q.h - 1 + q.b.length); +} + +/** + * `q` grown to `cap` slots, if more: the items moved as std's `handle_capacity_increase` + * moves them, the wrapped tail after the old end if it is shorter and fits, or else the + * head to the new end. + */ +function regrow(q: VecDeque, cap: number): void { + const old = q.b.length; + if (cap <= old) return; + let h = q.h; + if (h > old - q.n) { + const head = old - h; + const tail = q.n - head; + if (head <= tail || cap - old < tail) h = cap - head; + } + place(q, cap, h); +} + +/** `q`'s items moved, in order, to `cap` new slots from `h` on. */ +function place(q: VecDeque, cap: number, h: number): void { + const b = slots(cap, holdsBytes(q)); + for (let i = 0, j = h; i < q.n; i++, j = j + 1 === cap ? 0 : j + 1) b[j] = q.b[at(q, i)]; q.b = b; - q.h = 0; + q.h = h; +} + +/** Room for one more item, grown as std's `grow_one`. */ +function grow(q: VecDeque): void { + if (q.n === q.b.length) regrow(q, capReserve(q.n, q.n, 1, q.s)); } export function dequePushBack(q: VecDeque, item: T): void { @@ -2644,7 +2716,7 @@ export function dequePushBack(q: VecDeque, item: T): void { export function dequePushFront(q: VecDeque, item: T): void { grow(q); - q.h = (q.h - 1) & (q.b.length - 1); + q.h = before(q); q.b[q.h] = item; q.n++; } @@ -2715,13 +2787,16 @@ export function dequeDrop(q: VecDeque, f: (item: T) => void): void { dropAll(items, f); } -/** `clear`, which leaves the deque empty and then drops each item, front to back. */ +/** `clear`, which leaves the deque empty, its head at the front, and then drops each item, front to back. */ export function dequeClear(q: VecDeque, f?: (item: T) => void): void { - const old: VecDeque = { b: q.b, h: q.h, n: q.n }; - q.b = []; + const items: T[] = []; + for (let i = 0; i < q.n; i++) { + items.push(q.b[at(q, i)] as T); + q.b[at(q, i)] = undefined; + } q.h = 0; q.n = 0; - if (f !== undefined) dequeDrop(old, f); + if (f !== undefined) dropAll(items, f); } /** `truncate`: the first `len` items, if there are more, and then each other drops in order. */ @@ -2781,133 +2856,342 @@ export function dequeSwapRemove(q: VecDeque, i: number, back = false, none return (back ? dequePopBack(q) : dequePopFront(q)) as T; } -/** `remove`: the item at `i`, with those after it moved up, or else `none`. */ +/** `remove`: the item at `i`, with the shorter side moved over its slot, as std's, or else `none`. */ export function dequeRemove(q: VecDeque, i: number): T | undefined; export function dequeRemove(q: VecDeque, i: number, none: None): T | None; export function dequeRemove(q: VecDeque, i: number, none?: None): T | None | undefined { if (i >= q.n) return none; const item = q.b[at(q, i)] as T; - for (let j = i; j + 1 < q.n; j++) q.b[at(q, j)] = q.b[at(q, j + 1)]; - dequePopBack(q); + if (q.n - i - 1 < i) { + for (let j = i; j + 1 < q.n; j++) q.b[at(q, j)] = q.b[at(q, j + 1)]; + q.b[at(q, q.n - 1)] = undefined; + } else { + for (let j = i; j > 0; j--) q.b[at(q, j)] = q.b[at(q, j - 1)]; + q.b[q.h] = undefined; + q.h = at(q, 1); + } + q.n--; return item; } -/** `insert`: `item` at `i`, with those from `i` on moved down. */ +/** `insert`: `item` at `i`, with the shorter side moved to make room, as std's. */ export function dequeInsert(q: VecDeque, i: number, item: T): void { if (i > q.n) panic("index out of bounds"); - dequePushBack(q, item); - for (let j = q.n - 1; j > i; j--) q.b[at(q, j)] = q.b[at(q, j - 1)]; + grow(q); + if (q.n - i < i) { + for (let j = q.n; j > i; j--) q.b[at(q, j)] = q.b[at(q, j - 1)]; + } else { + q.h = before(q); + for (let j = 0; j < i; j++) q.b[at(q, j)] = q.b[at(q, j + 1)]; + } q.b[at(q, i)] = item; + q.n++; } /** - * An iterator of a deque's items from index `front` up to `back`, which drops those it - * still holds by `drop` as it drops, if it owns them, as a `drain` does. + * Where the first of the two slices of `q`'s items `start..end` ends, as std's + * `slice_ranges` splits them at the end of its slots. */ -class DequeIter extends Iter implements Disposable { +function firstEnd(q: VecDeque, start: number, end: number): number { + return start === end ? end : Math.min(end, start + q.b.length - at(q, start)); +} + +/** + * A deque's `Iter`, or `IterMut` lending each item's place if `lend`: the items at `f1..e1`, + * then `f2..e2`, the two slices std's walks, which it swaps as one ends, as std's does. + */ +class DequeIter extends Iter> { private readonly q: VecDeque; - private front: number; - private back: number; + private readonly lend: boolean; + private f1: number; + private e1: number; + private f2: number; + private e2: number; + + constructor(q: VecDeque, lend: boolean, f1: number, e1: number, f2: number, e2: number) { + super(); + this.q = q; + this.lend = lend; + this.f1 = f1; + this.e1 = e1; + this.f2 = f2; + this.e2 = e2; + } + + /** Item `i`, or its place. */ + private item(i: number): T | Place { + return this.lend ? new AtIndex(this.q.b as T[], at(this.q, i)) : (this.q.b[at(this.q, i)] as T); + } + + /** The two slices, swapped, as std's once the one it reads from ends. */ + private swap(): void { + [this.f1, this.e1, this.f2, this.e2] = [this.f2, this.e2, this.f1, this.e1]; + } + + /** The items each slice has left, as `as_slices` gives them. */ + slices(): [T[], T[]] { + const items = (f: number, e: number) => { + const out: T[] = []; + for (let i = f; i < e; i++) out.push(this.q.b[at(this.q, i)] as T); + return out; + }; + return [items(this.f1, this.e1), items(this.f2, this.e2)]; + } + + next(): T | Place | Done { + if (this.f1 === this.e1) this.swap(); + return this.f1 < this.e1 ? this.item(this.f1++) : DONE; + } + + override nextBack(): T | Place | Done { + if (this.f2 === this.e2) this.swap(); + return this.f2 < this.e2 ? this.item(--this.e2) : DONE; + } + + override advanceBy(n: number): number { + const k = Math.min(n, this.e1 - this.f1); + this.f1 += k; + if (k === n) return 0; + this.swap(); + const rest = Math.min(n - k, this.e1 - this.f1); + this.f1 += rest; + return n - k - rest; + } + + override advanceBackBy(n: number): number { + const k = Math.min(n, this.e2 - this.f2); + this.e2 -= k; + if (k === n) return 0; + this.swap(); + const rest = Math.min(n - k, this.e2 - this.f2); + this.e2 -= rest; + return n - k - rest; + } + + /** std's `try_fold`, which reads the first slice and then the second, swapping neither, and `try_rfold` the second and then the first. */ + override folded(): Iter> { + return new Folded( + () => (this.f1 < this.e1 ? this.item(this.f1++) : this.f2 < this.e2 ? this.item(this.f2++) : DONE), + () => (this.f2 < this.e2 ? this.item(--this.e2) : this.f1 < this.e1 ? this.item(--this.e1) : DONE), + ); + } + + override remaining(): Iterable { + const [a, b] = this.slices(); + return a.concat(b); + } + + override clone(): Iter> { + return new DequeIter(this.q, this.lend, this.f1, this.e1, this.f2, this.e2); + } + + override len(): number { + return this.e1 - this.f1 + (this.e2 - this.f2); + } + + override sizeHint(): SizeHint { + return exactHint(this.len()); + } +} + +/** A deque's `Iter` over its items `start..end`, split where `as_slices` splits them, or with `lend`, its `IterMut`. */ +function dequeSlices(q: VecDeque, lend: boolean, start: number, end: number): DequeIter { + const mid = firstEnd(q, start, end); + return new DequeIter(q, lend, start, mid, mid, end); +} + +/** `iter` and `iter_mut`. */ +export function dequeIter(q: VecDeque): Iter { + return dequeSlices(q, false, 0, q.n) as Iter; +} + +/** `iter_mut` of items JS copies: the place of each. */ +export function dequeIterMut(q: VecDeque): Iter> { + return dequeSlices(q, true, 0, q.n) as Iter>; +} + +/** `Debug` of a deque's `Iter` or `IterMut`, `name`: the two slices it has left. */ +export function fmtDequeIter(it: Iter, f: Formatter, debug: Debug, name: string): FmtResult { + const [a, b] = (it as DequeIter).slices(); + return fmtDebugTupleFields(f, name, [(f) => fmtList(a, f, debug), (f) => fmtList(b, f, debug)]); +} + +/** `as_slices`, and with `lend`, `as_mut_slices`, whose slices write into the deque. */ +export function dequeAsSlices(q: VecDeque, lend = false): [T[], T[]] { + const p = at(q, 0); + const n = firstEnd(q, 0, q.n); + const part = (start: number, end: number) => (lend ? sliceView(q.b as T[], start, end) : q.b.slice(start, end) as T[]); + return [part(p, p + n), part(0, q.n - n)]; +} + +/** `as_slices` and `as_mut_slices` of bytes, which view the deque's. */ +export function dequeByteSlices(q: VecDeque): [ByteSlice, ByteSlice] { + const n = firstEnd(q, 0, q.n); + const b = q.b as unknown as Uint8Array; + return [new ByteSlice(b, at(q, 0), n), new ByteSlice(b, 0, q.n - n)]; +} + +/** + * `into_iter`: the deque itself, popping each item from either end, which drops those it + * still holds by `drop` as it drops, and which `collect` into a deque gives back as it is. + */ +class DequeIntoIter extends Iter implements Disposable { + readonly q: VecDeque; private readonly drop: ((item: T) => void) | undefined; - constructor(q: VecDeque, front: number, back: number, drop?: (item: T) => void) { + constructor(q: VecDeque, drop?: (item: T) => void) { super(); this.q = q; - this.front = front; - this.back = back; this.drop = drop; } next(): T | Done { - return this.front < this.back ? (this.q.b[at(this.q, this.front++)] as T) : DONE; + return this.q.n === 0 ? DONE : (dequePopFront(this.q) as T); } - override remaining(): Iterable { - return new DequeIter(this.q, this.front, this.back); + override nextBack(): T | Done { + return this.q.n === 0 ? DONE : (dequePopBack(this.q) as T); } - /** std's: where it is, or of `into_iter`, what it has left, each cloned in order by `h.v`. */ - override clone(h?: Clones): Iter { - if (h?.v === undefined) return new DequeIter(this.q, this.front, this.back, this.drop); - const clone = h.v as (item: T) => T; - const items: T[] = []; - for (let i = this.front; i < this.back; i++) items.push(clone(this.q.b[at(this.q, i)] as T)); - return iterSlice(items, this.drop); + /** std's: the first `n` drained, or all cleared, either of which drops them in order. */ + override advanceBy(n: number): number { + const len = this.q.n; + if (len < n) dequeClear(this.q, this.drop); + else new DequeDrain(this.q, 0, n, this.drop)[Symbol.dispose](); + return Math.max(n - len, 0); } - override nextBack(): T | Done { - return this.front < this.back ? (this.q.b[at(this.q, --this.back)] as T) : DONE; + /** std's: the last `n` truncated, or all cleared. */ + override advanceBackBy(n: number): number { + const len = this.q.n; + if (len < n) dequeClear(this.q, this.drop); + else dequeTruncate(this.q, len - n, this.drop); + return Math.max(n - len, 0); + } + + override remaining(): Iterable { + return dequeIter(this.q) as Iterable; + } + + /** std's: a clone of the deque, each item cloned in order by `h.v`. */ + override clone(h?: Clones): Iter { + return new DequeIntoIter(dequeClone(this.q, h?.v as ((item: T) => T) | undefined), this.drop); } override len(): number { - return this.back - this.front; + return this.q.n; } override sizeHint(): SizeHint { - return exactHint(this.len()); + return exactHint(this.q.n); } [Symbol.dispose](): void { - if (this.drop === undefined) return; - const items: T[] = []; - while (this.front < this.back) items.push(this.q.b[at(this.q, this.front++)] as T); - dropAll(items, this.drop); + if (this.drop !== undefined) dequeClear(this.q, this.drop); } } +/** `into_iter`, whose items drop by `drop` with it. */ +export function dequeIntoIter(q: VecDeque, drop?: (item: T) => void): Iter { + return new DequeIntoIter(q, drop); +} + /** - * `iter` and `iter_mut`, and with what drops each item, `into_iter`, whose `last`, - * `count`, and skips are a `Vec`'s. + * `collect` into a deque of `size`-byte items, of bytes if `bytes`, from `it`, a deque's + * `into_iter` or a `Vec`'s, which std's gives the buffer of as it is: a deque's, or a + * `Vec`'s with its head where its front was read to. */ -export function dequeIter(q: VecDeque, drop?: (item: T) => void): Iter { - if (drop === undefined) return new DequeIter(q, 0, q.n); - const items: T[] = []; - for (let i = 0; i < q.n; i++) items.push(q.b[at(q, i)] as T); - return iterSlice(items, drop); +export function dequeFromIntoIter(it: Iter, size: number, bytes = false): VecDeque { + if (it instanceof DequeIntoIter) return it.q; + const v = it as unknown as { s: T[] & Capped; front: number; back: number }; + const q = dequeWithCapacity(capOf(v.s.length, v.s.cap, size), size, bytes); + q.n = v.back - v.front; + q.h = size === 0 || q.n === 0 ? 0 : v.front; + for (let i = 0; i < q.n; i++) q.b[q.h + i] = v.s[v.front + i]; + return q; } -/** `iter_mut` of items JS copies: the place of each. */ -export function dequeIterMut(q: VecDeque): Iter> { - return new DequePlaces(q); +/** + * `drain`: the items within `r`, which the deque gives up its length past the start of as + * std's does, so one never dropped leaks the rest. Those it still holds as it drops each + * drop by `drop`, front to back, and then the shorter of the items before and after the + * range moves next to the other. + */ +export function dequeDrain(q: VecDeque, r: Bounds, drop?: (item: T) => void): Iter { + const [start, end] = boundsRange(r, q.n); + return new DequeDrain(q, start, end - start, drop); } -/** A deque's `iter_mut` of items JS copies, which lends each as its place. */ -class DequePlaces extends Iter> { +/** A deque's drain, with std's counts: `idx` the next item's index, and `rest` of the range left, std's `remaining`. */ +class DequeDrain extends Iter implements Disposable { private readonly q: VecDeque; - private front = 0; - private back: number; + readonly drainLen: number; + idx: number; + readonly tailLen: number; + rest: number; + private readonly drop: ((item: T) => void) | undefined; + private joined = false; - constructor(q: VecDeque) { + constructor(q: VecDeque, start: number, drainLen: number, drop?: (item: T) => void) { super(); this.q = q; - this.back = q.n; + this.drainLen = drainLen; + this.idx = start; + this.tailLen = q.n - start - drainLen; + this.rest = drainLen; + this.drop = drop; + q.n = start; } - next(): Place | Done { - return this.front < this.back ? new AtIndex(this.q.b as T[], at(this.q, this.front++)) : DONE; + next(): T | Done { + if (this.rest === 0) return DONE; + this.rest--; + return this.q.b[at(this.q, this.idx++)] as T; } - override nextBack(): Place | Done { - return this.front < this.back ? new AtIndex(this.q.b as T[], at(this.q, --this.back)) : DONE; + override nextBack(): T | Done { + if (this.rest === 0) return DONE; + return this.q.b[at(this.q, this.idx + --this.rest)] as T; } override len(): number { - return this.back - this.front; + return this.rest; } override sizeHint(): SizeHint { - return exactHint(this.len()); + return exactHint(this.rest); + } + + [Symbol.dispose](): void { + if (this.joined) return; + this.joined = true; + const q = this.q; + const items: T[] = []; + for (; this.rest > 0; this.rest--) items.push(q.b[at(q, this.idx++)] as T); + if (this.drop !== undefined) dropAll(items, this.drop); + const head = q.n; + const tail = this.tailLen; + const gap = this.drainLen; + q.n = head + tail; + if (q.s === 0) return; + // The shorter side moves next to the other, and the slots it leaves are cleared. + if (head < tail) { + for (let i = head - 1; i >= 0; i--) q.b[at(q, i + gap)] = q.b[at(q, i)]; + for (let i = 0; i < gap; i++) q.b[at(q, i)] = undefined; + } else { + for (let i = 0; i < tail; i++) q.b[at(q, head + i)] = q.b[at(q, head + gap + i)]; + for (let i = 0; i < gap; i++) q.b[at(q, q.n + i)] = undefined; + } + if (q.n === 0) q.h = 0; + else if (head < tail) q.h = at(q, gap); } } -/** `drain`: the items within `r`, taken out at once, which drop by `drop` as `dequeIter`'s. */ -export function dequeDrain(q: VecDeque, r: Bounds, drop?: (item: T) => void): Iter { - const [start, end] = boundsRange(r, q.n); - const taken: VecDeque = { b: [], h: 0, n: 0 }; - for (let i = start; i < end; i++) dequePushBack(taken, q.b[at(q, i)] as T); - for (let i = end; i < q.n; i++) q.b[at(q, i - (end - start))] = q.b[at(q, i)]; - dequeTruncate(q, q.n - (end - start)); - return new DequeIter(taken, 0, taken.n, drop); +/** `Debug` of a deque's `Drain`: its counts, each by `debug`, as std's tuple of them. */ +export function fmtDequeDrain(it: Iter, f: Formatter, debug: Debug): FmtResult { + const d = it as unknown as DequeDrain; + const counts = [d.drainLen, d.idx, d.tailLen, d.rest]; + return fmtDebugTupleFields(f, "Drain", counts.map((n) => (f: Formatter) => debug(n, f))); } /** `slice::range`: the start and end of `r` within `n` elements, panicking as std's does. */ @@ -3092,18 +3376,38 @@ class ByteVecDrain extends Iter implements Disposable { * `extend`, and `collect` into a deque through `dequeNew`, which takes `items` as `take` * says and reserves as `iterExtend` does. */ -export function dequeExtend(q: VecDeque, items: Iter, take?: Take, size?: number, trusted = false): VecDeque { - return vecExtending(q, q.n, items, (item) => dequePushBack(q, item), take, size, trusted, q, true); +export function dequeExtend(q: VecDeque, items: Iter, take?: Take, trusted = false): VecDeque { + if (trusted) { + dequeReserve(q, trustedUpper(items)); + return extending(q, items, (item) => dequePushBack(q, item), take); + } + // std's reserves for the lower bound past each item it reads into a full deque, and the first. + for (let item = items.next(), first = true; item !== DONE; item = items.next(), first = false) { + if (first || q.n === q.b.length) dequeReserve(q, satAdd(items.sizeHint()[0], 1)); + q.b[at(q, q.n++)] = item; + } + if (take !== undefined) dispose(items); + return q; } -/** `clone` of `size`-byte items, with each through its `Clone`, or as itself without one, with room for exactly them. */ -export function dequeClone(q: VecDeque, item: (value: T) => T = itself, size: number): VecDeque { - const out = dequeNew(); - for (let i = 0; i < q.n; i++) dequePushBack(out, item(q.b[at(q, i)] as T)); - capSet(out, out.n, out.n, size); +/** `clone`, with each item through its `Clone`, or as itself without one, with room for exactly them. */ +export function dequeClone(q: VecDeque, item: (value: T) => T = itself): VecDeque { + const out = dequeWithCapacity(q.n, q.s, holdsBytes(q)); + for (let i = 0; i < q.n; i++) out.b[i] = item(q.b[at(q, i)] as T); + out.n = q.n; return out; } +/** + * `clone_from`: `q` cleared, which drops its items in order, then a clone of each of `src`'s + * in its room, as std's `extend` reserves for them. + */ +export function dequeCloneFrom(q: VecDeque, src: VecDeque, item: (value: T) => T = itself, drop?: (item: T) => void): void { + dequeClear(q, drop); + dequeReserve(q, src.n); + for (let i = 0; i < src.n; i++) q.b[at(q, q.n++)] = item(src.b[at(src, i)] as T); +} + // LinkedList /** A `LinkedList` node, linked to the one before, `p`, and after, `x`: the place of its item `v`. */ @@ -3760,9 +4064,9 @@ export function byteVecPart(): Part { return vectorPart(byteVecPush, byteVecReserve); } -/** A `VecDeque` of `size`-byte elements, which pushes each at the back. */ -export function dequePart(size?: number): Part, T> { - return vectorPart(dequePushBack, size === undefined ? undefined : (q, additional) => dequeReserve(q, additional, size)); +/** A `VecDeque`, which pushes each at the back. */ +export function dequePart(): Part, T> { + return vectorPart(dequePushBack, dequeReserve); } /** A `LinkedList`, which pushes each at the back, and never reserves. */ diff --git a/ts/runtime/rt/iter.ts b/ts/runtime/rt/iter.ts index 6f1c6437e..af129ae5c 100644 --- a/ts/runtime/rt/iter.ts +++ b/ts/runtime/rt/iter.ts @@ -41,7 +41,7 @@ const USIZE_MAX = 0xffffffff; type Drop = (value: T) => void; /** `a + b`, saturating at `usize::MAX` as std's size hints do. */ -function satAdd(a: number, b: number): number { +export function satAdd(a: number, b: number): number { return Math.min(a + b, USIZE_MAX); } @@ -256,7 +256,7 @@ abstract class Calling extends Adaptor { } /** An adaptor folded, whose `next` and `nextBack` are `front` and `back`, which share its state. */ -class Folded extends Iter { +export class Folded extends Iter { readonly front: () => T | Done; readonly back: () => T | Done; diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index 75dbfc627..30a0b51ab 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -39,7 +39,7 @@ pub fn call<'tcx>( None => match (owner, name, self_std, self_ty) { ("Default", "default", Some(std), Some(t)) | ("Clone", "clone", Some(std), Some(t)) - | ("Clone", "clone_from", Some(std @ Std::LinkedList), Some(t)) + | ("Clone", "clone_from", Some(std @ (Std::LinkedList | Std::VecDeque)), Some(t)) | ("Index" | "IndexMut", "index" | "index_mut", Some(std), Some(t)) | ("Extend", "extend", Some(std), Some(t)) | ("From", "from", Some(std), Some(t)) @@ -268,7 +268,7 @@ pub fn lending(std: Std) -> bool { /// indices of the collection's type arguments whose runtime function takes what drops each, /// after its own arguments: the key `insert` and `entry` are given if an equal one is there /// already, the key `remove` takes out, the value `or_insert` is given if one is, and what -/// `clear`, `retain`, and `truncate` discard. An iterator, and `extend` and `from`, take +/// `clear`, `retain`, `truncate`, and a deque's `clone_from` discard. An iterator, and `extend` and `from`, take /// theirs where they map. fn discarded(std: Std, owner: &str, name: &str) -> Option<&'static [usize]> { let map = matches!(std, Std::HashMap | Std::BTreeMap); @@ -280,7 +280,7 @@ fn discarded(std: Std, owner: &str, name: &str) -> Option<&'static [usize]> { (_, "or_insert") if std == Std::Entry => &[1], (_, "clear" | "retain" | "retain_mut") if map => &[0, 1], (_, "clear" | "retain" | "retain_mut") if set => &[0], - (_, "clear" | "retain" | "retain_mut" | "truncate") if std == Std::VecDeque => &[0], + (_, "clear" | "retain" | "retain_mut" | "truncate" | "clone_from") if std == Std::VecDeque => &[0], (_, "clear") if std == Std::LinkedList => &[0], (_, "clear" | "retain") if std == Std::BinaryHeap => &[0], _ => return None, @@ -1270,7 +1270,19 @@ fn btree_new<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, span: Span) -> Ex /// An empty `VecDeque` of type `coll`. fn deque_new<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, span: Span) -> Expr { - empty(b, Expr::rt("dequeNew", vec![]), coll, span) + let made = Expr::rt("dequeNew", deque_items(b, arg(coll, 0), span)); + empty(b, made, coll, span) +} + +/// What a runtime function that makes a `VecDeque` of `item`s is given after its own +/// arguments: their size, by which std's grows it, and whether they are bytes, which it +/// holds in a `Uint8Array` its slices view. +fn deque_items<'tcx>(b: &mut Body<'_, '_, 'tcx>, item: Ty<'tcx>, span: Span) -> Vec { + let bytes = matches!(item.kind(), ty::Uint(ty::UintTy::U8)); + super::iter::tail( + vec![super::iter::size_of(b, item, span)], + vec![Expr::lit(bytes.to_string())], + ) } /// A method of `VecDeque`, or of a trait it implements. @@ -1289,17 +1301,14 @@ fn deque<'tcx>( let back = |values: Vec| flagged(values, true, none); let e = match (owner, name) { (_, "new") | ("Default", "default") => deque_new(b, coll, span), - // What reads or sets a capacity is given the size of the items, by which std's - // grows it. (_, "with_capacity") => { - values.push(super::iter::size_of(b, item, span)); + values.extend(deque_items(b, item, span)); empty(b, Expr::rt("dequeWithCapacity", values), coll, span) } (_, "capacity" | "reserve" | "reserve_exact" | "shrink_to" | "shrink_to_fit") => { if name == "shrink_to_fit" { values.push(Expr::lit("0")); } - values.push(super::iter::size_of(b, item, span)); let f = match name { "capacity" => "dequeCapacity", "reserve" => "dequeReserve", @@ -1334,6 +1343,13 @@ fn deque<'tcx>( } (_, "iter_mut") if b.t.needs_place(item) => Expr::rt("dequeIterMut", values), (_, "iter" | "iter_mut") => Expr::rt("dequeIter", values), + // Each a copy of its part of the buffer, or with `_mut`, a view that writes into it; + // bytes are views either way. + (_, "as_slices" | "as_mut_slices") if matches!(item.kind(), ty::Uint(ty::UintTy::U8)) => { + Expr::rt("dequeByteSlices", values) + } + (_, "as_slices") => Expr::rt("dequeAsSlices", values), + (_, "as_mut_slices") => Expr::rt("dequeAsSlices", flagged(values, true, false)), (_, "drain") => { let ranged = bounds(b, call, values.pop()?); values.push(ranged.bounds.clone()); @@ -1342,18 +1358,29 @@ fn deque<'tcx>( } ("Index" | "IndexMut", "index" | "index_mut") => Expr::rt("dequeIndex", values), ("Clone", "clone") => { + let clone = clone_fn(b, item, span); + Expr::rt("dequeClone", super::iter::tail(values, vec![clone])) + } + // std's clears it, which drops its items, and extends it by clones of the source's, + // keeping its capacity. + ("Clone", "clone_from") => { values.push(clone_fn(b, item, span)); - values.push(super::iter::size_of(b, item, span)); - Expr::rt("dequeClone", values) + Expr::rt("dequeCloneFrom", values) } - // `From>` keeps the vector's capacity. + // `From>` keeps the vector's capacity, and `From<[T; N]>` holds exactly `N`. ("From", "from") if b.t.std_of(library::targ(call.args, 1)) == Some(Std::Vec) => { let v = values.pop()?; let v = match matches!(item.kind(), ty::Uint(ty::UintTy::U8)) { true => Expr::rt("byteVecToVec", vec![v]), false => v, }; - empty(b, Expr::rt("dequeFromVec", vec![v]), coll, span) + let made = Expr::rt("dequeFromVec", [vec![v], deque_items(b, item, span)].concat()); + empty(b, made, coll, span) + } + ("From", "from") if library::targ(call.args, 1).is_array() => { + let a = values.pop()?; + let made = Expr::rt("dequeFromArray", [vec![a], deque_items(b, item, span)].concat()); + empty(b, made, coll, span) } ("Extend", "extend") | ("From", "from") => { let (source, iter) = extend_source(b, coll, call, owner, values.pop()?)?; @@ -1652,7 +1679,13 @@ pub fn extend<'tcx>( ) } Std::Vec => Expr::rt("iterExtend", super::iter::tail(vec![target, items], vec_reserve(b))), - Std::VecDeque => Expr::rt("dequeExtend", super::iter::tail(vec![target, items], vec_reserve(b))), + Std::VecDeque => { + let take = super::iter::iter_take(b, iter, trusted, span); + Expr::rt( + "dequeExtend", + super::iter::tail(vec![target, items], vec![take, Expr::lit(trusted.to_string())]), + ) + } // By `for_each`, reserving nothing. Std::LinkedList => { let take = super::iter::iter_take(b, iter, true, span); @@ -1804,7 +1837,7 @@ fn part<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, item: Ty<'tcx>, span: let part = match std { Std::Vec if matches!(arg(coll, 0).kind(), ty::Uint(ty::UintTy::U8)) => Expr::rt("byteVecPart", Vec::new()), Std::Vec => Expr::rt("vecPart", super::iter::tail(Vec::new(), size(b))), - Std::VecDeque => Expr::rt("dequePart", super::iter::tail(Vec::new(), size(b))), + Std::VecDeque => Expr::rt("dequePart", Vec::new()), Std::LinkedList => Expr::rt("listPart", Vec::new()), Std::BinaryHeap => { let le = heap_tests(b, arg(coll, 0), false, span); @@ -2768,6 +2801,8 @@ pub fn into_iter<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr, sp _ => return None, }; if !ty.is_ref() { + // A deque's is the deque itself, which it pops from. + let name = if name == "dequeIter" { "dequeIntoIter" } else { name }; let droppers = entry_droppers(b, coll, span); return Some(Expr::rt(name, super::iter::tail(vec![value], droppers))); } @@ -2806,10 +2841,26 @@ pub fn collect<'tcx>( let target = list_new(b, ty, span); extend(b, ty, arg(ty, 0), target, iter, from, span)? } - // std's collects into a `Vec` first, whose capacity it keeps. + // std's takes the buffer of a deque's or a `Vec`'s `into_iter` as it is, and + // collects any other into a `Vec` first, whose capacity it keeps. Std::VecDeque => { - let items = super::iter::to_array(b, iter, from, arg(ty, 0), trusted, span); - empty(b, Expr::rt("dequeFromVec", vec![items]), ty, span) + let item = arg(ty, 0); + let bytes = matches!(item.kind(), ty::Uint(ty::UintTy::U8)); + let path = from.ty_adt_def().map(|adt| library::std_path(b.t.tcx, adt.did()).join("::")); + let whole = match path.as_deref() { + Some("collections::vec_deque::into_iter::IntoIter") => true, + // A `Vec`'s reads a view of its bytes, which leaves its capacity behind. + Some("vec::into_iter::IntoIter") => !bytes, + _ => false, + }; + let made = match whole { + true => Expr::rt("dequeFromIntoIter", [vec![iter], deque_items(b, item, span)].concat()), + false => { + let items = super::iter::to_array(b, iter, from, item, trusted, span); + Expr::rt("dequeFromVec", [vec![items], deque_items(b, item, span)].concat()) + } + }; + empty(b, made, ty, span) } _ => return None, }) diff --git a/ts/src/lower/drop.rs b/ts/src/lower/drop.rs index c0044d356..46dbcf33a 100644 --- a/ts/src/lower/drop.rs +++ b/ts/src/lower/drop.rs @@ -76,11 +76,14 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { Some(Std::Entry) => args.types().next().is_some_and(|k| self.drops(k)), // The items of the `Vec` it owns. Some(Std::Cow) => library::cow_slice(tcx, ty).is_some_and(|elem| self.drops(elem)), - // A `Vec`'s drain moves the vector's tail back as it drops, and a `String`'s takes - // the drained text out of it. + // A `Vec`'s drain moves the vector's tail back as it drops, a deque's joins the + // items before and after the range, and a `String`'s takes the drained text out + // of it. None if { let path = library::std_path(tcx, adt.did()); - path == ["vec", "drain", "Drain"] || path == ["string", "Drain"] + path == ["vec", "drain", "Drain"] + || path == ["collections", "vec_deque", "drain", "Drain"] + || path == ["string", "Drain"] } => { true diff --git a/ts/src/lower/fmt.rs b/ts/src/lower/fmt.rs index 2848f4b7a..4ec7690fe 100644 --- a/ts/src/lower/fmt.rs +++ b/ts/src/lower/fmt.rs @@ -467,9 +467,8 @@ pub fn std_impl<'tcx>( } /// `Debug` of one of std's iterators that lists the items it has left, as std writes -/// them, or `None` for another type. A deque's `Iter` and `IterMut` write the two halves of -/// its ring buffer, which the runtime's deque splits elsewhere than std's, and its `Drain` -/// its indices, so they stay refused. +/// them, or `None` for another type. A deque's `Iter` and `IterMut` write the two slices of +/// its ring buffer they have left, and its `Drain` its counts. fn iter_debug<'tcx>( b: &mut Body<'_, '_, 'tcx>, did: DefId, @@ -497,6 +496,15 @@ fn iter_debug<'tcx>( let path: Vec<&str> = path.iter().map(String::as_str).collect(); let (item, wraps): (Item, &[Wrap]) = match path.as_slice() { ["str", "iter", "Chars"] => return Some(Expr::rt("fmtChars", vec![value.clone(), f.clone()])), + ["collections", "vec_deque", "iter" | "iter_mut", name @ ("Iter" | "IterMut")] => { + let debug = b.fmt_fn(Trait::Debug, args.types().next()?, span); + let call = vec![value.clone(), f.clone(), debug, Expr::Str((*name).into())]; + return Some(Expr::rt("fmtDequeIter", call)); + } + ["collections", "vec_deque", "drain", "Drain"] => { + let len = b.fmt_fn(Trait::Debug, tcx.types.usize, span); + return Some(Expr::rt("fmtDequeDrain", vec![value.clone(), f.clone(), len])); + } // The list it has left, then its length. ["collections", "linked_list", name @ ("Iter" | "IterMut")] => { let debug = b.fmt_fn(Trait::Debug, args.types().next()?, span); diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index 0b8443030..5ceb1e2eb 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -538,9 +538,11 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } // `*self = source.clone()`, as std's `Clone` for a `T: Clone` has `clone_from` and // its `ToOwned` has `clone_into`, cloning before it drops what it writes over. A - // list's maps, as it clones each element into one of its own nodes. + // list's maps, as it clones each element into one of its own nodes, and a deque's, + // as it clears itself first and keeps its capacity. ("Clone", "clone_from") | ("ToOwned", "clone_into") - if !self.b.t.translated(def_id, gargs) && self.b.t.std_of(targ(0)?) != Some(Std::LinkedList) => + if !self.b.t.translated(def_id, gargs) + && !matches!(self.b.t.std_of(targ(0)?), Some(Std::LinkedList | Std::VecDeque)) => { let ty = targ(0)?; if !ty.is_sized(tcx, self.b.t.typing_env_pub()) { From 51ec10914e9d510c080253be6bb7baac300baf09 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Mon, 2 Nov 2026 07:41:29 -0800 Subject: [PATCH 03/10] style(ts): format Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/src/harness.rs | 4 ++-- ts/src/lower/collections.rs | 4 +++- ts/src/lower/fmt.rs | 7 ++++++- 3 files changed, 11 insertions(+), 4 deletions(-) diff --git a/ts/fixtures/lang/src/harness.rs b/ts/fixtures/lang/src/harness.rs index 38dc994dc..b7f09633b 100644 --- a/ts/fixtures/lang/src/harness.rs +++ b/ts/fixtures/lang/src/harness.rs @@ -5,8 +5,8 @@ use crate::{ args, arrays, ascii, atomics, borrows, bounds, boxes, capacity, captures, cells, chars, chunks, clones, collections, combinators, conversions, counts, cows, cycles, defaults, durations, dyns, edits, errors, fields, floats, fmt, folds, generics, hashes, hints, holds, ints, iters, joins, keys, lengths, lists, locals, locks, - methods, nested, objects, orders, pointers, refs, results, returns, rings, saturates, separated, shapes, singles, slices, - splits, statics, strs, tuples, utf8, wrappers, wraps, zeros, + methods, nested, objects, orders, pointers, refs, results, returns, rings, saturates, separated, shapes, singles, + slices, splits, statics, strs, tuples, utf8, wrappers, wraps, zeros, }; /// The native side's entry: [`run`], except that a case starting with 0xff prints a diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index 30a0b51ab..1c5dc7c94 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -2846,7 +2846,9 @@ pub fn collect<'tcx>( Std::VecDeque => { let item = arg(ty, 0); let bytes = matches!(item.kind(), ty::Uint(ty::UintTy::U8)); - let path = from.ty_adt_def().map(|adt| library::std_path(b.t.tcx, adt.did()).join("::")); + let path = from + .ty_adt_def() + .map(|adt| library::std_path(b.t.tcx, adt.did()).join("::")); let whole = match path.as_deref() { Some("collections::vec_deque::into_iter::IntoIter") => true, // A `Vec`'s reads a view of its bytes, which leaves its capacity behind. diff --git a/ts/src/lower/fmt.rs b/ts/src/lower/fmt.rs index 4ec7690fe..6c0a9bfec 100644 --- a/ts/src/lower/fmt.rs +++ b/ts/src/lower/fmt.rs @@ -496,7 +496,12 @@ fn iter_debug<'tcx>( let path: Vec<&str> = path.iter().map(String::as_str).collect(); let (item, wraps): (Item, &[Wrap]) = match path.as_slice() { ["str", "iter", "Chars"] => return Some(Expr::rt("fmtChars", vec![value.clone(), f.clone()])), - ["collections", "vec_deque", "iter" | "iter_mut", name @ ("Iter" | "IterMut")] => { + [ + "collections", + "vec_deque", + "iter" | "iter_mut", + name @ ("Iter" | "IterMut"), + ] => { let debug = b.fmt_fn(Trait::Debug, args.types().next()?, span); let call = vec![value.clone(), f.clone(), debug, Expr::Str((*name).into())]; return Some(Expr::rt("fmtDequeIter", call)); From 6a6c21b82b565c6d88996a4f62c0d3f90668543c Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Mon, 2 Nov 2026 07:44:00 -0800 Subject: [PATCH 04/10] fix(ts): clone a deque into another by its clone_from Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/src/rings.rs | 7 +++++-- ts/src/lower/collections.rs | 14 ++++++++++---- 2 files changed, 15 insertions(+), 6 deletions(-) diff --git a/ts/fixtures/lang/src/rings.rs b/ts/fixtures/lang/src/rings.rs index c7efc8719..cddab383d 100644 --- a/ts/fixtures/lang/src/rings.rs +++ b/ts/fixtures/lang/src/rings.rs @@ -147,7 +147,7 @@ fn steps(data: &[u8], out: &mut Vec) { } } -/// A deque made anew from `q`: a clone, or one with room of its own cloned from it, +/// A deque made anew from `q`: a clone, or one with room of its own cloned into from it, /// collected from its own `into_iter` or a `Vec`'s read in part, whose buffers std's takes /// as they are, or from a `Vec` it collects. fn remade(q: VecDeque, arg: u8) -> VecDeque { @@ -157,7 +157,10 @@ fn remade(q: VecDeque, arg: u8) -> VecDeque { 0 => { let mut own = VecDeque::with_capacity(skip * 3); own.push_front(T::make(arg)); - own.clone_from(&q); + match arg & 0x40 { + 0 => own.clone_from(&q), + _ => q.clone_into(&mut own), + } own } 1 => { diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index 1c5dc7c94..d58f27e29 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -40,6 +40,7 @@ pub fn call<'tcx>( ("Default", "default", Some(std), Some(t)) | ("Clone", "clone", Some(std), Some(t)) | ("Clone", "clone_from", Some(std @ (Std::LinkedList | Std::VecDeque)), Some(t)) + | ("ToOwned", "clone_into", Some(std @ Std::VecDeque), Some(t)) | ("Index" | "IndexMut", "index" | "index_mut", Some(std), Some(t)) | ("Extend", "extend", Some(std), Some(t)) | ("From", "from", Some(std), Some(t)) @@ -268,7 +269,7 @@ pub fn lending(std: Std) -> bool { /// indices of the collection's type arguments whose runtime function takes what drops each, /// after its own arguments: the key `insert` and `entry` are given if an equal one is there /// already, the key `remove` takes out, the value `or_insert` is given if one is, and what -/// `clear`, `retain`, `truncate`, and a deque's `clone_from` discard. An iterator, and `extend` and `from`, take +/// `clear`, `retain`, `truncate`, and a deque's `clone_from` and `clone_into` discard. An iterator, and `extend` and `from`, take /// theirs where they map. fn discarded(std: Std, owner: &str, name: &str) -> Option<&'static [usize]> { let map = matches!(std, Std::HashMap | Std::BTreeMap); @@ -280,7 +281,9 @@ fn discarded(std: Std, owner: &str, name: &str) -> Option<&'static [usize]> { (_, "or_insert") if std == Std::Entry => &[1], (_, "clear" | "retain" | "retain_mut") if map => &[0, 1], (_, "clear" | "retain" | "retain_mut") if set => &[0], - (_, "clear" | "retain" | "retain_mut" | "truncate" | "clone_from") if std == Std::VecDeque => &[0], + (_, "clear" | "retain" | "retain_mut" | "truncate" | "clone_from" | "clone_into") if std == Std::VecDeque => { + &[0] + } (_, "clear") if std == Std::LinkedList => &[0], (_, "clear" | "retain") if std == Std::BinaryHeap => &[0], _ => return None, @@ -1362,8 +1365,11 @@ fn deque<'tcx>( Expr::rt("dequeClone", super::iter::tail(values, vec![clone])) } // std's clears it, which drops its items, and extends it by clones of the source's, - // keeping its capacity. - ("Clone", "clone_from") => { + // keeping its capacity; `clone_into` is the target's `clone_from`. + ("Clone", "clone_from") | ("ToOwned", "clone_into") => { + if name == "clone_into" { + values.reverse(); + } values.push(clone_fn(b, item, span)); Expr::rt("dequeCloneFrom", values) } From a23e4fa3f6fd6552f0e21d985228d110d30fb6c0 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Mon, 2 Nov 2026 08:17:09 -0800 Subject: [PATCH 05/10] test(ts): refresh the snapshots of deques' new arguments Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/codec/expected/bench.ts | 2 +- ts/fixtures/lang/expected/rings.ts | 40 +++++++++++++++------ ts/fixtures/share/expected/harness.ts | 4 +-- ts/fixtures/task/expected/drops.ts | 4 +-- ts/fixtures/task/expected/drops/closures.ts | 2 +- ts/fixtures/task/expected/drops/folds.ts | 2 +- ts/fixtures/task/expected/drops/inside.ts | 2 +- ts/fixtures/task/expected/drops/iters.ts | 10 +++--- 8 files changed, 43 insertions(+), 23 deletions(-) diff --git a/ts/fixtures/codec/expected/bench.ts b/ts/fixtures/codec/expected/bench.ts index 5389411ab..4d1351e0c 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -443,7 +443,7 @@ export function push(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void let _37!: rt.u32; const count2: rt.u32 = rt.u64Low(rt.u64Min(takeU64(data)[0], 65536)); if (selector === 1) { - const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const q: rt.VecDeque = rt.dequeNew(4) as rt.VecDeque; let iterStart: rt.u32 = 0; const iterEnd: rt.u32 = count2; while ((_18 = iterStart++) < iterEnd) { diff --git a/ts/fixtures/lang/expected/rings.ts b/ts/fixtures/lang/expected/rings.ts index 899fa149c..cad1023a8 100644 --- a/ts/fixtures/lang/expected/rings.ts +++ b/ts/fixtures/lang/expected/rings.ts @@ -675,7 +675,7 @@ export function steps$unit(dataData: Uint8Array, dataStart: number, dataLen: num } /** - * A deque made anew from `q`: a clone, or one with room of its own cloned from it, + * A deque made anew from `q`: a clone, or one with room of its own cloned into from it, * collected from its own `into_iter` or a `Vec`'s read in part, whose buffers std's takes * as they are, or from a `Vec` it collects. */ @@ -687,7 +687,11 @@ export function remade$String(q: rt.VecDeque, arg: rt.u8): rt.VecDeque = rt.dequeWithCapacity(rt.usizeMul(skip, 3), 12) as rt.VecDeque; const _18: string = make$rings_Item_String(arg); rt.dequePushFront(own, _18); - rt.dequeCloneFrom(own, q, undefined); + if ((arg & 64) === 0) { + rt.dequeCloneFrom(own, q, undefined); + } else { + rt.dequeCloneFrom(own, q, undefined); + } return own; } return rt.dequeClone(q); @@ -725,7 +729,7 @@ export function remade$String(q: rt.VecDeque, arg: rt.u8): rt.VecDeque, arg: rt.u8): rt.VecDeq const own: rt.VecDeque = rt.dequeWithCapacity(rt.usizeMul(skip, 3), 1101) as rt.VecDeque; const _18: Big.Big = Big.make$rings_Item(arg); rt.dequePushFront(own, _18); - rt.dequeCloneFrom(own, q, Big.clone$Clone); + if ((arg & 64) === 0) { + rt.dequeCloneFrom(own, q, Big.clone$Clone); + } else { + rt.dequeCloneFrom(own, q, Big.clone$Clone); + } return own; } return rt.dequeClone(q, Big.clone$Clone); @@ -775,7 +783,7 @@ export function remade$rings_Big(q: rt.VecDeque, arg: rt.u8): rt.VecDeq } /** - * A deque made anew from `q`: a clone, or one with room of its own cloned from it, + * A deque made anew from `q`: a clone, or one with room of its own cloned into from it, * collected from its own `into_iter` or a `Vec`'s read in part, whose buffers std's takes * as they are, or from a `Vec` it collects. */ @@ -787,7 +795,11 @@ export function remade$u32(q: rt.VecDeque, arg: rt.u8): rt.VecDeque = rt.dequeWithCapacity(rt.usizeMul(skip, 3), 4) as rt.VecDeque; const _18: rt.u32 = make$rings_Item_u32(arg); rt.dequePushFront(own, _18); - rt.dequeCloneFrom(own, q, undefined); + if ((arg & 64) === 0) { + rt.dequeCloneFrom(own, q, undefined); + } else { + rt.dequeCloneFrom(own, q, undefined); + } return own; } return rt.dequeClone(q); @@ -825,7 +837,7 @@ export function remade$u32(q: rt.VecDeque, arg: rt.u8): rt.VecDeque, arg: rt.u8): rt.VecDeque const own: rt.VecDeque = rt.dequeWithCapacity(rt.usizeMul(skip, 3), 1, true) as rt.VecDeque; const _18: rt.u8 = make$rings_Item_u8(arg); rt.dequePushFront(own, _18); - rt.dequeCloneFrom(own, q, undefined); + if ((arg & 64) === 0) { + rt.dequeCloneFrom(own, q, undefined); + } else { + rt.dequeCloneFrom(own, q, undefined); + } return own; } return rt.dequeClone(q); @@ -875,7 +891,7 @@ export function remade$u8(q: rt.VecDeque, arg: rt.u8): rt.VecDeque } /** - * A deque made anew from `q`: a clone, or one with room of its own cloned from it, + * A deque made anew from `q`: a clone, or one with room of its own cloned into from it, * collected from its own `into_iter` or a `Vec`'s read in part, whose buffers std's takes * as they are, or from a `Vec` it collects. */ @@ -887,7 +903,11 @@ export function remade$unit(q: rt.VecDeque, arg: rt.u8): rt.VecDeque< const own: rt.VecDeque = rt.dequeWithCapacity(rt.usizeMul(skip, 3), 0) as rt.VecDeque; make$rings_Item_unit(arg); rt.dequePushFront(own, undefined); - rt.dequeCloneFrom(own, q, undefined); + if ((arg & 64) === 0) { + rt.dequeCloneFrom(own, q, undefined); + } else { + rt.dequeCloneFrom(own, q, undefined); + } return own; } return rt.dequeClone(q); diff --git a/ts/fixtures/share/expected/harness.ts b/ts/fixtures/share/expected/harness.ts index dd85bf2ff..c1d776e6b 100644 --- a/ts/fixtures/share/expected/harness.ts +++ b/ts/fixtures/share/expected/harness.ts @@ -25,8 +25,8 @@ export function run(input: rt.ByteSlice): rt.ByteVec { rt.idx(w, 1); return Uint8Array.of(_3, w.data[w.start + 1]); }), undefined, 2, true); - const deque: rt.VecDeque = rt.dequeNew() as rt.VecDeque; - rt.dequeExtend(deque, rt.iterMap(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 2, true); + const deque: rt.VecDeque = rt.dequeNew(2) as rt.VecDeque; + rt.dequeExtend(deque, rt.iterMap(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray), undefined, true); const _47: rt.Iter = rt.iterFlatMap(rt.iterLend(rt.dequeIter(deque), rt.byteSliceFrom), (p: rt.ByteSlice): Uint8Array => { return Uint8Array.of(p.data[p.start], p.data[p.start + 1]); }, (value: Uint8Array) => rt.iterSlice(value), false, 2); diff --git a/ts/fixtures/task/expected/drops.ts b/ts/fixtures/task/expected/drops.ts index 3b9b5e76b..5c8bd1add 100644 --- a/ts/fixtures/task/expected/drops.ts +++ b/ts/fixtures/task/expected/drops.ts @@ -395,7 +395,7 @@ export function ordered(log: Log.Log, id: rt.u32): void { Log.note(log, _185); const _201: Key.Key = key(12); rt.btreeAdd(set, _201, rt.drop); - const queue: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const queue: rt.VecDeque = rt.dequeNew(8) as rt.VecDeque; let iterStart: rt.u32 = 20; const iterEnd: rt.u32 = 26; while ((_208 = iterStart++) < iterEnd) { @@ -928,7 +928,7 @@ export function elements(log: Log.Log, id: rt.u32): void { }); const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part8, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; Log.note(log, rt.fmtFormat(["called ", args14[0]])); - const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const q: rt.VecDeque = rt.dequeNew(8) as rt.VecDeque; rt.dequePushBack(q, undefined as Guard.Guard | undefined); const _186: Guard.Guard | undefined = guard(4); rt.dequePushBack(q, _186); diff --git a/ts/fixtures/task/expected/drops/closures.ts b/ts/fixtures/task/expected/drops/closures.ts index e0e53ec42..5ca9706bd 100644 --- a/ts/fixtures/task/expected/drops/closures.ts +++ b/ts/fixtures/task/expected/drops/closures.ts @@ -678,7 +678,7 @@ export function iterated(log: Log.Log, id: rt.u32): void { captured22[Symbol.dispose](); }); rt.dropAfter(_475, () => rt.btreeRetain(map, _475, undefined, rt.drop)); - const queue: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const queue: rt.VecDeque = rt.dequeNew(8) as rt.VecDeque; const _479: Guard.Guard = guard(33); rt.dequePushBack(queue, _479); const _484: Guard.Guard = guard(34); diff --git a/ts/fixtures/task/expected/drops/folds.ts b/ts/fixtures/task/expected/drops/folds.ts index 143c50552..1bacf0bd7 100644 --- a/ts/fixtures/task/expected/drops/folds.ts +++ b/ts/fixtures/task/expected/drops/folds.ts @@ -221,7 +221,7 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { return g66; }, (): void => { captured54[Symbol.dispose](); - })), "next", 8, true)) as rt.VecDeque; + })), "next", 8, true), 8) as rt.VecDeque; const _206: rt.Iter = rt.iterSlice(guards(4, 7), rt.drop); _1089 = false; const captured55 = d; diff --git a/ts/fixtures/task/expected/drops/inside.ts b/ts/fixtures/task/expected/drops/inside.ts index 06049bc4d..9238113f8 100644 --- a/ts/fixtures/task/expected/drops/inside.ts +++ b/ts/fixtures/task/expected/drops/inside.ts @@ -70,7 +70,7 @@ export function inside(log: Log.Log, id: rt.u32, arg: rt.u8): void { const _139: rt.usize = v.length; const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_136, f), (f: rt.Formatter) => rt.usizeDisplay(_139, f)]; Log.note(log, rt.fmtFormat(["drained ", args10[0], " ", args10[1]])); - const q: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(new rt.Range(6, 9), guard), undefined, 8, true)) as rt.VecDeque; + const q: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(new rt.Range(6, 9), guard), undefined, 8, true), 8) as rt.VecDeque; const it: rt.Iter = rt.dropAfter(new Spent.Spent(guard(11), 0, 2), (range13) => rt.dequeDrain(q, rt.boundsOf(range13, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rt.drop), rt.drop); const part17 = option_map$1raha9y(rt.iterToOption(it.next()), (g12: Guard.Guard): rt.u32 => { const _012: rt.u32 = Guard.id(g12); diff --git a/ts/fixtures/task/expected/drops/iters.ts b/ts/fixtures/task/expected/drops/iters.ts index 6a423d68e..64328bfb3 100644 --- a/ts/fixtures/task/expected/drops/iters.ts +++ b/ts/fixtures/task/expected/drops/iters.ts @@ -404,7 +404,7 @@ export function collected(log: Log.Log, id: rt.u32): void { v9.push(_223); const _228: Guard.Guard = guard(20); v9.push(_228); - const queue: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterSlice(v9, rt.drop), "next", 8, true)) as rt.VecDeque; + const queue: rt.VecDeque = rt.dequeFromIntoIter(rt.iterSlice(v9, rt.drop), 8) as rt.VecDeque; const v10: [rt.u32, Guard.Guard][] = []; const _237: [rt.u32, Guard.Guard] = [1, guard(21)]; v10.push(_237); @@ -494,7 +494,7 @@ export function drained(log: Log.Log, id: rt.u32): void { const _63: string = rt.fmtFormat(["set ", args4[0]]); rt.drop(_70); Log.note(log, _63); - const queue: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const queue: rt.VecDeque = rt.dequeNew(8) as rt.VecDeque; let iterStart: rt.u32 = 15; const iterEnd: rt.u32 = 20; while ((_80 = iterStart++) < iterEnd) { @@ -511,7 +511,7 @@ export function drained(log: Log.Log, id: rt.u32): void { Log.note(log, rt.fmtFormat(["drain ", args6[0]])); rt.drop(range); const _113: rt.usize = queue.n; - const _119: rt.Iter = rt.dequeIter(queue, rt.drop); + const _119: rt.Iter = rt.dequeIntoIter(queue, rt.drop); const _116: rt.u32 = option_mapOr$01ozsk3(rt.iterToOption(_119.next()), 0, (g3: Guard.Guard): rt.u32 => { const _07: rt.u32 = Guard.id(g3); g3[Symbol.dispose](); @@ -658,7 +658,7 @@ export function extended(log: Log.Log, id: rt.u32): void { const _192: Key.Key = key(16); v7.push(_192); rt.btreeExtendKeys(ordered, rt.iterSlice(v7, rt.drop), false, rt.drop, "fold"); - const queue: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const queue: rt.VecDeque = rt.dequeNew(8) as rt.VecDeque; const _198: Guard.Guard = guard(18); rt.dequePushBack(queue, _198); const v8: Guard.Guard[] = []; @@ -666,7 +666,7 @@ export function extended(log: Log.Log, id: rt.u32): void { v8.push(_207); const _212: Guard.Guard = guard(20); v8.push(_212); - rt.dequeExtend(queue, rt.iterSlice(v8, rt.drop), "fold", 8, true); + rt.dequeExtend(queue, rt.iterSlice(v8, rt.drop), "fold", true); const _221: rt.usize = rt.btreeLen(tree); const _224: rt.usize = rt.btreeLen(ordered); const _227: rt.usize = queue.n; From 438957215ea0e5db81b1ab6cb6f616cf8955df23 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Mon, 2 Nov 2026 08:31:41 -0800 Subject: [PATCH 06/10] fix(ts): collect a byte vector's iterator into a deque with its capacity A Vec's into_iter runs over its whole buffer, whose length is its exact capacity, so a deque collected from it takes std's buffer and head. Co-Authored-By: Claude Opus 5.5 --- quest/m3/ts-vec-exact-capacity.md | 4 +- ts/fixtures/lang/expected/capacity.ts | 10 +-- ts/fixtures/lang/expected/clones.ts | 38 +++++----- ts/fixtures/lang/expected/cycles.ts | 2 +- ts/fixtures/lang/expected/fmt.ts | 4 +- ts/fixtures/lang/expected/hints.ts | 2 +- ts/fixtures/lang/expected/holds.ts | 2 +- ts/fixtures/lang/expected/iters.ts | 102 +++++++++++++------------- ts/fixtures/lang/expected/keys.ts | 22 +++--- ts/fixtures/lang/expected/lists.ts | 6 +- ts/fixtures/lang/expected/locals.ts | 8 +- ts/fixtures/lang/expected/nested.ts | 4 +- ts/fixtures/lang/expected/orders.ts | 4 +- ts/fixtures/lang/expected/pointers.ts | 4 +- ts/fixtures/lang/expected/refs.ts | 4 +- ts/fixtures/lang/expected/rings.ts | 97 +++++++++++------------- ts/fixtures/lang/expected/slices.ts | 4 +- ts/fixtures/lang/expected/tuples.ts | 54 +++++++------- ts/fixtures/lang/expected/wrappers.ts | 2 +- ts/fixtures/lang/src/rings.rs | 7 -- ts/runtime/rt/collections.ts | 4 +- ts/runtime/rt/iter.ts | 7 ++ ts/src/lower/collections.rs | 11 +-- ts/src/lower/iter.rs | 4 + ts/src/lower/mir/step.rs | 7 +- 25 files changed, 200 insertions(+), 213 deletions(-) diff --git a/quest/m3/ts-vec-exact-capacity.md b/quest/m3/ts-vec-exact-capacity.md index 9b1477d8c..8dd4fa25e 100644 --- a/quest/m3/ts-vec-exact-capacity.md +++ b/quest/m3/ts-vec-exact-capacity.md @@ -13,12 +13,10 @@ Found splitting a deque's slices where std's does exact capacity, but one made from a `Vec`, by `From>` or by `collect`, takes the capacity the runtime models for the `Vec`, which holds only std's guarantees (decided 2026-11-01) and so recomputes from its length after a pop, `truncate`, or `drain`. A -`Vec`'s `into_iter` also reads a view of its bytes, which leaves the capacity behind, -so `collect` into a deque cannot keep std's buffer and head. +`Vec` already holds its exact capacity as its buffer's length. - Record the capacity where a step shrinks the length, and measure its cost on pops with the codec's [TS benchmark](/ts/README.md#bench). -- Carry a `Vec`'s capacity into its `into_iter`. - Needs the maintainer's call against the 2026-11-01 decision. Public API: the translator's output. diff --git a/ts/fixtures/lang/expected/capacity.ts b/ts/fixtures/lang/expected/capacity.ts index ea6960531..b2e3720f9 100644 --- a/ts/fixtures/lang/expected/capacity.ts +++ b/ts/fixtures/lang/expected/capacity.ts @@ -591,12 +591,12 @@ export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: nu Known.remade(k, false); } else if (_42 === 18) { const keep2: () => boolean = alternate(); - v = rt.iterToByteVec(rt.iterFilter(rt.iterSlice(rt.byteVecView(v)), (_26: rt.u8): boolean => { + v = rt.iterToByteVec(rt.iterFilter(rt.byteVecIntoIter(v), (_26: rt.u8): boolean => { return keep2(); }), "next"); Known.remade(k, false); } else if (_42 === 19) { - const it: rt.Iter = rt.iterSlice(rt.byteVecView(v)); + const it: rt.Iter = rt.byteVecIntoIter(v); const _174: rt.u8 = rt.u8Rem(arg, 8); let iterStart: rt.u8 = 0; const iterEnd: rt.u8 = _174; @@ -628,7 +628,7 @@ export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: nu rt.byteVecDedup(v); Known.loose(k); } else if (_42 === 23) { - const it2: rt.Iter = rt.iterSlice(rt.byteVecView(v)); + const it2: rt.Iter = rt.byteVecIntoIter(v); const _236: rt.u8 = rt.u8Rem(arg, 4); let iterStart2: rt.u8 = 0; const iterEnd2: rt.u8 = _236; @@ -1800,11 +1800,11 @@ export function collects(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const _37: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(n, data.length)); rt.byteVecExtendFromSlice(bytes, _37); Known.put(exact, out, bytes.length, bytes.data.length); - const odd: rt.ByteVec = rt.iterToByteVec(rt.iterFilter(rt.iterSlice(rt.byteVecView(rt.byteVecFrom(rt.byteVecView(bytes)))), (b5: rt.u8): boolean => { + const odd: rt.ByteVec = rt.iterToByteVec(rt.iterFilter(rt.byteVecIntoIter(rt.byteVecFrom(rt.byteVecView(bytes))), (b5: rt.u8): boolean => { return rt.u8Rem(b5, 2) === 1; }), "next"); Known.put(loose, out, odd.length, odd.data.length); - const wide: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteVecView(bytes)), (a0: rt.u8): rt.u16 => { + const wide: rt.u16[] = rt.iterToArray(rt.iterMap(rt.byteVecIntoIter(bytes), (a0: rt.u8): rt.u16 => { return a0 as rt.u16; }), undefined, 2, true); const _64: rt.usize = wide.length; diff --git a/ts/fixtures/lang/expected/clones.ts b/ts/fixtures/lang/expected/clones.ts index 8751363a6..8dfb2d08f 100644 --- a/ts/fixtures/lang/expected/clones.ts +++ b/ts/fixtures/lang/expected/clones.ts @@ -6614,7 +6614,7 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }, plan, (x68: rt.u8): rt.u8 => { return x68; }, out); - turns$vec_IntoIter_u8_clones_iters_closure18_clones_iters_closure19(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(data))), (it76: rt.Iter): rt.u8 | undefined => { + turns$vec_IntoIter_u8_clones_iters_closure18_clones_iters_closure19(rt.byteVecIntoIter(rt.byteSliceToByteVec(data)), (it76: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it76.nextBack()); }, plan, (x69: rt.u8): rt.u8 => { return x69; @@ -6861,7 +6861,7 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }, out); turns$iter_Flatten_iter_Map_slice_Chunks_u8_clones_iters_closure89_clones_iters_closure90_clones_iters_closure91(rt.iterFlatten(rt.iterMap(rt.byteSliceChunks(data, n), (c3: rt.ByteSlice): rt.ByteVec => { return rt.byteSliceToByteVec(c3); - }), (value: rt.ByteVec) => rt.iterSlice(rt.byteVecView(value))), (it43: rt.Iter): rt.u8 | undefined => { + }), (value: rt.ByteVec) => rt.byteVecIntoIter(value)), (it43: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it43.nextBack()); }, plan, (x47: rt.u8): rt.u8 => { return x47; @@ -7005,7 +7005,7 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(zip3.clone(), zip3), (x29: rt.u8): rt.u8 => { return x29 ^ 64; }), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.refCellReplace(log, new rt.ByteVec()))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.refCellReplace(log, new rt.ByteVec())), undefined, true); } else if (_9 === 8) { it = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(data))); let iterStart5: rt.usize = 0; @@ -7252,9 +7252,9 @@ export function unordered$iter_Copied_collections_hash_map_Keys_u8_u8(it: rt.Ite const _16: [rt.ByteVec, rt.ByteVec] = [_17, rt.iterToByteVec(other, "next")]; const rest: rt.ByteVec = _17; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); - rt.iterExtendBytes(all, rt.iterSlice(rt.byteVecView(rest)), undefined, true); + rt.iterExtendBytes(all, rt.byteVecIntoIter(rest), undefined, true); rt.byteSliceView(rt.byteVecSlice(all)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(all)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(all), undefined, true); } /** @@ -7270,9 +7270,9 @@ export function unordered$iter_Copied_collections_hash_map_Values_u8_u8(it: rt.I const _16: [rt.ByteVec, rt.ByteVec] = [_17, rt.iterToByteVec(other, "next")]; const rest: rt.ByteVec = _17; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); - rt.iterExtendBytes(all, rt.iterSlice(rt.byteVecView(rest)), undefined, true); + rt.iterExtendBytes(all, rt.byteVecIntoIter(rest), undefined, true); rt.byteSliceView(rt.byteVecSlice(all)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(all)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(all), undefined, true); } /** @@ -7288,9 +7288,9 @@ export function unordered$iter_Copied_collections_hash_set_Difference_u8_hash_Ra const _16: [rt.ByteVec, rt.ByteVec] = [_17, rt.iterToByteVec(other, "next")]; const rest: rt.ByteVec = _17; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); - rt.iterExtendBytes(all, rt.iterSlice(rt.byteVecView(rest)), undefined, true); + rt.iterExtendBytes(all, rt.byteVecIntoIter(rest), undefined, true); rt.byteSliceView(rt.byteVecSlice(all)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(all)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(all), undefined, true); } /** @@ -7306,9 +7306,9 @@ export function unordered$iter_Copied_collections_hash_set_Intersection_u8_hash_ const _16: [rt.ByteVec, rt.ByteVec] = [_17, rt.iterToByteVec(other, "next")]; const rest: rt.ByteVec = _17; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); - rt.iterExtendBytes(all, rt.iterSlice(rt.byteVecView(rest)), undefined, true); + rt.iterExtendBytes(all, rt.byteVecIntoIter(rest), undefined, true); rt.byteSliceView(rt.byteVecSlice(all)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(all)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(all), undefined, true); } /** @@ -7324,9 +7324,9 @@ export function unordered$iter_Copied_collections_hash_set_Iter_u8(it: rt.Iter { return _23 === 7; }) ? 1 : 0); diff --git a/ts/fixtures/lang/expected/fmt.ts b/ts/fixtures/lang/expected/fmt.ts index 9f5db53d7..bdb2ae5d0 100644 --- a/ts/fixtures/lang/expected/fmt.ts +++ b/ts/fixtures/lang/expected/fmt.ts @@ -1008,7 +1008,7 @@ export function iters(data: rt.ByteSlice, out: rt.ByteVec): void { }), undefined, 16, true)), front, back); const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part3, f, (value: fmt_Pair.Pair, f: rt.Formatter) => fmt_Pair.fmt$fmt_Debug(value, f), ["IntoIter"])]; put(out, rt.fmtFormat([args6[0], "|", rt.fmtSpec({ alternate: true }, args6[0])])); - const part4 = ends$iters_vec_IntoIter_u8(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(data))), front, back); + const part4 = ends$iters_vec_IntoIter_u8(rt.byteVecIntoIter(rt.byteSliceToByteVec(data)), front, back); const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part4, f, rt.u8Debug, ["IntoIter"])]; put(out, rt.fmtFormat([rt.fmtSpec({ debugHex: "x" }, args8[0])])); const it4: rt.Iter = ends$iters_vec_Drain_fmt_Hex(rt.vecDrain(rt.iterToArray(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 5), (_23: rt.u8): Hex.Hex => { @@ -1037,7 +1037,7 @@ export function iters(data: rt.ByteSlice, out: rt.ByteVec): void { put(out, rt.fmtFormat([args16[0]])); const _165: Array = []; const _174: rt.Iter = rt.iterSlice(_165); - const _176: rt.Iter = rt.iterSlice(rt.byteVecView(new rt.ByteVec())); + const _176: rt.Iter = rt.byteVecIntoIter(new rt.ByteVec()); const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(_174, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), ["Iter"]), (f: rt.Formatter) => rt.fmtIter(_176, f, rt.u8Debug, ["IntoIter"])]; put(out, rt.fmtFormat([args18[0], "|", rt.fmtSpec({ alternate: true }, args18[1])])); const heap: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterSlice(rt.byteSliceView(data)), undefined, 1, true), rt.le, rt.ge, rt.lt); diff --git a/ts/fixtures/lang/expected/hints.ts b/ts/fixtures/lang/expected/hints.ts index 41c5e8df9..161fdfc51 100644 --- a/ts/fixtures/lang/expected/hints.ts +++ b/ts/fixtures/lang/expected/hints.ts @@ -1962,7 +1962,7 @@ export function hints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (_312 === 0) { walk$slice_Iter_u8(rt.iterSlice(rt.byteSliceView(bytes)), steps, out); } else if (_312 === 1) { - walk$vec_IntoIter_u8(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(bytes))), steps, out); + walk$vec_IntoIter_u8(rt.byteVecIntoIter(rt.byteSliceToByteVec(bytes)), steps, out); } else if (_312 === 2) { walk$array_IntoIter_u8_3(rt.iterSlice(Uint8Array.of(at(3), at(4), at(5))), steps, out); } else if (_312 === 3) { diff --git a/ts/fixtures/lang/expected/holds.ts b/ts/fixtures/lang/expected/holds.ts index 234798d63..7b4590a02 100644 --- a/ts/fixtures/lang/expected/holds.ts +++ b/ts/fixtures/lang/expected/holds.ts @@ -123,7 +123,7 @@ export function indexed(data: rt.ByteSlice, out: rt.ByteVec): void { const _31: rt.u8 = rt.u8WrappingAdd(v.data[at], i2 & 0xff); v.data[at] = _31; } - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); } /** diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index d21d32c91..ed312ea30 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -340,12 +340,12 @@ export function reducers(data: rt.ByteSlice, out: rt.ByteVec): void { }), 204, (v: rt.ByteVec): rt.u8 => { return v.length & 0xff; })); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(option_unwrapOrDefault$0wx44sw(rt.iterReduce(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_23: rt.u8): rt.ByteVec => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(option_unwrapOrDefault$0wx44sw(rt.iterReduce(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_23: rt.u8): rt.ByteVec => { return rt.byteVecFrom(Uint8Array.of(_23)); }), (a4: rt.ByteVec, b7: rt.ByteVec): rt.ByteVec => { - rt.iterExtendBytes(a4, rt.iterSlice(rt.byteVecView(b7)), undefined, true); + rt.iterExtendBytes(a4, rt.byteVecIntoIter(b7), undefined, true); return a4; - })))), undefined, true); + }))), undefined, true); const it: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(data))); const _38: rt.Place | undefined = rt.peekablePeekMut(it, true); if (_38 !== undefined) { @@ -367,7 +367,7 @@ export function reducers(data: rt.ByteSlice, out: rt.ByteVec): void { if (_73 !== undefined) { rt.byteVecPush(_73, 153); } - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(option_unwrapOrDefault$0wx44sw(rt.iterToOption(words.next())))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(option_unwrapOrDefault$0wx44sw(rt.iterToOption(words.next()))), undefined, true); const _87: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(first)); rt.byteVecPush(out, option_mapOr$1a3irjf(rt.peekableNextIfEq(words, _87, rt.eqBytes), 136, (w: rt.ByteVec): rt.u8 => { return w.data[rt.idx(w, 0)]; @@ -380,8 +380,8 @@ export function reducers(data: rt.ByteSlice, out: rt.ByteVec): void { if (_94 !== undefined) { _94.v = 119; } - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(log)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(bytes), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(log), undefined, true); } export function eq$cmp_PartialEq_iters_Quarter_u8(self: rt.u8, other: Quarter.Quarter): boolean { @@ -567,7 +567,7 @@ export function peekedOthers(data: rt.ByteSlice, out: rt.ByteVec): void { }), 170, (b9: rt.Place): rt.u8 => { return b9.v; })); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(bytes), undefined, true); const it11: rt.Peekable = rt.iterPeekable(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): Quarter.Quarter => { return { _0: _210, _1: calls }; })); @@ -1990,9 +1990,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2299[0] as rt.u32, _2299[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_41 === 4) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z, (_2298: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z, (_2298: [rt.u8, rt.u8]): rt.u8 => { return _2298[0] ^ _2298[1]; - }), undefined, true))), undefined, true); + }), undefined, true)), undefined, true); } else if (_41 === 5) { rt.byteVecPush(out, rt.iterFold(z, 0, (acc7: rt.u8, p20: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc7, 3) ^ _40(p20); @@ -2179,9 +2179,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2268[0] as rt.u32, _2268[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_202 === 4) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z3, (_2267: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z3, (_2267: [rt.u8, rt.u8]): rt.u8 => { return _2267[0] ^ _2267[1]; - }), undefined, true))), undefined, true); + }), undefined, true)), undefined, true); } else if (_202 === 5) { rt.byteVecPush(out, rt.iterFold(z3, 0, (acc6: rt.u8, p18: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc6, 3) ^ _201(p18); @@ -2366,9 +2366,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2237[0] as rt.u32, _2237[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_381 === 4) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z5, (_2236: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z5, (_2236: [rt.u8, rt.u8]): rt.u8 => { return _2236[0] ^ _2236[1]; - }), undefined, true))), undefined, true); + }), undefined, true)), undefined, true); } else if (_381 === 5) { rt.byteVecPush(out, rt.iterFold(z5, 0, (acc5: rt.u8, p16: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc5, 3) ^ _380(p16); @@ -2526,12 +2526,12 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_28 === 2) { if (!other) { if ((kind & 16) === 0) { - const z7: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x138: rt.u8): rt.u8 => { + const z7: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x138: rt.u8): rt.u8 => { const _6178: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6178.value, x138 ^ 7); rt.refMutRelease(_6178); return x138; - }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x139: rt.u8): rt.u8 => { + }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x139: rt.u8): rt.u8 => { const _6179: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6179.value, x139 ^ 8); rt.refMutRelease(_6179); @@ -2553,9 +2553,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2206[0] as rt.u32, _2206[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_574 === 4) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z7, (_2205: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z7, (_2205: [rt.u8, rt.u8]): rt.u8 => { return _2205[0] ^ _2205[1]; - }), undefined, true))), undefined, true); + }), undefined, true)), undefined, true); } else if (_574 === 5) { rt.byteVecPush(out, rt.iterFold(z7, 0, (acc4: rt.u8, p14: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc4, 3) ^ _573(p14); @@ -2588,12 +2588,12 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else { const _612: rt.usize = rt.usizeRem(data.length, 8); if (_612 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x135: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x135: rt.u8): rt.u8 => { const _6176: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6176.value, x135 ^ 7); rt.refMutRelease(_6176); return x135; - }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x136: rt.u8): rt.u8 => { + }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x136: rt.u8): rt.u8 => { const _6177: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6177.value, x136 ^ 8); rt.refMutRelease(_6177); @@ -2602,12 +2602,12 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u8Rem(_2198[0], 2) === 0; })) & 0xff); } else if (_612 === 1) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilterMap(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x132: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterFilterMap(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x132: rt.u8): rt.u8 => { const _6174: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6174.value, x132 ^ 7); rt.refMutRelease(_6174); return x132; - }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x133: rt.u8): rt.u8 => { + }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x133: rt.u8): rt.u8 => { const _6175: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6175.value, x133 ^ 8); rt.refMutRelease(_6175); @@ -2616,12 +2616,12 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u8CheckedSub(_2197[0], _2197[1]); })) & 0xff); } else if (_612 === 2) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkipWhile(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x129: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterSkipWhile(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x129: rt.u8): rt.u8 => { const _6172: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6172.value, x129 ^ 7); rt.refMutRelease(_6172); return x129; - }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x130: rt.u8): rt.u8 => { + }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x130: rt.u8): rt.u8 => { const _6173: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6173.value, x130 ^ 8); rt.refMutRelease(_6173); @@ -2630,12 +2630,12 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return _2196[0] < 128; })) & 0xff); } else if (_612 === 3) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(rt.iterMap(rt.iterEnumerate(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x127: rt.u8): rt.u8 => { + rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(rt.iterMap(rt.iterEnumerate(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x127: rt.u8): rt.u8 => { const _6170: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6170.value, x127 ^ 7); rt.refMutRelease(_6170); return x127; - }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x128: rt.u8): rt.u8 => { + }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x128: rt.u8): rt.u8 => { const _6171: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6171.value, x128 ^ 8); rt.refMutRelease(_6171); @@ -2644,48 +2644,48 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return _2195[0] & 0xff; })), 238)); } else if (_612 === 4) { - rt.byteVecPush(out, rt.iterCount(rt.iterChain(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x125: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterChain(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x125: rt.u8): rt.u8 => { const _6168: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6168.value, x125 ^ 7); rt.refMutRelease(_6168); return x125; - }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x126: rt.u8): rt.u8 => { + }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x126: rt.u8): rt.u8 => { const _6169: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6169.value, x126 ^ 8); rt.refMutRelease(_6169); return x126; }), "len"), rt.iterSlice([[1, 2] as [rt.u8, rt.u8]]))) & 0xff); } else if (_612 === 5) { - rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x123: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x123: rt.u8): rt.u8 => { const _6166: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6166.value, x123 ^ 7); rt.refMutRelease(_6166); return x123; - }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x124: rt.u8): rt.u8 => { + }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x124: rt.u8): rt.u8 => { const _6167: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6167.value, x124 ^ 8); rt.refMutRelease(_6167); return x124; }), "len"), n)) & 0xff); } else if (_612 === 6) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x121: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x121: rt.u8): rt.u8 => { const _6164: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6164.value, x121 ^ 7); rt.refMutRelease(_6164); return x121; - }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x122: rt.u8): rt.u8 => { + }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x122: rt.u8): rt.u8 => { const _6165: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6165.value, x122 ^ 8); rt.refMutRelease(_6165); return x122; }), "len"), n)) & 0xff); } else { - const p4: rt.Peekable<[rt.u8, rt.u8]> = rt.iterPeekable(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x119: rt.u8): rt.u8 => { + const p4: rt.Peekable<[rt.u8, rt.u8]> = rt.iterPeekable(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x119: rt.u8): rt.u8 => { const _6162: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6162.value, x119 ^ 7); rt.refMutRelease(_6162); return x119; - }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x120: rt.u8): rt.u8 => { + }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x120: rt.u8): rt.u8 => { const _6163: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6163.value, x120 ^ 8); rt.refMutRelease(_6163); @@ -2695,7 +2695,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } } else if ((kind & 16) === 0) { - const z9: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x107: rt.u8): rt.u8 => { + const z9: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x107: rt.u8): rt.u8 => { const _6158: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6158.value, x107 ^ 9); rt.refMutRelease(_6158); @@ -2723,9 +2723,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2193[0] as rt.u32, _2193[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_751 === 4) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z9, (_2192: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z9, (_2192: [rt.u8, rt.u8]): rt.u8 => { return _2192[0] ^ _2192[1]; - }), undefined, true))), undefined, true); + }), undefined, true)), undefined, true); } else if (_751 === 5) { rt.byteVecPush(out, rt.iterFold(z9, 0, (acc3: rt.u8, p12: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc3, 3) ^ _750(p12); @@ -2758,7 +2758,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else { const _789: rt.usize = rt.usizeRem(data.length, 8); if (_789 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x104: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x104: rt.u8): rt.u8 => { const _6156: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6156.value, x104 ^ 9); rt.refMutRelease(_6156); @@ -2773,7 +2773,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u8Rem(_2184[0], 2) === 0; })) & 0xff); } else if (_789 === 1) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilterMap(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x101: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterFilterMap(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x101: rt.u8): rt.u8 => { const _6154: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6154.value, x101 ^ 9); rt.refMutRelease(_6154); @@ -2788,7 +2788,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u8CheckedSub(_2182[0], _2182[1]); })) & 0xff); } else if (_789 === 2) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkipWhile(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x98: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterSkipWhile(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x98: rt.u8): rt.u8 => { const _6152: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6152.value, x98 ^ 9); rt.refMutRelease(_6152); @@ -2803,7 +2803,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return _2180[0] < 128; })) & 0xff); } else if (_789 === 3) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(rt.iterMap(rt.iterEnumerate(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x96: rt.u8): rt.u8 => { + rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(rt.iterMap(rt.iterEnumerate(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x96: rt.u8): rt.u8 => { const _6150: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6150.value, x96 ^ 9); rt.refMutRelease(_6150); @@ -2818,7 +2818,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return _2178[0] & 0xff; })), 238)); } else if (_789 === 4) { - rt.byteVecPush(out, rt.iterCount(rt.iterChain(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x94: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterChain(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x94: rt.u8): rt.u8 => { const _6148: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6148.value, x94 ^ 9); rt.refMutRelease(_6148); @@ -2831,7 +2831,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return x95; }), "len"), rt.iterSlice([[1, 2] as [rt.u8, rt.u8]]))) & 0xff); } else if (_789 === 5) { - rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x92: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x92: rt.u8): rt.u8 => { const _6146: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6146.value, x92 ^ 9); rt.refMutRelease(_6146); @@ -2844,7 +2844,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return x93; }), "len"), n)) & 0xff); } else if (_789 === 6) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x90: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x90: rt.u8): rt.u8 => { const _6144: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6144.value, x90 ^ 9); rt.refMutRelease(_6144); @@ -2857,7 +2857,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return x91; }), "len"), n)) & 0xff); } else { - const p5: rt.Peekable<[rt.u8, rt.u8]> = rt.iterPeekable(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x88: rt.u8): rt.u8 => { + const p5: rt.Peekable<[rt.u8, rt.u8]> = rt.iterPeekable(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x88: rt.u8): rt.u8 => { const _6142: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6142.value, x88 ^ 9); rt.refMutRelease(_6142); @@ -2905,9 +2905,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2171[0] as rt.u32, _2171[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_927 === 4) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z11, (_2170: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z11, (_2170: [rt.u8, rt.u8]): rt.u8 => { return _2170[0] ^ _2170[1]; - }), "next"))), undefined, true); + }), "next")), undefined, true); } else if (_927 === 5) { rt.byteVecPush(out, rt.iterFold(z11, 0, (acc2: rt.u8, p10: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc2, 3) ^ _926(p10); @@ -3116,9 +3116,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2131[0] as rt.u32, _2131[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_1102 === 4) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z13, (_2130: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z13, (_2130: [rt.u8, rt.u8]): rt.u8 => { return _2130[0] ^ _2130[1]; - }), undefined, true))), undefined, true); + }), undefined, true)), undefined, true); } else if (_1102 === 5) { rt.byteVecPush(out, rt.iterFold(z13, 0, (acc: rt.u8, p8: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc, 3) ^ _1101(p8); @@ -4610,7 +4610,7 @@ export function adapted(a: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const v: rt.ByteVec = new rt.ByteVec(); const _22: rt.Iter = rt.iterTake(new rt.RangeFrom(lo, rt.u8Step), 3); rt.iterExtendBytes(v, _22, undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.iterExtendBytes(out, rt.iterTake(rt.iterFlatten(rt.iterSlice([new rt.RangeFrom(lo, rt.u8Step), new rt.RangeFrom(rt.u8Div(b, 2), rt.u8Step)])), 5), "next"); rt.iterExtendBytes(out, rt.iterTake(rt.iterFlatMap(it(), (x: rt.u8): rt.RangeFrom => { return new rt.RangeFrom(rt.u8Div(x, 4), rt.u8Step); @@ -4625,7 +4625,7 @@ export function adapted(a: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterMap(rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _54, true, undefined, undefined, undefined, 8, true)), (_24: [rt.u8, rt.usize]): rt.u8 => { return _24[0] ^ (_24[1] & 0xff); }), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterTake(rt.iterStepBy(new rt.RangeFrom(lo, rt.u8Step), 3), 4), "next"))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterTake(rt.iterStepBy(new rt.RangeFrom(lo, rt.u8Step), 3), 4), "next")), undefined, true); rt.iterExtendBytes(out, rt.strBytes(rt.stringExtendChars("", rt.iterTake(new rt.RangeFrom(97, rt.charStep), rt.usizeRem(n, 6)))), undefined, true); const _77: [rt.usize, rt.usize | undefined] = rt.iterZip(it(), new rt.RangeFrom(lo, rt.u8Step), "len").sizeHint(); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_77[0] & 0xff, option_mapOr$02k4ito(_77[1], 238, (h: rt.usize): rt.u8 => { @@ -4691,7 +4691,7 @@ export function overflowed(a: rt.u8, _dataData: Uint8Array, _dataStart: number, return c & 0xff; })); } else { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(new rt.RangeFrom(top, rt.u8Step), undefined, true))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(new rt.RangeFrom(top, rt.u8Step), undefined, true)), undefined, true); } } diff --git a/ts/fixtures/lang/expected/keys.ts b/ts/fixtures/lang/expected/keys.ts index 65a8e47df..452e4d26a 100644 --- a/ts/fixtures/lang/expected/keys.ts +++ b/ts/fixtures/lang/expected/keys.ts @@ -1797,7 +1797,7 @@ export function keyed$Option_u8_2_keys_arrays_closure5(data: rt.ByteSlice, make: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -2053,7 +2053,7 @@ export function keyed$bool_2_keys_arrays_closure4(data: rt.ByteSlice, make: (a0: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -2308,7 +2308,7 @@ export function keyed$char_2_keys_arrays_closure3(data: rt.ByteSlice, make: (a0: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -2564,7 +2564,7 @@ export function keyed$i32_2_keys_arrays_closure2(data: rt.ByteSlice, make: (a0: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -2819,7 +2819,7 @@ export function keyed$keys_Hop_2_keys_arrays_closure6(data: rt.ByteSlice, make: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -3075,7 +3075,7 @@ export function keyed$u16_2_keys_arrays_closure0(data: rt.ByteSlice, make: (a0: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -3331,7 +3331,7 @@ export function keyed$u32_0_keys_arrays_closure7(data: rt.ByteSlice, make: (a0: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -3587,7 +3587,7 @@ export function keyed$u32_275_keys_arrays_closure8(data: rt.ByteSlice, make: (a0 rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -3843,7 +3843,7 @@ export function keyed$u64_2_keys_arrays_closure1(data: rt.ByteSlice, make: (a0: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -4176,7 +4176,7 @@ export function taken$0_keys_byte_refs_closure1(data: rt.ByteSlice, make: (a0: r const _332: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_332.value, counted2); rt.refMutRelease(_332); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.refCellReplace(log, new rt.ByteVec()))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.refCellReplace(log, new rt.ByteVec())), undefined, true); const lent: [rt.ByteSlice, rt.ByteSlice][] = rt.iterToArray(rt.iterMap(rt.iterLend(rt.hashIter(map), (held20): [rt.ByteSlice, rt.ByteSlice] => { return [rt.byteSliceFrom(held20[0]), rt.byteSliceFrom(held20[1])]; }), (_23: [rt.ByteSlice, rt.ByteSlice]): [rt.ByteSlice, rt.ByteSlice] => { @@ -4477,7 +4477,7 @@ export function taken$2_keys_byte_refs_closure0(data: rt.ByteSlice, make: (a0: r const _332: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_332.value, counted2); rt.refMutRelease(_332); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.refCellReplace(log, new rt.ByteVec()))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.refCellReplace(log, new rt.ByteVec())), undefined, true); const lent: [rt.ByteSlice, rt.ByteSlice][] = rt.iterToArray(rt.iterMap(rt.iterLend(rt.hashIter(map), (held20): [rt.ByteSlice, rt.ByteSlice] => { return [rt.byteSliceFrom(held20[0]), rt.byteSliceFrom(held20[1])]; }), (_23: [rt.ByteSlice, rt.ByteSlice]): [rt.ByteSlice, rt.ByteSlice] => { diff --git a/ts/fixtures/lang/expected/lists.ts b/ts/fixtures/lang/expected/lists.ts index c553e8c4b..33a583b7e 100644 --- a/ts/fixtures/lang/expected/lists.ts +++ b/ts/fixtures/lang/expected/lists.ts @@ -115,10 +115,10 @@ export function lists(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (_13 === 11) { l = rt.replaceIn(m, l); } else { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.listExtractIfMut(l, (x5: rt.Place): boolean => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.listExtractIfMut(l, (x5: rt.Place): boolean => { x5.v = rt.u8WrappingAdd(x5.v, 1); return rt.u8Rem(x5.v, 3) === 0; - }), "next"))), undefined, true); + }), "next")), undefined, true); } } } @@ -193,7 +193,7 @@ export function edges(data: rt.ByteSlice, out: rt.ByteVec): void { const _64: rt.LinkedList = rt.listClone(whole, undefined); rt.listAppend(from, _64); const _68: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(7, 8)); - rt.listExtend(from, rt.iterSlice(rt.byteVecView(_68))); + rt.listExtend(from, rt.byteVecIntoIter(_68)); items(from, out); const _75: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): [rt.u8, rt.u8] => { const b: rt.u8 = _2; diff --git a/ts/fixtures/lang/expected/locals.ts b/ts/fixtures/lang/expected/locals.ts index 3ce07f5df..93a7811eb 100644 --- a/ts/fixtures/lang/expected/locals.ts +++ b/ts/fixtures/lang/expected/locals.ts @@ -61,9 +61,9 @@ export function locals(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, ((a0: rt.Cell): rt.u32 => { return a0.v; })(COUNT.get()) & 0xff); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(withBorrow$1k8k9m1(LOG, (log2: rt.ByteVec): rt.ByteVec => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(withBorrow$1k8k9m1(LOG, (log2: rt.ByteVec): rt.ByteVec => { return rt.byteVecFrom(rt.byteVecView(log2)); - }))), undefined, true); + })), undefined, true); rt.byteVecPush(out, ((p: locals_Polling.Polling): rt.u8 => { return option_mapOr$0ucbp7g(copy$Option_tuple2_u64_u64(p.current.v), 253, (_2: [rt.u64, rt.u64]): rt.u8 => { return rt.u64Low(_2[0]) & 0xff; @@ -165,9 +165,9 @@ export function locals(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, withBorrow$0r4ucls(LOG, (log4: rt.ByteVec): rt.u8 => { return log4.length & 0xff; })); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(replace$1xk72wn(LOG, rt.byteVecFrom(Uint8Array.of(op))))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(replace$1xk72wn(LOG, rt.byteVecFrom(Uint8Array.of(op)))), undefined, true); rt.localKeyRefCellSet(LOG, rt.byteVecFrom(Uint8Array.of(op, op))); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(local_take$122f15k(LOG))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(local_take$122f15k(LOG)), undefined, true); rt.localKeyRefCellSet(LOG, rt.byteVecFrom(Uint8Array.of(1, 2, 3))); const _141: rt.LocalKey> = HELD; const _144: rt.Arc> = rt.arcClone(log); diff --git a/ts/fixtures/lang/expected/nested.ts b/ts/fixtures/lang/expected/nested.ts index cfc1d2a74..8c36e89f4 100644 --- a/ts/fixtures/lang/expected/nested.ts +++ b/ts/fixtures/lang/expected/nested.ts @@ -441,7 +441,7 @@ export function closures(data: rt.ByteSlice, out: rt.ByteVec): void { }, undefined, rt.None), "next", 2)), (_222: rt.u8 | undefined): rt.u8 => { return code(_222); }), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(seen)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(seen), undefined, true); let steps: rt.u8 = 0; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.iterCount(rt.iterSuccessors(undefined, (_223: undefined): undefined | rt.None => { steps = rt.u8Add(steps, 1); @@ -761,7 +761,7 @@ export function units(data: rt.ByteSlice, out: rt.ByteVec): void { const byPointer: undefined[] = pointed(data, f); const generic: undefined[] = each$unit_nested_units_closure3(data, (_25: rt.u8): undefined => {}); const byName: undefined[] = each$unit_nested_ignore(data, ignore as (a0: rt.u8) => undefined); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(each$u8_nested_half(data, half))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(each$u8_nested_half(data, half)), undefined, true); const methods: undefined[] = madeAll$nested_Unit({}, data); const dynamic: undefined[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), rt.lent(ignore as (a0: rt.u8) => undefined)), undefined, 0, true); const iter: rt.Iter = rt.iterSlice([units, named, byPointer, generic, byName, methods, dynamic]); diff --git a/ts/fixtures/lang/expected/orders.ts b/ts/fixtures/lang/expected/orders.ts index 8be90efc1..7b773a30a 100644 --- a/ts/fixtures/lang/expected/orders.ts +++ b/ts/fixtures/lang/expected/orders.ts @@ -382,10 +382,10 @@ export function values(data: rt.ByteSlice, out: rt.ByteVec): void { const bytes: rt.BinaryHeap = rt.heapFrom(rt.byteVecToVec(rt.byteSliceToByteVec(data)), rt.le, rt.ge, rt.lt); rt.heapPush(bytes, data.length & 0xff, rt.le); rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.from(bytes.d)))), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFromVec(rt.heapIntoSortedVec(rt.heapClone(bytes, undefined, 1), rt.le, rt.ge, rt.lt)))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(rt.heapIntoSortedVec(rt.heapClone(bytes, undefined, 1), rt.le, rt.ge, rt.lt))), undefined, true); const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(bytes.d, f, rt.u8Debug)]; rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0]])), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFromVec(bytes.d))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(bytes.d)), undefined, true); const least: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u8 => { return _2; }), undefined, 1, true), rt.cmpLe(rt.cmpReverse(rt.cmp)), rt.cmpGe(rt.cmpReverse(rt.cmp)), rt.cmpLt(rt.cmpReverse(rt.cmp))); diff --git a/ts/fixtures/lang/expected/pointers.ts b/ts/fixtures/lang/expected/pointers.ts index f4c456db1..d4fd0509b 100644 --- a/ts/fixtures/lang/expected/pointers.ts +++ b/ts/fixtures/lang/expected/pointers.ts @@ -665,7 +665,7 @@ export function lapsed(data: rt.ByteSlice, out: rt.ByteVec): void { const _33: Log.Log = { bytes: rt.byteVecFrom(Uint8Array.of(n, ~n & 0xff)) }; const old3 = log; log = _33; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(old3.bytes)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(old3.bytes), undefined, true); const old2: Duo.Duo = rt.replaceIn(pair, { _0: n, _1: n ^ 15 }); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(old2._0, old2._1)), undefined, true); } else if (_24 === 2) { @@ -695,7 +695,7 @@ export function lapsed(data: rt.ByteSlice, out: rt.ByteVec): void { } } rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(pair._0, pair._1)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(log.bytes)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(log.bytes), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(window), undefined, true); } diff --git a/ts/fixtures/lang/expected/refs.ts b/ts/fixtures/lang/expected/refs.ts index 1c367ecac..0f7b55404 100644 --- a/ts/fixtures/lang/expected/refs.ts +++ b/ts/fixtures/lang/expected/refs.ts @@ -593,7 +593,7 @@ export function taken(data: rt.ByteSlice, out: rt.ByteVec): void { 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)), undefined, true); + rt.iterExtendBytes(swapped, rt.byteVecIntoIter(_45), undefined, true); } const list: (a0: rt.u8) => undefined = (b6: rt.u8): undefined => { const taken2 = pair[1].listed; @@ -606,7 +606,7 @@ export function taken(data: rt.ByteSlice, out: rt.ByteVec): void { }); for (const _57 of rt.byteSliceView(data)) { const _63: rt.ByteVec = option_unwrapOrDefault$0wx44sw(restock(pair[1], _57)); - rt.iterExtendBytes(swapped, rt.iterSlice(rt.byteVecView(_63)), undefined, true); + rt.iterExtendBytes(swapped, rt.byteVecIntoIter(_63), undefined, true); } const taken3 = pair[1].stale; pair[1].stale = new rt.ByteVec(); diff --git a/ts/fixtures/lang/expected/rings.ts b/ts/fixtures/lang/expected/rings.ts index cad1023a8..a228e3b77 100644 --- a/ts/fixtures/lang/expected/rings.ts +++ b/ts/fixtures/lang/expected/rings.ts @@ -714,18 +714,15 @@ export function remade$String(q: rt.VecDeque, arg: rt.u8): rt.VecDeque; } - if (true) { - const v: string[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 12, true); - rt.vecReserve(v, skip, 12); - const it3: rt.Iter = rt.iterSlice(v); - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = skip; - while (iterStart2++ < iterEnd2) { - rt.iterToOption(it3.next()); - } - return rt.dequeFromIntoIter(it3, 12) as rt.VecDeque; - } - return q; + const v: string[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 12, true); + rt.vecReserve(v, skip, 12); + const it3: rt.Iter = rt.iterSlice(v); + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = skip; + while (iterStart2++ < iterEnd2) { + rt.iterToOption(it3.next()); + } + return rt.dequeFromIntoIter(it3, 12) as rt.VecDeque; } /** @@ -768,18 +765,15 @@ export function remade$rings_Big(q: rt.VecDeque, arg: rt.u8): rt.VecDeq if (_8 === 3) { return rt.dequeFromVec(rt.iterToArray(rt.dequeIntoIter(q), undefined, 1101, true), 1101) as rt.VecDeque; } - if (true) { - const v: Big.Big[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 1101, true); - rt.vecReserve(v, skip, 1101); - const it3: rt.Iter = rt.iterSlice(v); - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = skip; - while (iterStart2++ < iterEnd2) { - rt.iterToOption(it3.next()); - } - return rt.dequeFromIntoIter(it3, 1101) as rt.VecDeque; + const v: Big.Big[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 1101, true); + rt.vecReserve(v, skip, 1101); + const it3: rt.Iter = rt.iterSlice(v); + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = skip; + while (iterStart2++ < iterEnd2) { + rt.iterToOption(it3.next()); } - return q; + return rt.dequeFromIntoIter(it3, 1101) as rt.VecDeque; } /** @@ -822,18 +816,15 @@ export function remade$u32(q: rt.VecDeque, arg: rt.u8): rt.VecDeque; } - if (true) { - const v: rt.u32[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 4, true); - rt.vecReserve(v, skip, 4); - const it3: rt.Iter = rt.iterSlice(v); - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = skip; - while (iterStart2++ < iterEnd2) { - rt.iterToOption(it3.next()); - } - return rt.dequeFromIntoIter(it3, 4) as rt.VecDeque; + const v: rt.u32[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 4, true); + rt.vecReserve(v, skip, 4); + const it3: rt.Iter = rt.iterSlice(v); + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = skip; + while (iterStart2++ < iterEnd2) { + rt.iterToOption(it3.next()); } - return q; + return rt.dequeFromIntoIter(it3, 4) as rt.VecDeque; } /** @@ -876,18 +867,15 @@ export function remade$u8(q: rt.VecDeque, arg: rt.u8): rt.VecDeque if (_8 === 3) { return rt.dequeFromVec(rt.byteVecToVec(rt.iterToByteVec(rt.dequeIntoIter(q), undefined, true)), 1, true) as rt.VecDeque; } - if (false) { - const v: rt.ByteVec = rt.iterToByteVec(rt.dequeIntoIter(q), undefined, true); - rt.byteVecReserve(v, skip); - const it3: rt.Iter = rt.iterSlice(rt.byteVecView(v)); - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = skip; - while (iterStart2++ < iterEnd2) { - rt.iterToOption(it3.next()); - } - return rt.dequeFromVec(rt.iterToArray(it3, "next", 1, true), 1, true) as rt.VecDeque; + const v: rt.ByteVec = rt.iterToByteVec(rt.dequeIntoIter(q), undefined, true); + rt.byteVecReserve(v, skip); + const it3: rt.Iter = rt.byteVecIntoIter(v); + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = skip; + while (iterStart2++ < iterEnd2) { + rt.iterToOption(it3.next()); } - return q; + return rt.dequeFromIntoIter(it3, 1, true) as rt.VecDeque; } /** @@ -930,18 +918,15 @@ export function remade$unit(q: rt.VecDeque, arg: rt.u8): rt.VecDeque< if (_8 === 3) { return rt.dequeFromVec(rt.iterToArray(rt.dequeIntoIter(q), undefined, 0, true), 0) as rt.VecDeque; } - if (true) { - const v: undefined[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 0, true); - rt.vecReserve(v, skip, 0); - const it3: rt.Iter = rt.iterSlice(v); - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = skip; - while (iterStart2++ < iterEnd2) { - rt.iterToOption(it3.next(), rt.None); - } - return rt.dequeFromIntoIter(it3, 0) as rt.VecDeque; + const v: undefined[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 0, true); + rt.vecReserve(v, skip, 0); + const it3: rt.Iter = rt.iterSlice(v); + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = skip; + while (iterStart2++ < iterEnd2) { + rt.iterToOption(it3.next(), rt.None); } - return q; + return rt.dequeFromIntoIter(it3, 0) as rt.VecDeque; } /** A drain of a range `arg` picks, written as it is read from either end and then dropped. */ diff --git a/ts/fixtures/lang/expected/slices.ts b/ts/fixtures/lang/expected/slices.ts index c1505a94d..71190292b 100644 --- a/ts/fixtures/lang/expected/slices.ts +++ b/ts/fixtures/lang/expected/slices.ts @@ -1208,7 +1208,7 @@ export function drains(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return x8.tag; }), undefined, true); rt.dropAll(taken); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.byteVecDrain(bytes, { end: b }), "fold", true))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.byteVecDrain(bytes, { end: b }), "fold", true)), undefined, true); rt.drop(rt.vecDrain(words, { end: b })); } else if (_31 === 3) { const drain4: rt.Iter = rt.vecDrain(items, new rt.RangeFrom(a, rt.usizeStep), rt.drop); @@ -1263,7 +1263,7 @@ export function drains(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const other: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(238)); const _195: rt.Iter = rt.iterRev(rt.byteVecDrain(bytes, new rt.Range(a, b))); rt.iterExtendBytes(other, _195, "fold", true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(other)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(other), undefined, true); rt.dropAll(kept); } flush(out); diff --git a/ts/fixtures/lang/expected/tuples.ts b/ts/fixtures/lang/expected/tuples.ts index e7085ece5..fa69f5d8d 100644 --- a/ts/fixtures/lang/expected/tuples.ts +++ b/ts/fixtures/lang/expected/tuples.ts @@ -82,7 +82,7 @@ export function ones(data: rt.ByteSlice, out: rt.ByteVec): void { const _22: rt.Iter<[rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_26: rt.u8): [rt.u8] => { return [_26] as [rt.u8]; }); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFromVec(rt.tupleExtendOne([rt.heapNew() as rt.BinaryHeap] as [rt.BinaryHeap], _22, (c3, items3) => rt.heapExtend(c3, items3, rt.le, rt.ge, rt.lt, undefined, 1, true))[0].d))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(rt.tupleExtendOne([rt.heapNew() as rt.BinaryHeap] as [rt.BinaryHeap], _22, (c3, items3) => rt.heapExtend(c3, items3, rt.le, rt.ge, rt.lt, undefined, 1, true))[0].d)), undefined, true); const _28: rt.Iter<[rt.u8]> = rt.iterMap(rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): boolean => { return (_210 & 1) === 0; }), (_211: rt.u8): [rt.u8] => { @@ -103,7 +103,7 @@ export function ones(data: rt.ByteSlice, out: rt.ByteVec): void { return [c7.data[c7.start]] as [rt.u8]; }); rt.tupleExtendOne(t, _48, (c8, items7) => rt.iterExtendBytes(c8, items7, undefined, true)); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(t[0])), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(t[0]), undefined, true); const t2: [string] = ["ab"]; const _56: rt.Iter<[string]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_214: rt.u8): [string] => { const _84: rt.usize = rt.u8Rem(_214, 3) as rt.usize; @@ -121,8 +121,8 @@ export function ones(data: rt.ByteSlice, out: rt.ByteVec): void { const _64: [[rt.ByteVec, rt.BinaryHeap]] = rt.tupleExtendOne([[new rt.ByteVec(), rt.heapNew() as rt.BinaryHeap]] as [[rt.ByteVec, rt.BinaryHeap]], _65, (c10, items9) => rt.tupleExtend(c10, items9, [rt.byteVecPart(), rt.heapPart(rt.le, 1)])); const v2: rt.ByteVec = _64[0][0]; const heap2: rt.BinaryHeap = _64[0][1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v2)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFromVec(heap2.d))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v2), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(heap2.d)), undefined, true); rt.tupleExtendOne([undefined] as [undefined], rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_216: rt.u8): [undefined] => { return [undefined] as [undefined]; }), (_c11, items10) => rt.iterFold(items10, undefined, () => undefined)); @@ -142,7 +142,7 @@ export function pairs(data: rt.ByteSlice, out: rt.ByteVec): void { const _5: [rt.ByteVec, string] = rt.tupleExtend([new rt.ByteVec(), ""] as [rt.ByteVec, string], _6, [rt.byteVecPart(), rt.STRING_CHARS_PART]); const v: rt.ByteVec = _5[0]; const s: string = _5[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); const _16: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): [rt.u8, rt.u8] => { const b2: rt.u8 = _25; @@ -151,7 +151,7 @@ export function pairs(data: rt.ByteSlice, out: rt.ByteVec): void { const _15: [rt.ByteVec, rt.BTreeSet] = rt.tupleExtend([new rt.ByteVec(), rt.btreeNew(rt.cmp) as rt.BTreeSet] as [rt.ByteVec, rt.BTreeSet], _16, [rt.byteVecPart(), rt.btreeKeysPart()]); const v2: rt.ByteVec = _15[0]; const tree: rt.BTreeSet = _15[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v2)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v2), undefined, true); rt.iterExtendBytes(out, rt.btreeKeys(tree), undefined, true); const _23: rt.Iter<[rt.u8, rt.u16]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_27: rt.u8): [rt.u8, rt.u16] => { const b3: rt.u8 = _27; @@ -160,14 +160,14 @@ export function pairs(data: rt.ByteSlice, out: rt.ByteVec): void { const _22: [rt.BinaryHeap, rt.VecDeque] = rt.tupleExtend([rt.heapNew() as rt.BinaryHeap, rt.dequeNew(2) as rt.VecDeque] as [rt.BinaryHeap, rt.VecDeque], _23, [rt.heapPart(rt.le, 1), rt.dequePart()]); const heap: rt.BinaryHeap = _22[0]; const q: rt.VecDeque = _22[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFromVec(heap.d))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(heap.d)), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.dequeIter(q), (n: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n).reverse(); }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); const _33: rt.Iter<[undefined, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): [undefined, rt.u8] => { return [undefined, _210] as [undefined, rt.u8]; }); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.tupleExtend([undefined, new rt.ByteVec()] as [undefined, rt.ByteVec], _33, [rt.UNIT_PART, rt.byteVecPart()])[1])), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.tupleExtend([undefined, new rt.ByteVec()] as [undefined, rt.ByteVec], _33, [rt.UNIT_PART, rt.byteVecPart()])[1]), undefined, true); const _39: rt.Iter<[rt.u16, rt.u8]> = rt.iterMap(rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (_211: rt.u8): boolean => { return _211 > 64; }), (_212: rt.u8): [rt.u16, rt.u8] => { @@ -193,7 +193,7 @@ export function triples(data: rt.ByteSlice, out: rt.ByteVec): void { const v: rt.ByteVec = _6[0]; const q: rt.VecDeque = _6[1]; const s: string = _6[2]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.dequeIter(q), (n: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n).reverse(); }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); @@ -210,7 +210,7 @@ export function triples(data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeIter(tree), (_25: [rt.u8, rt.u16]): Uint8Array => { return Uint8Array.of(_25[0], _25[1] & 0xff); }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFromVec(heap.d))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(heap.d)), undefined, true); const _35: rt.Iter<[rt.u8, [rt.char, rt.u16]]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_26: rt.u8): [rt.u8, [rt.char, rt.u16]] => { const b3: rt.u8 = _26; return [b3, [b3 as rt.char, rt.u16Add(b3 as rt.u16, 1)] as [rt.char, rt.u16]] as [rt.u8, [rt.char, rt.u16]]; @@ -219,7 +219,7 @@ export function triples(data: rt.ByteSlice, out: rt.ByteVec): void { const v2: rt.ByteVec = _34[0]; const s2: string = _34[1][0]; const w: rt.u16[] = _34[1][1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v2)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v2), undefined, true); rt.iterExtendBytes(out, rt.strBytes(s2), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(w), (n2: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n2).reverse(); @@ -231,7 +231,7 @@ export function triples(data: rt.ByteSlice, out: rt.ByteVec): void { const _49: [rt.ByteVec, [rt.BTreeSet]] = rt.tupleExtend([new rt.ByteVec(), [rt.btreeNew(rt.cmp) as rt.BTreeSet]] as [rt.ByteVec, [rt.BTreeSet]], _50, [rt.byteVecPart(), rt.tuplePart([rt.btreeKeysPart()])]); const v3: rt.ByteVec = _49[0]; const tree2: rt.BTreeSet = _49[1][0]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v3)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v3), undefined, true); rt.iterExtendBytes(out, rt.btreeKeys(tree2), undefined, true); } @@ -267,14 +267,14 @@ export function twelves(data: rt.ByteSlice, out: rt.ByteVec): void { const keys: rt.BTreeSet = _15[9]; const v: rt.ByteVec = _15[11][0]; const s: string = _15[11][1][0]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(bytes), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(wide), (n: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n).reverse(); }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); rt.iterExtendBytes(out, rt.strBytes(chars), undefined, true); rt.iterExtendBytes(out, rt.strBytes(texts), undefined, true); rt.iterExtendBytes(out, rt.dequeIntoIter(q), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFromVec(heap.d))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(heap.d)), undefined, true); entries(map, out); sorted(set, out); rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeIter(tree), (_210: [rt.u8, rt.u16]): Uint8Array => { @@ -284,7 +284,7 @@ export function twelves(data: rt.ByteSlice, out: rt.ByteVec): void { }); }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); rt.iterExtendBytes(out, rt.btreeKeys(keys), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); } @@ -304,7 +304,7 @@ export function extended(data: rt.ByteSlice, out: rt.ByteVec): void { const tree: rt.BTreeMap = t[2]; const q: rt.VecDeque = t[3]; const set: rt.HashSet = t[4]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeIter(tree), (_22: [rt.u8, rt.u16]): Uint8Array => { return Uint8Array.of(_22[0], _22[1] & 0xff); @@ -319,7 +319,7 @@ export function extended(data: rt.ByteSlice, out: rt.ByteVec): void { return [b2, [rt.u8Rem(b2, 4), b2] as [rt.u8, rt.u8]] as [rt.u8, [rt.u8, rt.u8]]; }); rt.tupleExtend(t2, _45, [rt.heapPart(rt.le, 1), rt.hashPart(undefined, undefined, 469762048)]); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFromVec(t2[0].d))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(t2[0].d)), undefined, true); entries(t2[1], out); } @@ -353,7 +353,7 @@ export function borrowed(data: rt.ByteSlice, out: rt.ByteVec): void { const copied: Spot.Spot[] = t[1]; const map: rt.HashMap = t[2]; const s: string = t[3]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterChain(rt.iterSlice(copied), rt.iterSlice(ones[0])), (p2: Spot.Spot): Uint8Array => { return Uint8Array.of(p2.x, p2.y & 0xff); }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); @@ -431,7 +431,7 @@ export function dropped(data: rt.ByteSlice, out: rt.ByteVec): void { const taken: tuples_Logged.Logged[] = _86[0]; const bytes: rt.ByteVec = _86[1]; flush(log.value, out); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(bytes), undefined, true); rt.dropAll(taken); flush(log.value, out); rt.hashDrop(keys, rt.drop); @@ -459,7 +459,7 @@ export function panicked(data: rt.ByteSlice, out: rt.ByteVec): void { const v: rt.ByteVec = _12[0]; const s: string = _12[1]; const w: rt.u16[] = _12[2]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(w), (n: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n).reverse(); @@ -525,7 +525,7 @@ export function shunted(data: rt.ByteSlice, out: rt.ByteVec): void { if (parsed.ok) { const v: rt.ByteVec = parsed.value[0]; const s: string = parsed.value[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); } else { rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(250, parsed.error)), undefined, true); @@ -621,7 +621,7 @@ export function own(data: rt.ByteSlice, out: rt.ByteVec): void { const _34: [rt.ByteVec, tuples_Tally.Tally] = rt.tupleExtend([new rt.ByteVec(), tuples_Tally.default$Default()] as [rt.ByteVec, tuples_Tally.Tally], _35, [rt.byteVecPart(), rt.ownPart(tuples_Tally.extend$iter_Extend_u8_Option_u8 as (a0: tuples_Tally.Tally, a1: rt.u8 | undefined) => undefined)]); const v: rt.ByteVec = _34[0]; const t2: tuples_Tally.Tally = _34[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.byteVecPush(out, t2.sum); calls(out); const _47: rt.Iter<[rt.u8, rt.u16]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(data2))), (_210: rt.u8): [rt.u8, rt.u16] => { @@ -667,7 +667,7 @@ export function own(data: rt.ByteSlice, out: rt.ByteVec): void { const _96: [rt.ByteVec, [tuples_Tally.Tally]] = rt.tupleExtend([new rt.ByteVec(), [tuples_Tally.default$Default()]] as [rt.ByteVec, [tuples_Tally.Tally]], _97, [rt.byteVecPart(), rt.tuplePart([rt.ownPart(tuples_Tally.extend$iter_Extend_u8_Option_u8 as (a0: tuples_Tally.Tally, a1: rt.u8 | undefined) => undefined)])]); const v2: rt.ByteVec = _96[0]; const t5: tuples_Tally.Tally = _96[1][0]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v2)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v2), undefined, true); rt.byteVecPush(out, t5.sum); calls(out); const _107: rt.Iter<[rt.char]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(data2))), (_216: rt.u8): [rt.char] => { @@ -685,7 +685,7 @@ export function own(data: rt.ByteSlice, out: rt.ByteVec): void { }); rt.tupleExtend(t6, _120, [rt.ownPart(tuples_Tally.extend$iter_Extend_u8_Option_u8 as (a0: tuples_Tally.Tally, a1: rt.u8 | undefined) => undefined), rt.byteVecPart(), rt.ownPart(Last.extend$iter_Extend_char_Option_char as (a0: rt.Place, a1: rt.char | undefined) => undefined, true)]); rt.byteVecPush(out, t6[0].sum); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(t6[1])), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(t6[1]), undefined, true); Last.put(t6[2], out); calls(out); const parsed: rt.Result<[tuples_Tally.Tally, rt.ByteVec], rt.u8> = rt.iterCollectResult(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(data2))), (_217: rt.u8): rt.Result<[rt.u8, rt.u8], rt.u8> => { @@ -699,7 +699,7 @@ export function own(data: rt.ByteSlice, out: rt.ByteVec): void { const t7: tuples_Tally.Tally = parsed.value[0]; const v3: rt.ByteVec = parsed.value[1]; rt.byteVecPush(out, t7.sum); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v3)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v3), undefined, true); } else { rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(250, parsed.error)), undefined, true); } @@ -715,7 +715,7 @@ export function own(data: rt.ByteSlice, out: rt.ByteVec): void { } else { const v4: rt.ByteVec = found[0]; const t8: tuples_Tally.Tally = found[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v4)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v4), undefined, true); rt.byteVecPush(out, t8.sum); } calls(out); @@ -798,7 +798,7 @@ export function ownPanicked(data: rt.ByteSlice, out: rt.ByteVec): void { const v: rt.ByteVec = _24[0]; const t: tuples_Tally.Tally = _24[1]; const s: string = _24[2]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.byteVecPush(out, t.sum); rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); } else { diff --git a/ts/fixtures/lang/expected/wrappers.ts b/ts/fixtures/lang/expected/wrappers.ts index a2ee895e4..8deba14ce 100644 --- a/ts/fixtures/lang/expected/wrappers.ts +++ b/ts/fixtures/lang/expected/wrappers.ts @@ -354,7 +354,7 @@ export function wrappers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void rt.byteVecPush(out, held.length & 0xff); bounds$ops_RangeInclusive_u64(out, extended); const narrow: rt.RangeInclusive = new rt.RangeInclusive(rt.u64Low(lo) & 0xff, rt.u64Low(hi) & 0xff, rt.u8Step); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterBorrow(narrow), undefined, true))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterBorrow(narrow), undefined, true)), undefined, true); rt.byteVecPush(out, rt.rangeInclusiveStart(narrow)); rt.byteVecPush(out, rt.rangeInclusiveIsEmpty(narrow) ? 1 : 0); bounds$ops_RangeTo_u64(out, { end: b }); diff --git a/ts/fixtures/lang/src/rings.rs b/ts/fixtures/lang/src/rings.rs index cddab383d..1fb06a23f 100644 --- a/ts/fixtures/lang/src/rings.rs +++ b/ts/fixtures/lang/src/rings.rs @@ -8,17 +8,12 @@ use std::fmt::Debug; /// An item a byte makes, which a write through a `&mut` changes. trait Item: Clone + Debug { - /// Whether it is a byte, which a deque holds in a `Uint8Array`. - const BYTE: bool = false; - fn make(b: u8) -> Self; fn bump(&mut self); } impl Item for u8 { - const BYTE: bool = true; - fn make(b: u8) -> Self { b } @@ -178,8 +173,6 @@ fn remade(q: VecDeque, arg: u8) -> VecDeque { it.collect() } 3 => VecDeque::from(q.into_iter().collect::>()), - // A `Vec`'s iterator reads a view of its bytes, which leaves its capacity behind. - _ if T::BYTE => q, _ => { let mut v: Vec = q.into_iter().collect(); v.reserve(skip); diff --git a/ts/runtime/rt/collections.ts b/ts/runtime/rt/collections.ts index 3317d4afa..bc1f42f8c 100644 --- a/ts/runtime/rt/collections.ts +++ b/ts/runtime/rt/collections.ts @@ -3103,8 +3103,8 @@ export function dequeIntoIter(q: VecDeque, drop?: (item: T) => void): Iter */ export function dequeFromIntoIter(it: Iter, size: number, bytes = false): VecDeque { if (it instanceof DequeIntoIter) return it.q; - const v = it as unknown as { s: T[] & Capped; front: number; back: number }; - const q = dequeWithCapacity(capOf(v.s.length, v.s.cap, size), size, bytes); + const v = it as unknown as { s: ArrayLike & Capped; front: number; back: number }; + const q = dequeWithCapacity(bytes ? v.s.length : capOf(v.s.length, v.s.cap, size), size, bytes); q.n = v.back - v.front; q.h = size === 0 || q.n === 0 ? 0 : v.front; for (let i = 0; i < q.n; i++) q.b[q.h + i] = v.s[v.front + i]; diff --git a/ts/runtime/rt/iter.ts b/ts/runtime/rt/iter.ts index af129ae5c..4b71d4134 100644 --- a/ts/runtime/rt/iter.ts +++ b/ts/runtime/rt/iter.ts @@ -298,6 +298,13 @@ export function iterSlice(s: ArrayLike, drop?: Drop): Iter { return new SliceIter(s, drop); } +/** `Vec::into_iter`: over the vector's whole buffer, whose length is its capacity, which a deque collected from it keeps. */ +export function byteVecIntoIter(v: ByteVec): Iter { + const it = new SliceIter(v.data); + it.back = v.length; + return it; +} + /** `slice::IterMut` of elements JS copies: the place of each. */ export function iterSliceMut(s: { [i: number]: T; length: number }): Iter> { return new SliceMutIter(s); diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index d58f27e29..dfb812149 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -2851,16 +2851,13 @@ pub fn collect<'tcx>( // collects any other into a `Vec` first, whose capacity it keeps. Std::VecDeque => { let item = arg(ty, 0); - let bytes = matches!(item.kind(), ty::Uint(ty::UintTy::U8)); let path = from .ty_adt_def() .map(|adt| library::std_path(b.t.tcx, adt.did()).join("::")); - let whole = match path.as_deref() { - Some("collections::vec_deque::into_iter::IntoIter") => true, - // A `Vec`'s reads a view of its bytes, which leaves its capacity behind. - Some("vec::into_iter::IntoIter") => !bytes, - _ => false, - }; + let whole = matches!( + path.as_deref(), + Some("collections::vec_deque::into_iter::IntoIter" | "vec::into_iter::IntoIter") + ); let made = match whole { true => Expr::rt("dequeFromIntoIter", [vec![iter], deque_items(b, item, span)].concat()), false => { diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index 73205ac10..c6e28c176 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -180,6 +180,10 @@ pub fn into_iter<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr, sp Std::Vec if places(b, args.type_at(0)) => { Some(Expr::rt("iterSliceMut", vec![library::elements(value, ty)])) } + // A `Vec`'s owned bytes keep its buffer, as a deque collected from them does. + Std::Vec if owned && matches!(args.type_at(0).kind(), ty::Uint(ty::UintTy::U8)) => { + Some(Expr::rt("byteVecIntoIter", vec![value])) + } Std::Vec => { let values = each(b, args.type_at(0), vec![library::elements(value, ty)]); Some(items(Expr::rt("iterSlice", values), args.type_at(0))) diff --git a/ts/src/lower/mir/step.rs b/ts/src/lower/mir/step.rs index 58119d720..3a6f5d9ff 100644 --- a/ts/src/lower/mir/step.rs +++ b/ts/src/lower/mir/step.rs @@ -271,8 +271,8 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { /// An iterator stepped in place, from the `rt.Iter` its mapping makes: `{ s, i: 0 }` /// from `rt.iterSlice(s)`, or `rt.iterSlice(s, drop)` of items it owns, which its drop - /// drops again, and `{ start, end }` from `new rt.Range(start, end)`. A moved one is - /// already made. + /// drops again, the view of `v`'s bytes from `rt.byteVecIntoIter(v)`, and + /// `{ start, end }` from `new rt.Range(start, end)`. A moved one is already made. pub(super) fn stepped_make(&mut self, value: Expr, span: rustc_span::Span) -> Expr { let rt = |f: &Expr, name: &str| matches!(f, Expr::Rt(n) if n == name); let object = |fields: [(&str, Expr); 2]| { @@ -283,6 +283,9 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { args.truncate(1); object([("s", args.pop().unwrap()), ("i", Expr::lit("0"))]) } + Expr::Call(f, args) if rt(&f, "byteVecIntoIter") && args.len() == 1 => { + object([("s", Expr::rt("byteVecView", args)), ("i", Expr::lit("0"))]) + } Expr::New(f, args) if rt(&f, "Range") && args.len() == 2 => { let [start, end] = <[Expr; 2]>::try_from(args).expect("checked above"); object([("start", start), ("end", end)]) From 21de74b83a3f0a81307a46ec685845cc2bbc0c66 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Mon, 2 Nov 2026 08:40:12 -0800 Subject: [PATCH 07/10] test(ts): refresh the harness snapshot after merging main Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/expected/harness.ts | 3 +++ 1 file changed, 3 insertions(+) diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index ed48d1927..f3e0aced8 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -49,6 +49,7 @@ import { lists as pointers_lists, shared as pointers_shared, places as pointers_ import { refs, toRefs, adapted as refs_adapted, compared } from "./refs.ts"; import { results as results_results } from "./results.ts"; import { returns } from "./returns.ts"; +import { slices as rings_slices } from "./rings.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"; import { copies as shapes_copies, order as shapes_order, discriminants, loops, patterns, uninhabited, closures as shapes_closures, library, flows } from "./shapes.ts"; @@ -282,6 +283,8 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) leaks(data98, out99); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["refs::compared", (a0159: rt.u8, a1159: rt.ByteSlice, a2159: rt.ByteVec): undefined => { compared(a0159, a1159.data, a1159.start, a1159.length, a2159); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["rings::slices", (a0160: rt.u8, a1160: rt.ByteSlice, a2160: rt.ByteVec): undefined => { + rings_slices(a0160, a1160.data, a1160.start, a1160.length, a2160); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; } From fb531ccd7c29156f9982ee6fd6e21db4bf3482f0 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Mon, 2 Nov 2026 08:56:39 -0800 Subject: [PATCH 08/10] fix(ts): clone a vector's iterator into a buffer of its own std's vec::IntoIter::clone copies what is left into a new Vec of exactly that capacity, which a deque collected from the clone takes, so even items that clone as themselves are copied. Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/caller.ts | 15 ++++++- ts/fixtures/lang/expected/capacity.ts | 6 +-- ts/fixtures/lang/expected/clones.ts | 4 +- ts/fixtures/lang/expected/rings.ts | 60 ++++++++++++++++++++------- ts/fixtures/lang/src/rings.rs | 10 +++-- ts/runtime/rt/collections.ts | 2 +- ts/runtime/rt/iter.ts | 5 ++- ts/src/lower/iter.rs | 9 +++- 8 files changed, 82 insertions(+), 29 deletions(-) diff --git a/ts/fixtures/lang/caller.ts b/ts/fixtures/lang/caller.ts index 591f9c1c0..f6be3b278 100644 --- a/ts/fixtures/lang/caller.ts +++ b/ts/fixtures/lang/caller.ts @@ -893,4 +893,17 @@ const ringsCases = Array.from({ length: 5 * 3 * 4 * 24 * 3 }, (_, i) => { return Uint8Array.of(...op("rings::slices"), kind, first, ...wrap, step, arg, step, arg ^ 0x25); }); -export const cases: Uint8Array[] = [...loops, ...durations, ...ints(), ...utf8, ...floats, ...formats, ...parsed, ...singlesCases, ...singlesFormats, ...singlesParsed, ...dyns, ...cells, ...shared, ...locks, ...guards, ...maps, ...mappedLocks, ...relocks, ...tries, ...mutexMaps, ...printed, ...downgrades, ...leaks, ...placeCompares, ...rwlocks, ...onces, ...bounds, ...unsafeCells, ...edits, ...subslices, ...consumers, ...closures, ...elements, ...ranges, ...reducers, ...sliceEdits, ...drains, ...iters, ...hinted, ...peekedOthers, ...hints, ...reserves, ...setOps, ...zeros, ...writes, ...floatsMulAdds, ...singlesMulAdds, ...unlikeEqs, ...ownNes, ...rangeFroms, ...compares, ...unlikeCompares, ...rangeMethods, ...wraps(), ...refOrders, ...saturates(), ...methods(), ...separated, ...asciiCases, ...gets, ...capacityCases, ...ringsCases]; +/** + * `rings::slices` remaking each wrapped deque each way and with a few skips: a clone, + * `clone_from`, `clone_into`, its `into_iter` read in part and by `nth`, from a `Vec`, and + * a `Vec`'s `into_iter` read in part, collected as it is and cloned; then pushed at both ends. + */ +const remadeCases = [0, 5, 0x2d, 0x37, 0x64, 0x6e, 1, 0x10, 2, 0x11, 3, 0x0e, 0x13, 0x45, 0x5f].flatMap((arg) => + Array.from({ length: 5 * 3 * 4 }, (_, i) => { + const [kind, first, wraps] = [i % 5, [0, 0x15, 0x1e][Math.floor(i / 5) % 3], [1, 3, 6, 10][Math.floor(i / 15)]]; + const wrap = Array.from({ length: wraps }, (_, j) => [j % 3 === 2 ? 4 : 0, j * 3, 6, 0, 4, j]).flat(); + return Uint8Array.of(...op("rings::slices"), kind, first, ...wrap, 22, arg, 0, 9, 4, 9); + }), +); + +export const cases: Uint8Array[] = [...loops, ...durations, ...ints(), ...utf8, ...floats, ...formats, ...parsed, ...singlesCases, ...singlesFormats, ...singlesParsed, ...dyns, ...cells, ...shared, ...locks, ...guards, ...maps, ...mappedLocks, ...relocks, ...tries, ...mutexMaps, ...printed, ...downgrades, ...leaks, ...placeCompares, ...rwlocks, ...onces, ...bounds, ...unsafeCells, ...edits, ...subslices, ...consumers, ...closures, ...elements, ...ranges, ...reducers, ...sliceEdits, ...drains, ...iters, ...hinted, ...peekedOthers, ...hints, ...reserves, ...setOps, ...zeros, ...writes, ...floatsMulAdds, ...singlesMulAdds, ...unlikeEqs, ...ownNes, ...rangeFroms, ...compares, ...unlikeCompares, ...rangeMethods, ...wraps(), ...refOrders, ...saturates(), ...methods(), ...separated, ...asciiCases, ...gets, ...capacityCases, ...ringsCases, ...remadeCases]; diff --git a/ts/fixtures/lang/expected/capacity.ts b/ts/fixtures/lang/expected/capacity.ts index b2e3720f9..f8ef3bcab 100644 --- a/ts/fixtures/lang/expected/capacity.ts +++ b/ts/fixtures/lang/expected/capacity.ts @@ -491,7 +491,7 @@ export function vecSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: n while (iterStart2++ < iterEnd2) { rt.iterToOption(it2.next()); } - v = rt.iterToArray(it2.clone(), "next", 2, true); + v = rt.iterToArray(it2.clone({ v: rt.itself }), "next", 2, true); Known.remade(k, true); const rest: rt.u16[] = rt.iterToArray(it2, "next", 2, true); Known.put({ exact: false, floor: 0 }, out, rest.length, rt.vecCapacity(rest, 2)); @@ -635,7 +635,7 @@ export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: nu while (iterStart2++ < iterEnd2) { rt.iterToOption(it2.next()); } - v = rt.iterToByteVec(it2.clone(), "next", true); + v = rt.iterToByteVec(it2.clone({ v: rt.itself }), "next", true); Known.remade(k, true); const rest: rt.ByteVec = rt.iterToByteVec(it2, "next", true); Known.put({ exact: false, floor: 0 }, out, rest.length, rest.data.length); @@ -787,7 +787,7 @@ export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: while (iterStart2++ < iterEnd2) { rt.iterToOption(it2.next(), rt.None); } - v = rt.iterToArray(it2.clone(), undefined, 0, true); + v = rt.iterToArray(it2.clone({ v: rt.itself }), undefined, 0, true); Known.remade(k, true); const rest: undefined[] = rt.iterToArray(it2, undefined, 0, true); Known.put({ exact: false, floor: 0 }, out, rest.length, rt.vecCapacity(rest, 0)); diff --git a/ts/fixtures/lang/expected/clones.ts b/ts/fixtures/lang/expected/clones.ts index 8dfb2d08f..a8dd1c354 100644 --- a/ts/fixtures/lang/expected/clones.ts +++ b/ts/fixtures/lang/expected/clones.ts @@ -2533,7 +2533,7 @@ export function turns$iter_Flatten_iter_Map_slice_Chunks_u8_clones_iters_closure rt.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); + const other: rt.Iter = it.clone({ o: { v: rt.itself } }); rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -6547,7 +6547,7 @@ export function turns$vec_IntoIter_u8_clones_iters_closure18_clones_iters_closur rt.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); + const other: rt.Iter = it.clone({ v: rt.itself }); rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); let ended: boolean = false; diff --git a/ts/fixtures/lang/expected/rings.ts b/ts/fixtures/lang/expected/rings.ts index a228e3b77..a1ac8d50d 100644 --- a/ts/fixtures/lang/expected/rings.ts +++ b/ts/fixtures/lang/expected/rings.ts @@ -676,10 +676,11 @@ export function steps$unit(dataData: Uint8Array, dataStart: number, dataLen: num /** * A deque made anew from `q`: a clone, or one with room of its own cloned into from it, - * collected from its own `into_iter` or a `Vec`'s read in part, whose buffers std's takes - * as they are, or from a `Vec` it collects. + * collected from its own `into_iter` or a `Vec`'s read in part, or that one's clone, + * whose buffers std's takes as they are, or from a `Vec` it collects. */ export function remade$String(q: rt.VecDeque, arg: rt.u8): rt.VecDeque { + let _0!: rt.VecDeque; const skip: rt.usize = rt.usizeRem(rt.u8Div(arg, 5) as rt.usize, 4); const _8: rt.u8 = rt.u8Rem(arg, 5); if (_8 === 0) { @@ -722,15 +723,21 @@ export function remade$String(q: rt.VecDeque, arg: rt.u8): rt.VecDeque; + if ((arg & 64) === 0) { + _0 = rt.dequeFromIntoIter(it3, 12) as rt.VecDeque; + } else { + _0 = rt.dequeFromIntoIter(it3.clone({ v: rt.itself }), 12) as rt.VecDeque; + } + return _0; } /** * A deque made anew from `q`: a clone, or one with room of its own cloned into from it, - * collected from its own `into_iter` or a `Vec`'s read in part, whose buffers std's takes - * as they are, or from a `Vec` it collects. + * collected from its own `into_iter` or a `Vec`'s read in part, or that one's clone, + * whose buffers std's takes as they are, or from a `Vec` it collects. */ export function remade$rings_Big(q: rt.VecDeque, arg: rt.u8): rt.VecDeque { + let _0!: rt.VecDeque; const skip: rt.usize = rt.usizeRem(rt.u8Div(arg, 5) as rt.usize, 4); const _8: rt.u8 = rt.u8Rem(arg, 5); if (_8 === 0) { @@ -773,15 +780,21 @@ export function remade$rings_Big(q: rt.VecDeque, arg: rt.u8): rt.VecDeq while (iterStart2++ < iterEnd2) { rt.iterToOption(it3.next()); } - return rt.dequeFromIntoIter(it3, 1101) as rt.VecDeque; + if ((arg & 64) === 0) { + _0 = rt.dequeFromIntoIter(it3, 1101) as rt.VecDeque; + } else { + _0 = rt.dequeFromIntoIter(it3.clone({ v: Big.clone$Clone }), 1101) as rt.VecDeque; + } + return _0; } /** * A deque made anew from `q`: a clone, or one with room of its own cloned into from it, - * collected from its own `into_iter` or a `Vec`'s read in part, whose buffers std's takes - * as they are, or from a `Vec` it collects. + * collected from its own `into_iter` or a `Vec`'s read in part, or that one's clone, + * whose buffers std's takes as they are, or from a `Vec` it collects. */ export function remade$u32(q: rt.VecDeque, arg: rt.u8): rt.VecDeque { + let _0!: rt.VecDeque; const skip: rt.usize = rt.usizeRem(rt.u8Div(arg, 5) as rt.usize, 4); const _8: rt.u8 = rt.u8Rem(arg, 5); if (_8 === 0) { @@ -824,15 +837,21 @@ export function remade$u32(q: rt.VecDeque, arg: rt.u8): rt.VecDeque; + if ((arg & 64) === 0) { + _0 = rt.dequeFromIntoIter(it3, 4) as rt.VecDeque; + } else { + _0 = rt.dequeFromIntoIter(it3.clone({ v: rt.itself }), 4) as rt.VecDeque; + } + return _0; } /** * A deque made anew from `q`: a clone, or one with room of its own cloned into from it, - * collected from its own `into_iter` or a `Vec`'s read in part, whose buffers std's takes - * as they are, or from a `Vec` it collects. + * collected from its own `into_iter` or a `Vec`'s read in part, or that one's clone, + * whose buffers std's takes as they are, or from a `Vec` it collects. */ export function remade$u8(q: rt.VecDeque, arg: rt.u8): rt.VecDeque { + let _0!: rt.VecDeque; const skip: rt.usize = rt.usizeRem(rt.u8Div(arg, 5) as rt.usize, 4); const _8: rt.u8 = rt.u8Rem(arg, 5); if (_8 === 0) { @@ -875,15 +894,21 @@ export function remade$u8(q: rt.VecDeque, arg: rt.u8): rt.VecDeque while (iterStart2++ < iterEnd2) { rt.iterToOption(it3.next()); } - return rt.dequeFromIntoIter(it3, 1, true) as rt.VecDeque; + if ((arg & 64) === 0) { + _0 = rt.dequeFromIntoIter(it3, 1, true) as rt.VecDeque; + } else { + _0 = rt.dequeFromIntoIter(it3.clone({ v: rt.itself }), 1, true) as rt.VecDeque; + } + return _0; } /** * A deque made anew from `q`: a clone, or one with room of its own cloned into from it, - * collected from its own `into_iter` or a `Vec`'s read in part, whose buffers std's takes - * as they are, or from a `Vec` it collects. + * collected from its own `into_iter` or a `Vec`'s read in part, or that one's clone, + * whose buffers std's takes as they are, or from a `Vec` it collects. */ export function remade$unit(q: rt.VecDeque, arg: rt.u8): rt.VecDeque { + let _0!: rt.VecDeque; const skip: rt.usize = rt.usizeRem(rt.u8Div(arg, 5) as rt.usize, 4); const _8: rt.u8 = rt.u8Rem(arg, 5); if (_8 === 0) { @@ -926,7 +951,12 @@ export function remade$unit(q: rt.VecDeque, arg: rt.u8): rt.VecDeque< while (iterStart2++ < iterEnd2) { rt.iterToOption(it3.next(), rt.None); } - return rt.dequeFromIntoIter(it3, 0) as rt.VecDeque; + if ((arg & 64) === 0) { + _0 = rt.dequeFromIntoIter(it3, 0) as rt.VecDeque; + } else { + _0 = rt.dequeFromIntoIter(it3.clone({ v: rt.itself }), 0) as rt.VecDeque; + } + return _0; } /** A drain of a range `arg` picks, written as it is read from either end and then dropped. */ diff --git a/ts/fixtures/lang/src/rings.rs b/ts/fixtures/lang/src/rings.rs index 1fb06a23f..468828b73 100644 --- a/ts/fixtures/lang/src/rings.rs +++ b/ts/fixtures/lang/src/rings.rs @@ -143,8 +143,8 @@ fn steps(data: &[u8], out: &mut Vec) { } /// A deque made anew from `q`: a clone, or one with room of its own cloned into from it, -/// collected from its own `into_iter` or a `Vec`'s read in part, whose buffers std's takes -/// as they are, or from a `Vec` it collects. +/// collected from its own `into_iter` or a `Vec`'s read in part, or that one's clone, +/// whose buffers std's takes as they are, or from a `Vec` it collects. fn remade(q: VecDeque, arg: u8) -> VecDeque { let skip = usize::from(arg / 5) % 4; match arg % 5 { @@ -180,7 +180,11 @@ fn remade(q: VecDeque, arg: u8) -> VecDeque { for _ in 0..skip { drop(it.next()); } - it.collect() + // A clone holds what is left in a buffer of its own. + match arg & 0x40 { + 0 => it.collect(), + _ => it.clone().collect(), + } } } } diff --git a/ts/runtime/rt/collections.ts b/ts/runtime/rt/collections.ts index bc1f42f8c..b42c82387 100644 --- a/ts/runtime/rt/collections.ts +++ b/ts/runtime/rt/collections.ts @@ -360,7 +360,7 @@ export function eqArc(eq: (a: T, b: T) => boolean, ident = false): (a: Arc } /** A value as its own clone. */ -function itself(value: T): T { +export function itself(value: T): T { return value; } diff --git a/ts/runtime/rt/iter.ts b/ts/runtime/rt/iter.ts index 4b71d4134..45ed71ab0 100644 --- a/ts/runtime/rt/iter.ts +++ b/ts/runtime/rt/iter.ts @@ -1503,11 +1503,12 @@ class SliceIter extends Iter implements Disposable { return Array.prototype.slice.call(this.s, this.front, this.back); } - /** std's: what it has left, each cloned in order by `h.v` into storage of its own, or else shared. */ + /** std's: what it has left, each cloned in order by `h.v` into storage of its own, of exactly their capacity, or else shared. */ override clone(h?: Clones): Iter { if (h?.v !== undefined) { - const items = Array.prototype.slice.call(this.s, this.front, this.back) as T[]; + const items = Array.prototype.slice.call(this.s, this.front, this.back) as T[] & Capped; for (let i = 0; i < items.length; i++) items[i] = cloned(items[i], h.v); + items.cap = items.length; return new SliceIter(items, this.drop); } const it = new SliceIter(this.s, this.drop); diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index c6e28c176..2c941a992 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -1001,9 +1001,14 @@ fn clones<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Option< "set", "Iter" | "Range" | "Difference" | "Intersection" | "Union" | "SymmetricDifference", ] => Expr::undefined(), + // std's copies what a `Vec`'s has left into a buffer of its own, even of items that + // clone as themselves, which a deque collected from it takes. + ["vec", "into_iter", "IntoIter"] => match value(b, arg(0)?) { + v if undefined(&v) => parts(vec![("v", Expr::Rt("itself".into()))]), + v => parts(vec![("v", v)]), + }, // Those that own their items, each cloned. - ["vec", "into_iter", "IntoIter"] - | ["array", "iter", "IntoIter"] + ["array", "iter", "IntoIter"] | ["option", "IntoIter"] | ["result", "IntoIter"] | ["iter", "sources", "once", "Once"] From 577eef43ea9b09b05ad0b8030d007d848dd042a7 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Mon, 2 Nov 2026 11:55:07 -0800 Subject: [PATCH 09/10] feat(ts): keep std's Vec capacity where it reuses a buffer A `collect` in place, `clone_from` into a `Vec`, a boxed slice, and `extend_from_slice` now hold std's capacity, so a deque made from such a `Vec` splits its slices where std's does. Record the maintainer's 2026-11-02 call to keep the guarantee-only model in the quest. Co-Authored-By: Claude Opus 5.5 --- quest/m3/ts-vec-exact-capacity.md | 11 +- ts/MIGRATE.md | 3 + ts/README.md | 5 +- ts/fixtures/lang/caller.ts | 11 +- ts/fixtures/lang/expected/boxes.ts | 10 +- ts/fixtures/lang/expected/capacity.ts | 345 ++++++++++++++--------- ts/fixtures/lang/expected/chars.ts | 2 +- ts/fixtures/lang/expected/conversions.ts | 40 +-- ts/fixtures/lang/expected/edits.ts | 4 +- ts/fixtures/lang/expected/harness.ts | 11 +- ts/fixtures/lang/expected/iters.ts | 4 +- ts/fixtures/lang/expected/refs.ts | 2 +- ts/fixtures/lang/expected/rings.ts | 85 ++++-- ts/fixtures/lang/expected/sorts.ts | 2 +- ts/fixtures/lang/src/capacity.rs | 55 ++-- ts/fixtures/lang/src/rings.rs | 16 +- ts/fixtures/task/expected/drops/folds.ts | 8 +- ts/fixtures/task/expected/drops/iters.ts | 12 +- ts/runtime/rt.ts | 20 +- ts/runtime/rt/iter.ts | 54 +++- ts/src/lower/iter.rs | 78 +++-- ts/src/lower/library.rs | 30 +- ts/src/lower/mir/call.rs | 7 + 23 files changed, 550 insertions(+), 265 deletions(-) diff --git a/quest/m3/ts-vec-exact-capacity.md b/quest/m3/ts-vec-exact-capacity.md index 8dd4fa25e..142a4f610 100644 --- a/quest/m3/ts-vec-exact-capacity.md +++ b/quest/m3/ts-vec-exact-capacity.md @@ -15,8 +15,13 @@ capacity the runtime models for the `Vec`, which holds only std's guarantees (de 2026-11-01) and so recomputes from its length after a pop, `truncate`, or `drain`. A `Vec` already holds its exact capacity as its buffer's length. -- Record the capacity where a step shrinks the length, and measure its cost on pops with - the codec's [TS benchmark](/ts/README.md#bench). -- Needs the maintainer's call against the 2026-11-01 decision. +- Recording the capacity on the array where a step shrinks the length (a `peak` each pop + raises) was measured on `push/stack`, which pushes onto a `Vec`, popping one every + fourth push, then pops it empty: 1.24x in Node, 1.11x in Chrome, 2.3x in Bun, and 2.8x + in Firefox, every other workload within noise. The maintainer kept the guarantee-only + model on 2026-11-02, accepting that a deque made from a shrunk `Vec` may split + differently from std's. +- Untried: a `Vec` as a wrapper object holding its own length and capacity over its + array, measured on the same workload before it is weighed against that decision. Public API: the translator's output. diff --git a/ts/MIGRATE.md b/ts/MIGRATE.md index 3408ea6ef..aeaea18fd 100644 --- a/ts/MIGRATE.md +++ b/ts/MIGRATE.md @@ -23,6 +23,9 @@ `rt.vecReserve(v, additional, 4)`, not the arithmetic an extend reserved by; `rt.vecPush` and `rt.vecGrow` are gone. `rt.heapClone` takes the element size after the clone function. +- `rt.vecExtendFromSlice` takes the element size in bytes after the slice, as in + `rt.vecExtendFromSlice(v, s, 4)`. `rt.iterToArray` and `rt.iterToByteVec` take the + source element size of a `collect` that may reuse its source's buffer last. - An `rt.VecDeque` holds std's capacity as its buffer's length and its item size as `s`, and a deque of bytes is a `Uint8Array`: `rt.dequeNew`, `rt.dequeWithCapacity`, and `rt.dequeFromVec` take the item size and whether it holds bytes, as in diff --git a/ts/README.md b/ts/README.md index 99d1f0882..435cffca5 100644 --- a/ts/README.md +++ b/ts/README.md @@ -792,8 +792,9 @@ they need. capacity held for the `Vec`. A `Vec` and `BinaryHeap` hold what std guarantees of their capacity: at least their length and what `with_capacity`, `reserve`, and `reserve_exact` ask for, and std's exactly where its doubling fixes it, - as through pushes. `clone_from` and `clone_into`, of which std guarantees only the - length, leave a clone's capacity, not the allocation std reuses. One holds a capacity, as `cap`, only where `with_capacity`, `reserve`, + as through pushes, a `clone_from` into a `Vec` that keeps its own, and a `collect` that + reuses its source's buffer, in place or from a boxed slice, whose capacity is its + length. One holds a capacity, as `cap`, only where `with_capacity`, `reserve`, `shrink_to`, a `clone`, or a `collect` or `extend` set it, so a push never reads or writes one. Reading it doubles it while short of the length, from the least std's `RawVec` allocates for the element size, which a run of pushes grows std's to. A diff --git a/ts/fixtures/lang/caller.ts b/ts/fixtures/lang/caller.ts index 7bb4ec108..fd4022cf2 100644 --- a/ts/fixtures/lang/caller.ts +++ b/ts/fixtures/lang/caller.ts @@ -866,13 +866,13 @@ const gets = [0, 0x10].flatMap((text) => { * it tries. */ const capacityCases = [ - ...[["capacity::vecs", 25], ["capacity::deques", 21], ["capacity::heaps", 13]].flatMap(([name, steps]) => + ...[["capacity::vecs", 29], ["capacity::deques", 21], ["capacity::heaps", 13]].flatMap(([name, steps]) => Array.from({ length: 5 * 2 * (steps as number) * 4 }, (_, i) => { const [kind, first, step, arg] = [i % 5, (Math.floor(i / 5) % 2) * 0x11, Math.floor(i / 10) % (steps as number), [3, 0xc1, 0xe3, 0x16][Math.floor(i / (10 * (steps as number)))]]; return Uint8Array.of(...op(name as string), kind, first, ...[0, 1, 0, 2, 0, 3, 0, 4, 0, 5].map((b, j) => (j % 2 === 0 ? b : b * 41)), step, arg, step, arg ^ 1); }), ), - ...[["capacity::vecs", 25], ["capacity::deques", 21], ["capacity::heaps", 13]].flatMap(([name, steps]) => + ...[["capacity::vecs", 29], ["capacity::deques", 21], ["capacity::heaps", 13]].flatMap(([name, steps]) => Array.from({ length: 5 * 2 * (steps as number) }, (_, i) => Uint8Array.of(...op(name as string), i % 5, 0, 0, 1, 3 + (Math.floor(i / 5) % 2), 3, Math.floor(i / 10), 0)), ), ...["capacity::vecs", "capacity::deques", "capacity::heaps"].flatMap((name) => @@ -895,10 +895,11 @@ const ringsCases = Array.from({ length: 5 * 3 * 4 * 24 * 3 }, (_, i) => { /** * `rings::slices` remaking each wrapped deque each way and with a few skips: a clone, - * `clone_from`, `clone_into`, its `into_iter` read in part and by `nth`, from a `Vec`, and - * a `Vec`'s `into_iter` read in part, collected as it is and cloned; then pushed at both ends. + * `clone_from`, `clone_into`, its `into_iter` read in part and by `nth`, from a `Vec` as it + * is and filtered in place, and a `Vec`'s `into_iter` read in part, collected as it is and + * cloned; then pushed at both ends. */ -const remadeCases = [0, 5, 0x2d, 0x37, 0x64, 0x6e, 1, 0x10, 2, 0x11, 3, 0x0e, 0x13, 0x45, 0x5f].flatMap((arg) => +const remadeCases = [0, 5, 0x2d, 0x37, 0x64, 0x6e, 1, 0x10, 2, 0x11, 3, 0x21, 0x0e, 0x13, 0x45, 0x5f].flatMap((arg) => Array.from({ length: 5 * 3 * 4 }, (_, i) => { const [kind, first, wraps] = [i % 5, [0, 0x15, 0x1e][Math.floor(i / 5) % 3], [1, 3, 6, 10][Math.floor(i / 15)]]; const wrap = Array.from({ length: wraps }, (_, j) => [j % 3 === 2 ? 4 : 0, j * 3, 6, 0, 4, j]).flat(); diff --git a/ts/fixtures/lang/expected/boxes.ts b/ts/fixtures/lang/expected/boxes.ts index f20a737eb..a0a3a774a 100644 --- a/ts/fixtures/lang/expected/boxes.ts +++ b/ts/fixtures/lang/expected/boxes.ts @@ -265,7 +265,7 @@ export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, rt.u64Eq(hash$boxed_Box_slice_u16(collected2), hash$slice_u16(rt.sliceRange(collected2, 0))) ? 1 : 0); const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(collected2, f, rt.u16Debug)]; fmt_put(out, rt.fmtFormat([args4[0]])); - const v3: rt.u16[] = fromVec2; + const v3: rt.u16[] = rt.vecExact(fromVec2, 2); v3.push(5); wides(v3, out); let slot2: rt.u16[] = fromArray2; @@ -275,7 +275,7 @@ export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const taken = slot2; slot2 = []; wides(taken, out); - const it: rt.Iter = rt.iterSlice(wide); + const it: rt.Iter = rt.iterSlice(rt.vecExact(wide, 2)); rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(option_unwrapOr$1j4op5y(rt.iterToOption(it.nextBack()), 0)).reverse()), undefined, true); rt.byteVecPush(out, it.len() & 0xff); rt.iterExtendBytes(out, rt.iterMap(it, (x4: rt.u16): rt.u8 => { @@ -309,7 +309,7 @@ export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { collected3[0][Symbol.dispose](); collected3[0] = _444; flush(log.value, out); - const it2: rt.Iter = rt.iterSlice(cloned3, rt.drop); + const it2: rt.Iter = rt.iterSlice(rt.vecExact(cloned3, 8), rt.drop); const _454: boxes_Logged.Logged | rt.Done = it2.next(); if (_454 !== rt.DONE) { const first: boxes_Logged.Logged = _454; @@ -321,7 +321,7 @@ export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.drop(it2); flush(log.value, out); rt.drop(back); - const v4: boxes_Logged.Logged[] = fromRef3; + const v4: boxes_Logged.Logged[] = rt.vecExact(fromRef3, 8); ids(v4, out); rt.dropAll(v4); flush(log.value, out); @@ -368,7 +368,7 @@ export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.idx(c, 1); return Uint8Array.of(_3, c.data[c.start + 1]); }), undefined, 2, true); - const quadsV: Uint8Array[] = quads.map(copy$array_u8); + const quadsV: Uint8Array[] = rt.vecExact(quads.map(copy$array_u8), 2); const _554: rt.ByteSlice | undefined = rt.optionMap(rt.sliceFirst(quadsV), rt.byteSliceFrom); if (_554 !== undefined) { _554.data[_554.start] = 119; diff --git a/ts/fixtures/lang/expected/capacity.ts b/ts/fixtures/lang/expected/capacity.ts index f8ef3bcab..3887980c3 100644 --- a/ts/fixtures/lang/expected/capacity.ts +++ b/ts/fixtures/lang/expected/capacity.ts @@ -93,7 +93,7 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d const _33: [rt.u8, rt.u8] = [_27.data[_27.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_27, 1), 0)]; const op: rt.u8 = _33[0]; const arg: rt.u8 = _33[1]; - const _42: rt.u8 = rt.u8Rem(op, 25); + const _42: rt.u8 = rt.u8Rem(op, 29); if (_42 === 0 || _42 === 1) { v.push(copy$array_u64(make(arg))); } else if (_42 === 2) { @@ -101,7 +101,7 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d Known.loose(k); } else if (_42 === 3 || _42 === 4) { const additional: rt.usize = amount(arg, v.length, size); - if (rt.u8Rem(op, 25) === 3) { + if (rt.u8Rem(op, 29) === 3) { rt.vecReserve(v, additional, 1280); } else { rt.vecReserveExact(v, additional, 1280); @@ -131,14 +131,13 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d } else if (_42 === 11) { rt.iterExtend(v, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 1280, true); } else if (_42 === 12) { - rt.vecExtendFromSlice(v, [make(arg), make(arg)], copy$array_u64); - Known.loose(k); + rt.vecExtendFromSlice(v, rt.vecFromElem(copy$array_u64(make(arg)), rt.u8Rem(arg, 24) as rt.usize, copy$array_u64), 1280, copy$array_u64); } else if (_42 === 13) { rt.vecTruncate(v, 0); Known.loose(k); } else if (_42 === 14) { const keep: () => boolean = alternate(); - rt.vecRetain(v, (_28: rt.u64[]): boolean => { + rt.vecRetain(v, (_29: rt.u64[]): boolean => { return keep(); }); Known.loose(k); @@ -149,14 +148,14 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d v = rt.vecExact(v.map(copy$array_u64), 1280); Known.remade(k, true); } else if (_42 === 17) { - v = v; - Known.remade(k, false); + v = rt.vecExact(v, 1280); + Known.remade(k, true); } else if (_42 === 18) { const keep2: () => boolean = alternate(); - v = rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_26: rt.u64[]): boolean => { + v = rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_28: rt.u64[]): boolean => { return keep2(); - }), "next", 1280); - Known.remade(k, false); + }), "next", 1280, false, 1280); + Known.remade(k, k.exact); } else if (_42 === 19) { const it: rt.Iter = rt.iterSlice(v); const _174: rt.u8 = rt.u8Rem(arg, 8); @@ -169,18 +168,18 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d rt.iterToOption(it.nextBack()); } } - v = rt.iterToArray(it, "next", 1280, true); - Known.remade(k, false); + v = rt.iterToArray(it, "next", 1280, true, 1280); + Known.remade(k, k.exact); } else if (_42 === 20) { let taken: rt.u64[][] = rt.replaceIn(v, []); - const _196: rt.u64[] = copy$array_u64(make(arg)); - taken.push(_196); - const _199: rt.usize = taken.length; - const _201: rt.usize = rt.vecCapacity(taken, 1280); - Known.put(k, out, _199, _201); - const _205: rt.u64[][] = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 1280); + const _197: rt.u64[] = copy$array_u64(make(arg)); + taken.push(_197); + const _200: rt.usize = taken.length; + const _202: rt.usize = rt.vecCapacity(taken, 1280); + Known.put(k, out, _200, _202); + const _206: rt.u64[][] = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 1280); const old = taken; - taken = _205; + taken = _206; v = old; Known.put(Known.new(0), out, taken.length, rt.vecCapacity(taken, 1280)); } else if (_42 === 21) { @@ -193,23 +192,42 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d Known.loose(k); } else if (_42 === 23) { const it2: rt.Iter = rt.iterSlice(v); - const _236: rt.u8 = rt.u8Rem(arg, 4); + const _237: rt.u8 = rt.u8Rem(arg, 4); let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _236; + const iterEnd2: rt.u8 = _237; while (iterStart2++ < iterEnd2) { rt.iterToOption(it2.next()); } - v = rt.iterToArray(it2.clone({ v: copy$array_u64 }), "next", 1280, true); + const exact: boolean = k.exact; + v = rt.iterToArray(it2.clone({ v: copy$array_u64 }), "next", 1280, true, 1280); Known.remade(k, true); - const rest: rt.u64[][] = rt.iterToArray(it2, "next", 1280, true); - Known.put({ exact: false, floor: 0 }, out, rest.length, rt.vecCapacity(rest, 1280)); + const rest: rt.u64[][] = rt.iterToArray(it2, "next", 1280, true, 1280); + Known.put({ exact, floor: 0 }, out, rest.length, rt.vecCapacity(rest, 1280)); } else if (_42 === 24) { v = rt.vecFromElem(copy$array_u64(make(arg)), rt.u8Rem(arg, 6) as rt.usize, copy$array_u64); Known.remade(k, false); + } else if (_42 === 25) { + rt.vecPopIf(v, (_26: rt.u64[]): boolean => { + return rt.u8Rem(arg, 2) === 1; + }); + Known.loose(k); + } else if (_42 === 26) { + v = rt.slicesJoin([rt.vecExact(v.map(copy$array_u64), 1280), v], 1280, undefined, undefined, copy$array_u64); + Known.remade(k, true); + } else if (_42 === 27) { + v = rt.iterToArray(rt.iterSlice(rt.vecExact(v, 1280)), "next", 1280, true, 1280); + Known.remade(k, true); + } else if (_42 === 28) { + let own: rt.u64[][] = rt.vecWithCapacity(rt.u8Rem(arg, 8) as rt.usize, 1280); + const _296: rt.u64[] = copy$array_u64(make(arg)); + own.push(_296); + own = rt.vecClonedInto(rt.vecExact(v.map(copy$array_u64), 1280), own, 1280); + v = own; + Known.remade(k, true); } - const _267: rt.usize = v.length; - const _269: rt.usize = rt.vecCapacity(v, 1280); - Known.put(k, out, _267, _269); + const _305: rt.usize = v.length; + const _307: rt.usize = rt.vecCapacity(v, 1280); + Known.put(k, out, _305, _307); } } @@ -239,7 +257,7 @@ export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, const _33: [rt.u8, rt.u8] = [_27.data[_27.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_27, 1), 0)]; const op: rt.u8 = _33[0]; const arg: rt.u8 = _33[1]; - const _42: rt.u8 = rt.u8Rem(op, 25); + const _42: rt.u8 = rt.u8Rem(op, 29); if (_42 === 0 || _42 === 1) { v.push(copy$tuple2_u64_u8(make(arg))); } else if (_42 === 2) { @@ -247,7 +265,7 @@ export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, Known.loose(k); } else if (_42 === 3 || _42 === 4) { const additional: rt.usize = amount(arg, v.length, size); - if (rt.u8Rem(op, 25) === 3) { + if (rt.u8Rem(op, 29) === 3) { rt.vecReserve(v, additional, 16); } else { rt.vecReserveExact(v, additional, 16); @@ -277,14 +295,13 @@ export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, } else if (_42 === 11) { rt.iterExtend(v, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 16, true); } else if (_42 === 12) { - rt.vecExtendFromSlice(v, [make(arg), make(arg)], copy$tuple2_u64_u8); - Known.loose(k); + rt.vecExtendFromSlice(v, rt.vecFromElem(copy$tuple2_u64_u8(make(arg)), rt.u8Rem(arg, 24) as rt.usize, copy$tuple2_u64_u8), 16, copy$tuple2_u64_u8); } else if (_42 === 13) { rt.vecTruncate(v, 0); Known.loose(k); } else if (_42 === 14) { const keep: () => boolean = alternate(); - rt.vecRetain(v, (_28: [rt.u64, rt.u8]): boolean => { + rt.vecRetain(v, (_29: [rt.u64, rt.u8]): boolean => { return keep(); }); Known.loose(k); @@ -295,14 +312,14 @@ export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, v = rt.vecExact(v.map(copy$tuple2_u64_u8), 16); Known.remade(k, true); } else if (_42 === 17) { - v = v; - Known.remade(k, false); + v = rt.vecExact(v, 16); + Known.remade(k, true); } else if (_42 === 18) { const keep2: () => boolean = alternate(); - v = rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_26: [rt.u64, rt.u8]): boolean => { + v = rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_28: [rt.u64, rt.u8]): boolean => { return keep2(); - }), "next", 16); - Known.remade(k, false); + }), "next", 16, false, 16); + Known.remade(k, k.exact); } else if (_42 === 19) { const it: rt.Iter<[rt.u64, rt.u8]> = rt.iterSlice(v); const _174: rt.u8 = rt.u8Rem(arg, 8); @@ -315,18 +332,18 @@ export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, rt.iterToOption(it.nextBack()); } } - v = rt.iterToArray(it, "next", 16, true); - Known.remade(k, false); + v = rt.iterToArray(it, "next", 16, true, 16); + Known.remade(k, k.exact); } else if (_42 === 20) { let taken: [rt.u64, rt.u8][] = rt.replaceIn(v, []); - const _196: [rt.u64, rt.u8] = copy$tuple2_u64_u8(make(arg)); - taken.push(_196); - const _199: rt.usize = taken.length; - const _201: rt.usize = rt.vecCapacity(taken, 16); - Known.put(k, out, _199, _201); - const _205: [rt.u64, rt.u8][] = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 16); + const _197: [rt.u64, rt.u8] = copy$tuple2_u64_u8(make(arg)); + taken.push(_197); + const _200: rt.usize = taken.length; + const _202: rt.usize = rt.vecCapacity(taken, 16); + Known.put(k, out, _200, _202); + const _206: [rt.u64, rt.u8][] = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 16); const old = taken; - taken = _205; + taken = _206; v = old; Known.put(Known.new(0), out, taken.length, rt.vecCapacity(taken, 16)); } else if (_42 === 21) { @@ -339,23 +356,42 @@ export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, Known.loose(k); } else if (_42 === 23) { const it2: rt.Iter<[rt.u64, rt.u8]> = rt.iterSlice(v); - const _236: rt.u8 = rt.u8Rem(arg, 4); + const _237: rt.u8 = rt.u8Rem(arg, 4); let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _236; + const iterEnd2: rt.u8 = _237; while (iterStart2++ < iterEnd2) { rt.iterToOption(it2.next()); } - v = rt.iterToArray(it2.clone({ v: copy$tuple2_u64_u8 }), "next", 16, true); + const exact: boolean = k.exact; + v = rt.iterToArray(it2.clone({ v: copy$tuple2_u64_u8 }), "next", 16, true, 16); Known.remade(k, true); - const rest: [rt.u64, rt.u8][] = rt.iterToArray(it2, "next", 16, true); - Known.put({ exact: false, floor: 0 }, out, rest.length, rt.vecCapacity(rest, 16)); + const rest: [rt.u64, rt.u8][] = rt.iterToArray(it2, "next", 16, true, 16); + Known.put({ exact, floor: 0 }, out, rest.length, rt.vecCapacity(rest, 16)); } else if (_42 === 24) { v = rt.vecFromElem(copy$tuple2_u64_u8(make(arg)), rt.u8Rem(arg, 6) as rt.usize, copy$tuple2_u64_u8); Known.remade(k, false); + } else if (_42 === 25) { + rt.vecPopIf(v, (_26: [rt.u64, rt.u8]): boolean => { + return rt.u8Rem(arg, 2) === 1; + }); + Known.loose(k); + } else if (_42 === 26) { + v = rt.slicesJoin([rt.vecExact(v.map(copy$tuple2_u64_u8), 16), v], 16, undefined, undefined, copy$tuple2_u64_u8); + Known.remade(k, true); + } else if (_42 === 27) { + v = rt.iterToArray(rt.iterSlice(rt.vecExact(v, 16)), "next", 16, true, 16); + Known.remade(k, true); + } else if (_42 === 28) { + let own: [rt.u64, rt.u8][] = rt.vecWithCapacity(rt.u8Rem(arg, 8) as rt.usize, 16); + const _296: [rt.u64, rt.u8] = copy$tuple2_u64_u8(make(arg)); + own.push(_296); + own = rt.vecClonedInto(rt.vecExact(v.map(copy$tuple2_u64_u8), 16), own, 16); + v = own; + Known.remade(k, true); } - const _267: rt.usize = v.length; - const _269: rt.usize = rt.vecCapacity(v, 16); - Known.put(k, out, _267, _269); + const _305: rt.usize = v.length; + const _307: rt.usize = rt.vecCapacity(v, 16); + Known.put(k, out, _305, _307); } } @@ -385,7 +421,7 @@ export function vecSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: n const _33: [rt.u8, rt.u8] = [_27.data[_27.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_27, 1), 0)]; const op: rt.u8 = _33[0]; const arg: rt.u8 = _33[1]; - const _42: rt.u8 = rt.u8Rem(op, 25); + const _42: rt.u8 = rt.u8Rem(op, 29); if (_42 === 0 || _42 === 1) { v.push(make(arg)); } else if (_42 === 2) { @@ -393,7 +429,7 @@ export function vecSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: n Known.loose(k); } else if (_42 === 3 || _42 === 4) { const additional: rt.usize = amount(arg, v.length, size); - if (rt.u8Rem(op, 25) === 3) { + if (rt.u8Rem(op, 29) === 3) { rt.vecReserve(v, additional, 2); } else { rt.vecReserveExact(v, additional, 2); @@ -423,14 +459,13 @@ export function vecSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: n } else if (_42 === 11) { rt.iterExtend(v, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 2, true); } else if (_42 === 12) { - rt.vecExtendFromSlice(v, [make(arg), make(arg)]); - Known.loose(k); + rt.vecExtendFromSlice(v, rt.vecFromElem(make(arg), rt.u8Rem(arg, 24) as rt.usize, undefined), 2); } else if (_42 === 13) { rt.vecTruncate(v, 0); Known.loose(k); } else if (_42 === 14) { const keep: () => boolean = alternate(); - rt.vecRetain(v, (_28: rt.u16): boolean => { + rt.vecRetain(v, (_29: rt.u16): boolean => { return keep(); }); Known.loose(k); @@ -441,14 +476,14 @@ export function vecSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: n v = rt.vecExact(v.slice(), 2); Known.remade(k, true); } else if (_42 === 17) { - v = v; - Known.remade(k, false); + v = rt.vecExact(v, 2); + Known.remade(k, true); } else if (_42 === 18) { const keep2: () => boolean = alternate(); - v = rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_26: rt.u16): boolean => { + v = rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_28: rt.u16): boolean => { return keep2(); - }), "next", 2); - Known.remade(k, false); + }), "next", 2, false, 2); + Known.remade(k, k.exact); } else if (_42 === 19) { const it: rt.Iter = rt.iterSlice(v); const _174: rt.u8 = rt.u8Rem(arg, 8); @@ -461,18 +496,18 @@ export function vecSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: n rt.iterToOption(it.nextBack()); } } - v = rt.iterToArray(it, "next", 2, true); - Known.remade(k, false); + v = rt.iterToArray(it, "next", 2, true, 2); + Known.remade(k, k.exact); } else if (_42 === 20) { let taken: rt.u16[] = rt.replaceIn(v, []); - const _196: rt.u16 = make(arg); - taken.push(_196); - const _199: rt.usize = taken.length; - const _201: rt.usize = rt.vecCapacity(taken, 2); - Known.put(k, out, _199, _201); - const _205: rt.u16[] = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 2); + const _197: rt.u16 = make(arg); + taken.push(_197); + const _200: rt.usize = taken.length; + const _202: rt.usize = rt.vecCapacity(taken, 2); + Known.put(k, out, _200, _202); + const _206: rt.u16[] = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 2); const old = taken; - taken = _205; + taken = _206; v = old; Known.put(Known.new(0), out, taken.length, rt.vecCapacity(taken, 2)); } else if (_42 === 21) { @@ -485,23 +520,42 @@ export function vecSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: n Known.loose(k); } else if (_42 === 23) { const it2: rt.Iter = rt.iterSlice(v); - const _236: rt.u8 = rt.u8Rem(arg, 4); + const _237: rt.u8 = rt.u8Rem(arg, 4); let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _236; + const iterEnd2: rt.u8 = _237; while (iterStart2++ < iterEnd2) { rt.iterToOption(it2.next()); } - v = rt.iterToArray(it2.clone({ v: rt.itself }), "next", 2, true); + const exact: boolean = k.exact; + v = rt.iterToArray(it2.clone({ v: rt.itself }), "next", 2, true, 2); Known.remade(k, true); - const rest: rt.u16[] = rt.iterToArray(it2, "next", 2, true); - Known.put({ exact: false, floor: 0 }, out, rest.length, rt.vecCapacity(rest, 2)); + const rest: rt.u16[] = rt.iterToArray(it2, "next", 2, true, 2); + Known.put({ exact, floor: 0 }, out, rest.length, rt.vecCapacity(rest, 2)); } else if (_42 === 24) { v = rt.vecFromElem(make(arg), rt.u8Rem(arg, 6) as rt.usize, undefined); Known.remade(k, false); + } else if (_42 === 25) { + rt.vecPopIfMut(v, (_26: rt.Place): boolean => { + return rt.u8Rem(arg, 2) === 1; + }); + Known.loose(k); + } else if (_42 === 26) { + v = rt.slicesJoin([rt.vecExact(v.slice(), 2), v], 2); + Known.remade(k, true); + } else if (_42 === 27) { + v = rt.iterToArray(rt.iterSlice(rt.vecExact(v, 2)), "next", 2, true, 2); + Known.remade(k, true); + } else if (_42 === 28) { + let own: rt.u16[] = rt.vecWithCapacity(rt.u8Rem(arg, 8) as rt.usize, 2); + const _296: rt.u16 = make(arg); + own.push(_296); + own = rt.vecClonedInto(rt.vecExact(v.slice(), 2), own, 2); + v = own; + Known.remade(k, true); } - const _267: rt.usize = v.length; - const _269: rt.usize = rt.vecCapacity(v, 2); - Known.put(k, out, _267, _269); + const _305: rt.usize = v.length; + const _307: rt.usize = rt.vecCapacity(v, 2); + Known.put(k, out, _305, _307); } } @@ -531,7 +585,7 @@ export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: nu const _33: [rt.u8, rt.u8] = [_27.data[_27.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_27, 1), 0)]; const op: rt.u8 = _33[0]; const arg: rt.u8 = _33[1]; - const _42: rt.u8 = rt.u8Rem(op, 25); + const _42: rt.u8 = rt.u8Rem(op, 29); if (_42 === 0 || _42 === 1) { rt.byteVecPush(v, make(arg)); } else if (_42 === 2) { @@ -539,7 +593,7 @@ export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: nu Known.loose(k); } else if (_42 === 3 || _42 === 4) { const additional: rt.usize = amount(arg, v.length, size); - if (rt.u8Rem(op, 25) === 3) { + if (rt.u8Rem(op, 29) === 3) { rt.byteVecReserve(v, additional); } else { rt.byteVecReserveExact(v, additional); @@ -569,14 +623,13 @@ export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: nu } else if (_42 === 11) { rt.iterExtendBytes(v, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, true); } else if (_42 === 12) { - rt.byteVecExtendFromSlice(v, rt.byteSliceFrom(Uint8Array.of(make(arg), make(arg)))); - Known.loose(k); + rt.byteVecExtendFromSlice(v, rt.byteVecSlice(rt.byteVecOf(make(arg), rt.u8Rem(arg, 24) as rt.usize))); } else if (_42 === 13) { rt.byteVecClear(v); Known.loose(k); } else if (_42 === 14) { const keep: () => boolean = alternate(); - rt.byteVecRetain(v, (_28: rt.u8): boolean => { + rt.byteVecRetain(v, (_29: rt.u8): boolean => { return keep(); }); Known.loose(k); @@ -588,13 +641,13 @@ export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: nu Known.remade(k, true); } else if (_42 === 17) { v = rt.byteSliceToByteVec(rt.byteVecSlice(v)); - Known.remade(k, false); + Known.remade(k, true); } else if (_42 === 18) { const keep2: () => boolean = alternate(); - v = rt.iterToByteVec(rt.iterFilter(rt.byteVecIntoIter(v), (_26: rt.u8): boolean => { + v = rt.iterToByteVec(rt.iterFilter(rt.byteVecIntoIter(v), (_28: rt.u8): boolean => { return keep2(); - }), "next"); - Known.remade(k, false); + }), "next", false, 1); + Known.remade(k, k.exact); } else if (_42 === 19) { const it: rt.Iter = rt.byteVecIntoIter(v); const _174: rt.u8 = rt.u8Rem(arg, 8); @@ -607,16 +660,16 @@ export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: nu rt.iterToOption(it.nextBack()); } } - v = rt.iterToByteVec(it, "next", true); - Known.remade(k, false); + v = rt.iterToByteVec(it, "next", true, 1); + Known.remade(k, k.exact); } else if (_42 === 20) { let taken: rt.ByteVec = rt.replaceIn(v, new rt.ByteVec()); - const _196: rt.u8 = make(arg); - rt.byteVecPush(taken, _196); + const _197: rt.u8 = make(arg); + rt.byteVecPush(taken, _197); Known.put(k, out, taken.length, taken.data.length); - const _205: rt.ByteVec = rt.byteVecWithCapacity(rt.u8Rem(arg, 6) as rt.usize); + const _206: rt.ByteVec = rt.byteVecWithCapacity(rt.u8Rem(arg, 6) as rt.usize); const old = taken; - taken = _205; + taken = _206; v = old; Known.put(Known.new(0), out, taken.length, taken.data.length); } else if (_42 === 21) { @@ -629,19 +682,38 @@ export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: nu Known.loose(k); } else if (_42 === 23) { const it2: rt.Iter = rt.byteVecIntoIter(v); - const _236: rt.u8 = rt.u8Rem(arg, 4); + const _237: rt.u8 = rt.u8Rem(arg, 4); let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _236; + const iterEnd2: rt.u8 = _237; while (iterStart2++ < iterEnd2) { rt.iterToOption(it2.next()); } - v = rt.iterToByteVec(it2.clone({ v: rt.itself }), "next", true); + const exact: boolean = k.exact; + v = rt.iterToByteVec(it2.clone({ v: rt.itself }), "next", true, 1); Known.remade(k, true); - const rest: rt.ByteVec = rt.iterToByteVec(it2, "next", true); - Known.put({ exact: false, floor: 0 }, out, rest.length, rest.data.length); + const rest: rt.ByteVec = rt.iterToByteVec(it2, "next", true, 1); + Known.put({ exact, floor: 0 }, out, rest.length, rest.data.length); } else if (_42 === 24) { v = rt.byteVecOf(make(arg), rt.u8Rem(arg, 6) as rt.usize); Known.remade(k, false); + } else if (_42 === 25) { + rt.byteVecPopIf(v, (_26: rt.Place): boolean => { + return rt.u8Rem(arg, 2) === 1; + }); + Known.loose(k); + } else if (_42 === 26) { + v = rt.byteSlicesJoin([rt.byteVecFrom(rt.byteVecView(v)), v], undefined, rt.byteVecSlice); + Known.remade(k, true); + } else if (_42 === 27) { + v = rt.iterToByteVec(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(v))), "next", true, 1); + Known.remade(k, true); + } else if (_42 === 28) { + let own: rt.ByteVec = rt.byteVecWithCapacity(rt.u8Rem(arg, 8) as rt.usize); + const _296: rt.u8 = make(arg); + rt.byteVecPush(own, _296); + own = rt.byteVecClonedInto(rt.byteVecFrom(rt.byteVecView(v)), own); + v = own; + Known.remade(k, true); } Known.put(k, out, v.length, v.data.length); } @@ -673,7 +745,7 @@ export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: const _33: [rt.u8, rt.u8] = [_27.data[_27.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_27, 1), 0)]; const op: rt.u8 = _33[0]; const arg: rt.u8 = _33[1]; - const _42: rt.u8 = rt.u8Rem(op, 25); + const _42: rt.u8 = rt.u8Rem(op, 29); if (_42 === 0 || _42 === 1) { const _44: undefined[] = v; make(arg); @@ -683,7 +755,7 @@ export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: Known.loose(k); } else if (_42 === 3 || _42 === 4) { const additional: rt.usize = amount(arg, v.length, size); - if (rt.u8Rem(op, 25) === 3) { + if (rt.u8Rem(op, 29) === 3) { rt.vecReserve(v, additional, 0); } else { rt.vecReserveExact(v, additional, 0); @@ -716,17 +788,15 @@ export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: } else if (_42 === 11) { rt.iterExtend(v, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 0, true); } else if (_42 === 12) { - const _121: undefined[] = v; - make(arg); + const _120: undefined[] = v; make(arg); - rt.vecExtendFromSlice(_121, [undefined, undefined]); - Known.loose(k); + rt.vecExtendFromSlice(_120, rt.vecFromElem(undefined, rt.u8Rem(arg, 24) as rt.usize, undefined), 0); } else if (_42 === 13) { rt.vecTruncate(v, 0); Known.loose(k); } else if (_42 === 14) { const keep: () => boolean = alternate(); - rt.vecRetain(v, (_28: undefined): boolean => { + rt.vecRetain(v, (_29: undefined): boolean => { return keep(); }); Known.loose(k); @@ -737,14 +807,14 @@ export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: v = rt.vecExact(v.slice(), 0); Known.remade(k, true); } else if (_42 === 17) { - v = v; - Known.remade(k, false); + v = rt.vecExact(v, 0); + Known.remade(k, true); } else if (_42 === 18) { const keep2: () => boolean = alternate(); - v = rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_26: undefined): boolean => { + v = rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_28: undefined): boolean => { return keep2(); }), "next", 0); - Known.remade(k, false); + Known.remade(k, k.exact); } else if (_42 === 19) { const it: rt.Iter = rt.iterSlice(v); const _174: rt.u8 = rt.u8Rem(arg, 8); @@ -758,17 +828,17 @@ export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: } } v = rt.iterToArray(it, undefined, 0, true); - Known.remade(k, false); + Known.remade(k, k.exact); } else if (_42 === 20) { let taken: undefined[] = rt.replaceIn(v, []); make(arg); taken.push(undefined); - const _199: rt.usize = taken.length; - const _201: rt.usize = rt.vecCapacity(taken, 0); - Known.put(k, out, _199, _201); - const _205: undefined[] = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 0); + const _200: rt.usize = taken.length; + const _202: rt.usize = rt.vecCapacity(taken, 0); + Known.put(k, out, _200, _202); + const _206: undefined[] = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 0); const old = taken; - taken = _205; + taken = _206; v = old; Known.put(Known.new(0), out, taken.length, rt.vecCapacity(taken, 0)); } else if (_42 === 21) { @@ -781,24 +851,43 @@ export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: Known.loose(k); } else if (_42 === 23) { const it2: rt.Iter = rt.iterSlice(v); - const _236: rt.u8 = rt.u8Rem(arg, 4); + const _237: rt.u8 = rt.u8Rem(arg, 4); let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _236; + const iterEnd2: rt.u8 = _237; while (iterStart2++ < iterEnd2) { rt.iterToOption(it2.next(), rt.None); } + const exact: boolean = k.exact; v = rt.iterToArray(it2.clone({ v: rt.itself }), undefined, 0, true); Known.remade(k, true); const rest: undefined[] = rt.iterToArray(it2, undefined, 0, true); - Known.put({ exact: false, floor: 0 }, out, rest.length, rt.vecCapacity(rest, 0)); + Known.put({ exact, floor: 0 }, out, rest.length, rt.vecCapacity(rest, 0)); } else if (_42 === 24) { make(arg); v = rt.vecFromElem(undefined, rt.u8Rem(arg, 6) as rt.usize, undefined); Known.remade(k, false); + } else if (_42 === 25) { + rt.vecPopIfMut(v, (_26: rt.Place): boolean => { + return rt.u8Rem(arg, 2) === 1; + }, undefined, rt.None); + Known.loose(k); + } else if (_42 === 26) { + v = rt.slicesJoin([rt.vecExact(v.slice(), 0), v], 0); + Known.remade(k, true); + } else if (_42 === 27) { + v = rt.iterToArray(rt.iterSlice(rt.vecExact(v, 0)), undefined, 0, true); + Known.remade(k, true); + } else if (_42 === 28) { + let own: undefined[] = rt.vecWithCapacity(rt.u8Rem(arg, 8) as rt.usize, 0); + make(arg); + own.push(undefined); + own = rt.vecClonedInto(rt.vecExact(v.slice(), 0), own, 0); + v = own; + Known.remade(k, true); } - const _267: rt.usize = v.length; - const _269: rt.usize = rt.vecCapacity(v, 0); - Known.put(k, out, _267, _269); + const _305: rt.usize = v.length; + const _307: rt.usize = rt.vecCapacity(v, 0); + Known.put(k, out, _305, _307); } } @@ -1791,10 +1880,10 @@ export function collects(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void if (_20 === 0) { const halves: rt.u32[] = rt.iterToArray(rt.iterMap(rt.iterSlice(pairs2), (_27: [rt.u32, rt.u32]): rt.u32 => { return _27[0]; - }), "next", 4, true); + }), "next", 4, true, 8); const _28: rt.usize = halves.length; const _30: rt.usize = rt.vecCapacity(halves, 4); - Known.put(loose, out, _28, _30); + Known.put(exact, out, _28, _30); } else if (_20 === 1) { const bytes: rt.ByteVec = rt.byteVecWithCapacity(rt.usizeAdd(n, 3)); const _37: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(n, data.length)); @@ -1802,8 +1891,8 @@ export function collects(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void Known.put(exact, out, bytes.length, bytes.data.length); const odd: rt.ByteVec = rt.iterToByteVec(rt.iterFilter(rt.byteVecIntoIter(rt.byteVecFrom(rt.byteVecView(bytes))), (b5: rt.u8): boolean => { return rt.u8Rem(b5, 2) === 1; - }), "next"); - Known.put(loose, out, odd.length, odd.data.length); + }), "next", false, 1); + Known.put(exact, out, odd.length, odd.data.length); const wide: rt.u16[] = rt.iterToArray(rt.iterMap(rt.byteVecIntoIter(bytes), (a0: rt.u8): rt.u16 => { return a0 as rt.u16; }), undefined, 2, true); diff --git a/ts/fixtures/lang/expected/chars.ts b/ts/fixtures/lang/expected/chars.ts index 98f915966..859c35d39 100644 --- a/ts/fixtures/lang/expected/chars.ts +++ b/ts/fixtures/lang/expected/chars.ts @@ -94,7 +94,7 @@ export function chars(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_4 === 2) { const cs: rt.char[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(scalars(data)), (a0: rt.u32): rt.char | undefined => { return rt.charFromU32(a0); - }), "next", 4); + }), "next", 4, false, 4); const sorted: rt.BTreeSet = rt.btreeNew(rt.cmp) as rt.BTreeSet; const seen: rt.HashSet = rt.hashNew() as rt.HashSet; const iter3: rt.Iter<[rt.usize, rt.char]> = rt.iterEnumerate(rt.iterSlice(cs)); diff --git a/ts/fixtures/lang/expected/conversions.ts b/ts/fixtures/lang/expected/conversions.ts index 02ed59fbb..34d170b04 100644 --- a/ts/fixtures/lang/expected/conversions.ts +++ b/ts/fixtures/lang/expected/conversions.ts @@ -321,12 +321,12 @@ export function cloneFromParam$String(to: rt.Place, from: string): void /** `clone_from` through a `&mut` whose place only the caller knows. */ export function cloneFromParam$Vec_u32(to: rt.u32[], from: rt.u32[]): void { - rt.replaceIn(to, rt.vecExact(from.slice(), 4)); + rt.replaceIn(to, rt.vecClonedInto(rt.vecExact(from.slice(), 4), to, 4)); } /** `clone_from` through a `&mut` whose place only the caller knows. */ export function cloneFromParam$Vec_u8(to: rt.ByteVec, from: rt.ByteVec): void { - rt.replaceIn(to, rt.byteVecFrom(rt.byteVecView(from))); + rt.replaceIn(to, rt.byteVecClonedInto(rt.byteVecFrom(rt.byteVecView(from)), to)); } /** `clone_from` through a `&mut` whose place only the caller knows. */ @@ -391,12 +391,12 @@ export function cloneIntoParam$String(from: string, to: rt.Place): void /** `clone_into` through a `&mut` whose place only the caller knows. */ export function cloneIntoParam$Vec_u32(from: rt.u32[], to: rt.u32[]): void { - rt.replaceIn(to, rt.vecExact(from.slice(), 4)); + rt.replaceIn(to, rt.vecClonedInto(rt.vecExact(from.slice(), 4), to, 4)); } /** `clone_into` through a `&mut` whose place only the caller knows. */ export function cloneIntoParam$Vec_u8(from: rt.ByteVec, to: rt.ByteVec): void { - rt.replaceIn(to, rt.byteVecFrom(rt.byteVecView(from))); + rt.replaceIn(to, rt.byteVecClonedInto(rt.byteVecFrom(rt.byteVecView(from)), to)); } /** `clone_into` through a `&mut` whose place only the caller knows. */ @@ -892,21 +892,23 @@ export function converted$Vec_u32(data: rt.ByteSlice, out: rt.ByteVec): void { let a: rt.u32[] = make$conversions_Value_Vec_u32(data, 0); const b: rt.u32[] = make$conversions_Value_Vec_u32(data, 3); const owned: rt.u32[] = rt.vecExact(a.slice(), 4); - a = rt.vecExact(b.slice(), 4); + a = rt.vecClonedInto(rt.vecExact(b.slice(), 4), a, 4); put$conversions_Value_Vec_u32(owned, out); put$conversions_Value_Vec_u32(a, out); let c: rt.u32[] = make$conversions_Value_Vec_u32(data, 6); - c = rt.vecExact(owned.slice(), 4); + c = rt.vecClonedInto(rt.vecExact(owned.slice(), 4), c, 4); put$conversions_Value_Vec_u32(c, out); cloneFromParam$Vec_u32(c, b); cloneIntoParam$Vec_u32(owned, a); put$conversions_Value_Vec_u32(c, out); put$conversions_Value_Vec_u32(a, out); const held: conversions_Held.Held = new conversions_Held.Held(make$conversions_Value_Vec_u32(data, 1)); - held.value = rt.vecExact(c.slice(), 4); + held.value = rt.vecClonedInto(rt.vecExact(c.slice(), 4), held.value, 4); const v: rt.u32[][] = [make$conversions_Value_Vec_u32(data, 2), make$conversions_Value_Vec_u32(data, 4)]; - v[rt.idx(v, 1)] = rt.vecExact(held.value.slice(), 4); - v[rt.idx(v, 0)] = rt.vecExact(b.slice(), 4); + const at = rt.idx(v, 1); + v[at] = rt.vecClonedInto(rt.vecExact(held.value.slice(), 4), v[at], 4); + const at2 = rt.idx(v, 0); + v[at2] = rt.vecClonedInto(rt.vecExact(b.slice(), 4), v[at2], 4); put$conversions_Value_Vec_u32(held.value, out); put$conversions_Value_Vec_u32(v[rt.idx(v, 0)], out); put$conversions_Value_Vec_u32(v[rt.idx(v, 1)], out); @@ -914,7 +916,7 @@ export function converted$Vec_u32(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, one.length & 0xff); const copied: rt.u32[] = rt.vecExact(one[0].slice(), 4); put$conversions_Value_Vec_u32(one[0], out); - a = rt.vecExact(copied.slice(), 4); + a = rt.vecClonedInto(rt.vecExact(copied.slice(), 4), a, 4); put$conversions_Value_Vec_u32(copied, out); put$conversions_Value_Vec_u32(a, out); const cell: rt.Cell = rt.cellOfPlace(rt.place(() => c, (value) => c = value)); @@ -939,7 +941,7 @@ export function converted$Vec_u32(data: rt.ByteSlice, out: rt.ByteVec): void { _116[0] = _114; const _124: rt.u32[][] = array; rt.idx(_124, 2); - _124[2] = rt.vecExact(c.slice(), 4); + _124[2] = rt.vecClonedInto(rt.vecExact(c.slice(), 4), _124[2], 4); for (const _134 of array) { put$conversions_Value_Vec_u32(_134, out); } @@ -953,21 +955,23 @@ export function converted$Vec_u8(data: rt.ByteSlice, out: rt.ByteVec): void { let a: rt.ByteVec = make$conversions_Value_Vec_u8(data, 0); const b: rt.ByteVec = make$conversions_Value_Vec_u8(data, 3); const owned: rt.ByteVec = rt.byteVecFrom(rt.byteVecView(a)); - a = rt.byteVecFrom(rt.byteVecView(b)); + a = rt.byteVecClonedInto(rt.byteVecFrom(rt.byteVecView(b)), a); put$conversions_Value_Vec_u8(owned, out); put$conversions_Value_Vec_u8(a, out); let c: rt.ByteVec = make$conversions_Value_Vec_u8(data, 6); - c = rt.byteVecFrom(rt.byteVecView(owned)); + c = rt.byteVecClonedInto(rt.byteVecFrom(rt.byteVecView(owned)), c); put$conversions_Value_Vec_u8(c, out); cloneFromParam$Vec_u8(c, b); cloneIntoParam$Vec_u8(owned, a); put$conversions_Value_Vec_u8(c, out); put$conversions_Value_Vec_u8(a, out); const held: conversions_Held.Held = new conversions_Held.Held(make$conversions_Value_Vec_u8(data, 1)); - held.value = rt.byteVecFrom(rt.byteVecView(c)); + held.value = rt.byteVecClonedInto(rt.byteVecFrom(rt.byteVecView(c)), held.value); const v: rt.ByteVec[] = [make$conversions_Value_Vec_u8(data, 2), make$conversions_Value_Vec_u8(data, 4)]; - v[rt.idx(v, 1)] = rt.byteVecFrom(rt.byteVecView(held.value)); - v[rt.idx(v, 0)] = rt.byteVecFrom(rt.byteVecView(b)); + const at = rt.idx(v, 1); + v[at] = rt.byteVecClonedInto(rt.byteVecFrom(rt.byteVecView(held.value)), v[at]); + const at2 = rt.idx(v, 0); + v[at2] = rt.byteVecClonedInto(rt.byteVecFrom(rt.byteVecView(b)), v[at2]); put$conversions_Value_Vec_u8(held.value, out); put$conversions_Value_Vec_u8(v[rt.idx(v, 0)], out); put$conversions_Value_Vec_u8(v[rt.idx(v, 1)], out); @@ -975,7 +979,7 @@ export function converted$Vec_u8(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, one.length & 0xff); const copied: rt.ByteVec = rt.byteVecFrom(rt.byteVecView(one[0])); put$conversions_Value_Vec_u8(one[0], out); - a = rt.byteVecFrom(rt.byteVecView(copied)); + a = rt.byteVecClonedInto(rt.byteVecFrom(rt.byteVecView(copied)), a); put$conversions_Value_Vec_u8(copied, out); put$conversions_Value_Vec_u8(a, out); const cell: rt.Cell = rt.cellOfPlace(rt.place(() => c, (value) => c = value)); @@ -1000,7 +1004,7 @@ export function converted$Vec_u8(data: rt.ByteSlice, out: rt.ByteVec): void { _116[0] = _114; const _124: rt.ByteVec[] = array; rt.idx(_124, 2); - _124[2] = rt.byteVecFrom(rt.byteVecView(c)); + _124[2] = rt.byteVecClonedInto(rt.byteVecFrom(rt.byteVecView(c)), _124[2]); for (const _134 of array) { put$conversions_Value_Vec_u8(_134, out); } diff --git a/ts/fixtures/lang/expected/edits.ts b/ts/fixtures/lang/expected/edits.ts index d8d63a646..5fb68a94b 100644 --- a/ts/fixtures/lang/expected/edits.ts +++ b/ts/fixtures/lang/expected/edits.ts @@ -250,7 +250,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, !rt.eqSlice(edits_Named.eq$cmp_PartialEq)(changed, named2) ? 1 : 0); rt.byteVecPush(out, rt.cmpSlice(edits_Named.partialCmp$cmp_PartialOrd)(changed, named2) === -1 ? 1 : 0); const _435: edits_Named.Named[] = rt.sliceRange(named2, 0, rt.usizeDiv(named2.length, 2)); - rt.vecExtendFromSlice(changed, _435, edits_Named.clone$Clone); + rt.vecExtendFromSlice(changed, _435, 16, edits_Named.clone$Clone); rt.byteVecPush(out, changed.length & 0xff); const nested: rt.u16[][] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): rt.u16[] => { const b5: rt.u8 = _29; @@ -272,7 +272,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _491: [rt.u8, rt.u8] = [at(1), at(0)]; rt.byteVecPush(out, rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])(_483, _491) === -1 ? 1 : 0); const grown: rt.u16[] = rt.vecExact(words.slice(), 2); - rt.vecExtendFromSlice(grown, words); + rt.vecExtendFromSlice(grown, words, 2); putU16s(out, grown); } else if (_8 === 5) { let tally: edits_Tally.Tally = { n: at(0), names: [strs_text(data)] }; diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 40f9dc8d7..f176eb9bb 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -49,6 +49,7 @@ import { lists as pointers_lists, shared as pointers_shared, places as pointers_ import { refs, toRefs, adapted as refs_adapted, compared } from "./refs.ts"; import { results as results_results } from "./results.ts"; import { returns } from "./returns.ts"; +import { slices as rings_slices } from "./rings.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"; import { copies as shapes_copies, order as shapes_order, discriminants, loops, patterns, uninhabited, closures as shapes_closures, library, flows } from "./shapes.ts"; @@ -285,12 +286,14 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) hashes_own(data99, out100); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["refs::compared", (a0159: rt.u8, a1159: rt.ByteSlice, a2159: rt.ByteVec): undefined => { compared(a0159, a1159.data, a1159.start, a1159.length, a2159); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["rings::slices", (a0160: rt.u8, a1160: rt.ByteSlice, a2160: rt.ByteVec): undefined => { + rings_slices(a0160, a1160.data, a1160.start, a1160.length, a2160); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::objects", (_2200: rt.u8, data100: rt.ByteSlice, out101: rt.ByteVec): undefined => { fmt_objects(data100, out101); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["sorts::sorts", (a0160: rt.u8, a1160: rt.ByteSlice, a2160: rt.ByteVec): undefined => { - sorts(a0160, a1160.data, a1160.start, a1160.length, a2160); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["sorts::disorders", disorders as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["sorts::btrees", (a0162: rt.u8, a1162: rt.ByteSlice, a2162: rt.ByteVec): undefined => { - sorts_btrees(a0162, a1162.data, a1162.start, a1162.length, a2162); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["sorts::sorts", (a0161: rt.u8, a1161: rt.ByteSlice, a2161: rt.ByteVec): undefined => { + sorts(a0161, a1161.data, a1161.start, a1161.length, a2161); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["sorts::disorders", disorders as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["sorts::btrees", (a0163: rt.u8, a1163: rt.ByteSlice, a2163: rt.ByteVec): undefined => { + sorts_btrees(a0163, a1163.data, a1163.start, a1163.length, a2163); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; } diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index 8cf262dea..4c45f7da8 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -2555,7 +2555,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_574 === 4) { rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z7, (_2205: [rt.u8, rt.u8]): rt.u8 => { return _2205[0] ^ _2205[1]; - }), undefined, true)), undefined, true); + }), undefined, true, 1)), undefined, true); } else if (_574 === 5) { rt.byteVecPush(out, rt.iterFold(z7, 0, (acc4: rt.u8, p14: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc4, 3) ^ _573(p14); @@ -2725,7 +2725,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_751 === 4) { rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z9, (_2192: [rt.u8, rt.u8]): rt.u8 => { return _2192[0] ^ _2192[1]; - }), undefined, true)), undefined, true); + }), undefined, true, 1)), undefined, true); } else if (_751 === 5) { rt.byteVecPush(out, rt.iterFold(z9, 0, (acc3: rt.u8, p12: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc3, 3) ^ _750(p12); diff --git a/ts/fixtures/lang/expected/refs.ts b/ts/fixtures/lang/expected/refs.ts index 42081723c..c38e6f6c3 100644 --- a/ts/fixtures/lang/expected/refs.ts +++ b/ts/fixtures/lang/expected/refs.ts @@ -576,7 +576,7 @@ export function taken(data: rt.ByteSlice, out: rt.ByteVec): void { return _25 > ((b4 as rt.u32)); }), (x3: rt.u32): rt.u32 => { return rt.u32Div(x3, 2); - }), "next", 4); + }), "next", 4, false, 4); })(); return held.length === 0; }) as rt.u32))); diff --git a/ts/fixtures/lang/expected/rings.ts b/ts/fixtures/lang/expected/rings.ts index a1ac8d50d..b32a05ea5 100644 --- a/ts/fixtures/lang/expected/rings.ts +++ b/ts/fixtures/lang/expected/rings.ts @@ -677,7 +677,8 @@ export function steps$unit(dataData: Uint8Array, dataStart: number, dataLen: num /** * A deque made anew from `q`: a clone, or one with room of its own cloned into from it, * collected from its own `into_iter` or a `Vec`'s read in part, or that one's clone, - * whose buffers std's takes as they are, or from a `Vec` it collects. + * whose buffers std's takes as they are, or from a `Vec` it collects, directly or through + * adaptors in place of another. */ export function remade$String(q: rt.VecDeque, arg: rt.u8): rt.VecDeque { let _0!: rt.VecDeque; @@ -713,11 +714,19 @@ export function remade$String(q: rt.VecDeque, arg: rt.u8): rt.VecDeque; } if (_8 === 3) { + if (!((arg & 32) === 0)) { + const v: string[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 12, true); + let kept: boolean = false; + return rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_2: string): boolean => { + kept = !kept; + return kept; + }), "next", 12, false, 12), 12) as rt.VecDeque; + } return rt.dequeFromVec(rt.iterToArray(rt.dequeIntoIter(q), undefined, 12, true), 12) as rt.VecDeque; } - const v: string[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 12, true); - rt.vecReserve(v, skip, 12); - const it3: rt.Iter = rt.iterSlice(v); + const v2: string[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 12, true); + rt.vecReserve(v2, skip, 12); + const it3: rt.Iter = rt.iterSlice(v2); let iterStart2: rt.usize = 0; const iterEnd2: rt.usize = skip; while (iterStart2++ < iterEnd2) { @@ -734,7 +743,8 @@ export function remade$String(q: rt.VecDeque, arg: rt.u8): rt.VecDeque, arg: rt.u8): rt.VecDeque { let _0!: rt.VecDeque; @@ -770,11 +780,19 @@ export function remade$rings_Big(q: rt.VecDeque, arg: rt.u8): rt.VecDeq return rt.dequeFromIntoIter(it2, 1101) as rt.VecDeque; } if (_8 === 3) { + if (!((arg & 32) === 0)) { + const v: Big.Big[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 1101, true); + let kept: boolean = false; + return rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_2: Big.Big): boolean => { + kept = !kept; + return kept; + }), "next", 1101, false, 1101), 1101) as rt.VecDeque; + } return rt.dequeFromVec(rt.iterToArray(rt.dequeIntoIter(q), undefined, 1101, true), 1101) as rt.VecDeque; } - const v: Big.Big[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 1101, true); - rt.vecReserve(v, skip, 1101); - const it3: rt.Iter = rt.iterSlice(v); + const v2: Big.Big[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 1101, true); + rt.vecReserve(v2, skip, 1101); + const it3: rt.Iter = rt.iterSlice(v2); let iterStart2: rt.usize = 0; const iterEnd2: rt.usize = skip; while (iterStart2++ < iterEnd2) { @@ -791,7 +809,8 @@ export function remade$rings_Big(q: rt.VecDeque, arg: rt.u8): rt.VecDeq /** * A deque made anew from `q`: a clone, or one with room of its own cloned into from it, * collected from its own `into_iter` or a `Vec`'s read in part, or that one's clone, - * whose buffers std's takes as they are, or from a `Vec` it collects. + * whose buffers std's takes as they are, or from a `Vec` it collects, directly or through + * adaptors in place of another. */ export function remade$u32(q: rt.VecDeque, arg: rt.u8): rt.VecDeque { let _0!: rt.VecDeque; @@ -827,11 +846,19 @@ export function remade$u32(q: rt.VecDeque, arg: rt.u8): rt.VecDeque; } if (_8 === 3) { + if (!((arg & 32) === 0)) { + const v: rt.u32[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 4, true); + let kept: boolean = false; + return rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_2: rt.u32): boolean => { + kept = !kept; + return kept; + }), "next", 4, false, 4), 4) as rt.VecDeque; + } return rt.dequeFromVec(rt.iterToArray(rt.dequeIntoIter(q), undefined, 4, true), 4) as rt.VecDeque; } - const v: rt.u32[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 4, true); - rt.vecReserve(v, skip, 4); - const it3: rt.Iter = rt.iterSlice(v); + const v2: rt.u32[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 4, true); + rt.vecReserve(v2, skip, 4); + const it3: rt.Iter = rt.iterSlice(v2); let iterStart2: rt.usize = 0; const iterEnd2: rt.usize = skip; while (iterStart2++ < iterEnd2) { @@ -848,7 +875,8 @@ export function remade$u32(q: rt.VecDeque, arg: rt.u8): rt.VecDeque, arg: rt.u8): rt.VecDeque { let _0!: rt.VecDeque; @@ -884,11 +912,19 @@ export function remade$u8(q: rt.VecDeque, arg: rt.u8): rt.VecDeque return rt.dequeFromIntoIter(it2, 1, true) as rt.VecDeque; } if (_8 === 3) { + if (!((arg & 32) === 0)) { + const v: rt.ByteVec = rt.iterToByteVec(rt.dequeIntoIter(q), undefined, true); + let kept: boolean = false; + return rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.byteVecIntoIter(v), (_2: rt.u8): boolean => { + kept = !kept; + return kept; + }), "next", 1, false, 1), 1, true) as rt.VecDeque; + } return rt.dequeFromVec(rt.byteVecToVec(rt.iterToByteVec(rt.dequeIntoIter(q), undefined, true)), 1, true) as rt.VecDeque; } - const v: rt.ByteVec = rt.iterToByteVec(rt.dequeIntoIter(q), undefined, true); - rt.byteVecReserve(v, skip); - const it3: rt.Iter = rt.byteVecIntoIter(v); + const v2: rt.ByteVec = rt.iterToByteVec(rt.dequeIntoIter(q), undefined, true); + rt.byteVecReserve(v2, skip); + const it3: rt.Iter = rt.byteVecIntoIter(v2); let iterStart2: rt.usize = 0; const iterEnd2: rt.usize = skip; while (iterStart2++ < iterEnd2) { @@ -905,7 +941,8 @@ export function remade$u8(q: rt.VecDeque, arg: rt.u8): rt.VecDeque /** * A deque made anew from `q`: a clone, or one with room of its own cloned into from it, * collected from its own `into_iter` or a `Vec`'s read in part, or that one's clone, - * whose buffers std's takes as they are, or from a `Vec` it collects. + * whose buffers std's takes as they are, or from a `Vec` it collects, directly or through + * adaptors in place of another. */ export function remade$unit(q: rt.VecDeque, arg: rt.u8): rt.VecDeque { let _0!: rt.VecDeque; @@ -941,11 +978,19 @@ export function remade$unit(q: rt.VecDeque, arg: rt.u8): rt.VecDeque< return rt.dequeFromIntoIter(it2, 0) as rt.VecDeque; } if (_8 === 3) { + if (!((arg & 32) === 0)) { + const v: undefined[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 0, true); + let kept: boolean = false; + return rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_2: undefined): boolean => { + kept = !kept; + return kept; + }), "next", 0), 0) as rt.VecDeque; + } return rt.dequeFromVec(rt.iterToArray(rt.dequeIntoIter(q), undefined, 0, true), 0) as rt.VecDeque; } - const v: undefined[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 0, true); - rt.vecReserve(v, skip, 0); - const it3: rt.Iter = rt.iterSlice(v); + const v2: undefined[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 0, true); + rt.vecReserve(v2, skip, 0); + const it3: rt.Iter = rt.iterSlice(v2); let iterStart2: rt.usize = 0; const iterEnd2: rt.usize = skip; while (iterStart2++ < iterEnd2) { diff --git a/ts/fixtures/lang/expected/sorts.ts b/ts/fixtures/lang/expected/sorts.ts index d73f3f5ba..83ee0f5db 100644 --- a/ts/fixtures/lang/expected/sorts.ts +++ b/ts/fixtures/lang/expected/sorts.ts @@ -730,7 +730,7 @@ export function btrees(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const keys_: rt.u16[] = keys(rt.min([0, 1, 2, 9, 13, 16, 17, 18, 20, 21, 32, 33, 48, 64, 65, 100, 300, 2000, 4096, 4097][_8], 300), dataData, dataStart, dataLen); const _17: rt.Iter> = rt.iterSlice(items$unit_sorts_btrees_closure0(keys_, (): undefined => {})); - put$unit(rt.iterToArray(rt.btreeKeys(rt.btreeCollectKeys(rt.btreeNew(sorts_Item.cmp$cmp_Ord_unit) as rt.BTreeSet>, rt.iterToArray(_17, "next", 4, true), 4, true, sorts_Item.lt$cmp_PartialOrd_unit, sorts_Item.eq$cmp_PartialEq_unit)), undefined, 4, true), out); + put$unit(rt.iterToArray(rt.btreeKeys(rt.btreeCollectKeys(rt.btreeNew(sorts_Item.cmp$cmp_Ord_unit) as rt.BTreeSet>, rt.iterToArray(_17, "next", 4, true, 4), 4, true, sorts_Item.lt$cmp_PartialOrd_unit, sorts_Item.eq$cmp_PartialEq_unit)), undefined, 4, true), out); const _27: rt.Iter<[sorts_Item.Item, rt.u16]> = rt.iterMap(rt.iterSlice(items$unit_sorts_btrees_closure1(keys_, (): undefined => {})), (x: sorts_Item.Item): [sorts_Item.Item, rt.u16] => { return [x, x.tag] as [sorts_Item.Item, rt.u16]; }); diff --git a/ts/fixtures/lang/src/capacity.rs b/ts/fixtures/lang/src/capacity.rs index 11e6b34ce..a577f9cd9 100644 --- a/ts/fixtures/lang/src/capacity.rs +++ b/ts/fixtures/lang/src/capacity.rs @@ -1,10 +1,10 @@ //! The capacity std's `Vec`, `VecDeque`, and `BinaryHeap` hold as each step of a case //! grows, shrinks, remakes, or reads one, of elements of each size its growth tells apart: -//! a byte, at most 1 KiB, past it, and none. std fixes a `Vec`'s and a `BinaryHeap`'s -//! exactly only through steps its doubling decides, such as pushes, `with_capacity`, -//! `reserve`, and `shrink_to`; past any other step, a case checks only what std -//! guarantees. A `VecDeque`'s it checks exactly past every step, as where its slices split -//! depends on it. A `HashMap`'s and a `HashSet`'s it checks only by std's guarantees. +//! a byte, at most 1 KiB, past it, and none. A `Vec`'s and a `BinaryHeap`'s it checks +//! exactly through steps that fix it from what they held, such as pushes, `with_capacity`, +//! `reserve`, `shrink_to`, a clone, `clone_from`, and a `collect` in place, and past a +//! step that shortens one only what std guarantees, as the runtime holds no more. A +//! `VecDeque`'s it checks exactly past every step, as where its slices split depends on it. A `HashMap`'s and a `HashSet`'s it checks only by std's guarantees. use std::collections::{BinaryHeap, HashMap, HashSet, VecDeque}; use std::mem; @@ -108,7 +108,7 @@ fn vec_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec) put(out, v.capacity()); for step in steps.chunks(2) { let (op, arg) = (step[0], step.get(1).copied().unwrap_or(0)); - match op % 25 { + match op % 29 { 0 | 1 => v.push(make(arg)), 2 => { drop(v.pop()); @@ -116,7 +116,7 @@ fn vec_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec) } 3 | 4 => { let additional = amount(arg, v.len(), size); - match op % 25 { + match op % 29 { 3 => v.reserve(additional), _ => v.reserve_exact(additional), } @@ -143,10 +143,8 @@ fn vec_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec) // Not `TrustedLen`, so it reserves only once full, and a `TrustedLen` one. 10 => v.extend((0..arg % 24).filter(|i| i % 3 != 0).map(make)), 11 => v.extend((0..arg % 24).map(make)), - 12 => { - v.extend_from_slice(&[make(arg), make(arg)]); - k.loose(); - } + // Room for the whole slice at once, which pushes would double to past it. + 12 => v.extend_from_slice(&vec![make(arg); usize::from(arg % 24)]), 13 => { v.clear(); k.loose(); @@ -166,13 +164,13 @@ fn vec_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec) } 17 => { v = v.into_boxed_slice().into_vec(); - k.remade(false); + k.remade(true); } // In place of its own, and of its own once read from either end. 18 => { let mut keep = alternate(); v = v.into_iter().filter(|_| keep()).collect(); - k.remade(false); + k.remade(k.exact); } 19 => { let mut it = v.into_iter(); @@ -180,7 +178,7 @@ fn vec_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec) drop(if i % 3 == 2 { it.next_back() } else { it.next() }); } v = it.collect(); - k.remade(false); + k.remade(k.exact); } 20 => { let mut taken = mem::take(&mut v); @@ -203,15 +201,38 @@ fn vec_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec) for _ in 0..arg % 4 { drop(it.next()); } + let exact = k.exact; v = it.clone().collect(); k.remade(true); let rest = it.collect::>(); - Known { exact: false, floor: 0 }.put(out, rest.len(), rest.capacity()); + Known { exact, floor: 0 }.put(out, rest.len(), rest.capacity()); } 24 => { v = vec![make(arg); usize::from(arg % 6)]; k.remade(false); } + 25 => { + drop(v.pop_if(|_| arg % 2 == 1)); + k.loose(); + } + // Joined, with room for exactly what it joins. + 26 => { + v = [v.clone(), v].concat(); + k.remade(true); + } + // A boxed slice's `into_iter` reads a `Vec` with room for exactly its elements. + 27 => { + v = v.into_boxed_slice().into_iter().collect(); + k.remade(true); + } + // Into one with room of its own, which std's keeps where it is enough. + 28 => { + let mut own = Vec::with_capacity(usize::from(arg % 8)); + own.push(make(arg)); + own.clone_from(&v); + v = own; + k.remade(true); + } _ => {} } k.put(out, v.len(), v.capacity()); @@ -370,7 +391,7 @@ pub fn collects(kind: u8, data: &[u8], out: &mut Vec) { // Two `u32`s to one in place, which fit twice as many. 0 => { let halves: Vec = pairs.into_iter().map(|(a, _)| a).collect(); - loose.put(out, halves.len(), halves.capacity()); + exact.put(out, halves.len(), halves.capacity()); } // Bytes in place of bytes, and wider items than bytes, which collect anew. 1 => { @@ -378,7 +399,7 @@ pub fn collects(kind: u8, data: &[u8], out: &mut Vec) { bytes.extend_from_slice(&data[..n.min(data.len())]); exact.put(out, bytes.len(), bytes.capacity()); let odd: Vec = bytes.clone().into_iter().filter(|b| b % 2 == 1).collect(); - loose.put(out, odd.len(), odd.capacity()); + exact.put(out, odd.len(), odd.capacity()); let wide: Vec = bytes.into_iter().map(u16::from).collect(); exact.put(out, wide.len(), wide.capacity()); } diff --git a/ts/fixtures/lang/src/rings.rs b/ts/fixtures/lang/src/rings.rs index 468828b73..fc35fc582 100644 --- a/ts/fixtures/lang/src/rings.rs +++ b/ts/fixtures/lang/src/rings.rs @@ -144,7 +144,8 @@ fn steps(data: &[u8], out: &mut Vec) { /// A deque made anew from `q`: a clone, or one with room of its own cloned into from it, /// collected from its own `into_iter` or a `Vec`'s read in part, or that one's clone, -/// whose buffers std's takes as they are, or from a `Vec` it collects. +/// whose buffers std's takes as they are, or from a `Vec` it collects, directly or through +/// adaptors in place of another. fn remade(q: VecDeque, arg: u8) -> VecDeque { let skip = usize::from(arg / 5) % 4; match arg % 5 { @@ -172,7 +173,18 @@ fn remade(q: VecDeque, arg: u8) -> VecDeque { drop(it.nth(skip)); it.collect() } - 3 => VecDeque::from(q.into_iter().collect::>()), + 3 if arg & 0x20 == 0 => VecDeque::from(q.into_iter().collect::>()), + // Through adaptors in place of a `Vec`, whose buffer std's keeps. + 3 => { + let v: Vec = q.into_iter().collect(); + let mut kept = false; + v.into_iter() + .filter(|_| { + kept = !kept; + kept + }) + .collect() + } _ => { let mut v: Vec = q.into_iter().collect(); v.reserve(skip); diff --git a/ts/fixtures/task/expected/drops/folds.ts b/ts/fixtures/task/expected/drops/folds.ts index 8856084bb..7e659f31c 100644 --- a/ts/fixtures/task/expected/drops/folds.ts +++ b/ts/fixtures/task/expected/drops/folds.ts @@ -194,7 +194,7 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { return g68; }, (): void => { captured56[Symbol.dispose](); - })), "next", 8, true); + })), "next", 8, true, 8); const _176: rt.Iter = rt.iterSlice(guards(4, 7), rt.drop); _1089 = false; const captured57 = d; @@ -221,7 +221,7 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { return g66; }, (): void => { captured54[Symbol.dispose](); - })), "next", 8, true), 8) as rt.VecDeque; + })), "next", 8, true, 8), 8) as rt.VecDeque; const _206: rt.Iter = rt.iterSlice(guards(4, 7), rt.drop); _1089 = false; const captured55 = d; @@ -1473,7 +1473,7 @@ export function closures(log: Log.Log, id: rt.u32): void { g3[Symbol.dispose](); return _06; }); - }), "next", 8); + }), "next", 8, false, 8); const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part2, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug))]; Log.note(log, rt.fmtFormat(["kept ", args2[0]])); const part3 = rt.iterFold(rt.iterFilterMap(rt.iterSlice(guards(1, 7), rt.drop), pick, rt.None), 0, (n3: rt.u32, o2: Guard.Guard | undefined): rt.u32 => { @@ -1728,7 +1728,7 @@ export function zips(log: Log.Log, id: rt.u32, arg: rt.u8): void { return rt.u32Sub(rt.u32Add(x2, Guard.id(captured3)), captured4); }, (): void => { captured3[Symbol.dispose](); - })), "next", 4, true); + })), "next", 4, true, 4); const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(n3, f), (f: rt.Formatter) => rt.fmtOption(at, f, rt.usizeDebug), (f: rt.Formatter) => rt.u32Display(sum, f), (f: rt.Formatter) => rt.usizeDisplay(skipped, f), (f: rt.Formatter) => rt.fmtList(kept, f, rt.u32Debug)]; Log.note(log, rt.fmtFormat(["no coerce ", args8[0], " ", args8[1], " ", args8[2], " ", args8[3], " ", args8[4]])); } else if (arg === 4) { diff --git a/ts/fixtures/task/expected/drops/iters.ts b/ts/fixtures/task/expected/drops/iters.ts index 6555c2d02..d5945be57 100644 --- a/ts/fixtures/task/expected/drops/iters.ts +++ b/ts/fixtures/task/expected/drops/iters.ts @@ -72,7 +72,7 @@ export function looped(log: Log.Log, id: rt.u32): void { v2.push(_105); const even: Guard.Guard[] = rt.iterToArray(rt.iterFilter(rt.iterSlice(v2, rt.drop), (g4: Guard.Guard): boolean => { return rt.u32Rem(Guard.id(g4), 2) === 0; - }, rt.drop), "next", 8); + }, rt.drop), "next", 8, false, 8); const part3 = even.length; const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part3, f)]; Log.note(log, rt.fmtFormat(["even ", args6[0]])); @@ -316,7 +316,7 @@ export function collected(log: Log.Log, id: rt.u32): void { v.push(_18); const _23: Guard.Guard = guard(3); v.push(_23); - const same: Guard.Guard[] = rt.iterToArray(rt.iterSlice(v, rt.drop), "next", 8, true); + const same: Guard.Guard[] = rt.iterToArray(rt.iterSlice(v, rt.drop), "next", 8, true, 8); const v2: Guard.Guard[] = []; const _33: Guard.Guard = guard(4); v2.push(_33); @@ -354,7 +354,7 @@ export function collected(log: Log.Log, id: rt.u32): void { return rt.Ok(g2); } return rt.Err(g2); - }), (values: rt.Iter) => rt.iterToArray(values, "next", 8), lib_drop$Vec_model_Guard); + }), (values: rt.Iter) => rt.iterToArray(values, "next", 8, false, 8), lib_drop$Vec_model_Guard); const part = results.ok; const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part, f)]; Log.note(log, rt.fmtFormat(["result ", args4[0]])); @@ -368,7 +368,7 @@ export function collected(log: Log.Log, id: rt.u32): void { v6.push(_140); const part2 = option_mapOr$0vxyhav(rt.iterCollectOption(rt.iterMap(rt.iterSlice(v6, rt.drop), (g3: Guard.Guard): Guard.Guard | undefined => { return g3; - }), (values: rt.Iter) => rt.iterToArray(values, "next", 8), lib_drop$Vec_model_Guard), 0, (v12: Guard.Guard[]): rt.usize => { + }), (values: rt.Iter) => rt.iterToArray(values, "next", 8, false, 8), lib_drop$Vec_model_Guard), 0, (v12: Guard.Guard[]): rt.usize => { const _06: rt.usize = v12.length; rt.dropAll(v12); return _06; @@ -383,7 +383,7 @@ export function collected(log: Log.Log, id: rt.u32): void { const _172: [rt.u32, Guard.Guard] = [2, guard(18)]; v7.push(_172); const _155: rt.Iter<[rt.u32, Guard.Guard]> = rt.iterSlice(v7, lib_drop$tuple2_u32_model_Guard); - const tree: rt.BTreeMap = rt.btreeCollect(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterToArray(_155, "next", 12, true), 12, true, undefined, undefined, rt.drop); + const tree: rt.BTreeMap = rt.btreeCollect(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterToArray(_155, "next", 12, true, 12), 12, true, undefined, undefined, rt.drop); const part3 = rt.btreeLen(tree); const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part3, f)]; Log.note(log, rt.fmtFormat(["tree ", args8[0]])); @@ -396,7 +396,7 @@ export function collected(log: Log.Log, id: rt.u32): void { const at = rt.idx(same, 0); _2[Symbol.dispose](); return same[at]; - }), "next", 4, true).length; + }), "next", 4, true, 8).length; const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part4, f)]; Log.note(log, rt.fmtFormat(["refs ", args10[0]])); const v9: Guard.Guard[] = []; diff --git a/ts/runtime/rt.ts b/ts/runtime/rt.ts index 6a597149d..b8aae2b35 100644 --- a/ts/runtime/rt.ts +++ b/ts/runtime/rt.ts @@ -840,8 +840,9 @@ export function vecSwapRemove(v: T[], i: number): T { return item; } -/** `Vec::extend_from_slice`: a clone of each element of `s`, pushed in order, as far as they clone. */ -export function vecExtendFromSlice(v: T[], s: ArrayLike, clone?: (item: T) => T): void { +/** `Vec::extend_from_slice` of `size`-byte elements: room reserved for `s`, then a clone of each of its elements pushed in order, as far as they clone. */ +export function vecExtendFromSlice(v: T[], s: ArrayLike, size: number, clone?: (item: T) => T): void { + vecReserve(v, s.length, size); for (let i = 0; i < s.length; i++) v.push(clone === undefined ? s[i] : clone(s[i])); } @@ -1339,6 +1340,21 @@ export function vecShrinkTo(v: T[] & Capped, min: number, size: number): void capSet(v, v.length, capShrink(v.length, vecCapacity(v, size), min), size); } +/** + * `clone`, the clone `clone_from` writes over `v`, with the capacity std's keeps of `v`'s + * for `size`-byte elements: as it was, or grown as `reserve` grows it if it held fewer. + */ +export function vecClonedInto(clone: T[], v: T[] & Capped, size: number): T[] { + capHold(clone, capReserve(0, vecCapacity(v, size), clone.length, size), size); + return clone; +} + +/** `vecClonedInto` of bytes. */ +export function byteVecClonedInto(clone: ByteVec, v: ByteVec): ByteVec { + byteVecReserveExact(clone, capReserve(0, v.data.length, clone.length, 1) - clone.length); + return clone; +} + /** `v`, a new `Vec` of `size`-byte elements, with room for exactly what it holds, as std's `clone` makes one. */ export function vecExact(v: T[], size: number): T[] { capSet(v, v.length, v.length, size); diff --git a/ts/runtime/rt/iter.ts b/ts/runtime/rt/iter.ts index f8d891a7f..d2372a715 100644 --- a/ts/runtime/rt/iter.ts +++ b/ts/runtime/rt/iter.ts @@ -22,7 +22,7 @@ // `owned` functions follow it, dispatching on the kind, so a bundle that never drops an // item carries none of it. -import { ByteSlice, ByteVec, byteVecExtendFromSlice, byteVecPush, byteVecReserve, byteVecWithCapacity, type Capped, capOf, capReserve, capSet, Err, type None, Ok, type Place, panic, place, type RangeBound, type Result, sliceView, vecCapacity, vecExtendFromSlice, vecMax, vecWithCapacity } from "../rt.ts"; +import { ByteSlice, ByteVec, byteVecExtendFromSlice, byteVecPush, byteVecReserve, byteVecReserveExact, byteVecShrinkTo, byteVecWithCapacity, type Capped, capHold, capOf, capReserve, capSet, Err, type None, Ok, type Place, panic, place, type RangeBound, type Result, sliceView, vecCapacity, vecExtendFromSlice, vecMax, vecWithCapacity } from "../rt.ts"; import { AtIndex, BTreeIter, HashIter, type Ordering } from "./collections.ts"; import { type Hasher, hash8 } from "./hash.ts"; import { charStep, intToBig, type Limbs, lt as wideLt, type Step } from "./int.ts"; @@ -563,11 +563,11 @@ export function capNext(it: Iter, len: number, cap: number, size: numbe */ export function slicesJoin(items: readonly V[], size: number, sep?: ArrayLike, slice?: (item: V) => ArrayLike, clone?: (item: T) => T): T[] { const parts = slice === undefined ? (items as unknown as readonly ArrayLike[]) : items.map(slice); - joinedLength(parts, sep, size); - const v: T[] = []; + // std's makes one with room for exactly them. + const v = vecWithCapacity(joinedLength(parts, sep, size), size); for (let i = 0; i < parts.length; i++) { - if (i > 0 && sep !== undefined) vecExtendFromSlice(v, sep, clone); - vecExtendFromSlice(v, parts[i], clone); + if (i > 0 && sep !== undefined) vecExtendFromSlice(v, sep, size, clone); + vecExtendFromSlice(v, parts[i], size, clone); } return v; } @@ -1245,8 +1245,36 @@ export function iterGe(a: Iter, b: Iter, cmp: (x: T, y: U) => Orderi return order !== undefined && order >= 0; } -/** `collect` into a `Vec`, as `iterExtend` of an empty one. */ -export function iterToArray(it: Iter, take?: Take, size?: number, trusted = false): T[] { +/** + * The capacity std's `collect` of `it` into a `Vec` of `size`-byte elements keeps of the + * `Vec` of `src`-byte ones it writes in place of, read before it reads `it`: through + * adaptors, all of its bytes, and of that `Vec`'s own `into_iter`, its buffer while unread + * at the front or at least half full, and else room reserved for what is left. + */ +function keptCapacity(it: Iter, src: number, size: number): number | undefined { + let from: Iter | undefined = it; + while (from !== undefined && !(from instanceof SliceIter)) { + // std's `SourceIter` reads through each adaptor to the iterator it wraps, a zip's first. + const wraps = from as unknown as { inner?: Iter; a?: Iter; outer?: Iter }; + from = wraps.inner ?? wraps.a ?? wraps.outer; + } + if (from === undefined) return undefined; + const s = from.s as ArrayLike & Capped; + const cap = s instanceof Uint8Array ? s.length : vecCapacity(s as unknown[] & Capped, src); + if (from !== it) return Math.floor((cap * src) / size); + const left = from.back - from.front; + return from.front === 0 || left >= Math.floor(cap / 2) ? cap : capReserve(0, 0, left, size); +} + +/** `collect` into a `Vec`, as `iterExtend` of an empty one, in place of a `Vec` of `src`-byte elements if given. */ +export function iterToArray(it: Iter, take?: Take, size?: number, trusted = false, src?: number): T[] { + const kept = src === undefined || size === undefined ? undefined : keptCapacity(it, src, size); + const out = toArray(it, take, size, trusted); + if (kept !== undefined) capHold(out, kept, size!); + return out; +} + +function toArray(it: Iter, take?: Take, size?: number, trusted = false): T[] { if (size !== undefined && !trusted) { const out: T[] = []; let cap = capOf(0, undefined, size); @@ -1269,8 +1297,16 @@ export function iterToArray(it: Iter, take?: Take, size?: number, trusted return out; } -/** `collect` into a `Vec`, as `iterExtendBytes` of an empty one. */ -export function iterToByteVec(it: Iter, take?: Take, trusted = false): ByteVec { +/** `collect` into a `Vec`, as `iterExtendBytes` of an empty one, in place of a `Vec` of `src`-byte elements if given. */ +export function iterToByteVec(it: Iter, take?: Take, trusted = false, src?: number): ByteVec { + const kept = src === undefined ? undefined : keptCapacity(it, src, 1); + const out = toByteVec(it, take, trusted); + if (kept !== undefined && kept > out.data.length) byteVecReserveExact(out, kept - out.length); + else if (kept !== undefined && kept < out.data.length) byteVecShrinkTo(out, kept); + return out; +} + +function toByteVec(it: Iter, take?: Take, trusted = false): ByteVec { // Its own loops: through `iterExtendBytes`, JavaScriptCore took 1.9x as long. if (!trusted) { const out = new ByteVec(); diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index 6f06fcaf7..0b9d08fa2 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -124,8 +124,16 @@ pub fn into_iter<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr, sp unboxed if unboxed != ty => (unboxed, b.t.pointee_value(ty, value)), _ => (ty, value), }; - // A boxed slice owns its elements, as the `Vec` std's `into_iter` makes of it does. - let ty = library::box_slice(tcx, ty).map_or(ty, |elem| Ty::new_slice(tcx, elem)); + // A boxed slice owns its elements, as the `Vec` std's `into_iter` makes of it does, with + // room for exactly them. + let (ty, value) = match library::box_slice(tcx, ty) { + Some(elem) if !matches!(elem.kind(), ty::Uint(ty::UintTy::U8)) => { + let size = size_of(b, elem, span); + (Ty::new_slice(tcx, elem), Expr::rt("vecExact", vec![value, size])) + } + Some(elem) => (Ty::new_slice(tcx, elem), value), + None => (ty, value), + }; let owned = !ty.is_ref(); if b.t.iter_item(ty).is_some() { not_bound(b, ty, span); @@ -1263,11 +1271,14 @@ fn collect<'tcx>( if let Some(elem) = elem { let v = match elem.kind() { ty::Uint(ty::UintTy::U8) => { - let (folds, by_index) = collect_folds(b, from, elem, span); + let (folds, by_index, src) = collect_folds(b, from, elem, span); let take = iter_take(b, from, folds, span); Expr::rt( "iterToByteVec", - tail(vec![iter], vec![take, Expr::lit((trusted || by_index).to_string())]), + tail( + vec![iter], + vec![take, Expr::lit((trusted || by_index).to_string()), src_size(src)], + ), ) } _ => to_array(b, iter, from, elem, trusted, span), @@ -1446,18 +1457,24 @@ pub(super) fn to_array<'tcx>( trusted: bool, span: Span, ) -> Expr { - let (folds, by_index) = collect_folds(b, from, elem, span); + let (folds, by_index, src) = collect_folds(b, from, elem, span); let take = iter_take(b, from, folds, span); let size = size_of(b, elem, span); Expr::rt( "iterToArray", tail( vec![iter], - vec![take, size, Expr::lit((trusted || by_index).to_string())], + vec![take, size, Expr::lit((trusted || by_index).to_string()), src_size(src)], ), ) } +/// The size of the elements of the `Vec` a `collect` writes in place of, which the runtime +/// keeps the capacity of as std's does, or `undefined`. +fn src_size(src: Option) -> Expr { + src.map_or_else(Expr::undefined, |size| Expr::lit(size.to_string())) +} + /// Whether std's `collect` of an iterator of type `from` into a `Vec` folds it, and /// whether by index, reading no item past its length. In place of the `Vec` its items come /// from, it reads a `TrustedRandomAccessNoCoerce` one by index and any other by `try_fold`, @@ -1465,11 +1482,17 @@ pub(super) fn to_array<'tcx>( /// `next` reads a side once past the other: that one folds, its length reserved as a /// `TrustedLen` one's, and is refused if it holds values that drop, which its `fold` drops /// as each fold ends. Elsewhere, it folds a `TrustedLen` one by its own `fold`, which drops -/// them first, and reads any other by `next`. -fn collect_folds<'tcx>(b: &mut Body<'_, '_, 'tcx>, from: Ty<'tcx>, elem: Ty<'tcx>, span: Span) -> (bool, bool) { - if !in_place(b.t, from, elem) { - return (implements(b.t, from, "TrustedLen"), false); - } +/// them first, and reads any other by `next`. Last, the size of the elements of the `Vec` +/// it writes in place of, if it does. +fn collect_folds<'tcx>( + b: &mut Body<'_, '_, 'tcx>, + from: Ty<'tcx>, + elem: Ty<'tcx>, + span: Span, +) -> (bool, bool, Option) { + let Some(src) = in_place(b.t, from, elem) else { + return (implements(b.t, from, "TrustedLen"), false, None); + }; let zips = from.walk().filter_map(|arg| arg.as_type()).any(|t| { matches!(t.kind(), ty::Adt(adt, _) if library::std_path(b.t.tcx, adt.did()).last().map(String::as_str) == Some("Zip")) }); @@ -1482,20 +1505,20 @@ fn collect_folds<'tcx>(b: &mut Body<'_, '_, 'tcx>, from: Ty<'tcx>, elem: Ty<'tcx ), ); } - (by_index, by_index) + (by_index, by_index, Some(src)) } -/// Whether std's `collect` of an iterator of type `iter` into a `Vec` writes in place -/// of the `Vec` its items come from, as its adaptors let it where each item's layout leaves -/// room. -fn in_place<'tcx>(t: &Translator<'_, 'tcx>, iter: Ty<'tcx>, elem: Ty<'tcx>) -> bool { +/// The size of the elements of the `Vec` std's `collect` of an iterator of type `iter` into +/// a `Vec` writes in place of, if it does, as its adaptors let it where each item's +/// layout leaves room. +fn in_place<'tcx>(t: &Translator<'_, 'tcx>, iter: Ty<'tcx>, elem: Ty<'tcx>) -> Option { let tcx = t.tcx; let env = t.typing_env_pub(); let (Some(steps), Some(source)) = (core_trait(tcx, "InPlaceIterable"), core_trait(tcx, "SourceIter")) else { - return false; + return None; }; if !implements(t, iter, "InPlaceIterable") || !implements(t, iter, "SourceIter") { - return false; + return None; } let assoc = |tr: DefId, name: &str| { tcx.associated_items(tr) @@ -1504,18 +1527,16 @@ fn in_place<'tcx>(t: &Translator<'_, 'tcx>, iter: Ty<'tcx>, elem: Ty<'tcx>) -> b .map(|item| item.def_id) }; // `::Source`, a `vec::IntoIter` of what it collects in place of. - let Some(src) = assoc(source, "Source").and_then(|item| { + let src = assoc(source, "Source").and_then(|item| { let projection = Ty::new_projection(tcx, ty::IsRigid::No, item, [iter]); tcx.try_normalize_erasing_regions(env, ty::Unnormalized::new_wip(projection)) .ok() - }) else { - return false; - }; + })?; let ty::Adt(adt, src_args) = src.kind() else { - return false; + return None; }; if library::std_path(tcx, adt.did()) != ["vec", "into_iter", "IntoIter"] { - return false; + return None; } // `MERGE_BY` and `EXPAND_BY`: how many source items make how many it collects, if known. let step = |name: &str| -> Option { @@ -1525,19 +1546,20 @@ fn in_place<'tcx>(t: &Translator<'_, 'tcx>, iter: Ty<'tcx>, elem: Ty<'tcx>) -> b Some(value.try_to_scalar_int()?.to_bits_unchecked()) }; let (Some(merge), Some(expand)) = (step("MERGE_BY"), step("EXPAND_BY")) else { - return false; + return None; }; let layout = |ty: Ty<'tcx>| tcx.layout_of(env.as_query_input(ty)).ok(); let (Some(from), Some(to)) = (layout(src_args.type_at(0)), layout(elem)) else { - return false; + return None; }; // As std's `in_place_collectible`, where `None`, an overflow, is 0. - !from.is_zst() + (!from.is_zst() && !to.is_zst() && from.align.abi == to.align.abi && merge > 0 && expand > 0 - && u128::from(from.size.bytes()) * merge >= u128::from(to.size.bytes()) * expand + && u128::from(from.size.bytes()) * merge >= u128::from(to.size.bytes()) * expand) + .then_some(from.size.bytes()) } /// Whether the crate's own `Ord` of `ty` has its own `max` or `min`, by `name`, which diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index 233cf5007..1fa9c708b 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -1421,7 +1421,7 @@ fn mapping<'tcx>( if let Some(elem) = box_slice(tcx, from) && b.t.std_of(to) == Some(Std::Vec) { - return Some(boxed_vec(value, elem)); + return Some(boxed_vec(b, value, elem, span)); } // A heap's `Vec` is its elements. if let ty::Adt(adt, args) = from.kind() @@ -2071,7 +2071,7 @@ fn mapping<'tcx>( super::iter::tail(vec![items, compare], vec![Expr::undefined(), drop]), ) } - ("slice", "into_vec") => boxed_vec(args.pop()?, targ(gargs, 0)), + ("slice", "into_vec") => boxed_vec(b, args.pop()?, targ(gargs, 0), span), ("Vec", "into_boxed_slice") => vec_boxed(args.pop()?, targ(gargs, 0)), // `vec![a, b]`'s array once `mir::vec` took the box away. A `Copy` aggregate's operand // may be shared with where it came from, which the vector must not change. @@ -2156,6 +2156,7 @@ fn mapping<'tcx>( ("Vec", "extend_from_slice") if is_u8(targ(gargs, 0)) => Expr::rt("byteVecExtendFromSlice", args), ("Vec", "extend_from_slice") => { let mut values = args; + values.push(super::iter::size_of(b, targ(gargs, 0), span)); let clone = super::collections::clone_fn(b, targ(gargs, 0), span); if !matches!(&clone, Expr::Lit(l) if l == "undefined") { values.push(clone); @@ -2759,11 +2760,30 @@ pub(super) fn vec_boxed(v: Expr, elem: Ty<'_>) -> Expr { } } -/// The `Vec` that a `Box<[elem]>`, `boxed`, becomes, as `into_vec` makes it. -fn boxed_vec(boxed: Expr, elem: Ty<'_>) -> Expr { +/// `clone`, the `Vec` that `clone_from` writes over `target`, with the capacity std's +/// keeps of `target`'s. +pub(super) fn vec_cloned_into<'tcx>( + b: &mut Body<'_, '_, 'tcx>, + clone: Expr, + target: Expr, + elem: Ty<'tcx>, + span: Span, +) -> Expr { + match elem.kind() { + ty::Uint(ty::UintTy::U8) => Expr::rt("byteVecClonedInto", vec![clone, target]), + _ => Expr::rt( + "vecClonedInto", + vec![clone, target, super::iter::size_of(b, elem, span)], + ), + } +} + +/// The `Vec` that a `Box<[elem]>`, `boxed`, becomes, as `into_vec` makes it, with room +/// for exactly its elements. +fn boxed_vec<'tcx>(b: &mut Body<'_, '_, 'tcx>, boxed: Expr, elem: Ty<'tcx>, span: Span) -> Expr { match elem.kind() { ty::Uint(ty::UintTy::U8) => Expr::rt("byteSliceToByteVec", vec![boxed]), - _ => boxed, + _ => Expr::rt("vecExact", vec![boxed, super::iter::size_of(b, elem, span)]), } } diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index b7b0badca..3067377e8 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -565,6 +565,13 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let clone = self .b .call_def(clone, tcx.mk_args(&[ty.into()]), vec![source], span, out); + // std's `Vec` keeps the target's buffer, grown if it holds fewer. + let clone = match ty.kind() { + ty::Adt(_, args) if self.b.t.std_of(ty) == Some(Std::Vec) => { + library::vec_cloned_into(self.b, clone, place.0.clone(), args.type_at(0), span) + } + _ => clone, + }; let drops = self.b.t.drops(ty); let old = self.swap_out(place, ty, clone, drops.then_some("old"), span, out); if drops && let Some(drop) = self.b.t.drop_value(old, ty, span) { From 55738827700e8e5554be13e6bbc57cb9959df616 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Mon, 2 Nov 2026 12:08:48 -0800 Subject: [PATCH 10/10] chore(ts): update snapshots for the merge Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/expected/elements.ts | 2 +- ts/fixtures/lang/expected/harness.ts | 11 +++++++---- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/ts/fixtures/lang/expected/elements.ts b/ts/fixtures/lang/expected/elements.ts index 179126a4b..9e79c751b 100644 --- a/ts/fixtures/lang/expected/elements.ts +++ b/ts/fixtures/lang/expected/elements.ts @@ -117,7 +117,7 @@ export function segments(data: rt.ByteSlice, out: rt.ByteVec): void { const one: rt.Place = rt.sliceAsPtr(a, 2); one.v = one.v ^ 15; rt.byteVecPush(out, one.v); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); segment[Symbol.dispose](); } diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 7fd1ea045..4616ae1b2 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -50,6 +50,7 @@ import { lists as pointers_lists, shared as pointers_shared, places as pointers_ import { refs, toRefs, adapted as refs_adapted, compared } from "./refs.ts"; import { results as results_results } from "./results.ts"; import { returns } from "./returns.ts"; +import { slices as rings_slices } from "./rings.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"; import { copies as shapes_copies, order as shapes_order, discriminants, loops, patterns, uninhabited, closures as shapes_closures, library, flows } from "./shapes.ts"; @@ -300,12 +301,14 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) hashes_own(data106, out107); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["refs::compared", (a0159: rt.u8, a1159: rt.ByteSlice, a2159: rt.ByteVec): undefined => { compared(a0159, a1159.data, a1159.start, a1159.length, a2159); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["rings::slices", (a0160: rt.u8, a1160: rt.ByteSlice, a2160: rt.ByteVec): undefined => { + rings_slices(a0160, a1160.data, a1160.start, a1160.length, a2160); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::objects", (_2207: rt.u8, data107: rt.ByteSlice, out108: rt.ByteVec): undefined => { fmt_objects(data107, out108); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["sorts::sorts", (a0160: rt.u8, a1160: rt.ByteSlice, a2160: rt.ByteVec): undefined => { - sorts(a0160, a1160.data, a1160.start, a1160.length, a2160); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["sorts::disorders", disorders as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["sorts::btrees", (a0162: rt.u8, a1162: rt.ByteSlice, a2162: rt.ByteVec): undefined => { - sorts_btrees(a0162, a1162.data, a1162.start, a1162.length, a2162); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["sorts::sorts", (a0161: rt.u8, a1161: rt.ByteSlice, a2161: rt.ByteVec): undefined => { + sorts(a0161, a1161.data, a1161.start, a1161.length, a2161); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["sorts::disorders", disorders as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["sorts::btrees", (a0163: rt.u8, a1163: rt.ByteSlice, a2163: rt.ByteVec): undefined => { + sorts_btrees(a0163, a1163.data, a1163.start, a1163.length, a2163); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; }