diff --git a/quest/m2/ts-model/README.md b/quest/m2/ts-model/README.md index 226ba89f7..5e018e4a3 100644 --- a/quest/m2/ts-model/README.md +++ b/quest/m2/ts-model/README.md @@ -46,5 +46,4 @@ Public API: the translator's output for moq-net's model. ## Required -- [The rest of std the model reaches](/quest/m2/ts-model/std-rest.md) - `Vec` and `VecDeque` capacity - [hashbrown as the runtime's map](/quest/m2/ts-model/hashbrown.md) - hashlink's `hashbrown` tables translate as `rt.HashMap`, with std's capacity diff --git a/quest/m2/ts-model/hashbrown.md b/quest/m2/ts-model/hashbrown.md index de552b951..8aae1c57b 100644 --- a/quest/m2/ts-model/hashbrown.md +++ b/quest/m2/ts-model/hashbrown.md @@ -15,13 +15,10 @@ being what JS has no counterpart of. - Map it as std's map is: std's `HashMap` is hashbrown's, so the same runtime functions stand in for both, with no config. -- `capacity` follows hashbrown's `capacity_to_buckets` and `allocation_size` exactly, as - [the rest of std](/quest/m2/ts-model/std-rest.md) decided for `Vec`'s capacity. +- `capacity` follows hashbrown's `capacity_to_buckets` and `allocation_size` exactly. + Open: a `Vec`'s follows only std's guarantees and doubles as it grows (decided + 2026-11-01), so whether a map's must be exact is the maintainer's call. - `HashTable`'s methods take the hash and the equality from the caller, so it needs a table keyed by the caller's hash, not the runtime's own. Public API: the translator's output. - -## Required - -- [The rest of std the model reaches](/quest/m2/ts-model/std-rest.md) - std's exact capacity, which hashbrown's growth reuses diff --git a/quest/m2/ts-model/std-rest.md b/quest/m2/ts-model/std-rest.md deleted file mode 100644 index cff1ad2bf..000000000 --- a/quest/m2/ts-model/std-rest.md +++ /dev/null @@ -1,29 +0,0 @@ -# [M] The rest of std the model reaches - -## Goal - -rust2-ts translates the std calls the model's census still refuses outside other quests: -`Vec`'s and `VecDeque`'s `capacity`, `reserve`, and `shrink_to`, and `String::with_capacity`, -proven by differential tests against native Rust. - -## Plan - -Left by [#168](https://github.com/moq-dev/rust2/pull/168) on 2026-10-28, which translated -the rest of what the census refused in std. Decided with the maintainer on 2026-10-28: - -- **Capacity: std's exact growth, everywhere.** moq-net reads `capacity` to decide when to - prune (`cache.rs`'s `hold_head`, `resume.rs`'s readers) and bills `VecDeque` growth by - it (`group.rs`), so a capacity other than std's changes what it does. Every `Vec` and - `VecDeque` carries std's capacity (`RawVec::grow_amortized`, its minimum non-zero - capacity by element size, `with_capacity` exact, `shrink_to`, and what `collect` and - `clone` allocate), through every runtime function that allocates. Measure push cost on - the TS benchmark before and after. -- An extend reserves by the size hint only once the collection is full, so its `capacity - overflow` depends on capacity. Until it is modeled, `rt.vecCapacity` takes every `Vec`, - `VecDeque`, and `BinaryHeap` an extend starts from as full, which is std's for one - `Vec::new`, `vec!`, or a `TrustedLen` collect made, but not after a `reserve` or `pop`: - replace it with the real capacity. -- `RandomState` and `BuildHasher::hash_one` landed first, in - [#261](https://github.com/moq-dev/rust2/pull/261), for hashbrown's default hasher. - -Public API: the translator's output. diff --git a/quest/m3/README.md b/quest/m3/README.md index 05b305a08..e391a5e39 100644 --- a/quest/m3/README.md +++ b/quest/m3/README.md @@ -32,6 +32,7 @@ generic std gap is planned here even when moq never calls it. - [A B-tree's searches call Ord as std's do](/quest/m3/ts-btree-search-order.md) - a B-tree's lookups and inserts call a key's own `Ord` in std's order and number - [Rc and Arc of a slice](/quest/m3/ts-shared-slices.md) - `Rc<[T]>` and `Arc<[T]>` from a `Vec`, a slice, or an iterator translate - [The rest of a boxed slice's impls](/quest/m3/ts-boxed-slice-rest.md) - `clone_from`, `AsRef`, `AsMut`, `TryFrom` into a boxed array, and `Box` into bytes translate for boxed slices +- [The rest of a vector's methods](/quest/m3/ts-vec-rest.md) - `append`, `resize`, `split_off`, `try_reserve`, and `Vec::from(VecDeque)` translate - [The rest of a guard's methods](/quest/m3/ts-guard-rest.md) - `Debug` of `RefCell` and `RwLock` guards, `MutexGuard::map`, and the guards' `try_map` translate - [Aborts in the differential](/quest/m3/ts-abort-differential.md) - the lang differential compares wasm32's aborts, so an `RwLock` locked again while held is tested - [A reversed zip's per-pair cost](/quest/m3/ts-zip-rev-overhead.md) - a reversed by-index zip costs per pair what a forward one does, or the gap is explained diff --git a/quest/m3/ts-buf-mut-forward.md b/quest/m3/ts-buf-mut-forward.md index e9f83c49b..a4ae859f6 100644 --- a/quest/m3/ts-buf-mut-forward.md +++ b/quest/m3/ts-buf-mut-forward.md @@ -16,7 +16,7 @@ moq-net's census reaches none of them, so this is m3 under the all-of-std decisi - Mapping them as the buffer's own methods is the likely shape, but the provided bodies grow through `chunk_mut`, which reserves 64 bytes when full, where `Vec`'s and `BytesMut`'s overrides reserve what they write. Match the provided body's capacity once - capacity is exact ([std's capacity](/quest/m2/ts-model/std-rest.md), - [`BytesMut`'s](/quest/m3/ts-bytes-capacity.md)), not the override's. + `BytesMut`'s capacity is exact ([`BytesMut`'s](/quest/m3/ts-bytes-capacity.md)), not the + override's. Public API: the translator's output. diff --git a/quest/m3/ts-deque-slices.md b/quest/m3/ts-deque-slices.md index 456c26621..89405b040 100644 --- a/quest/m3/ts-deque-slices.md +++ b/quest/m3/ts-deque-slices.md @@ -20,11 +20,10 @@ the rest of std's iterators' `Debug`. 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. - -## Required - -- [The rest of std the model reaches](/quest/m2/ts-model/std-rest.md) - `VecDeque` carries std's capacity, which the split depends on diff --git a/quest/m3/ts-vec-rest.md b/quest/m3/ts-vec-rest.md new file mode 100644 index 000000000..56f4ea908 --- /dev/null +++ b/quest/m3/ts-vec-rest.md @@ -0,0 +1,23 @@ +# [M] The rest of a vector's methods + +## Goal + +[rust2-ts](/ts/README.md) translates the `Vec` and `VecDeque` methods still refused, each +holding what std guarantees of its capacity, proven by differential tests against native +Rust. + +## Plan + +Found carrying capacity through every vector: these have no mapping, and std's bodies move +elements through raw pointers, so each refuses with its span: + +- `Vec::append`, `resize`, `resize_with`, `split_off`, `extend_from_within`, and + `try_reserve`, and `VecDeque`'s `append`, `resize`, and `split_off`. +- `From>` for `Vec`. + +A vector's capacity follows only std's guarantees, at least its length and what +`with_capacity` and `reserve` ask for, and doubles as it grows (decided with the +maintainer on 2026-11-01). No consumer calls them yet; they are planned here as part of +std. + +Public API: the translator's output. diff --git a/ts/MIGRATE.md b/ts/MIGRATE.md index 78ffbf364..439d9cade 100644 --- a/ts/MIGRATE.md +++ b/ts/MIGRATE.md @@ -2,6 +2,11 @@ ## 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. - 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 339c92e72..52da3d1c6 100644 --- a/ts/README.md +++ b/ts/README.md @@ -268,8 +268,7 @@ std's adaptors through `rt.iterFrom`. A caller calls `next()` for one item, or i an `rt.Iter` with `for ... of`. Each `rt.Iter`'s `sizeHint` is std's `size_hint`, its upper bound `undefined` for `None`, and a `collect` or `extend` into a `Vec`, `VecDeque`, `BinaryHeap`, B-tree, or hash collection reserves by it where std's does, panicking with -std's capacity overflow past the most it holds. Capacity isn't modeled, so a collection -an `extend` starts from is taken as full. A tuple of these, of `String`s, `()`, or such +std's capacity overflow past the most it holds. A tuple of these, of `String`s, `()`, or such tuples, collects, unzips, and extends as std's tuple impls do: a 1-tuple's collection by its own `extend`, and a longer one's each reserving the lower bound, in field order, before each item's fields go into them in order, as `rt.tupleExtend(t, it, [rt.vecPart(2), @@ -743,7 +742,14 @@ they need. and Chrome; 64 keys a node measured best of 16 to 128. A hash map's JS primitive keys are a JS `Map`'s, the engine's own hash table; its other keys go into a second `Map` by their translated hash, chained by `Eq`. `VecDeque` is a ring buffer over an array - whose length is a power of two. A `LinkedList` is nodes linked both ways, as std's are, + whose length is a power of two. A `Vec`, `VecDeque`, 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. 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 + `Vec`'s is its buffer's length. A `LinkedList` is nodes linked both ways, as std's are, so `append` is O(1) and `split_off` walks from the nearer end; each node is the place `iter_mut` and `front_mut` lend of an item JS copies. Dropping a whole map or set drops its entries in the runtime's order, keys' for a B-tree, not std's node by node: std leaves that order @@ -803,7 +809,7 @@ an iterator adaptor, and values that drop in some iterators ([drop order](/quest function without a mapping of its own that makes or reads an `Option` whose `None` is `rt.None`, as `Iterator::scan` of `Option`s does, an `Option` of an `Option` of `()` or another `Option`, an instance of a generic type whose field is an `Option` of a type parameter -that can be `undefined`, a collection's `capacity`, looking up a key by +that can be `undefined`, a `String`'s or hash collection's `capacity`, looking up a key by another type it borrows as through the crate's own `Borrow`, a `&mut` to a value JS copies that std makes, other than a map's, or hands a closure, as `iter_mut` and `and_modify` do, one into a `Result`'s payload passed on or kept, `Hasher::write` of bytes, the adaptors diff --git a/ts/bench/moq.ts b/ts/bench/moq.ts index b677dc48b..bfe4b3527 100644 --- a/ts/bench/moq.ts +++ b/ts/bench/moq.ts @@ -14,6 +14,7 @@ import * as Varint from "moq/js/net/src/varint.ts"; import { iterate } from "./iter.ts"; import { order } from "./order.ts"; +import { push } from "./push.ts"; import { rescale } from "./rescale.ts"; import { ordered } from "./sorted.ts"; import { interleave, stamp } from "./timestamp.ts"; @@ -62,6 +63,8 @@ export function run(input: Uint8Array): Uint8Array | Promise { return interleave(data); case 12: return order(selector, data); + case 13: + return push(data); default: throw new Error(`unknown workload ${op}`); } diff --git a/ts/bench/push.ts b/ts/bench/push.ts new file mode 100644 index 000000000..6f712ffea --- /dev/null +++ b/ts/bench/push.ts @@ -0,0 +1,16 @@ +// The `push/` workloads' hand-written route: `bench.rs`'s op 13, as TypeScript grows a +// list: `push` onto an array, for a `VecDeque` too, as JS has no deque. + +/** Run op 13, as `bench::run` does, for the count `data` starts with. */ +export function push(data: Uint8Array): Uint8Array { + const padded = new Uint8Array(8); + padded.set(data.subarray(0, 8)); + const count = Math.min(Number(new DataView(padded.buffer).getBigUint64(0)), 1 << 16); + const v: number[] = []; + for (let i = 0; i < count; i++) v.push(i); + const out = new Uint8Array(16); + const view = new DataView(out.buffer); + view.setBigUint64(0, BigInt(v.length)); + view.setBigUint64(8, BigInt(v[v.length >> 1] ?? 0)); + return out; +} diff --git a/ts/bench/workloads.ts b/ts/bench/workloads.ts index 8bd36a709..953648da0 100644 --- a/ts/bench/workloads.ts +++ b/ts/bench/workloads.ts @@ -5,7 +5,7 @@ export interface Workload { /** What is coded, such as `varint/quic/2B` or `frames/video/lite-07`, iterated, or converted. */ name: string; - op: "encode" | "decode" | "iterate" | "map" | "convert" | "add" | "compare" | "order" | "handoff"; + op: "encode" | "decode" | "iterate" | "map" | "convert" | "add" | "compare" | "order" | "push" | "handoff"; /** Varints, frame headers, messages, items, keys, timestamps, integers, or handoffs per call, which each time is divided by. */ items: number; input: Uint8Array; @@ -99,6 +99,11 @@ export function workloads(encode: (input: Uint8Array) => Uint8Array): Workload[] orders.forEach((name, selector) => { out.push({ name: `order/${name}`, op: "order", items: count, input: Uint8Array.of(12, selector, ...u64(BigInt(count))) }); }); + + // `bench.rs`'s op 13: pushes, which grow a vector by std's capacity. + ["vec", "deque"].forEach((name, selector) => { + out.push({ name: `push/${name}`, op: "push", items: count, input: Uint8Array.of(13, selector, ...u64(BigInt(count))) }); + }); return out; } diff --git a/ts/fixtures/codec/expected/bench.ts b/ts/fixtures/codec/expected/bench.ts index eca36456d..f0c14e951 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -9,7 +9,7 @@ import type * as EncodeError from "./coding/encode.EncodeError.ts"; import * as Encoder from "./coding/encode.Encoder.ts"; import { zigzag as varint_zigzag, unzigzag } from "./coding/varint.ts"; import * as Form from "./coding/varint.Form.ts"; -import { unwrapOr$11c0we2 as option_unwrapOr$11c0we2, map$1cf8u0y as option_map$1cf8u0y } from "./core/option.ts"; +import { unwrapOr$11c0we2 as option_unwrapOr$11c0we2, map$1cf8u0y as option_map$1cf8u0y, mapOr$1jt76jv as option_mapOr$1jt76jv } from "./core/option.ts"; import { form, liteVersion, putU64 as harness_putU64, putUsize, takeU64, decodeError, encodeError } from "./harness.ts"; import * as Group from "./lite/group.Group.ts"; import type * as lite_version_Version from "./lite/version.Version.ts"; @@ -45,6 +45,8 @@ export function run(input: rt.ByteSlice): rt.ByteVec { interleave(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (op === 12) { order(selector, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + } else if (op === 13) { + push(selector, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else { decoded(decodeGroup(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), liteVersion(selector), out), out); } @@ -384,6 +386,40 @@ export function order(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi } } +/** + * `count` integers pushed onto a `Vec`, or a `VecDeque` if `selector` is 1: its length + * and middle item. + */ +export function push(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + let _13!: [rt.usize, rt.u32 | undefined]; + let _18!: rt.u32; + 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; + let iterStart: rt.u32 = 0; + const iterEnd: rt.u32 = count2; + while ((_18 = iterStart++) < iterEnd) { + rt.dequePushBack(q, _18); + } + _13 = [q.n, rt.dequeGet(q, rt.usizeDiv(q.n, 2))] as [rt.usize, rt.u32 | undefined]; + } else { + const v: rt.u32[] = []; + let iterStart2: rt.u32 = 0; + const iterEnd2: rt.u32 = count2; + while ((_37 = iterStart2++) < iterEnd2) { + v.push(_37); + } + _13 = [v.length, rt.sliceGet(v, rt.usizeDiv(v.length, 2))] as [rt.usize, rt.u32 | undefined]; + } + const len: rt.usize = _13[0]; + const middle: rt.u32 | undefined = _13[1]; + putUsize(out, len); + harness_putU64(out, option_mapOr$1jt76jv(middle, 0, (a0: rt.u32): rt.u64 => { + return a0 as rt.u64; + })); +} + /** * One iterator chain over every byte, picked by `chain`, with closures that cost little * next to the iterator protocol they run through. diff --git a/ts/fixtures/codec/expected/coding/version.Versions.ts b/ts/fixtures/codec/expected/coding/version.Versions.ts index 897ece610..a7ca70ff4 100644 --- a/ts/fixtures/codec/expected/coding/version.Versions.ts +++ b/ts/fixtures/codec/expected/coding/version.Versions.ts @@ -76,7 +76,7 @@ export function encode$coding_encode_Encode_lite_version_Version(self: Versions, } export function from$convert_From_array2_coding_version_Version(vs: coding_version_Version.Version[]): Versions { - return { _0: vs.slice() }; + return { _0: rt.vecExact(vs.slice(), 8) }; } //# sourceMappingURL=version.Versions.ts.map diff --git a/ts/fixtures/codec/expected/core/option.ts b/ts/fixtures/codec/expected/core/option.ts index 0a87147b4..efb225183 100644 --- a/ts/fixtures/codec/expected/core/option.ts +++ b/ts/fixtures/codec/expected/core/option.ts @@ -24,6 +24,13 @@ export function map$1cf8u0y(self: rt.u64 | undefined, f: (a0: rt.u64) => rt.u64) return f(self); } +export function mapOr$1jt76jv(self: rt.u32 | undefined, default_: rt.u64, _: (a0: rt.u32) => rt.u64): rt.u64 { + if (self === undefined) { + return default_; + } + return self as rt.u64; +} + export function okOr$1lamf4s(self: rt.u64 | undefined, err: EncodeError.EncodeError): rt.Result { if (self === undefined) { return rt.Err(err); diff --git a/ts/fixtures/codec/src/bench.rs b/ts/fixtures/codec/src/bench.rs index dd5ed9ea0..52b1cf976 100644 --- a/ts/fixtures/codec/src/bench.rs +++ b/ts/fixtures/codec/src/bench.rs @@ -4,11 +4,11 @@ //! decode's input. Op 6 runs iterator chains over its bytes instead, as moq-net's model //! writes them, op 7 decodes frame headers as they arrive a few bytes at a time, op 8 //! keeps a `BTreeMap`, as moq-net's model keeps its state, op 9 converts timestamps -//! between timescales, ops 10 and 11 add and order them as moq-net's `Timestamp` does, and -//! op 12 orders integers by std's own `Ord`. +//! between timescales, ops 10 and 11 add and order them as moq-net's `Timestamp` does, +//! op 12 orders integers by std's own `Ord`, and op 13 pushes onto vectors. use std::cmp::Ordering; -use std::collections::{BTreeMap, BTreeSet, BinaryHeap}; +use std::collections::{BTreeMap, BTreeSet, BinaryHeap, VecDeque}; use crate::coding::{Decode, DecodeError, Decoder, Encode, EncodeError, Encoder, Form, varint}; use crate::harness::{decode_error, encode_error, form, lite_version, put_u64, put_usize, take_u64}; @@ -37,6 +37,7 @@ pub fn run(input: &[u8]) -> Vec { 10 => stamp(data, &mut out), 11 => interleave(data, &mut out), 12 => order(selector, data, &mut out), + 13 => push(selector, data, &mut out), _ => decoded(decode_group(data, lite_version(selector), &mut out), &mut out), } out @@ -252,6 +253,31 @@ fn order(selector: u8, data: &[u8], out: &mut Vec) { } } +/// `count` integers pushed onto a `Vec`, or a `VecDeque` if `selector` is 1: its length +/// and middle item. +fn push(selector: u8, data: &[u8], out: &mut Vec) { + let (count, _) = take_u64(data); + let count = count.min(1 << 16) as u32; + let (len, middle) = match selector { + 1 => { + let mut q = VecDeque::new(); + for i in 0..count { + q.push_back(i); + } + (q.len(), q.get(q.len() / 2).copied()) + } + _ => { + let mut v = Vec::new(); + for i in 0..count { + v.push(i); + } + (v.len(), v.get(v.len() / 2).copied()) + } + }; + put_usize(out, len); + put_u64(out, middle.map_or(0, u64::from)); +} + /// One iterator chain over every byte, picked by `chain`, with closures that cost little /// next to the iterator protocol they run through. fn iterate(chain: u8, data: &[u8], out: &mut Vec) { diff --git a/ts/fixtures/lang/caller.ts b/ts/fixtures/lang/caller.ts index 73c9b4d74..8b588da7f 100644 --- a/ts/fixtures/lang/caller.ts +++ b/ts/fixtures/lang/caller.ts @@ -784,4 +784,27 @@ const gets = [0, 0x10].flatMap((text) => { ); }); -export const cases: Uint8Array[] = [...loops, ...durations, ...ints(), ...utf8, ...floats, ...formats, ...parsed, ...singlesCases, ...singlesFormats, ...singlesParsed, ...dyns, ...cells, ...shared, ...locks, ...guards, ...maps, ...mappedLocks, ...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]; +/** + * `capacity` cases of each element type: each step of a vector, a deque, and a heap, by a + * few, past what it may hold, and within eight of `usize::MAX`, once it grew past its + * least capacity, made by `new` and by `with_capacity`; each step after a `reserve` or + * `reserve_exact` that needed no room, whose floor it keeps; a run of pushes that doubles + * it from each; and each way `collects` makes one, of each length it tries. + */ +const capacityCases = [ + ...[["capacity::vecs", 25], ["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]) => + 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) => + Array.from({ length: 5 * 2 }, (_, i) => Uint8Array.of(op(name), i % 5, Math.floor(i / 5) * 0x11, ...Array.from({ length: 40 }, (_, p) => [0, p]).flat())), + ), + ...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, ...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]; diff --git a/ts/fixtures/lang/expected/ascii.ts b/ts/fixtures/lang/expected/ascii.ts index b45562229..94e96dee6 100644 --- a/ts/fixtures/lang/expected/ascii.ts +++ b/ts/fixtures/lang/expected/ascii.ts @@ -170,14 +170,14 @@ export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * each method of `char`. */ export function chars(_1: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const all: rt.char[] = [0, 9, 10, 11, 12, 13, 31, 32, 33, 47, 48, 55, 56, 57, 58, 64, 65, 70, 71, 90, 91, 96, 97, 102, 103, 122, 123, 126, 127, 128, 192, 255, 256, 383, 304, 8490, 55295, 57344, 65535, 65536, 1114111].slice(); + const all: rt.char[] = rt.vecExact([0, 9, 10, 11, 12, 13, 31, 32, 33, 47, 48, 55, 56, 57, 58, 64, 65, 70, 71, 90, 91, 96, 97, 102, 103, 122, 123, 126, 127, 128, 192, 255, 256, 383, 304, 8490, 55295, 57344, 65535, 65536, 1114111].slice(), 4); const _9: rt.Iter = rt.iterFilterMap(rt.byteSliceChunks(data, 4), (c2: rt.ByteSlice): rt.char | undefined => { return rt.charFromU32(rt.u32FromBeBytes(rt.bytesFromFn(4, (i2: rt.usize): rt.u8 => { return option_unwrapOr$0r2bmpr(rt.byteSliceGet(c2, i2), 0); }))); }); rt.iterExtend(all, _9, "next", 4); - const others: rt.char[] = all.slice(); + const others: rt.char[] = rt.vecExact(all.slice(), 4); const iter: rt.Iter<[rt.usize, rt.char]> = rt.iterEnumerate(rt.iterSlice(all)); while (true) { const _19: [rt.usize, rt.char] | rt.Done = iter.next(); diff --git a/ts/fixtures/lang/expected/boxes.ts b/ts/fixtures/lang/expected/boxes.ts index 73c7f9a89..481c9015d 100644 --- a/ts/fixtures/lang/expected/boxes.ts +++ b/ts/fixtures/lang/expected/boxes.ts @@ -134,7 +134,7 @@ export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { bytes(fromMut, out); bytes(rt.byteVecSlice(source), out); bytes(rt.byteSliceFrom(rt.byteSliceToArray(data2)), out); - const spare: rt.ByteVec = new rt.ByteVec(64); + const spare: rt.ByteVec = rt.byteVecWithCapacity(64); rt.byteVecExtendFromSlice(spare, data2); let fromVec: rt.ByteSlice = rt.byteVecSlice(spare); scramble(rt.place(() => fromVec, (value4) => fromVec = value4)); @@ -239,7 +239,7 @@ export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } wides(fromRef2, out); wides(wide, out); - const fromVec2: rt.u16[] = wide.slice(); + const fromVec2: rt.u16[] = rt.vecExact(wide.slice(), 2); const _295: rt.Place | undefined = rt.sliceLastMut(fromVec2); if (_295 !== undefined) { _295.v = 48879; diff --git a/ts/fixtures/lang/expected/capacity.Known.ts b/ts/fixtures/lang/expected/capacity.Known.ts new file mode 100644 index 000000000..d3594a762 --- /dev/null +++ b/ts/fixtures/lang/expected/capacity.Known.ts @@ -0,0 +1,53 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import { put as capacity_put } from "./capacity.ts"; + +/** + * What std fixes of a vector's capacity as steps change it: its value while `exact`, and + * else that it holds at least the length and `floor`, the most `with_capacity` or + * `reserve` asked for since a shrink. + */ +export interface Known { + exact: boolean; + floor: rt.usize; +} + +/** A vector just made, with room for at least `floor`. */ +function new_(floor: rt.usize): Known { + return { exact: true, floor }; +} + +/** Whatever capacity a step left, holding at least `floor` still. */ +export function loose(self: Known): void { + self.exact = false; +} + +/** A vector made anew, which holds what std guarantees of it. */ +export function remade(self: Known, exact: boolean): void { + Object.assign(self, { exact, floor: 0 }); +} + +/** After `reserve` made room for `additional` past `len`. */ +export function reserved(self: Known, len: rt.usize, additional: rt.usize): void { + self.floor = rt.max(self.floor, rt.usizeAdd(len, additional)); +} + +/** After `shrink_to` of `min`, holding `len`. */ +export function shrunk(self: Known, len: rt.usize, min: rt.usize): void { + self.floor = rt.min(self.floor, rt.max(len, min)); +} + +/** `len` and what this fixes of `cap`. */ +export function put(self: Known, out: rt.ByteVec, len: rt.usize, cap: rt.usize): void { + capacity_put(out, len); + if (!self.exact) { + capacity_put(out, cap >= rt.max(len, self.floor) ? 1 : 0); + } else { + capacity_put(out, cap); + } +} + +export { new_ as new }; + +//# sourceMappingURL=capacity.Known.ts.map diff --git a/ts/fixtures/lang/expected/capacity.ts b/ts/fixtures/lang/expected/capacity.ts new file mode 100644 index 000000000..fe21f1184 --- /dev/null +++ b/ts/fixtures/lang/expected/capacity.ts @@ -0,0 +1,1964 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import { copy$array_u64, copy$tuple2_u32_u32, copy$tuple2_u64_u8 } from "./lib.ts"; +import * as Known from "./capacity.Known.ts"; +import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$1t0muvr as option_mapOr$1t0muvr, mapOr$1ttssgs as option_mapOr$1ttssgs } from "./core/option.ts"; + +/** 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())); +} + +/** + * How many to reserve by `arg`, beside `len` of `size`-byte elements: a few, or one to + * eight past what a vector of them may hold, or within eight of `usize::MAX`, either of + * which panics before it allocates. + */ +export function amount(arg: rt.u8, len: rt.usize, size: rt.usize): rt.usize { + const _4: rt.u8 = arg >> 5; + if (_4 === 7) { + return rt.usizeSub(4294967295, (arg & 7) as rt.usize); + } + if (_4 === 6) { + if (size > 0) { + return rt.usizeAdd(rt.usizeAdd(rt.usizeSub(rt.usizeDiv(2147483647, size), len), 1), (arg & 7) as rt.usize); + } + } + return (arg & 31) as rt.usize; +} + +/** A test that keeps every other element it is asked about. */ +export function alternate(): () => boolean { + let captured: boolean = false; + return (): boolean => { + captured = !captured; + return captured; + }; +} + +/** + * A `Vec` that `data`'s first byte makes, by `with_capacity` if odd, and each pair after + * it changes, its length and capacity after each. + */ +export function vecs(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const _5: rt.u8 = rt.u8Rem(kind, 5); + if (_5 === 0) { + vecSteps$u8(dataData, dataStart, dataLen, (b3: rt.u8): rt.u8 => { + return b3; + }, out); + } else if (_5 === 1) { + vecSteps$u16(dataData, dataStart, dataLen, (a0: rt.u8): rt.u16 => { + return a0 as rt.u16; + }, out); + } else if (_5 === 2) { + vecSteps$tuple2_u64_u8(dataData, dataStart, dataLen, (b2: rt.u8): [rt.u64, rt.u8] => { + return [b2 as rt.u64, b2] as [rt.u64, rt.u8]; + }, out); + } else if (_5 === 3) { + vecSteps$array160_u64(dataData, dataStart, dataLen, (b: rt.u8): rt.u64[] => { + const _3: rt.u64 = b as rt.u64; + return Array.from({ length: 160 }, (): rt.u64 => { + return _3; + }); + }, out); + } else { + vecSteps$unit(dataData, dataStart, dataLen, (_2: rt.u8): undefined => {}, out); + } +} + +export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => rt.u64[], out: rt.ByteVec): void { + let v!: rt.u64[][]; + let _177!: rt.u8; + const size: rt.usize = 1280; + const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [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, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; + }); + const first: rt.u8 = _7[0]; + if ((first & 1) === 1) { + v = rt.vecWithCapacity(first >> 3 as rt.usize, 1280); + } else { + v = []; + } + const k: Known.Known = Known.new(rt.vecCapacity(v, 1280)); + put(out, rt.vecCapacity(v, 1280)); + const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + while (true) { + const _27: rt.ByteSlice | rt.Done = iter.next(); + if (_27 === 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, 25); + if (_42 === 0 || _42 === 1) { + v.push(copy$array_u64(make(arg))); + } else if (_42 === 2) { + v.pop(); + Known.loose(k); + } else if (_42 === 3 || _42 === 4) { + const additional: rt.usize = amount(arg, v.length, size); + if (rt.u8Rem(op, 25) === 3) { + rt.vecReserve(v, additional, 1280); + } else { + rt.vecReserveExact(v, additional, 1280); + } + Known.reserved(k, v.length, additional); + } else if (_42 === 5) { + rt.vecShrinkTo(v, rt.u8Rem(arg, 40) as rt.usize, 1280); + Known.shrunk(k, v.length, rt.u8Rem(arg, 40) as rt.usize); + } else if (_42 === 6) { + rt.vecShrinkTo(v, 0, 1280); + Known.shrunk(k, v.length, 0); + k.exact = true; + } else if (_42 === 7) { + rt.vecTruncate(v, rt.u8Rem(arg, 8) as rt.usize); + Known.loose(k); + } else if (_42 === 8) { + rt.vecInsert(v, rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.length, 1)), copy$array_u64(make(arg))); + } else if (_42 === 9) { + if (!((v.length === 0))) { + rt.vecRemove(v, rt.usizeRem(arg as rt.usize, v.length)); + Known.loose(k); + } + } else if (_42 === 10) { + rt.iterExtend(v, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i2: rt.u8): boolean => { + return rt.u8Rem(i2, 3) !== 0; + }), make), "next", 1280); + } 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); + } 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 => { + return keep(); + }); + Known.loose(k); + } else if (_42 === 15) { + rt.drop(rt.vecDrain(v, { end: rt.min(v.length, rt.u8Rem(arg, 4) as rt.usize) })); + Known.loose(k); + } else if (_42 === 16) { + v = rt.vecExact(v.map(copy$array_u64), 1280); + Known.remade(k, true); + } else if (_42 === 17) { + v = v; + Known.remade(k, false); + } else if (_42 === 18) { + const keep2: () => boolean = alternate(); + v = rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_26: rt.u64[]): boolean => { + return keep2(); + }), "next", 1280); + Known.remade(k, false); + } else if (_42 === 19) { + const it: rt.Iter = rt.iterSlice(v); + const _174: rt.u8 = rt.u8Rem(arg, 8); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _174; + while ((_177 = iterStart++) < iterEnd) { + if (!(rt.u8Rem(_177, 3) === 2)) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + } + v = rt.iterToArray(it, "next", 1280, true); + Known.remade(k, false); + } 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 old = taken; + taken = _205; + v = old; + Known.put(Known.new(0), out, taken.length, rt.vecCapacity(taken, 1280)); + } else if (_42 === 21) { + if (!((v.length === 0))) { + rt.vecSwapRemove(v, rt.usizeRem(arg as rt.usize, v.length)); + Known.loose(k); + } + } else if (_42 === 22) { + rt.vecDedupBy(v, rt.eqSlice(rt.u64Eq)); + Known.loose(k); + } else if (_42 === 23) { + const it2: rt.Iter = rt.iterSlice(v); + const _236: rt.u8 = rt.u8Rem(arg, 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _236; + while (iterStart2++ < iterEnd2) { + rt.iterToOption(it2.next()); + } + v = rt.iterToArray(it2.clone({ v: copy$array_u64 }), "next", 1280, true); + 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)); + } 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); + } + const _267: rt.usize = v.length; + const _269: rt.usize = rt.vecCapacity(v, 1280); + Known.put(k, out, _267, _269); + } +} + +export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => [rt.u64, rt.u8], out: rt.ByteVec): void { + let v!: [rt.u64, rt.u8][]; + let _177!: rt.u8; + const size: rt.usize = 16; + const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [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, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; + }); + const first: rt.u8 = _7[0]; + if ((first & 1) === 1) { + v = rt.vecWithCapacity(first >> 3 as rt.usize, 16); + } else { + v = []; + } + const k: Known.Known = Known.new(rt.vecCapacity(v, 16)); + put(out, rt.vecCapacity(v, 16)); + const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + while (true) { + const _27: rt.ByteSlice | rt.Done = iter.next(); + if (_27 === 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, 25); + if (_42 === 0 || _42 === 1) { + v.push(copy$tuple2_u64_u8(make(arg))); + } else if (_42 === 2) { + v.pop(); + Known.loose(k); + } else if (_42 === 3 || _42 === 4) { + const additional: rt.usize = amount(arg, v.length, size); + if (rt.u8Rem(op, 25) === 3) { + rt.vecReserve(v, additional, 16); + } else { + rt.vecReserveExact(v, additional, 16); + } + Known.reserved(k, v.length, additional); + } else if (_42 === 5) { + rt.vecShrinkTo(v, rt.u8Rem(arg, 40) as rt.usize, 16); + Known.shrunk(k, v.length, rt.u8Rem(arg, 40) as rt.usize); + } else if (_42 === 6) { + rt.vecShrinkTo(v, 0, 16); + Known.shrunk(k, v.length, 0); + k.exact = true; + } else if (_42 === 7) { + rt.vecTruncate(v, rt.u8Rem(arg, 8) as rt.usize); + Known.loose(k); + } else if (_42 === 8) { + rt.vecInsert(v, rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.length, 1)), copy$tuple2_u64_u8(make(arg))); + } else if (_42 === 9) { + if (!((v.length === 0))) { + rt.vecRemove(v, rt.usizeRem(arg as rt.usize, v.length)); + Known.loose(k); + } + } else if (_42 === 10) { + rt.iterExtend(v, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i2: rt.u8): boolean => { + return rt.u8Rem(i2, 3) !== 0; + }), make), "next", 16); + } 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); + } 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 => { + return keep(); + }); + Known.loose(k); + } else if (_42 === 15) { + rt.drop(rt.vecDrain(v, { end: rt.min(v.length, rt.u8Rem(arg, 4) as rt.usize) })); + Known.loose(k); + } else if (_42 === 16) { + v = rt.vecExact(v.map(copy$tuple2_u64_u8), 16); + Known.remade(k, true); + } else if (_42 === 17) { + v = v; + Known.remade(k, false); + } else if (_42 === 18) { + const keep2: () => boolean = alternate(); + v = rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_26: [rt.u64, rt.u8]): boolean => { + return keep2(); + }), "next", 16); + Known.remade(k, false); + } else if (_42 === 19) { + const it: rt.Iter<[rt.u64, rt.u8]> = rt.iterSlice(v); + const _174: rt.u8 = rt.u8Rem(arg, 8); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _174; + while ((_177 = iterStart++) < iterEnd) { + if (!(rt.u8Rem(_177, 3) === 2)) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + } + v = rt.iterToArray(it, "next", 16, true); + Known.remade(k, false); + } 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 old = taken; + taken = _205; + v = old; + Known.put(Known.new(0), out, taken.length, rt.vecCapacity(taken, 16)); + } else if (_42 === 21) { + if (!((v.length === 0))) { + rt.vecSwapRemove(v, rt.usizeRem(arg as rt.usize, v.length)); + Known.loose(k); + } + } else if (_42 === 22) { + rt.vecDedupBy(v, rt.eqTuple([rt.u64Eq, rt.same])); + 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); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _236; + while (iterStart2++ < iterEnd2) { + rt.iterToOption(it2.next()); + } + v = rt.iterToArray(it2.clone({ v: copy$tuple2_u64_u8 }), "next", 16, true); + 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)); + } 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); + } + const _267: rt.usize = v.length; + const _269: rt.usize = rt.vecCapacity(v, 16); + Known.put(k, out, _267, _269); + } +} + +export function vecSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => rt.u16, out: rt.ByteVec): void { + let v!: rt.u16[]; + let _177!: rt.u8; + const size: rt.usize = 2; + const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [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, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; + }); + const first: rt.u8 = _7[0]; + if ((first & 1) === 1) { + v = rt.vecWithCapacity(first >> 3 as rt.usize, 2); + } else { + v = []; + } + const k: Known.Known = Known.new(rt.vecCapacity(v, 2)); + put(out, rt.vecCapacity(v, 2)); + const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + while (true) { + const _27: rt.ByteSlice | rt.Done = iter.next(); + if (_27 === 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, 25); + if (_42 === 0 || _42 === 1) { + v.push(make(arg)); + } else if (_42 === 2) { + v.pop(); + Known.loose(k); + } else if (_42 === 3 || _42 === 4) { + const additional: rt.usize = amount(arg, v.length, size); + if (rt.u8Rem(op, 25) === 3) { + rt.vecReserve(v, additional, 2); + } else { + rt.vecReserveExact(v, additional, 2); + } + Known.reserved(k, v.length, additional); + } else if (_42 === 5) { + rt.vecShrinkTo(v, rt.u8Rem(arg, 40) as rt.usize, 2); + Known.shrunk(k, v.length, rt.u8Rem(arg, 40) as rt.usize); + } else if (_42 === 6) { + rt.vecShrinkTo(v, 0, 2); + Known.shrunk(k, v.length, 0); + k.exact = true; + } else if (_42 === 7) { + rt.vecTruncate(v, rt.u8Rem(arg, 8) as rt.usize); + Known.loose(k); + } else if (_42 === 8) { + rt.vecInsert(v, rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.length, 1)), make(arg)); + } else if (_42 === 9) { + if (!((v.length === 0))) { + rt.vecRemove(v, rt.usizeRem(arg as rt.usize, v.length)); + Known.loose(k); + } + } else if (_42 === 10) { + rt.iterExtend(v, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i2: rt.u8): boolean => { + return rt.u8Rem(i2, 3) !== 0; + }), make), "next", 2); + } 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); + } 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 => { + return keep(); + }); + Known.loose(k); + } else if (_42 === 15) { + rt.drop(rt.vecDrain(v, { end: rt.min(v.length, rt.u8Rem(arg, 4) as rt.usize) })); + Known.loose(k); + } else if (_42 === 16) { + v = rt.vecExact(v.slice(), 2); + Known.remade(k, true); + } else if (_42 === 17) { + v = v; + Known.remade(k, false); + } else if (_42 === 18) { + const keep2: () => boolean = alternate(); + v = rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_26: rt.u16): boolean => { + return keep2(); + }), "next", 2); + Known.remade(k, false); + } else if (_42 === 19) { + const it: rt.Iter = rt.iterSlice(v); + const _174: rt.u8 = rt.u8Rem(arg, 8); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _174; + while ((_177 = iterStart++) < iterEnd) { + if (!(rt.u8Rem(_177, 3) === 2)) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + } + v = rt.iterToArray(it, "next", 2, true); + Known.remade(k, false); + } 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 old = taken; + taken = _205; + v = old; + Known.put(Known.new(0), out, taken.length, rt.vecCapacity(taken, 2)); + } else if (_42 === 21) { + if (!((v.length === 0))) { + rt.vecSwapRemove(v, rt.usizeRem(arg as rt.usize, v.length)); + Known.loose(k); + } + } else if (_42 === 22) { + rt.vecDedupBy(v, rt.same); + Known.loose(k); + } else if (_42 === 23) { + const it2: rt.Iter = rt.iterSlice(v); + const _236: rt.u8 = rt.u8Rem(arg, 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _236; + while (iterStart2++ < iterEnd2) { + rt.iterToOption(it2.next()); + } + v = rt.iterToArray(it2.clone(), "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)); + } else if (_42 === 24) { + v = rt.vecFromElem(make(arg), rt.u8Rem(arg, 6) as rt.usize, undefined); + Known.remade(k, false); + } + const _267: rt.usize = v.length; + const _269: rt.usize = rt.vecCapacity(v, 2); + Known.put(k, out, _267, _269); + } +} + +export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { + let v!: rt.ByteVec; + let _177!: rt.u8; + const size: rt.usize = 1; + const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [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, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; + }); + const first: rt.u8 = _7[0]; + if ((first & 1) === 1) { + v = rt.byteVecWithCapacity(first >> 3 as rt.usize); + } else { + v = new rt.ByteVec(); + } + const k: Known.Known = Known.new(v.data.length); + put(out, v.data.length); + const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + while (true) { + const _27: rt.ByteSlice | rt.Done = iter.next(); + if (_27 === 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, 25); + if (_42 === 0 || _42 === 1) { + rt.byteVecPush(v, make(arg)); + } else if (_42 === 2) { + rt.byteVecPop(v); + Known.loose(k); + } else if (_42 === 3 || _42 === 4) { + const additional: rt.usize = amount(arg, v.length, size); + if (rt.u8Rem(op, 25) === 3) { + rt.byteVecReserve(v, additional); + } else { + rt.byteVecReserveExact(v, additional); + } + Known.reserved(k, v.length, additional); + } else if (_42 === 5) { + rt.byteVecShrinkTo(v, rt.u8Rem(arg, 40) as rt.usize); + Known.shrunk(k, v.length, rt.u8Rem(arg, 40) as rt.usize); + } else if (_42 === 6) { + rt.byteVecShrinkTo(v, 0); + Known.shrunk(k, v.length, 0); + k.exact = true; + } else if (_42 === 7) { + rt.byteVecTruncate(v, rt.u8Rem(arg, 8) as rt.usize); + Known.loose(k); + } else if (_42 === 8) { + rt.byteVecInsert(v, rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.length, 1)), make(arg)); + } else if (_42 === 9) { + if (!((v.length === 0))) { + rt.byteVecRemove(v, rt.usizeRem(arg as rt.usize, v.length)); + Known.loose(k); + } + } else if (_42 === 10) { + rt.iterExtendBytes(v, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i2: rt.u8): boolean => { + return rt.u8Rem(i2, 3) !== 0; + }), make), "next"); + } 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); + } 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 => { + return keep(); + }); + Known.loose(k); + } else if (_42 === 15) { + rt.drop(rt.byteVecDrain(v, { end: rt.min(v.length, rt.u8Rem(arg, 4) as rt.usize) })); + Known.loose(k); + } else if (_42 === 16) { + v = rt.byteVecFrom(rt.byteVecView(v)); + Known.remade(k, true); + } else if (_42 === 17) { + v = rt.byteSliceToByteVec(rt.byteVecSlice(v)); + 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 => { + return keep2(); + }), "next"); + Known.remade(k, false); + } else if (_42 === 19) { + const it: rt.Iter = rt.iterSlice(rt.byteVecView(v)); + const _174: rt.u8 = rt.u8Rem(arg, 8); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _174; + while ((_177 = iterStart++) < iterEnd) { + if (!(rt.u8Rem(_177, 3) === 2)) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + } + v = rt.iterToByteVec(it, "next", true); + Known.remade(k, false); + } else if (_42 === 20) { + let taken: rt.ByteVec = rt.replaceIn(v, new rt.ByteVec()); + const _196: rt.u8 = make(arg); + rt.byteVecPush(taken, _196); + Known.put(k, out, taken.length, taken.data.length); + const _205: rt.ByteVec = rt.byteVecWithCapacity(rt.u8Rem(arg, 6) as rt.usize); + const old = taken; + taken = _205; + v = old; + Known.put(Known.new(0), out, taken.length, taken.data.length); + } else if (_42 === 21) { + if (!((v.length === 0))) { + rt.byteVecSwapRemove(v, rt.usizeRem(arg as rt.usize, v.length)); + Known.loose(k); + } + } else if (_42 === 22) { + rt.byteVecDedup(v); + Known.loose(k); + } else if (_42 === 23) { + const it2: rt.Iter = rt.iterSlice(rt.byteVecView(v)); + const _236: rt.u8 = rt.u8Rem(arg, 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _236; + while (iterStart2++ < iterEnd2) { + rt.iterToOption(it2.next()); + } + v = rt.iterToByteVec(it2.clone(), "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); + } else if (_42 === 24) { + v = rt.byteVecOf(make(arg), rt.u8Rem(arg, 6) as rt.usize); + Known.remade(k, false); + } + Known.put(k, out, v.length, v.data.length); + } +} + +export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => undefined, out: rt.ByteVec): void { + let v!: undefined[]; + let _177!: rt.u8; + const size: rt.usize = 0; + const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [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, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; + }); + const first: rt.u8 = _7[0]; + if ((first & 1) === 1) { + v = rt.vecWithCapacity(first >> 3 as rt.usize, 0); + } else { + v = []; + } + const k: Known.Known = Known.new(rt.vecCapacity(v, 0)); + put(out, rt.vecCapacity(v, 0)); + const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + while (true) { + const _27: rt.ByteSlice | rt.Done = iter.next(); + if (_27 === 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, 25); + if (_42 === 0 || _42 === 1) { + const _44: undefined[] = v; + make(arg); + _44.push(undefined); + } else if (_42 === 2) { + rt.vecPop(v, rt.None); + Known.loose(k); + } else if (_42 === 3 || _42 === 4) { + const additional: rt.usize = amount(arg, v.length, size); + if (rt.u8Rem(op, 25) === 3) { + rt.vecReserve(v, additional, 0); + } else { + rt.vecReserveExact(v, additional, 0); + } + Known.reserved(k, v.length, additional); + } else if (_42 === 5) { + rt.vecShrinkTo(v, rt.u8Rem(arg, 40) as rt.usize, 0); + Known.shrunk(k, v.length, rt.u8Rem(arg, 40) as rt.usize); + } else if (_42 === 6) { + rt.vecShrinkTo(v, 0, 0); + Known.shrunk(k, v.length, 0); + k.exact = true; + } else if (_42 === 7) { + rt.vecTruncate(v, rt.u8Rem(arg, 8) as rt.usize); + Known.loose(k); + } else if (_42 === 8) { + const _88: undefined[] = v; + const _89: rt.usize = rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.length, 1)); + make(arg); + rt.vecInsert(_88, _89, undefined); + } else if (_42 === 9) { + if (!((v.length === 0))) { + rt.vecRemove(v, rt.usizeRem(arg as rt.usize, v.length)); + Known.loose(k); + } + } else if (_42 === 10) { + rt.iterExtend(v, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i2: rt.u8): boolean => { + return rt.u8Rem(i2, 3) !== 0; + }), make), "next", 0); + } 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); + make(arg); + rt.vecExtendFromSlice(_121, [undefined, undefined]); + Known.loose(k); + } 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 => { + return keep(); + }); + Known.loose(k); + } else if (_42 === 15) { + rt.drop(rt.vecDrain(v, { end: rt.min(v.length, rt.u8Rem(arg, 4) as rt.usize) })); + Known.loose(k); + } else if (_42 === 16) { + v = rt.vecExact(v.slice(), 0); + Known.remade(k, true); + } else if (_42 === 17) { + v = v; + Known.remade(k, false); + } else if (_42 === 18) { + const keep2: () => boolean = alternate(); + v = rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_26: undefined): boolean => { + return keep2(); + }), "next", 0); + Known.remade(k, false); + } else if (_42 === 19) { + const it: rt.Iter = rt.iterSlice(v); + const _174: rt.u8 = rt.u8Rem(arg, 8); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _174; + while ((_177 = iterStart++) < iterEnd) { + if (!(rt.u8Rem(_177, 3) === 2)) { + rt.iterToOption(it.next(), rt.None); + } else { + rt.iterToOption(it.nextBack(), rt.None); + } + } + v = rt.iterToArray(it, undefined, 0, true); + Known.remade(k, false); + } 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 old = taken; + taken = _205; + v = old; + Known.put(Known.new(0), out, taken.length, rt.vecCapacity(taken, 0)); + } else if (_42 === 21) { + if (!((v.length === 0))) { + rt.vecSwapRemove(v, rt.usizeRem(arg as rt.usize, v.length)); + Known.loose(k); + } + } else if (_42 === 22) { + rt.vecDedupBy(v, rt.same); + Known.loose(k); + } else if (_42 === 23) { + const it2: rt.Iter = rt.iterSlice(v); + const _236: rt.u8 = rt.u8Rem(arg, 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _236; + while (iterStart2++ < iterEnd2) { + rt.iterToOption(it2.next(), rt.None); + } + v = rt.iterToArray(it2.clone(), 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)); + } else if (_42 === 24) { + make(arg); + v = rt.vecFromElem(undefined, rt.u8Rem(arg, 6) as rt.usize, undefined); + Known.remade(k, false); + } + const _267: rt.usize = v.length; + const _269: rt.usize = rt.vecCapacity(v, 0); + Known.put(k, out, _267, _269); + } +} + +/** A `VecDeque`, as `vecs` steps a `Vec`. */ +export function deques(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const _5: rt.u8 = rt.u8Rem(kind, 5); + if (_5 === 0) { + dequeSteps$u8(dataData, dataStart, dataLen, (b3: rt.u8): rt.u8 => { + return b3; + }, out); + } else if (_5 === 1) { + dequeSteps$u16(dataData, dataStart, dataLen, (a0: rt.u8): rt.u16 => { + return a0 as rt.u16; + }, out); + } else if (_5 === 2) { + dequeSteps$tuple2_u64_u8(dataData, dataStart, dataLen, (b2: rt.u8): [rt.u64, rt.u8] => { + return [b2 as rt.u64, b2] as [rt.u64, rt.u8]; + }, out); + } else if (_5 === 3) { + dequeSteps$array160_u64(dataData, dataStart, dataLen, (b: rt.u8): rt.u64[] => { + const _3: rt.u64 = b as rt.u64; + return Array.from({ length: 160 }, (): rt.u64 => { + return _3; + }); + }, out); + } else { + dequeSteps$unit(dataData, dataStart, dataLen, (_2: rt.u8): undefined => {}, out); + } +} + +export function dequeSteps$array160_u64(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => rt.u64[], out: rt.ByteVec): void { + let q!: rt.VecDeque; + const size: rt.usize = 1280; + const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [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, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; + }); + const first: rt.u8 = _7[0]; + if ((first & 1) === 1) { + q = rt.dequeWithCapacity(first >> 3 as rt.usize, 1280) as rt.VecDeque; + } else { + q = rt.dequeNew() as rt.VecDeque; + } + const k: Known.Known = Known.new(rt.dequeCapacity(q, 1280)); + put(out, rt.dequeCapacity(q, 1280)); + const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + while (true) { + const _27: rt.ByteSlice | rt.Done = iter.next(); + if (_27 === 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.dequePushBack(q, copy$array_u64(make(arg))); + } else if (_42 === 1) { + rt.dequePushFront(q, copy$array_u64(make(arg))); + } else if (_42 === 2) { + rt.dequePopFront(q); + Known.loose(k); + } else if (_42 === 3 || _42 === 4) { + const additional: rt.usize = amount(arg, q.n, size); + if (rt.u8Rem(op, 21) === 3) { + rt.dequeReserve(q, additional, 1280); + } else { + rt.dequeReserveExact(q, additional, 1280); + } + 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) { + rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); + Known.loose(k); + } else if (_42 === 8) { + rt.dequeInsert(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), copy$array_u64(make(arg))); + } else if (_42 === 9) { + rt.dequeRemove(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1))); + Known.loose(k); + } else if (_42 === 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) { + rt.dequeClear(q); + Known.loose(k); + } else if (_42 === 13) { + const keep: () => boolean = alternate(); + rt.dequeRetain(q, (_28: 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) { + const keep2: () => boolean = alternate(); + q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_26: 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); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _173; + 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)); + } 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); + } + const _204: rt.usize = q.n; + const _206: rt.usize = rt.dequeCapacity(q, 1280); + Known.put(k, out, _204, _206); + } +} + +export function dequeSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => [rt.u64, rt.u8], out: rt.ByteVec): void { + let q!: rt.VecDeque<[rt.u64, rt.u8]>; + const size: rt.usize = 16; + const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [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, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; + }); + const first: rt.u8 = _7[0]; + 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]>; + } + const k: Known.Known = Known.new(rt.dequeCapacity(q, 16)); + put(out, rt.dequeCapacity(q, 16)); + const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + while (true) { + const _27: rt.ByteSlice | rt.Done = iter.next(); + if (_27 === 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.dequePushBack(q, copy$tuple2_u64_u8(make(arg))); + } else if (_42 === 1) { + rt.dequePushFront(q, copy$tuple2_u64_u8(make(arg))); + } else if (_42 === 2) { + rt.dequePopFront(q); + Known.loose(k); + } else if (_42 === 3 || _42 === 4) { + const additional: rt.usize = amount(arg, q.n, size); + if (rt.u8Rem(op, 21) === 3) { + rt.dequeReserve(q, additional, 16); + } else { + rt.dequeReserveExact(q, additional, 16); + } + 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) { + rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); + Known.loose(k); + } else if (_42 === 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) { + rt.dequeRemove(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1))); + Known.loose(k); + } else if (_42 === 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) { + rt.dequeClear(q); + Known.loose(k); + } else if (_42 === 13) { + const keep: () => boolean = alternate(); + rt.dequeRetain(q, (_28: [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) { + const keep2: () => boolean = alternate(); + q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_26: [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); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _173; + 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)); + } 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); + } + const _204: rt.usize = q.n; + const _206: rt.usize = rt.dequeCapacity(q, 16); + Known.put(k, out, _204, _206); + } +} + +export function dequeSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => rt.u16, out: rt.ByteVec): void { + let q!: rt.VecDeque; + const size: rt.usize = 2; + const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [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, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; + }); + const first: rt.u8 = _7[0]; + if ((first & 1) === 1) { + q = rt.dequeWithCapacity(first >> 3 as rt.usize, 2) as rt.VecDeque; + } else { + q = rt.dequeNew() as rt.VecDeque; + } + const k: Known.Known = Known.new(rt.dequeCapacity(q, 2)); + put(out, rt.dequeCapacity(q, 2)); + const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + while (true) { + const _27: rt.ByteSlice | rt.Done = iter.next(); + if (_27 === 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.dequePushBack(q, make(arg)); + } else if (_42 === 1) { + rt.dequePushFront(q, make(arg)); + } else if (_42 === 2) { + rt.dequePopFront(q); + Known.loose(k); + } else if (_42 === 3 || _42 === 4) { + const additional: rt.usize = amount(arg, q.n, size); + if (rt.u8Rem(op, 21) === 3) { + rt.dequeReserve(q, additional, 2); + } else { + rt.dequeReserveExact(q, additional, 2); + } + 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) { + rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); + Known.loose(k); + } else if (_42 === 8) { + rt.dequeInsert(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), make(arg)); + } else if (_42 === 9) { + rt.dequeRemove(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1))); + Known.loose(k); + } else if (_42 === 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) { + rt.dequeClear(q); + Known.loose(k); + } else if (_42 === 13) { + const keep: () => boolean = alternate(); + rt.dequeRetain(q, (_28: 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) { + const keep2: () => boolean = alternate(); + q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_26: 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); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _173; + 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)); + } 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); + } + const _204: rt.usize = q.n; + const _206: rt.usize = rt.dequeCapacity(q, 2); + Known.put(k, out, _204, _206); + } +} + +export function dequeSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { + let q!: rt.VecDeque; + const size: rt.usize = 1; + const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [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, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; + }); + const first: rt.u8 = _7[0]; + if ((first & 1) === 1) { + q = rt.dequeWithCapacity(first >> 3 as rt.usize, 1) as rt.VecDeque; + } else { + q = rt.dequeNew() as rt.VecDeque; + } + const k: Known.Known = Known.new(rt.dequeCapacity(q, 1)); + put(out, rt.dequeCapacity(q, 1)); + const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + while (true) { + const _27: rt.ByteSlice | rt.Done = iter.next(); + if (_27 === 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.dequePushBack(q, make(arg)); + } else if (_42 === 1) { + rt.dequePushFront(q, make(arg)); + } else if (_42 === 2) { + rt.dequePopFront(q); + Known.loose(k); + } else if (_42 === 3 || _42 === 4) { + const additional: rt.usize = amount(arg, q.n, size); + if (rt.u8Rem(op, 21) === 3) { + rt.dequeReserve(q, additional, 1); + } else { + rt.dequeReserveExact(q, additional, 1); + } + 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) { + rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); + Known.loose(k); + } else if (_42 === 8) { + rt.dequeInsert(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), make(arg)); + } else if (_42 === 9) { + rt.dequeRemove(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1))); + Known.loose(k); + } else if (_42 === 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) { + rt.dequeClear(q); + Known.loose(k); + } else if (_42 === 13) { + const keep: () => boolean = alternate(); + rt.dequeRetain(q, (_28: 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) { + const keep2: () => boolean = alternate(); + q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_26: 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); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _173; + 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)); + } 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); + } + const _204: rt.usize = q.n; + const _206: rt.usize = rt.dequeCapacity(q, 1); + Known.put(k, out, _204, _206); + } +} + +export function dequeSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => undefined, out: rt.ByteVec): void { + let q!: rt.VecDeque; + const size: rt.usize = 0; + const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [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, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; + }); + const first: rt.u8 = _7[0]; + if ((first & 1) === 1) { + q = rt.dequeWithCapacity(first >> 3 as rt.usize, 0) as rt.VecDeque; + } else { + q = rt.dequeNew() as rt.VecDeque; + } + const k: Known.Known = Known.new(rt.dequeCapacity(q, 0)); + put(out, rt.dequeCapacity(q, 0)); + const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + while (true) { + const _27: rt.ByteSlice | rt.Done = iter.next(); + if (_27 === 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; + make(arg); + rt.dequePushBack(_44, undefined); + } else if (_42 === 1) { + const _46: rt.VecDeque = q; + make(arg); + rt.dequePushFront(_46, undefined); + } else if (_42 === 2) { + rt.dequePopFront(q, rt.None); + Known.loose(k); + } else if (_42 === 3 || _42 === 4) { + const additional: rt.usize = amount(arg, q.n, size); + if (rt.u8Rem(op, 21) === 3) { + rt.dequeReserve(q, additional, 0); + } else { + rt.dequeReserveExact(q, additional, 0); + } + 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) { + 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)); + make(arg); + rt.dequeInsert(_90, _91, undefined); + } else if (_42 === 9) { + rt.dequeRemove(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), rt.None); + Known.loose(k); + } else if (_42 === 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) { + rt.dequeClear(q); + Known.loose(k); + } else if (_42 === 13) { + const keep: () => boolean = alternate(); + rt.dequeRetain(q, (_28: 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) { + const keep2: () => boolean = alternate(); + q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_26: 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); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _173; + 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)); + } 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); + } + const _204: rt.usize = q.n; + const _206: rt.usize = rt.dequeCapacity(q, 0); + Known.put(k, out, _204, _206); + } +} + +/** A `BinaryHeap`, as `vecs` steps a `Vec`, and the `Vec` it gives up at the end. */ +export function heaps(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const _5: rt.u8 = rt.u8Rem(kind, 5); + if (_5 === 0) { + heapSteps$u8(dataData, dataStart, dataLen, (b3: rt.u8): rt.u8 => { + return b3; + }, out); + } else if (_5 === 1) { + heapSteps$u16(dataData, dataStart, dataLen, (a0: rt.u8): rt.u16 => { + return a0 as rt.u16; + }, out); + } else if (_5 === 2) { + heapSteps$tuple2_u64_u8(dataData, dataStart, dataLen, (b2: rt.u8): [rt.u64, rt.u8] => { + return [b2 as rt.u64, b2] as [rt.u64, rt.u8]; + }, out); + } else if (_5 === 3) { + heapSteps$array160_u64(dataData, dataStart, dataLen, (b: rt.u8): rt.u64[] => { + const _3: rt.u64 = b as rt.u64; + return Array.from({ length: 160 }, (): rt.u64 => { + return _3; + }); + }, out); + } else { + heapSteps$unit(dataData, dataStart, dataLen, (_2: rt.u8): undefined => {}, out); + } +} + +export function heapSteps$array160_u64(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => rt.u64[], out: rt.ByteVec): void { + let h!: rt.BinaryHeap; + const size: rt.usize = 1280; + const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [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, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; + }); + const first: rt.u8 = _7[0]; + if ((first & 1) === 1) { + h = rt.heapWithCapacity(first >> 3 as rt.usize, 1280) as rt.BinaryHeap; + } else { + h = rt.heapNew() as rt.BinaryHeap; + } + const k: Known.Known = Known.new(rt.vecCapacity(h.d, 1280)); + put(out, rt.vecCapacity(h.d, 1280)); + const other: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; + const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + while (true) { + const _28: rt.ByteSlice | rt.Done = iter.next(); + if (_28 === rt.DONE) { + break; + } + rt.idx(_28, 0); + const _34: [rt.u8, rt.u8] = [_28.data[_28.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_28, 1), 0)]; + const op: rt.u8 = _34[0]; + const arg: rt.u8 = _34[1]; + const _43: rt.u8 = rt.u8Rem(op, 13); + if (_43 === 0 || _43 === 1) { + rt.heapPush(h, copy$array_u64(make(arg)), rt.cmpLe(rt.cmpSlice(rt.cmp))); + } else if (_43 === 2) { + rt.heapPop(h, rt.cmpLe(rt.cmpSlice(rt.cmp))); + Known.loose(k); + } else if (_43 === 3 || _43 === 4) { + const additional: rt.usize = amount(arg, h.d.length, size); + if (rt.u8Rem(op, 13) === 3) { + rt.vecReserve(h.d, additional, 1280); + } else { + rt.vecReserveExact(h.d, additional, 1280); + } + Known.reserved(k, h.d.length, additional); + } else if (_43 === 5) { + rt.vecShrinkTo(h.d, rt.u8Rem(arg, 40) as rt.usize, 1280); + Known.shrunk(k, h.d.length, rt.u8Rem(arg, 40) as rt.usize); + } else if (_43 === 6) { + rt.vecShrinkTo(h.d, 0, 1280); + Known.shrunk(k, h.d.length, 0); + k.exact = true; + } else if (_43 === 7) { + rt.heapClear(h); + Known.loose(k); + } else if (_43 === 8) { + rt.heapExtend(h, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { + return rt.u8Rem(i, 3) !== 0; + }), make), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp)), "next", 1280); + } else if (_43 === 9) { + const _94: rt.u64[] = copy$array_u64(make(arg)); + rt.heapPush(other, _94, rt.cmpLe(rt.cmpSlice(rt.cmp))); + rt.heapAppend(h, other, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); + Known.remade(k, false); + Known.put({ exact: false, floor: 0 }, out, other.d.length, rt.vecCapacity(other.d, 1280)); + } else if (_43 === 10) { + rt.drop(rt.heapDrain(h)); + Known.loose(k); + } else if (_43 === 11) { + const _111: rt.PeekMut | undefined = rt.heapPeekMut(h, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); + if (_111 !== undefined) { + const top: rt.PeekMut = _111; + const _115: rt.u64[] = copy$array_u64(make(arg)); + rt.peekMutDerefMut(top); + Object.assign(top.v, _115); + } + Known.remade(k, false); + } else { + h = rt.heapFrom(h.d, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); + } + const _127: rt.usize = h.d.length; + const _129: rt.usize = rt.vecCapacity(h.d, 1280); + Known.put(k, out, _127, _129); + } + const cloned: rt.u64[][] = rt.heapClone(h, copy$array_u64, 1280).d; + Known.put(Known.new(0), out, cloned.length, rt.vecCapacity(cloned, 1280)); + const sorted: rt.u64[][] = rt.heapIntoSortedVec(h, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); + const _145: rt.usize = sorted.length; + const _147: rt.usize = rt.vecCapacity(sorted, 1280); + Known.put(k, out, _145, _147); +} + +export function heapSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => [rt.u64, rt.u8], out: rt.ByteVec): void { + let h!: rt.BinaryHeap<[rt.u64, rt.u8]>; + const size: rt.usize = 16; + const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [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, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; + }); + const first: rt.u8 = _7[0]; + if ((first & 1) === 1) { + h = rt.heapWithCapacity(first >> 3 as rt.usize, 16) as rt.BinaryHeap<[rt.u64, rt.u8]>; + } else { + h = rt.heapNew() as rt.BinaryHeap<[rt.u64, rt.u8]>; + } + const k: Known.Known = Known.new(rt.vecCapacity(h.d, 16)); + put(out, rt.vecCapacity(h.d, 16)); + const other: rt.BinaryHeap<[rt.u64, rt.u8]> = rt.heapNew() as rt.BinaryHeap<[rt.u64, rt.u8]>; + const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + while (true) { + const _28: rt.ByteSlice | rt.Done = iter.next(); + if (_28 === rt.DONE) { + break; + } + rt.idx(_28, 0); + const _34: [rt.u8, rt.u8] = [_28.data[_28.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_28, 1), 0)]; + const op: rt.u8 = _34[0]; + const arg: rt.u8 = _34[1]; + const _43: rt.u8 = rt.u8Rem(op, 13); + if (_43 === 0 || _43 === 1) { + rt.heapPush(h, copy$tuple2_u64_u8(make(arg)), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))); + } else if (_43 === 2) { + rt.heapPop(h, rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))); + Known.loose(k); + } else if (_43 === 3 || _43 === 4) { + const additional: rt.usize = amount(arg, h.d.length, size); + if (rt.u8Rem(op, 13) === 3) { + rt.vecReserve(h.d, additional, 16); + } else { + rt.vecReserveExact(h.d, additional, 16); + } + Known.reserved(k, h.d.length, additional); + } else if (_43 === 5) { + rt.vecShrinkTo(h.d, rt.u8Rem(arg, 40) as rt.usize, 16); + Known.shrunk(k, h.d.length, rt.u8Rem(arg, 40) as rt.usize); + } else if (_43 === 6) { + rt.vecShrinkTo(h.d, 0, 16); + Known.shrunk(k, h.d.length, 0); + k.exact = true; + } else if (_43 === 7) { + rt.heapClear(h); + Known.loose(k); + } else if (_43 === 8) { + rt.heapExtend(h, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { + return rt.u8Rem(i, 3) !== 0; + }), make), 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])), "next", 16); + } else if (_43 === 9) { + const _94: [rt.u64, rt.u8] = copy$tuple2_u64_u8(make(arg)); + rt.heapPush(other, _94, rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))); + rt.heapAppend(h, other, 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]))); + Known.remade(k, false); + Known.put({ exact: false, floor: 0 }, out, other.d.length, rt.vecCapacity(other.d, 16)); + } else if (_43 === 10) { + rt.drop(rt.heapDrain(h)); + Known.loose(k); + } else if (_43 === 11) { + const _111: rt.PeekMut<[rt.u64, rt.u8]> | undefined = rt.heapPeekMut(h, 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]))); + if (_111 !== undefined) { + const top: rt.PeekMut<[rt.u64, rt.u8]> = _111; + const _115: [rt.u64, rt.u8] = copy$tuple2_u64_u8(make(arg)); + rt.peekMutDerefMut(top); + Object.assign(top.v, _115); + } + Known.remade(k, false); + } else { + h = rt.heapFrom(h.d, 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]))); + } + const _127: rt.usize = h.d.length; + const _129: rt.usize = rt.vecCapacity(h.d, 16); + Known.put(k, out, _127, _129); + } + const cloned: [rt.u64, rt.u8][] = rt.heapClone(h, copy$tuple2_u64_u8, 16).d; + Known.put(Known.new(0), out, cloned.length, rt.vecCapacity(cloned, 16)); + const sorted: [rt.u64, rt.u8][] = rt.heapIntoSortedVec(h, 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]))); + const _145: rt.usize = sorted.length; + const _147: rt.usize = rt.vecCapacity(sorted, 16); + Known.put(k, out, _145, _147); +} + +export function heapSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => rt.u16, out: rt.ByteVec): void { + let h!: rt.BinaryHeap; + const size: rt.usize = 2; + const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [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, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; + }); + const first: rt.u8 = _7[0]; + if ((first & 1) === 1) { + h = rt.heapWithCapacity(first >> 3 as rt.usize, 2) as rt.BinaryHeap; + } else { + h = rt.heapNew() as rt.BinaryHeap; + } + const k: Known.Known = Known.new(rt.vecCapacity(h.d, 2)); + put(out, rt.vecCapacity(h.d, 2)); + const other: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; + const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + while (true) { + const _28: rt.ByteSlice | rt.Done = iter.next(); + if (_28 === rt.DONE) { + break; + } + rt.idx(_28, 0); + const _34: [rt.u8, rt.u8] = [_28.data[_28.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_28, 1), 0)]; + const op: rt.u8 = _34[0]; + const arg: rt.u8 = _34[1]; + const _43: rt.u8 = rt.u8Rem(op, 13); + if (_43 === 0 || _43 === 1) { + rt.heapPush(h, make(arg), rt.le); + } else if (_43 === 2) { + rt.heapPop(h, rt.le); + Known.loose(k); + } else if (_43 === 3 || _43 === 4) { + const additional: rt.usize = amount(arg, h.d.length, size); + if (rt.u8Rem(op, 13) === 3) { + rt.vecReserve(h.d, additional, 2); + } else { + rt.vecReserveExact(h.d, additional, 2); + } + Known.reserved(k, h.d.length, additional); + } else if (_43 === 5) { + rt.vecShrinkTo(h.d, rt.u8Rem(arg, 40) as rt.usize, 2); + Known.shrunk(k, h.d.length, rt.u8Rem(arg, 40) as rt.usize); + } else if (_43 === 6) { + rt.vecShrinkTo(h.d, 0, 2); + Known.shrunk(k, h.d.length, 0); + k.exact = true; + } else if (_43 === 7) { + rt.heapClear(h); + Known.loose(k); + } else if (_43 === 8) { + rt.heapExtend(h, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { + return rt.u8Rem(i, 3) !== 0; + }), make), rt.le, rt.ge, rt.lt, "next", 2); + } else if (_43 === 9) { + const _94: rt.u16 = make(arg); + rt.heapPush(other, _94, rt.le); + rt.heapAppend(h, other, rt.le, rt.ge, rt.lt); + Known.remade(k, false); + Known.put({ exact: false, floor: 0 }, out, other.d.length, rt.vecCapacity(other.d, 2)); + } else if (_43 === 10) { + rt.drop(rt.heapDrain(h)); + Known.loose(k); + } else if (_43 === 11) { + const _111: rt.PeekMut | undefined = rt.heapPeekMut(h, rt.le, rt.ge, rt.lt); + if (_111 !== undefined) { + const top: rt.PeekMut = _111; + const _115: rt.u16 = make(arg); + rt.peekMutDerefMut(top); + top.v = _115; + } + Known.remade(k, false); + } else { + h = rt.heapFrom(h.d, rt.le, rt.ge, rt.lt); + } + const _127: rt.usize = h.d.length; + const _129: rt.usize = rt.vecCapacity(h.d, 2); + Known.put(k, out, _127, _129); + } + const cloned: rt.u16[] = rt.heapClone(h, undefined, 2).d; + Known.put(Known.new(0), out, cloned.length, rt.vecCapacity(cloned, 2)); + const sorted: rt.u16[] = rt.heapIntoSortedVec(h, rt.le, rt.ge, rt.lt); + const _145: rt.usize = sorted.length; + const _147: rt.usize = rt.vecCapacity(sorted, 2); + Known.put(k, out, _145, _147); +} + +export function heapSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { + let h!: rt.BinaryHeap; + const size: rt.usize = 1; + const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [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, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; + }); + const first: rt.u8 = _7[0]; + if ((first & 1) === 1) { + h = rt.heapWithCapacity(first >> 3 as rt.usize, 1) as rt.BinaryHeap; + } else { + h = rt.heapNew() as rt.BinaryHeap; + } + const k: Known.Known = Known.new(rt.vecCapacity(h.d, 1)); + put(out, rt.vecCapacity(h.d, 1)); + const other: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; + const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + while (true) { + const _28: rt.ByteSlice | rt.Done = iter.next(); + if (_28 === rt.DONE) { + break; + } + rt.idx(_28, 0); + const _34: [rt.u8, rt.u8] = [_28.data[_28.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_28, 1), 0)]; + const op: rt.u8 = _34[0]; + const arg: rt.u8 = _34[1]; + const _43: rt.u8 = rt.u8Rem(op, 13); + if (_43 === 0 || _43 === 1) { + rt.heapPush(h, make(arg), rt.le); + } else if (_43 === 2) { + rt.heapPop(h, rt.le); + Known.loose(k); + } else if (_43 === 3 || _43 === 4) { + const additional: rt.usize = amount(arg, h.d.length, size); + if (rt.u8Rem(op, 13) === 3) { + rt.vecReserve(h.d, additional, 1); + } else { + rt.vecReserveExact(h.d, additional, 1); + } + Known.reserved(k, h.d.length, additional); + } else if (_43 === 5) { + rt.vecShrinkTo(h.d, rt.u8Rem(arg, 40) as rt.usize, 1); + Known.shrunk(k, h.d.length, rt.u8Rem(arg, 40) as rt.usize); + } else if (_43 === 6) { + rt.vecShrinkTo(h.d, 0, 1); + Known.shrunk(k, h.d.length, 0); + k.exact = true; + } else if (_43 === 7) { + rt.heapClear(h); + Known.loose(k); + } else if (_43 === 8) { + rt.heapExtend(h, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { + return rt.u8Rem(i, 3) !== 0; + }), make), rt.le, rt.ge, rt.lt, "next", 1); + } else if (_43 === 9) { + const _94: rt.u8 = make(arg); + rt.heapPush(other, _94, rt.le); + rt.heapAppend(h, other, rt.le, rt.ge, rt.lt); + Known.remade(k, false); + Known.put({ exact: false, floor: 0 }, out, other.d.length, rt.vecCapacity(other.d, 1)); + } else if (_43 === 10) { + rt.drop(rt.heapDrain(h)); + Known.loose(k); + } else if (_43 === 11) { + const _111: rt.PeekMut | undefined = rt.heapPeekMut(h, rt.le, rt.ge, rt.lt); + if (_111 !== undefined) { + const top: rt.PeekMut = _111; + const _115: rt.u8 = make(arg); + rt.peekMutDerefMut(top); + top.v = _115; + } + Known.remade(k, false); + } else { + h = rt.heapFrom(rt.byteVecToVec(rt.byteVecFromVec(h.d)), rt.le, rt.ge, rt.lt); + } + const _127: rt.usize = h.d.length; + const _129: rt.usize = rt.vecCapacity(h.d, 1); + Known.put(k, out, _127, _129); + } + const cloned: rt.ByteVec = rt.byteVecFromVec(rt.heapClone(h, undefined, 1).d); + Known.put(Known.new(0), out, cloned.length, cloned.data.length); + const sorted: rt.ByteVec = rt.byteVecFromVec(rt.heapIntoSortedVec(h, rt.le, rt.ge, rt.lt)); + Known.put(k, out, sorted.length, sorted.data.length); +} + +export function heapSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => undefined, out: rt.ByteVec): void { + let h!: rt.BinaryHeap; + const size: rt.usize = 0; + const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [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, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; + }); + const first: rt.u8 = _7[0]; + if ((first & 1) === 1) { + h = rt.heapWithCapacity(first >> 3 as rt.usize, 0) as rt.BinaryHeap; + } else { + h = rt.heapNew() as rt.BinaryHeap; + } + const k: Known.Known = Known.new(rt.vecCapacity(h.d, 0)); + put(out, rt.vecCapacity(h.d, 0)); + const other: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; + const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + while (true) { + const _28: rt.ByteSlice | rt.Done = iter.next(); + if (_28 === rt.DONE) { + break; + } + rt.idx(_28, 0); + const _34: [rt.u8, rt.u8] = [_28.data[_28.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_28, 1), 0)]; + const op: rt.u8 = _34[0]; + const arg: rt.u8 = _34[1]; + const _43: rt.u8 = rt.u8Rem(op, 13); + if (_43 === 0 || _43 === 1) { + const _45: rt.BinaryHeap = h; + make(arg); + rt.heapPush(_45, undefined, rt.cmpLe(rt.cmpNothing)); + } else if (_43 === 2) { + rt.heapPop(h, rt.cmpLe(rt.cmpNothing), rt.None); + Known.loose(k); + } else if (_43 === 3 || _43 === 4) { + const additional: rt.usize = amount(arg, h.d.length, size); + if (rt.u8Rem(op, 13) === 3) { + rt.vecReserve(h.d, additional, 0); + } else { + rt.vecReserveExact(h.d, additional, 0); + } + Known.reserved(k, h.d.length, additional); + } else if (_43 === 5) { + rt.vecShrinkTo(h.d, rt.u8Rem(arg, 40) as rt.usize, 0); + Known.shrunk(k, h.d.length, rt.u8Rem(arg, 40) as rt.usize); + } else if (_43 === 6) { + rt.vecShrinkTo(h.d, 0, 0); + Known.shrunk(k, h.d.length, 0); + k.exact = true; + } else if (_43 === 7) { + rt.heapClear(h); + Known.loose(k); + } else if (_43 === 8) { + rt.heapExtend(h, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { + return rt.u8Rem(i, 3) !== 0; + }), make), rt.cmpLe(rt.cmpNothing), rt.cmpGe(rt.cmpNothing), rt.cmpLt(rt.cmpNothing), "next", 0); + } else if (_43 === 9) { + make(arg); + rt.heapPush(other, undefined, rt.cmpLe(rt.cmpNothing)); + rt.heapAppend(h, other, rt.cmpLe(rt.cmpNothing), rt.cmpGe(rt.cmpNothing), rt.cmpLt(rt.cmpNothing)); + Known.remade(k, false); + Known.put({ exact: false, floor: 0 }, out, other.d.length, rt.vecCapacity(other.d, 0)); + } else if (_43 === 10) { + rt.drop(rt.heapDrain(h)); + Known.loose(k); + } else if (_43 === 11) { + const _111: rt.PeekMut | undefined = rt.heapPeekMut(h, rt.cmpLe(rt.cmpNothing), rt.cmpGe(rt.cmpNothing), rt.cmpLt(rt.cmpNothing)); + if (_111 !== undefined) { + const top: rt.PeekMut = _111; + make(arg); + rt.peekMutDerefMut(top); + top.v = undefined; + } + Known.remade(k, false); + } else { + h = rt.heapFrom(h.d, rt.cmpLe(rt.cmpNothing), rt.cmpGe(rt.cmpNothing), rt.cmpLt(rt.cmpNothing)); + } + const _127: rt.usize = h.d.length; + const _129: rt.usize = rt.vecCapacity(h.d, 0); + Known.put(k, out, _127, _129); + } + const cloned: undefined[] = rt.heapClone(h, undefined, 0).d; + Known.put(Known.new(0), out, cloned.length, rt.vecCapacity(cloned, 0)); + const sorted: undefined[] = rt.heapIntoSortedVec(h, rt.cmpLe(rt.cmpNothing), rt.cmpGe(rt.cmpNothing), rt.cmpLt(rt.cmpNothing)); + const _145: rt.usize = sorted.length; + const _147: rt.usize = rt.vecCapacity(sorted, 0); + Known.put(k, out, _145, _147); +} + +/** + * What collections each way std's makes them from an iterator hold room for: in place of + * a `Vec` of elements of another size, by a tuple's `Extend`, by `vec!`, and by + * `with_capacity` past what one may hold, which panics. + */ +export function collects(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + const n: rt.usize = option_mapOr$1t0muvr(rt.byteSliceFirst(data), 0, (_2: rt.u8): rt.usize => { + return rt.u8Rem(_2, 24) as rt.usize; + }); + const pairs2: [rt.u32, rt.u32][] = rt.vecWithCapacity(rt.usizeAdd(n, rt.u8Rem(kind, 4) as rt.usize), 8); + const _15: rt.Iter<[rt.u32, rt.u32]> = rt.iterMap(new rt.Range(0, n as rt.u32), (i: rt.u32): [rt.u32, rt.u32] => { + return [i, i] as [rt.u32, rt.u32]; + }); + rt.iterExtend(pairs2, _15, undefined, 8, true); + const exact: Known.Known = Known.new(0); + const loose: Known.Known = { exact: false, floor: 0 }; + const _20: rt.u8 = rt.u8Rem(kind, 8); + 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); + const _28: rt.usize = halves.length; + const _30: rt.usize = rt.vecCapacity(halves, 4); + Known.put(loose, 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)); + 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 => { + 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 => { + return a0 as rt.u16; + }), undefined, 2, true); + const _64: rt.usize = wide.length; + const _66: rt.usize = rt.vecCapacity(wide, 2); + Known.put(exact, out, _64, _66); + } else if (_20 === 2) { + 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 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); + 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]; + }); + const _90: [rt.ByteVec, rt.BinaryHeap] = rt.tupleExtend([new rt.ByteVec(), rt.heapNew() as rt.BinaryHeap] as [rt.ByteVec, rt.BinaryHeap], _91, [rt.byteVecPart(), rt.heapPart(rt.le, 4)]); + const c: rt.ByteVec = _90[0]; + const d: rt.BinaryHeap = _90[1]; + Known.put(exact, out, c.length, c.data.length); + const _103: rt.usize = d.d.length; + const _105: rt.usize = rt.vecCapacity(d.d, 4); + Known.put(exact, out, _103, _105); + } else if (_20 === 3) { + const filled: rt.u16[] = rt.vecFromElem(0, n, undefined); + const _110: rt.usize = filled.length; + const _112: rt.usize = rt.vecCapacity(filled, 2); + Known.put(loose, out, _110, _112); + const units: undefined[] = rt.vecFromElem(undefined, n, undefined); + const _117: rt.usize = units.length; + const _119: rt.usize = rt.vecCapacity(units, 0); + Known.put(exact, out, _117, _119); + } 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)); + } 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 _147: rt.usize = q2.n; + const _149: rt.usize = rt.dequeCapacity(q2, 1); + 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; + const _157: rt.usize = rt.vecCapacity(heap.d, 1); + Known.put(loose, out, _155, _157); + const v2: rt.ByteVec = rt.byteVecFromVec(heap.d); + Known.put(loose, out, v2.length, v2.data.length); + } else { + const grown: rt.ByteVec = rt.byteVecFrom(rt.byteVecView(rt.byteVecOf(7, n))); + const _171: rt.Iter = rt.iterFilter(new rt.Range(0, n & 0xff), (b3: rt.u8): boolean => { + return rt.u8Rem(b3, 2) === 0; + }); + rt.iterExtendBytes(grown, _171, "next"); + Known.put(exact, out, grown.length, grown.data.length); + rt.byteVecShrinkTo(grown, rt.usizeDiv(n, 2)); + Known.put(exact, out, grown.length, grown.data.length); + } +} + +//# sourceMappingURL=capacity.ts.map diff --git a/ts/fixtures/lang/expected/chars.ts b/ts/fixtures/lang/expected/chars.ts index 1fd6c6623..98f915966 100644 --- a/ts/fixtures/lang/expected/chars.ts +++ b/ts/fixtures/lang/expected/chars.ts @@ -6,7 +6,7 @@ import { put as fmt_put } from "./fmt.ts"; /** The scalars to try: the edges, then each big-endian `u32` in `data`, zero-padded. */ export function scalars(data: rt.ByteSlice): rt.u32[] { - const all: rt.u32[] = [0, 127, 128, 255, 256, 2047, 2048, 55295, 55296, 56319, 56320, 57343, 57344, 65533, 65535, 65536, 1114109, 1114111, 1114112, 4294967295].slice(); + const all: rt.u32[] = rt.vecExact([0, 127, 128, 255, 256, 2047, 2048, 55295, 55296, 56319, 56320, 57343, 57344, 65533, 65535, 65536, 1114109, 1114111, 1114112, 4294967295].slice(), 4); let rest: rt.ByteSlice = data; while (true) { if (!((rest.length === 0))) { diff --git a/ts/fixtures/lang/expected/clones.ts b/ts/fixtures/lang/expected/clones.ts index 3e4756bb7..63df0a599 100644 --- a/ts/fixtures/lang/expected/clones.ts +++ b/ts/fixtures/lang/expected/clones.ts @@ -2694,7 +2694,7 @@ export function turns$iter_Flatten_vec_IntoIter_Vec_clones_Logged_clones_owned_c } } const other: rt.Iter = it.clone({ i: { v: (a0: clones_Logged.Logged[]): clones_Logged.Logged[] => { - return a0.map(clones_Logged.clone$Clone); + return rt.vecExact(a0.map(clones_Logged.clone$Clone), 8); } }, o: { v: clones_Logged.clone$Clone } }); rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); @@ -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)), (it8: rt.Iter): rt.u8 | undefined => { + 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 => { return rt.iterToOption(it8.nextBack()); }, plan, (x11: rt.u8): rt.u8 => { return x11; @@ -7409,10 +7409,9 @@ export function owned(data: rt.ByteSlice, plan: Plan.Plan, out: rt.ByteVec): voi return _04; }, out); flush(log.value, out); - const _35: rt.Iter = 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.dequeIter(rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 4), (_22: rt.u8): clones_Logged.Logged => { return logged(_22 & 112); - }); - turns$collections_vec_deque_IntoIter_clones_Logged_clones_owned_closure5_clones_owned_closure6(rt.dequeIter(rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(rt.iterToArray(_35, undefined, 8, true))), rt.drop), (it7: rt.Iter): clones_Logged.Logged | undefined => { + }), undefined, 8, true)) 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); @@ -7456,7 +7455,7 @@ export function owned(data: rt.ByteSlice, plan: Plan.Plan, out: rt.ByteVec): voi rt.drop(rt.iterToOption(it4.next())); rt.drop(rt.iterToOption(it4.nextBack())); const clone4: rt.Iter = it4.clone({ i: { v: (a07: clones_Logged.Logged[]): clones_Logged.Logged[] => { - return a07.map(clones_Logged.clone$Clone); + return rt.vecExact(a07.map(clones_Logged.clone$Clone), 8); } }, o: { v: clones_Logged.clone$Clone } }); flush(log.value, out); rt.drop(it4); diff --git a/ts/fixtures/lang/expected/collections.ts b/ts/fixtures/lang/expected/collections.ts index ca4d5a865..d7eb7e3a4 100644 --- a/ts/fixtures/lang/expected/collections.ts +++ b/ts/fixtures/lang/expected/collections.ts @@ -930,7 +930,7 @@ export function touch(q: rt.VecDeque): rt.VecDeque { export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { let drained2!: rt.ByteVec; const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; - const pairs: rt.VecDeque<[rt.u8, rt.u8]> = rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8]>; + 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); if (_12 === 0) { @@ -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)); - touch(q); - touch(q); + rt.dequeShrinkTo(touch(q), 0, 1); + rt.dequeReserve(touch(q), 1, 1); rt.byteVecPush(out, q.n & 0xff); rt.iterExtendBytes(out, rt.iterRev(rt.dequeIter(q)), undefined, true); if (!((q.n === 0))) { @@ -978,11 +978,10 @@ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.dequeDrain(q, undefined), "next"))); rt.byteVecPush(out, q.n === 0 ? 1 : 0); - const _111: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): collections_Tally.Tally => { + 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 }; - }); - const tallies: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _111, undefined, 2, true); - const copy: rt.VecDeque = rt.dequeClone(tallies, copy$collections_Tally); + }), undefined, 2, true)) as rt.VecDeque; + const copy: rt.VecDeque = rt.dequeClone(tallies, copy$collections_Tally, 2); const _115: collections_Tally.Tally | undefined = rt.dequeEnd(copy); if (_115 !== undefined) { _115.n = _115.n ^ 255; @@ -1027,8 +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 _198: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const q2: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _198, undefined, 1, true); + const q2: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterSlice(rt.byteSliceView(data)), undefined, 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"); @@ -3756,10 +3754,9 @@ export function unlikeEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi putEq(rt.eqSeq(rt.same)(bytes, data), log, out); const _334: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0), 0)); putEq(rt.eqSeq(rt.same)(bytes, _334), log, out); - const _341: rt.Iter = rt.iterMap(rt.dequeIter(bytes), (_28: rt.u8): rt.u16 => { + const wide: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.dequeIter(bytes), (_28: rt.u8): rt.u16 => { return _28 as rt.u16; - }); - const wide: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _341, undefined, 2, true); + }), undefined, 2, true)) as rt.VecDeque; const wrapped: rt.VecDeque = rt.dequeNew() as rt.VecDeque; const iter4: rt.Iter = rt.iterRev(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(stepped)))); while (true) { @@ -3770,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)]; + const _366: rt.VecDeque[] = [rt.dequeClone(wide, undefined, 2)]; 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()])); @@ -3794,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), bytes])); + const it2: rt.Peekable> = rt.iterPeekable(rt.iterSlice([rt.dequeClone(bytes, undefined, 1), 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); @@ -3987,13 +3984,13 @@ export function ownNes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { putEq(rt.eqSlice((a10: collections_Picky.Picky, b10: collections_Picky.Picky): boolean => { return !collections_Picky.ne$cmp_PartialEq(a10, b10); })(pa, _117), log, out); - const _123: collections_Picky.Picky[][] = [a.map(collections_Picky.clone$Clone), a.map(collections_Picky.clone$Clone)]; - const _130: collections_Picky.Picky[][] = [a.map(collections_Picky.clone$Clone), b.map(collections_Picky.clone$Clone)]; + const _123: collections_Picky.Picky[][] = [rt.vecExact(a.map(collections_Picky.clone$Clone), 8), rt.vecExact(a.map(collections_Picky.clone$Clone), 8)]; + const _130: collections_Picky.Picky[][] = [rt.vecExact(a.map(collections_Picky.clone$Clone), 8), rt.vecExact(b.map(collections_Picky.clone$Clone), 8)]; putEq(rt.eqSlice(rt.eqSlice((a11: collections_Picky.Picky, b11: collections_Picky.Picky): boolean => { return !collections_Picky.ne$cmp_PartialEq(a11, b11); }))(_123, _130), log, out); - const _139: collections_Picky.Picky[][] = [a.map(collections_Picky.clone$Clone), b.map(collections_Picky.clone$Clone)]; - const _146: collections_Picky.Picky[][] = [a.map(collections_Picky.clone$Clone), a.map(collections_Picky.clone$Clone)]; + const _139: collections_Picky.Picky[][] = [rt.vecExact(a.map(collections_Picky.clone$Clone), 8), rt.vecExact(b.map(collections_Picky.clone$Clone), 8)]; + const _146: collections_Picky.Picky[][] = [rt.vecExact(a.map(collections_Picky.clone$Clone), 8), rt.vecExact(a.map(collections_Picky.clone$Clone), 8)]; putEq(!rt.eqSlice(rt.eqSlice((a20: collections_Picky.Picky, b12: collections_Picky.Picky): boolean => { return !collections_Picky.ne$cmp_PartialEq(a20, b12); }))(_139, _146), log, out); @@ -4111,9 +4108,9 @@ export function ownNes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const shared: rt.Arc[] = each$collections_Picky_sync_Arc_collections_Picky_collections_own_nes_closure16(a, (p12: collections_Picky.Picky): rt.Arc => { return new rt.Arc(collections_Picky.clone$Clone(p12)); }); - const _426: rt.Arc[] = shared.map((a041: rt.Arc): rt.Arc => { + const _426: rt.Arc[] = rt.vecExact(shared.map((a041: rt.Arc): rt.Arc => { return rt.arcClone(a041); - }); + }), 4); putEq(rt.eqSlice(rt.eqArc((a35: collections_Picky.Picky, b27: collections_Picky.Picky): boolean => { return !collections_Picky.ne$cmp_PartialEq(a35, b27); }, true))(shared, _426), log, out); @@ -4155,7 +4152,7 @@ export function ownNes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _504: [collections_Picky.Picky] = [one(b, 0)]; putEq(!rt.eqTuple([collections_Picky.eq$cmp_PartialEq])(_496, _504), log, out); putEq(collections_Picky.eq$cmp_PartialEq(one(a, 1), one(b, 1)), log, out); - const _531: [rt.Cow, rt.Cow] = [new rt.Borrowed(rt.sliceRange(a, 0)), b.map(collections_Picky.clone$Clone)]; + const _531: [rt.Cow, rt.Cow] = [new rt.Borrowed(rt.sliceRange(a, 0)), rt.vecExact(b.map(collections_Picky.clone$Clone), 8)]; const ca: rt.Cow = _531[0]; const cb: rt.Cow = _531[1]; putEq(rt.eqSlice((a42: collections_Picky.Picky, b34: collections_Picky.Picky): boolean => { @@ -4388,8 +4385,8 @@ export function cellEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const _595: [Quirky.Quirky[], Quirky.Quirky[]] = [copy$array_collections_Quirky([x, y, x]).map(copy$collections_Quirky), copy$array_collections_Quirky([y, y, x]).map(copy$collections_Quirky)]; const va: Quirky.Quirky[] = _595[0]; const vb: Quirky.Quirky[] = _595[1]; - const _603: rt.RefCell = new rt.RefCell(va.map(copy$collections_Quirky)); - const _607: rt.RefCell = new rt.RefCell(vb.map(copy$collections_Quirky)); + const _603: rt.RefCell = new rt.RefCell(rt.vecExact(va.map(copy$collections_Quirky), 8)); + const _607: rt.RefCell = new rt.RefCell(rt.vecExact(vb.map(copy$collections_Quirky), 8)); putEq(rt.refCellBy(rt.eqSlice((a2: Quirky.Quirky, b2: Quirky.Quirky): boolean => { return !Quirky.ne$cmp_PartialEq(a2, b2); }))(_603, _607), log, out); @@ -5238,7 +5235,7 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo } const _1431: [ByRef.ByRef[], rt.ByteVec] = [rt.iterToArray(rt.iterSlice(byRef), undefined, 4, true), out]; const xs: ByRef.ByRef[] = _1431[0]; - const sorted: ByRef.ByRef[] = xs.slice(); + const sorted: ByRef.ByRef[] = rt.vecExact(xs.slice(), 4); rt.sliceSort(sorted, rt.cmpLt(ByRef.partialCmp$cmp_PartialOrd_ref)); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(sorted), (x4: ByRef.ByRef): rt.u8 => { return x4._0 & 0xff; @@ -5284,11 +5281,10 @@ 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); - const _1531: ByRef.ByRef[] = xs.slice(); - rt.byteVecPush(out, rt.dequeContains(rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_1531), undefined, 4, true), 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)) 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[] = xs2.slice(); + const sorted2: ByVal.ByVal[] = rt.vecExact(xs2.slice(), 4); rt.sliceSort(sorted2, rt.cmpLt(ByVal.partialCmp$cmp_PartialOrd)); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(sorted2), (x10: ByVal.ByVal): rt.u8 => { return x10._0 & 0xff; @@ -5334,11 +5330,10 @@ 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); - const _1641: ByVal.ByVal[] = xs2.slice(); - rt.byteVecPush(out, rt.dequeContains(rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_1641), undefined, 4, true), 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)) 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[] = xs3.slice(); + const sorted3: Mixed.Mixed[] = rt.vecExact(xs3.slice(), 4); rt.sliceSort(sorted3, rt.cmpLt(Mixed.partialCmp$cmp_PartialOrd)); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(sorted3), (x16: Mixed.Mixed): rt.u8 => { return x16._0 & 0xff; @@ -5384,8 +5379,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); - const _1751: Mixed.Mixed[] = xs3.slice(); - rt.byteVecPush(out, rt.dequeContains(rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_1751), undefined, 4, true), 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)) 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/core/option.ts b/ts/fixtures/lang/expected/core/option.ts index 158148c4f..efd655972 100644 --- a/ts/fixtures/lang/expected/core/option.ts +++ b/ts/fixtures/lang/expected/core/option.ts @@ -1400,6 +1400,13 @@ export function mapOr$1hjjwvv(self: [rt.Mutex, rt.u8] | undefined, defaul return f(self); } +export function mapOr$1ttssgs(self: [rt.u8, rt.ByteSlice] | undefined, default_: [rt.u8, rt.ByteSlice], f: (a0: [rt.u8, rt.ByteSlice]) => [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] { + if (self === undefined) { + return default_; + } + return f(self); +} + export function mapOr$0mmpeqx(self: [rt.u8, rt.u8] | undefined, default_: rt.u8, f: (a0: [rt.u8, rt.u8]) => rt.u8): rt.u8 { if (self === undefined) { return default_; @@ -1878,11 +1885,11 @@ export function clone$14nprly(self: string | undefined): string | undefined { return self; } -export function clone$096c3ul(self: rt.u16[] | undefined): rt.u16[] | undefined { +export function clone$0hmts8n(self: rt.u16[] | undefined): rt.u16[] | undefined { if (self === undefined) { return undefined; } - return self.slice(); + return rt.vecExact(self.slice(), 2); } export function clone$1grnave(self: rt.ByteVec | undefined): rt.ByteVec | undefined { diff --git a/ts/fixtures/lang/expected/counts.ts b/ts/fixtures/lang/expected/counts.ts index 9381f6867..d9a46b6d8 100644 --- a/ts/fixtures/lang/expected/counts.ts +++ b/ts/fixtures/lang/expected/counts.ts @@ -298,9 +298,9 @@ export function clonedArcs(data: rt.ByteSlice, out: rt.ByteVec): void { _192 = false; } else if (_34 === 6) { const _125: rt.Arc[] | undefined = rt.sliceFirst(lists); - const list: rt.Arc[] | undefined = _125 === undefined ? undefined : _125.map((a0: rt.Arc): rt.Arc => { + const list: rt.Arc[] | undefined = _125 === undefined ? undefined : rt.vecExact(_125.map((a0: rt.Arc): rt.Arc => { return rt.arcClone(a0); - }); + }), 4); rt.byteVecPush(out, option_mapOr$1unqgn7(list, 253, (l: rt.Arc[]): rt.u8 => { return l.length & 0xff; })); @@ -655,9 +655,9 @@ export function clonedRcs(data: rt.ByteSlice, out: rt.ByteVec): void { _192 = false; } else if (_34 === 6) { const _125: rt.Arc[] | undefined = rt.sliceFirst(lists); - const list: rt.Arc[] | undefined = _125 === undefined ? undefined : _125.map((a0: rt.Arc): rt.Arc => { + const list: rt.Arc[] | undefined = _125 === undefined ? undefined : rt.vecExact(_125.map((a0: rt.Arc): rt.Arc => { return rt.arcClone(a0); - }); + }), 4); rt.byteVecPush(out, option_mapOr$1unqgn7(list, 253, (l: rt.Arc[]): rt.u8 => { return l.length & 0xff; })); diff --git a/ts/fixtures/lang/expected/cows.ts b/ts/fixtures/lang/expected/cows.ts index cfbfab9ce..e16d42932 100644 --- a/ts/fixtures/lang/expected/cows.ts +++ b/ts/fixtures/lang/expected/cows.ts @@ -158,7 +158,7 @@ export function cowOf(v: rt.u16[], owned: boolean): rt.Cow { if (!owned) { return new rt.Borrowed(v); } - return v.slice(); + return rt.vecExact(v.slice(), 2); } export function putWords(out: rt.ByteVec, v: rt.u16[]): void { @@ -226,7 +226,7 @@ export function slices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { putWords(out, rt.cowIntoOwned(c)); const empty: rt.Cow = []; putWords(out, rt.cowSlice(empty)); - const iter: rt.Iter> = rt.iterSlice([new rt.Borrowed(half), v.slice(), new rt.Borrowed(v), new rt.Borrowed([3, 1, 4]), rt.iterToArray(rt.iterRev(rt.iterSlice(v)), undefined, 2, true)]); + const iter: rt.Iter> = rt.iterSlice([new rt.Borrowed(half), rt.vecExact(v.slice(), 2), new rt.Borrowed(v), new rt.Borrowed([3, 1, 4]), rt.iterToArray(rt.iterRev(rt.iterSlice(v)), undefined, 2, true)]); while (true) { const _100: rt.Cow | rt.Done = iter.next(); if (_100 === rt.DONE) { @@ -278,7 +278,7 @@ export function slices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _201: rt.u16[] = rt.sliceRange(v, 0); const _197: boolean = rt.eqSlice(rt.same)(rt.cowSlice(a), _201); const _203: boolean = rt.eqSlice(rt.same)(rt.cowSlice(a), v); - const _209: rt.u16[] = half.slice(); + const _209: rt.u16[] = rt.vecExact(half.slice(), 2); const _206: boolean = !rt.eqSlice(rt.same)(rt.cowSlice(a), _209); const _210: boolean = rt.eqSlice(rt.same)(half, rt.cowSlice(b)); const _213: boolean = rt.eqSlice(rt.same)(v, rt.cowSlice(a)); @@ -337,7 +337,7 @@ export function slices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, borrowed.slice.length & 0xff); } else { rt.vecTruncate(e as rt.u16[], 1); - const _336: rt.u16[] = half.slice(); + const _336: rt.u16[] = rt.vecExact(half.slice(), 2); (e as rt.u16[]) = _336; rt.byteVecPush(out, (e as rt.u16[]).length & 0xff); } @@ -353,7 +353,7 @@ export function slices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { b16: { if (d instanceof rt.Borrowed) { if ((d as rt.Borrowed).slice.length > 1) { - _359 = rt.sliceRange((d as rt.Borrowed).slice, 1).slice(); + _359 = rt.vecExact(rt.sliceRange((d as rt.Borrowed).slice, 1).slice(), 2); break b16; } } @@ -408,7 +408,7 @@ export function slices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (!owned) { c4 = new rt.Borrowed(rt.sliceRange(items, 0)); } else { - c4 = items.map(cows_Tally.clone$Clone); + c4 = rt.vecExact(items.map(cows_Tally.clone$Clone), 8); } rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.cellReplace(log, 0)))); const copy: rt.Cow = rt.cowClone(c4, cows_Tally.clone$Clone); diff --git a/ts/fixtures/lang/expected/edits.ts b/ts/fixtures/lang/expected/edits.ts index 7579ae0b4..090c62c6a 100644 --- a/ts/fixtures/lang/expected/edits.ts +++ b/ts/fixtures/lang/expected/edits.ts @@ -47,7 +47,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }; const _8: rt.u8 = rt.u8Rem(kind, 8); if (_8 === 0) { - const v: rt.u16[] = words.slice(); + const v: rt.u16[] = rt.vecExact(words.slice(), 2); const seen: rt.u16[] = []; rt.vecRetain(v, (_227: rt.u16): boolean => { const x4: rt.u16 = _227; @@ -73,7 +73,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.stringLen(s3) > 1; }); rt.byteVecPush(out, names.length & 0xff); - const v2: rt.u16[] = words.slice(); + const v2: rt.u16[] = rt.vecExact(words.slice(), 2); while (true) { const _55: rt.u16 | undefined = rt.vecPopIfMut(v2, (x5: rt.Place): boolean => { x5.v = x5.v ^ 1; @@ -146,10 +146,10 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.vecDedupBy(names2, rt.same); rt.byteVecPush(out, names2.length & 0xff); } else if (_8 === 2) { - const v4: rt.u16[] = words.slice(); + const v4: rt.u16[] = rt.vecExact(words.slice(), 2); rt.sliceSort(v4, rt.lt); putU16s(out, v4); - const v5: rt.u16[] = words.slice(); + const v5: rt.u16[] = rt.vecExact(words.slice(), 2); rt.sliceSortBy(v5, (a: rt.u16, b6: rt.u16): rt.Ordering => { return rt.cmp(b6, a); }); @@ -199,7 +199,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, _263); } } else if (_8 === 3) { - const v6: rt.u16[] = words.slice(); + const v6: rt.u16[] = rt.vecExact(words.slice(), 2); putU16s(out, [option_unwrapOr$1j4op5y(rt.sliceLast(v6), 65535)]); const runs: [rt.u16, rt.u16 | undefined][] = rt.iterToArray(rt.iterMap(rt.iterSlice(words), (_210: rt.u16): [rt.u16, rt.u16 | undefined] => { return [_210, undefined] as [rt.u16, rt.u16 | undefined]; @@ -229,7 +229,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _366: [rt.usize, rt.usize] = [rt.usizeRem(at(0) as rt.usize, 8), rt.usizeRem(at(1) as rt.usize, 8)]; const i: rt.usize = _366[0]; const j: rt.usize = _366[1]; - const moved: rt.u16[] = words.slice(); + const moved: rt.u16[] = rt.vecExact(words.slice(), 2); putU16s(out, [rt.vecSwapRemove(moved, i)]); putU16s(out, moved); rt.sliceSwap(moved, i, j); @@ -239,9 +239,9 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const w4: rt.u16 = _28; return { id: w4, name: text(rt.byteSliceFrom(Uint8Array.of(w4 & 0xff))) }; }), undefined, 16, true); - const cloned: edits_Named.Named[] = named2.map(edits_Named.clone$Clone); + 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); - const changed: edits_Named.Named[] = named2.map(edits_Named.clone$Clone); + const changed: edits_Named.Named[] = rt.vecExact(named2.map(edits_Named.clone$Clone), 16); const _411: edits_Named.Named | undefined = rt.sliceFirst(changed); if (_411 !== undefined) { _411.name = _411.name + "!"; @@ -258,9 +258,9 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u16Add(i4 as rt.u16, b5 as rt.u16); }), undefined, 2, true); }), undefined, 12, true); - const _453: rt.u16[][] = nested.map((a027: rt.u16[]): rt.u16[] => { - return a027.slice(); - }); + const _453: rt.u16[][] = rt.vecExact(nested.map((a027: rt.u16[]): rt.u16[] => { + 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 copy: [string, rt.u8] = rt.tupleClone(pair, [undefined, undefined]); @@ -271,7 +271,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _483: [rt.u8, rt.u8] = [at(0), at(1)]; 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[] = words.slice(); + const grown: rt.u16[] = rt.vecExact(words.slice(), 2); rt.vecExtendFromSlice(grown, words); putU16s(out, grown); } else if (_8 === 5) { @@ -282,8 +282,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, taken3.n); rt.byteVecPush(out, tally.n); fmt_put(out, tally.names[rt.idx(tally.names, 0)]); - const _525: rt.Iter = rt.iterSlice(words); - let queue: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _525, undefined, 2, true); + 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; const taken4 = queue; queue = default_2; @@ -321,7 +320,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _634: rt.usize = rt.usizeRem(at(1) as rt.usize, 8); const removed: edits_Named.Named = rt.vecRemove(v7, _634); putU16s(out, [removed.id]); - const kept: edits_Named.Named[] = v7.map(edits_Named.clone$Clone); + const kept: edits_Named.Named[] = rt.vecExact(v7.map(edits_Named.clone$Clone), 16); const _649: rt.usize = rt.usizeRem(at(2) as rt.usize, 4); rt.vecTruncate(v7, _649); putU16s(out, _605(v7)); @@ -340,8 +339,8 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }) === option_map$0xa0bn7(held, (b4: edits_Named.Named): rt.u16 => { return b4.id; }) ? 1 : 0); - const some: edits_Named.Named[] | undefined = kept.map(edits_Named.clone$Clone); - const _701: edits_Named.Named[] | undefined = kept.map(edits_Named.clone$Clone); + const some: edits_Named.Named[] | undefined = rt.vecExact(kept.map(edits_Named.clone$Clone), 16); + const _701: edits_Named.Named[] | undefined = rt.vecExact(kept.map(edits_Named.clone$Clone), 16); rt.byteVecPush(out, rt.eqOption(rt.eqSlice(edits_Named.eq$cmp_PartialEq))(some, _701) ? 1 : 0); rt.byteVecPush(out, rt.eqOption(rt.eqSlice(edits_Named.eq$cmp_PartialEq))(some, undefined) ? 1 : 0); const _715: edits_Named.Named[] = []; @@ -464,7 +463,7 @@ export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v2)); rt.byteVecPush(out, 254); } - const halves: rt.u16[] = words.slice(); + const halves: rt.u16[] = rt.vecExact(words.slice(), 2); rt.vecRetainMut(halves, (x2: rt.Place): boolean => { x2.v = rt.u16Div(x2.v, 2); return rt.u16Rem(x2.v, 3) !== 0; @@ -499,13 +498,13 @@ export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v5)); rt.byteVecPush(out, 254); } - const v6: rt.u16[] = words.slice(); + const v6: rt.u16[] = rt.vecExact(words.slice(), 2); rt.vecDedupByMut(v6, (a4: rt.Place, b10: rt.Place): boolean => { b10.v = rt.u16Add(b10.v, 1); return rt.u16Div(a4.v, 8) === rt.u16Div(b10.v, 8); }); putU16s(out, v6); - const v7: rt.u16[] = words.slice(); + const v7: rt.u16[] = rt.vecExact(words.slice(), 2); rt.vecDedupByKeyMut(v7, (x: rt.Place): rt.u16 => { x.v = x.v ^ 1; return rt.u16Div(x.v, 16); diff --git a/ts/fixtures/lang/expected/errors.ts b/ts/fixtures/lang/expected/errors.ts index 67b4a0d98..10150aca7 100644 --- a/ts/fixtures/lang/expected/errors.ts +++ b/ts/fixtures/lang/expected/errors.ts @@ -436,9 +436,9 @@ export function eqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.idx(_14, _15); input = input + String.fromCodePoint(_14[_15]); } - const all: string[] = ["", "0", "-0", "1", "-1", "+", "a", "ab", "😀", "true", "false", "127", "128", "-128", "-129", "256", "18446744073709551615", "18446744073709551616", "-170141183460469231731687303715884105729", "1.5", "1e400", "NaN", "inf"].slice(); + const all: string[] = rt.vecExact(["", "0", "-0", "1", "-1", "+", "a", "ab", "😀", "true", "false", "127", "128", "-128", "-129", "256", "18446744073709551615", "18446744073709551616", "-170141183460469231731687303715884105729", "1.5", "1e400", "NaN", "inf"].slice(), 8); all.push(input); - const bytes: rt.ByteSlice[] = [rt.byteSliceFrom(Uint8Array.of()), rt.byteSliceFrom(Uint8Array.of(97)), rt.byteSliceFrom(Uint8Array.of(255)), rt.byteSliceFrom(Uint8Array.of(97, 255)), rt.byteSliceFrom(Uint8Array.of(195)), rt.byteSliceFrom(Uint8Array.of(97, 195)), rt.byteSliceFrom(Uint8Array.of(224, 128)), rt.byteSliceFrom(Uint8Array.of(240, 159, 152)), rt.byteSliceFrom(Uint8Array.of(240, 159, 152, 128)), rt.byteSliceFrom(Uint8Array.of(237, 160, 128))].slice(); + const bytes: rt.ByteSlice[] = rt.vecExact([rt.byteSliceFrom(Uint8Array.of()), rt.byteSliceFrom(Uint8Array.of(97)), rt.byteSliceFrom(Uint8Array.of(255)), rt.byteSliceFrom(Uint8Array.of(97, 255)), rt.byteSliceFrom(Uint8Array.of(195)), rt.byteSliceFrom(Uint8Array.of(97, 195)), rt.byteSliceFrom(Uint8Array.of(224, 128)), rt.byteSliceFrom(Uint8Array.of(240, 159, 152)), rt.byteSliceFrom(Uint8Array.of(240, 159, 152, 128)), rt.byteSliceFrom(Uint8Array.of(237, 160, 128))].slice(), 8); bytes.push(data); const _32: rt.u8 = rt.u8Rem(kind, 15); if (_32 === 0) { diff --git a/ts/fixtures/lang/expected/fmt.ts b/ts/fixtures/lang/expected/fmt.ts index c19f86727..db283be35 100644 --- a/ts/fixtures/lang/expected/fmt.ts +++ b/ts/fixtures/lang/expected/fmt.ts @@ -258,7 +258,7 @@ export function nested(data: rt.ByteSlice): Nested.Nested { _22 = { tag: "Rect", corner: { x: 0, y: 0 }, width: at(3) as rt.u16, height: 9 } as shapes_Shape.Shape; } const _35: rt.ByteVec = rt.byteSliceToByteVec(rt.byteSliceRange(data, 0, rt.min(data.length, 4))); - const _40: fmt_Pair.Pair[] = [{ _0: at(4), _1: -1 }, { _0: 2, _1: { hi: -0x80000000, lo: 0 } as rt.i64 }].slice(); + const _40: fmt_Pair.Pair[] = rt.vecExact([{ _0: at(4), _1: -1 }, { _0: 2, _1: { hi: -0x80000000, lo: 0 } as rt.i64 }].slice(), 16); if (!(rt.u8Rem(at(5), 2) === 0)) { _49 = undefined; } else { @@ -371,12 +371,12 @@ export function written(data: rt.ByteSlice, out: rt.ByteVec): void { const arg = { _0: "pad" }; const args6: rt.Fmt[] = [(f: rt.Formatter) => Padded.fmt$fmt_Display(arg, f)]; put(out, rt.fmtFormat([args6[0], "|", rt.fmtSpec({ align: ">", width: 6 }, args6[0]), "|", rt.fmtSpec({ fill: "_", align: "^", width: 9 }, args6[0]), "|", rt.fmtSpec({ width: 30 }, args6[0]), "|"])); - const manual: Manual.Manual = { id: at(1), list: [1, at(2) as rt.u16].slice() }; + const manual: Manual.Manual = { id: at(1), list: rt.vecExact([1, at(2) as rt.u16].slice(), 2) }; const _71: rt.u16[] = []; const empty: Manual.Manual = { id: 0, list: _71 }; const args8: rt.Fmt[] = [(f: rt.Formatter) => Manual.fmt$fmt_Debug(manual, f), (f: rt.Formatter) => Manual.fmt$fmt_Debug(empty, f)]; put(out, rt.fmtFormat([args8[0], " ", rt.fmtSpec({ alternate: true }, args8[0]), " ", args8[1]])); - const seq: Seq.Seq = { _0: [{ _0: at(3), _1: 0 }, { _0: 1, _1: -1 }].slice() }; + const seq: Seq.Seq = { _0: rt.vecExact([{ _0: at(3), _1: 0 }, { _0: 1, _1: -1 }].slice(), 16) }; const _97: fmt_Pair.Pair[] = []; const none: Seq.Seq = { _0: _97 }; const args10: rt.Fmt[] = [(f: rt.Formatter) => Seq.fmt$fmt_Debug(seq, f), (f: rt.Formatter) => Seq.fmt$fmt_Debug(none, f)]; @@ -694,7 +694,7 @@ export function wrapped(data: rt.ByteSlice, out: rt.ByteVec): void { const rc: rt.Arc = new rt.Arc(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_310]); const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, rc.value), (f: rt.Formatter) => rt.fmtStr(rc.value, f)]; put(out, rt.fmtFormat([args18[0], "|", rt.fmtSpec({ align: ">", width: 8, precision: 2 }, args18[0]), "|", args18[1]])); - const list: rt.Arc = new rt.Arc([{ _0: at(7), _1: 2 }, { _0: 3, _1: -4 }].slice()); + const list: rt.Arc = new rt.Arc(rt.vecExact([{ _0: at(7), _1: 2 }, { _0: 3, _1: -4 }].slice(), 16)); const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(list.value, f, (value: fmt_Pair.Pair, f: rt.Formatter) => fmt_Pair.fmt$fmt_Debug(value, f))]; put(out, rt.fmtFormat([args20[0], " ", rt.fmtSpec({ alternate: true }, args20[0])])); const held: rt.Range> = new rt.Range(new rt.Arc(a), new rt.Arc(b)); @@ -731,7 +731,7 @@ export function collections(data: rt.ByteSlice, out: rt.ByteVec): void { const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; - const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const q: rt.VecDeque = rt.dequeWithCapacity(4, 2) as rt.VecDeque; for (const b of rt.byteSliceView(data)) { const _12: rt.u8 = rt.u8Rem(b, 4); if (_12 === 0) { @@ -748,7 +748,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.dequeNew() as rt.VecDeque; + const wrapped: rt.VecDeque = rt.dequeWithCapacity(4, 4) as rt.VecDeque; rt.dequeExtend(wrapped, rt.iterSlice([{ _0: 1 }, { _0: 2 }]), undefined, 4, true); const _48: Hex.Hex = { _0: rt.u32Mul(at(0) as rt.u32, 4097) }; rt.dequePushFront(wrapped, _48); @@ -761,8 +761,7 @@ export function collections(data: rt.ByteSlice, out: rt.ByteVec): void { 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 _91: rt.Iter = rt.iterMap(new rt.Range(0, rt.u8Rem(at(2), 3)), (_2: rt.u8): undefined => {}); - const units: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _91, undefined, 0, true); + 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 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; @@ -1048,18 +1047,17 @@ export function iters(data: rt.ByteSlice, out: rt.ByteVec): void { const part7 = ends$iters_collections_binary_heap_Iter_u8(rt.heapIter(heap), front, back); const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part7, f, rt.u8Debug, ["Iter"])]; put(out, rt.fmtFormat([args20[0], "|", rt.fmtSpec({ alternate: true }, args20[0])])); - const part8 = ends$iters_collections_binary_heap_IntoIter_u8(rt.heapIter(rt.heapClone(heap)), front, back); + const part8 = ends$iters_collections_binary_heap_IntoIter_u8(rt.heapIter(rt.heapClone(heap, undefined, 1)), front, back); const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part8, f, rt.u8Debug, ["IntoIter"])]; put(out, rt.fmtFormat([args22[0]])); - const it8: rt.Iter = ends$iters_collections_binary_heap_Drain_u8(rt.heapDrain(rt.heapClone(heap)), front, back); + const it8: rt.Iter = ends$iters_collections_binary_heap_Drain_u8(rt.heapDrain(rt.heapClone(heap, undefined, 1)), front, back); 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 _236: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_27: rt.u8): rt.u8 | undefined => { + 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 b4: rt.u8 = _27; return thenSome$0d5am30(rt.u8Rem(b4, 3) !== 0, b4); - }); - const part9 = ends$iters_collections_vec_deque_IntoIter_Option_u8(rt.dequeIter(rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _236, undefined, 2, true)), front, back); + }), undefined, 2, true)) 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/generics.Runs.ts b/ts/fixtures/lang/expected/generics.Runs.ts index f9b772f86..56bb84a40 100644 --- a/ts/fixtures/lang/expected/generics.Runs.ts +++ b/ts/fixtures/lang/expected/generics.Runs.ts @@ -2,15 +2,15 @@ import * as rt from "./rt.ts"; import { copy$array_u16, copy$array_u8 } from "./lib.ts"; -import { clone$096c3ul as option_clone$096c3ul, clone$1grnave as option_clone$1grnave } from "./core/option.ts"; +import { clone$0hmts8n as option_clone$0hmts8n, clone$1grnave as option_clone$1grnave } from "./core/option.ts"; import type * as generics_Run from "./generics.Run.ts"; export function clone$Clone_u16(self: Runs): Runs { - return new Runs(copy$array_u16(copy$array_u16(self.array as rt.u16[])), (self.list as rt.u16[]).slice(), self.view as rt.u16[], (self.boxed as rt.u16[]).slice(), rt.cowClone(self.cow as rt.Cow), (self.pairs as rt.u16[][]).map(copy$array_u16), option_clone$096c3ul(self.maybe as rt.u16[] | undefined)); + return new Runs(copy$array_u16(copy$array_u16(self.array as rt.u16[])), rt.vecExact((self.list as rt.u16[]).slice(), 2), self.view as rt.u16[], (self.boxed as rt.u16[]).slice(), rt.cowClone(self.cow as rt.Cow), rt.vecExact((self.pairs as rt.u16[][]).map(copy$array_u16), 4), option_clone$0hmts8n(self.maybe as rt.u16[] | undefined)); } export function clone$Clone_u8(self: Runs): Runs { - return new Runs(copy$array_u8(rt.byteSliceToArray(rt.byteSliceFrom(self.array as Uint8Array))), rt.byteVecFrom(rt.byteVecView(self.list as rt.ByteVec)), self.view as rt.ByteSlice, rt.byteSliceFrom(rt.byteSliceToArray(self.boxed as rt.ByteSlice)), rt.byteCowClone(self.cow as rt.ByteCow), (self.pairs as Uint8Array[]).map(copy$array_u8), option_clone$1grnave(self.maybe as rt.ByteVec | undefined)); + return new Runs(copy$array_u8(rt.byteSliceToArray(rt.byteSliceFrom(self.array as Uint8Array))), rt.byteVecFrom(rt.byteVecView(self.list as rt.ByteVec)), self.view as rt.ByteSlice, rt.byteSliceFrom(rt.byteSliceToArray(self.boxed as rt.ByteSlice)), rt.byteCowClone(self.cow as rt.ByteCow), rt.vecExact((self.pairs as Uint8Array[]).map(copy$array_u8), 2), option_clone$1grnave(self.maybe as rt.ByteVec | undefined)); } export function fmt$fmt_Debug_u16(self: Runs, f: rt.Formatter): rt.Result { @@ -161,7 +161,7 @@ export function push$u8(self: Runs, item: rt.u8): void { export function run$u16(self: Runs): generics_Run.Run { const _2: rt.usize = rt.usizeRem((self.list as rt.u16[]).length, 3); if (_2 === 0) { - return { tag: "Listed", _0: (self.list as rt.u16[]).slice() } as generics_Run.Run; + return { tag: "Listed", _0: rt.vecExact((self.list as rt.u16[]).slice(), 2) } as generics_Run.Run; } if (_2 === 1) { return { tag: "Fixed", array: [(self.array as rt.u16[])[0], (self.array as rt.u16[])[2]] } as generics_Run.Run; diff --git a/ts/fixtures/lang/expected/generics.ts b/ts/fixtures/lang/expected/generics.ts index 40218e409..e26b4709a 100644 --- a/ts/fixtures/lang/expected/generics.ts +++ b/ts/fixtures/lang/expected/generics.ts @@ -75,7 +75,7 @@ export function methods(data: rt.ByteSlice, out: rt.ByteVec): void { const _193: rt.u8 = option_unwrapOr$0r2bmpr(Wrap.get$Option_u8(none), some.count); const args10: rt.Fmt[] = [(f: rt.Formatter) => Wrap.fmt$fmt_Debug_Vec_u16(list, f), (f: rt.Formatter) => Wrap.fmt$fmt_Debug_Option_u8(none, f), (f: rt.Formatter) => Wrap.fmt$fmt_Debug_Option_u8(some, f), (f: rt.Formatter) => Wrap.fmt$fmt_Debug_Result_u8_shapes_Shape(err, f), (f: rt.Formatter) => rt.u8Debug(_193, f)]; fmt_put(out, rt.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " ", args10[3], " ", args10[4]])); - const tagged: generics_Tagged.Tagged, rt.i16> = new generics_Tagged.Tagged({ tag: "Right", value: 500 } as Either.Either, Wrap.new$i16(rt.i16Sub(at(8) as rt.i16, 100)), [Wrap.new$i16(-1), Wrap.new$i16(at(9) as rt.i16)].slice()); + const tagged: generics_Tagged.Tagged, rt.i16> = new generics_Tagged.Tagged({ tag: "Right", value: 500 } as Either.Either, Wrap.new$i16(rt.i16Sub(at(8) as rt.i16, 100)), rt.vecExact([Wrap.new$i16(-1), Wrap.new$i16(at(9) as rt.i16)].slice(), 4)); const _237: Wrap.Wrap | undefined = generics_Tagged.first$generics_Either_u8_u16_i16(tagged); const args12: rt.Fmt[] = [(f: rt.Formatter) => generics_Tagged.fmt$fmt_Debug_generics_Either_u8_u16_i16(tagged, f), (f: rt.Formatter) => rt.fmtOption(_237, f, (value: Wrap.Wrap, f: rt.Formatter) => Wrap.fmt$fmt_Debug_i16(value, f))]; fmt_put(out, rt.fmtFormat([args12[0], " ", args12[1]])); @@ -205,9 +205,9 @@ export function runs(data: rt.ByteSlice, out: rt.ByteVec): void { return _22 as rt.u16; }), undefined, 2, true); const n2: rt.u16 = option_unwrapOrDefault$001fvl5(rt.sliceFirst(data3)); - const _129: rt.u16[] = data3.slice(); + const _129: rt.u16[] = rt.vecExact(data3.slice(), 2); const _131: rt.u16[] = data3; - const _133: rt.u16[] = data3.slice(); + const _133: rt.u16[] = rt.vecExact(data3.slice(), 2); const _136: rt.Cow = new rt.Borrowed(data3); const _139: rt.u16[][] = []; const runs2: Runs.Runs = new Runs.Runs(Array.from({ length: 3 }, (): rt.u16 => { @@ -260,7 +260,7 @@ export function runs(data: rt.ByteSlice, out: rt.ByteVec): void { return tick(_28); }), undefined, 8, true); const _246: Ticked.Ticked[] = [tick(1), tick(2), tick(3)]; - const _256: Ticked.Ticked[] = ticks.map(Ticked.clone$Clone); + const _256: Ticked.Ticked[] = rt.vecExact(ticks.map(Ticked.clone$Clone), 8); const _258: Ticked.Ticked[] = ticks; const _260: Ticked.Ticked[] = [tick(4)]; if (rt.usizeRem(data.length, 2) === 0) { diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index f59dc2e82..53f7a2b71 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -8,12 +8,13 @@ import { atomics } from "./atomics.ts"; import { borrows as borrows_borrows, guards, maps as borrows_maps } from "./borrows.ts"; import { bounds as bounds_bounds } from "./bounds.ts"; import { boxes, places as boxes_places } from "./boxes.ts"; +import { vecs as capacity_vecs, deques as capacity_deques, heaps as capacity_heaps, collects } from "./capacity.ts"; import { captures } from "./captures.ts"; import { cells as cells_cells } from "./cells.ts"; import { chars as chars_chars } from "./chars.ts"; import { chunks } from "./chunks.ts"; import { iters as clones_iters } from "./clones.ts"; -import { hashMaps, sets, btreeMaps, deques, vecs, stores, optionals, setOps, unlikeEqs, ownNes, cellEqs, unlikeCompares, refOrders } from "./collections.ts"; +import { hashMaps, sets, btreeMaps, deques as collections_deques, vecs as collections_vecs, stores, optionals, setOps, unlikeEqs, ownNes, cellEqs, unlikeCompares, refOrders } from "./collections.ts"; import { combinators } from "./combinators.ts"; import { arcs as counts_arcs, clonedArcs, cyclicArcs, uniqueArcs, clonedRcs, cyclicRcs, rcs, uniqueRcs, copies as counts_copies } from "./counts.ts"; import { cows, slices as cows_slices, bytes as cows_bytes } from "./cows.ts"; @@ -99,11 +100,11 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::order", (_2115: rt.u8, data16: rt.ByteSlice, out16: rt.ByteVec): undefined => { shapes_order(data16, out16); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::hash_maps", hashMaps as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::sets", sets as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::btree_maps", btreeMaps as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::deques", (_2116: rt.u8, data17: rt.ByteSlice, out17: rt.ByteVec): undefined => { - deques(data17, out17); + collections_deques(data17, out17); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::flows", (_2117: rt.u8, data18: rt.ByteSlice, out18: rt.ByteVec): undefined => { flows(data18, out18); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::keys", keys_keys as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["chars::chars", chars_chars as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::strs", strs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::vecs", (_2118: rt.u8, data19: rt.ByteSlice, out19: rt.ByteVec): undefined => { - vecs(data19, out19); + collections_vecs(data19, out19); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::slices", strs_slices as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::stores", (_2119: rt.u8, data20: rt.ByteSlice, out20: rt.ByteVec): undefined => { stores(data20, out20); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["chunks::chunks", chunks as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cows::cows", cows as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["durations::durations", durations as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["combinators::combinators", combinators as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["splits::splits", splits as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["nested::nested", nested_nested as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["refs::refs", (_2120: rt.u8, data21: rt.ByteSlice, out21: rt.ByteVec): undefined => { @@ -260,7 +261,13 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) borrows_maps(data91, out92); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locks::mapped", (_2192: rt.u8, data92: rt.ByteSlice, out93: rt.ByteVec): undefined => { mapped(data92, out93); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["capacity::vecs", (a0152: rt.u8, a1152: rt.ByteSlice, a2152: rt.ByteVec): undefined => { + capacity_vecs(a0152, a1152.data, a1152.start, a1152.length, a2152); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["capacity::deques", (a0153: rt.u8, a1153: rt.ByteSlice, a2153: rt.ByteVec): undefined => { + capacity_deques(a0153, a1153.data, a1153.start, a1153.length, a2153); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["capacity::heaps", (a0154: rt.u8, a1154: rt.ByteSlice, a2154: rt.ByteVec): undefined => { + capacity_heaps(a0154, a1154.data, a1154.start, a1154.length, a2154); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["capacity::collects", collects as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; } /** Run one case. */ diff --git a/ts/fixtures/lang/expected/hints.ts b/ts/fixtures/lang/expected/hints.ts index 29edc347d..49b695820 100644 --- a/ts/fixtures/lang/expected/hints.ts +++ b/ts/fixtures/lang/expected/hints.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; -import { copy$array_u32, copy$array_u64 } from "./lib.ts"; +import { copy$array_u32, copy$array_u64, copy$tuple2_u64_u8 } from "./lib.ts"; import { thenSome$1ugl8af } from "./core/bool.ts"; import { unwrapOr$1rbuegs as option_unwrapOr$1rbuegs, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$0ow0wo0 as option_mapOr$0ow0wo0, mapOr$0r2th8w as option_mapOr$0r2th8w, mapOr$0pdoq6p as option_mapOr$0pdoq6p, mapOr$0amk6zv as option_mapOr$0amk6zv, mapOr$1umcrqz as option_mapOr$1umcrqz, mapOr$08xwngs as option_mapOr$08xwngs } from "./core/option.ts"; import { unwrapOr$0u9zzk3 as result_unwrapOr$0u9zzk3 } from "./core/result.ts"; @@ -2081,8 +2081,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 _437: rt.Iter = rt.iterSlice(rt.byteSliceView(bytes)); - const deque: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _437, undefined, 1, true); + const deque: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterSlice(rt.byteSliceView(bytes)), undefined, 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); @@ -2624,10 +2623,9 @@ 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.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 1100).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100)) as rt.VecDeque)).n; } else if (coll === 4) { - const _21: rt.u32[][] = rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 1100, true); + 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); len = q.n; } else if (coll === 5) { @@ -2695,10 +2693,9 @@ 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.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 1100).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100)) as rt.VecDeque)).n; } else if (coll === 4) { - const _21: rt.u32[][] = rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 1100, true); + 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); len = q.n; } else if (coll === 5) { @@ -2766,10 +2763,9 @@ 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.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 1100).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100)) as rt.VecDeque)).n; } else if (coll === 4) { - const _21: rt.u32[][] = rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 1100, true); + 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); len = q.n; } else if (coll === 5) { @@ -2837,10 +2833,9 @@ 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.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 1100, true).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 1100, true)) as rt.VecDeque)).n; } else if (coll === 4) { - const _21: rt.u32[][] = rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 1100, true); + 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); len = q.n; } else if (coll === 5) { @@ -2908,10 +2903,9 @@ 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.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 1100).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100)) as rt.VecDeque)).n; } else if (coll === 4) { - const _21: rt.u32[][] = rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 1100, true); + 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); len = q.n; } else if (coll === 5) { @@ -2978,10 +2972,9 @@ 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.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 0).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0)) as rt.VecDeque)).n; } else if (coll === 4) { - const _21: hints_Unit.Unit[] = rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 0, true); + 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); len = q.n; } else if (coll === 5) { @@ -3048,10 +3041,9 @@ 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.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 0).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0)) as rt.VecDeque)).n; } else if (coll === 4) { - const _21: hints_Unit.Unit[] = rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 0, true); + 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); len = q.n; } else if (coll === 5) { @@ -3118,10 +3110,9 @@ 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.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 0).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0)) as rt.VecDeque)).n; } else if (coll === 4) { - const _21: hints_Unit.Unit[] = rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 0, true); + 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); len = q.n; } else if (coll === 5) { @@ -3188,10 +3179,9 @@ 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.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 0, true).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 0, true)) as rt.VecDeque)).n; } else if (coll === 4) { - const _21: hints_Unit.Unit[] = rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 0, true); + 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); len = q.n; } else if (coll === 5) { @@ -3258,10 +3248,9 @@ 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.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 0).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0)) as rt.VecDeque)).n; } else if (coll === 4) { - const _21: hints_Unit.Unit[] = rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 0, true); + 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); len = q.n; } else if (coll === 5) { @@ -3317,6 +3306,7 @@ export function fill$hints_Unit_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_ /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ export function fill$tuple2_u64_u8_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3_hints_typed_closure2_tuple2_u64_u8_hints_reserves_closure3(coll: rt.u8, items: rt.Iter<[rt.u64, rt.u8]>, seed: [rt.u64, rt.u8], out: rt.ByteVec): void { let len!: rt.usize; + seed = copy$tuple2_u64_u8(seed); if (coll === 0) { len = rt.iterToArray(items, "next", 16).length; } else if (coll === 1) { @@ -3324,20 +3314,19 @@ export function fill$tuple2_u64_u8_iter_Filter_iter_Map_ops_RangeInclusive_u32_h rt.iterExtend(v, items, "next", 16); len = v.length; } else if (coll === 2) { - const v2: [rt.u64, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + const v2: [rt.u64, rt.u8][] = rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8); rt.iterExtend(v2, items, "next", 16); len = v2.length; } else if (coll === 3) { - len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, items, "next", 16).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16)) as rt.VecDeque<[rt.u64, rt.u8]>)).n; } else if (coll === 4) { - const _21: [rt.u64, rt.u8][] = rt.vecFromElem(seed, 2, undefined); - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, rt.iterSlice(_21), 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)) as rt.VecDeque<[rt.u64, rt.u8]>; rt.dequeExtend(q, items, "next", 16); 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; } else if (coll === 6) { - const h: rt.BinaryHeap<[rt.u64, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), 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]))); + const h: rt.BinaryHeap<[rt.u64, rt.u8]> = rt.heapFrom(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8), 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]))); rt.heapExtend(h, items, 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])), "next", 16); len = h.d.length; } else if (coll === 7) { @@ -3387,6 +3376,7 @@ export function fill$tuple2_u64_u8_iter_Filter_iter_Map_ops_RangeInclusive_u32_h /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ export function fill$tuple2_u64_u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3(coll: rt.u8, items: rt.Iter<[rt.u64, rt.u8]>, seed: [rt.u64, rt.u8], out: rt.ByteVec): void { let len!: rt.usize; + seed = copy$tuple2_u64_u8(seed); if (coll === 0) { len = rt.iterToArray(items, "next", 16).length; } else if (coll === 1) { @@ -3394,20 +3384,19 @@ export function fill$tuple2_u64_u8_iter_Map_iter_Flatten_array_IntoIter_ops_Rang rt.iterExtend(v, items, "next", 16); len = v.length; } else if (coll === 2) { - const v2: [rt.u64, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + const v2: [rt.u64, rt.u8][] = rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8); rt.iterExtend(v2, items, "next", 16); len = v2.length; } else if (coll === 3) { - len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, items, "next", 16).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16)) as rt.VecDeque<[rt.u64, rt.u8]>)).n; } else if (coll === 4) { - const _21: [rt.u64, rt.u8][] = rt.vecFromElem(seed, 2, undefined); - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, rt.iterSlice(_21), 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)) as rt.VecDeque<[rt.u64, rt.u8]>; rt.dequeExtend(q, items, "next", 16); 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; } else if (coll === 6) { - const h: rt.BinaryHeap<[rt.u64, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), 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]))); + const h: rt.BinaryHeap<[rt.u64, rt.u8]> = rt.heapFrom(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8), 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]))); rt.heapExtend(h, items, 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])), "next", 16); len = h.d.length; } else if (coll === 7) { @@ -3457,6 +3446,7 @@ export function fill$tuple2_u64_u8_iter_Map_iter_Flatten_array_IntoIter_ops_Rang /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ export function fill$tuple2_u64_u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3(coll: rt.u8, items: rt.Iter<[rt.u64, rt.u8]>, seed: [rt.u64, rt.u8], out: rt.ByteVec): void { let len!: rt.usize; + seed = copy$tuple2_u64_u8(seed); if (coll === 0) { len = rt.iterToArray(items, "next", 16).length; } else if (coll === 1) { @@ -3464,20 +3454,19 @@ export function fill$tuple2_u64_u8_iter_Map_iter_Flatten_array_IntoIter_ops_Rang rt.iterExtend(v, items, "next", 16); len = v.length; } else if (coll === 2) { - const v2: [rt.u64, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + const v2: [rt.u64, rt.u8][] = rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8); rt.iterExtend(v2, items, "next", 16); len = v2.length; } else if (coll === 3) { - len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, items, "next", 16).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16)) as rt.VecDeque<[rt.u64, rt.u8]>)).n; } else if (coll === 4) { - const _21: [rt.u64, rt.u8][] = rt.vecFromElem(seed, 2, undefined); - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, rt.iterSlice(_21), 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)) as rt.VecDeque<[rt.u64, rt.u8]>; rt.dequeExtend(q, items, "next", 16); 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; } else if (coll === 6) { - const h: rt.BinaryHeap<[rt.u64, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), 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]))); + const h: rt.BinaryHeap<[rt.u64, rt.u8]> = rt.heapFrom(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8), 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]))); rt.heapExtend(h, items, 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])), "next", 16); len = h.d.length; } else if (coll === 7) { @@ -3527,6 +3516,7 @@ export function fill$tuple2_u64_u8_iter_Map_iter_Flatten_array_IntoIter_ops_Rang /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ export function fill$tuple2_u64_u8_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3(coll: rt.u8, items: rt.Iter<[rt.u64, rt.u8]>, seed: [rt.u64, rt.u8], out: rt.ByteVec): void { let len!: rt.usize; + seed = copy$tuple2_u64_u8(seed); if (coll === 0) { len = rt.iterToArray(items, undefined, 16, true).length; } else if (coll === 1) { @@ -3534,20 +3524,19 @@ export function fill$tuple2_u64_u8_iter_Map_ops_RangeInclusive_u32_hints_typed_c rt.iterExtend(v, items, undefined, 16, true); len = v.length; } else if (coll === 2) { - const v2: [rt.u64, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + const v2: [rt.u64, rt.u8][] = rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8); rt.iterExtend(v2, items, undefined, 16, true); len = v2.length; } else if (coll === 3) { - len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, items, undefined, 16, true).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 16, true)) as rt.VecDeque<[rt.u64, rt.u8]>)).n; } else if (coll === 4) { - const _21: [rt.u64, rt.u8][] = rt.vecFromElem(seed, 2, undefined); - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, rt.iterSlice(_21), 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)) as rt.VecDeque<[rt.u64, rt.u8]>; rt.dequeExtend(q, items, undefined, 16, 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; } else if (coll === 6) { - const h: rt.BinaryHeap<[rt.u64, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), 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]))); + const h: rt.BinaryHeap<[rt.u64, rt.u8]> = rt.heapFrom(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8), 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]))); rt.heapExtend(h, items, 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])), undefined, 16, true); len = h.d.length; } else if (coll === 7) { @@ -3597,6 +3586,7 @@ export function fill$tuple2_u64_u8_iter_Map_ops_RangeInclusive_u32_hints_typed_c /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ export function fill$tuple2_u64_u8_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3(coll: rt.u8, items: rt.Iter<[rt.u64, rt.u8]>, seed: [rt.u64, rt.u8], out: rt.ByteVec): void { let len!: rt.usize; + seed = copy$tuple2_u64_u8(seed); if (coll === 0) { len = rt.iterToArray(items, "next", 16).length; } else if (coll === 1) { @@ -3604,20 +3594,19 @@ export function fill$tuple2_u64_u8_iter_Skip_iter_Map_ops_RangeInclusive_u32_hin rt.iterExtend(v, items, "next", 16); len = v.length; } else if (coll === 2) { - const v2: [rt.u64, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + const v2: [rt.u64, rt.u8][] = rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8); rt.iterExtend(v2, items, "next", 16); len = v2.length; } else if (coll === 3) { - len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, items, "next", 16).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16)) as rt.VecDeque<[rt.u64, rt.u8]>)).n; } else if (coll === 4) { - const _21: [rt.u64, rt.u8][] = rt.vecFromElem(seed, 2, undefined); - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, rt.iterSlice(_21), 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)) as rt.VecDeque<[rt.u64, rt.u8]>; rt.dequeExtend(q, items, "next", 16); 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; } else if (coll === 6) { - const h: rt.BinaryHeap<[rt.u64, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), 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]))); + const h: rt.BinaryHeap<[rt.u64, rt.u8]> = rt.heapFrom(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8), 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]))); rt.heapExtend(h, items, 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])), "next", 16); len = h.d.length; } else if (coll === 7) { @@ -3678,10 +3667,9 @@ 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.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>, items, "next", 3).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; } else if (coll === 4) { - const _21: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined); - const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>, rt.iterSlice(_21), undefined, 3, true); + 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); len = q.n; } else if (coll === 5) { @@ -3748,10 +3736,9 @@ 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.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>, items, "next", 3).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; } else if (coll === 4) { - const _21: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined); - const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>, rt.iterSlice(_21), undefined, 3, true); + 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); len = q.n; } else if (coll === 5) { @@ -3818,10 +3805,9 @@ 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.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>, items, "next", 3).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; } else if (coll === 4) { - const _21: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined); - const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>, rt.iterSlice(_21), undefined, 3, true); + 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); len = q.n; } else if (coll === 5) { @@ -3888,10 +3874,9 @@ 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.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>, items, undefined, 3, true).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 3, true)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; } else if (coll === 4) { - const _21: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined); - const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>, rt.iterSlice(_21), undefined, 3, true); + 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); len = q.n; } else if (coll === 5) { @@ -3958,10 +3943,9 @@ 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.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>, items, "next", 3).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; } else if (coll === 4) { - const _21: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined); - const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>, rt.iterSlice(_21), undefined, 3, true); + 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); len = q.n; } else if (coll === 5) { @@ -4028,10 +4012,9 @@ 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.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 4).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4)) as rt.VecDeque)).n; } else if (coll === 4) { - const _21: rt.u32[] = rt.vecFromElem(seed, 2, undefined); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 4, true); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined)) as rt.VecDeque; rt.dequeExtend(q, items, "next", 4); len = q.n; } else if (coll === 5) { @@ -4098,10 +4081,9 @@ 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.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 4).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4)) as rt.VecDeque)).n; } else if (coll === 4) { - const _21: rt.u32[] = rt.vecFromElem(seed, 2, undefined); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 4, true); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined)) as rt.VecDeque; rt.dequeExtend(q, items, "next", 4); len = q.n; } else if (coll === 5) { @@ -4168,10 +4150,9 @@ 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.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 4).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4)) as rt.VecDeque)).n; } else if (coll === 4) { - const _21: rt.u32[] = rt.vecFromElem(seed, 2, undefined); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 4, true); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined)) as rt.VecDeque; rt.dequeExtend(q, items, "next", 4); len = q.n; } else if (coll === 5) { @@ -4238,10 +4219,9 @@ 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.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 4, true).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 4, true)) as rt.VecDeque)).n; } else if (coll === 4) { - const _21: rt.u32[] = rt.vecFromElem(seed, 2, undefined); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 4, true); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined)) as rt.VecDeque; rt.dequeExtend(q, items, undefined, 4, true); len = q.n; } else if (coll === 5) { @@ -4308,10 +4288,9 @@ 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.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 4).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4)) as rt.VecDeque)).n; } else if (coll === 4) { - const _21: rt.u32[] = rt.vecFromElem(seed, 2, undefined); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 4, true); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined)) as rt.VecDeque; rt.dequeExtend(q, items, "next", 4); len = q.n; } else if (coll === 5) { @@ -4378,16 +4357,15 @@ 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.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 1).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1)) as rt.VecDeque)).n; } else if (coll === 4) { - const _21: rt.ByteVec = rt.byteVecOf(seed, 2); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(rt.byteVecView(_21)), undefined, 1, true); + const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2))) as rt.VecDeque; rt.dequeExtend(q, items, "next", 1); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 1), rt.le, rt.ge, rt.lt).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(Array.from(rt.byteVecView(rt.byteVecOf(seed, 2))), rt.le, rt.ge, rt.lt); + const h: rt.BinaryHeap = rt.heapFrom(rt.byteVecToVec(rt.byteVecOf(seed, 2)), rt.le, rt.ge, rt.lt); rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 1); len = h.d.length; } else if (coll === 7) { @@ -4448,16 +4426,15 @@ 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.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 1).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1)) as rt.VecDeque)).n; } else if (coll === 4) { - const _21: rt.ByteVec = rt.byteVecOf(seed, 2); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(rt.byteVecView(_21)), undefined, 1, true); + const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2))) as rt.VecDeque; rt.dequeExtend(q, items, "next", 1); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 1), rt.le, rt.ge, rt.lt).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(Array.from(rt.byteVecView(rt.byteVecOf(seed, 2))), rt.le, rt.ge, rt.lt); + const h: rt.BinaryHeap = rt.heapFrom(rt.byteVecToVec(rt.byteVecOf(seed, 2)), rt.le, rt.ge, rt.lt); rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 1); len = h.d.length; } else if (coll === 7) { @@ -4518,16 +4495,15 @@ 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.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 1).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1)) as rt.VecDeque)).n; } else if (coll === 4) { - const _21: rt.ByteVec = rt.byteVecOf(seed, 2); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(rt.byteVecView(_21)), undefined, 1, true); + const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2))) as rt.VecDeque; rt.dequeExtend(q, items, "next", 1); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 1), rt.le, rt.ge, rt.lt).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(Array.from(rt.byteVecView(rt.byteVecOf(seed, 2))), rt.le, rt.ge, rt.lt); + const h: rt.BinaryHeap = rt.heapFrom(rt.byteVecToVec(rt.byteVecOf(seed, 2)), rt.le, rt.ge, rt.lt); rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 1); len = h.d.length; } else if (coll === 7) { @@ -4588,16 +4564,15 @@ 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.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 1, true).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 1, true)) as rt.VecDeque)).n; } else if (coll === 4) { - const _21: rt.ByteVec = rt.byteVecOf(seed, 2); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(rt.byteVecView(_21)), undefined, 1, true); + const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2))) as rt.VecDeque; rt.dequeExtend(q, items, undefined, 1, 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; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(Array.from(rt.byteVecView(rt.byteVecOf(seed, 2))), rt.le, rt.ge, rt.lt); + const h: rt.BinaryHeap = rt.heapFrom(rt.byteVecToVec(rt.byteVecOf(seed, 2)), rt.le, rt.ge, rt.lt); rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, undefined, 1, true); len = h.d.length; } else if (coll === 7) { @@ -4658,16 +4633,15 @@ 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.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 1).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1)) as rt.VecDeque)).n; } else if (coll === 4) { - const _21: rt.ByteVec = rt.byteVecOf(seed, 2); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(rt.byteVecView(_21)), undefined, 1, true); + const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2))) as rt.VecDeque; rt.dequeExtend(q, items, "next", 1); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 1), rt.le, rt.ge, rt.lt).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(Array.from(rt.byteVecView(rt.byteVecOf(seed, 2))), rt.le, rt.ge, rt.lt); + const h: rt.BinaryHeap = rt.heapFrom(rt.byteVecToVec(rt.byteVecOf(seed, 2)), rt.le, rt.ge, rt.lt); rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 1); len = h.d.length; } else if (coll === 7) { diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index 79022c065..d21d32c91 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -429,7 +429,7 @@ export function peekedOthers(data: rt.ByteSlice, out: rt.ByteVec): void { }), undefined, 12, true); const _12: string | undefined = rt.sliceFirst(words); const first: string = option_unwrapOrDefault$165pyh5(_12 === undefined ? undefined : _12); - const it: rt.Peekable = rt.iterPeekable(rt.iterSlice(words.slice())); + const it: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.vecExact(words.slice(), 12))); const part = option_asDeref$0w8at8i(rt.peekableNextIfEq(it, "a", (a0: string, a1: string): boolean => { return a0 === a1; })); @@ -489,7 +489,7 @@ export function peekedOthers(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, _4(part11)); const part12 = option_asDeref$0w8at8i(rt.iterToOption(it5.next())); rt.byteVecPush(out, _4(part12)); - const part13 = option_asDeref$0w8at8i(rt.peekableNextIfEq(rt.iterPeekable(rt.iterSlice(words.slice())), first, (a012: string, a18: string): boolean => { + const part13 = option_asDeref$0w8at8i(rt.peekableNextIfEq(rt.iterPeekable(rt.iterSlice(rt.vecExact(words.slice(), 12))), first, (a012: string, a18: string): boolean => { return a012 === a18; })); rt.byteVecPush(out, _4(part13)); @@ -1515,7 +1515,7 @@ export function optionItems(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecPush(out, _138); } - for (const a2 of nested.slice()) { + for (const a2 of rt.vecExact(nested.slice(), 2)) { if (a2 !== rt.None) { if (a2 !== undefined) { rt.byteVecPush(out, a2); diff --git a/ts/fixtures/lang/expected/joins.ts b/ts/fixtures/lang/expected/joins.ts index c77dc6bc8..3c10edf32 100644 --- a/ts/fixtures/lang/expected/joins.ts +++ b/ts/fixtures/lang/expected/joins.ts @@ -125,7 +125,7 @@ export function joins(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { wides(rt.slicesJoin(slices, 2, [sep2]), out); wides(rt.slicesJoin(slices, 2, rt.sliceRange(wideSeps, 0)), out); const boxed2: rt.u16[][] = rt.iterToArray(rt.iterMap(rt.iterMap(rt.iterSlice(wide), (a015: rt.u16[]): rt.u16[] => { - return a015.slice(); + return rt.vecExact(a015.slice(), 2); }), (a016: rt.u16[]): rt.u16[] => { return a016; }), undefined, 8, true); @@ -221,7 +221,7 @@ export function joins(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (rt.usizeRem(_212[0], 2) === 0) { return new rt.Borrowed(rt.sliceRange(_212[1], 0)); } - return _212[1].slice(); + return rt.vecExact(_212[1].slice(), 2); }), undefined, 12, true); wides(rt.slicesJoin(wide3, 2, undefined, rt.cowSlice), out); wides(rt.slicesJoin(wide3, 2, [65535], rt.cowSlice), out); diff --git a/ts/fixtures/lang/expected/keys.ts b/ts/fixtures/lang/expected/keys.ts index 39b2e0b44..acc506612 100644 --- a/ts/fixtures/lang/expected/keys.ts +++ b/ts/fixtures/lang/expected/keys.ts @@ -1864,9 +1864,9 @@ export function keyed$Option_u8_2_keys_arrays_closure5(data: rt.ByteSlice, make: return make(b4); })); rt.byteVecPush(out, rt.hashAdd(options, _476) ? 1 : 0); - const _487: Array = make(b4).slice(); + const _487: Array = rt.vecExact(make(b4).slice(), 2); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(vecs, _487, i3 & 0xff), 204)); - const _498: Array = make(rt.u8Div(b4, 2)).slice(); + const _498: Array = rt.vecExact(make(rt.u8Div(b4, 2)).slice(), 2); rt.byteVecPush(out, rt.btreeAdd(lists, _498) ? 1 : 0); } rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); @@ -2120,9 +2120,9 @@ export function keyed$bool_2_keys_arrays_closure4(data: rt.ByteSlice, make: (a0: return make(b4); }); rt.byteVecPush(out, rt.hashAdd(options, _476) ? 1 : 0); - const _487: boolean[] = make(b4).slice(); + const _487: boolean[] = rt.vecExact(make(b4).slice(), 1); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(vecs, _487, i3 & 0xff), 204)); - const _498: boolean[] = make(rt.u8Div(b4, 2)).slice(); + const _498: boolean[] = rt.vecExact(make(rt.u8Div(b4, 2)).slice(), 1); rt.byteVecPush(out, rt.btreeAdd(lists, _498) ? 1 : 0); } rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); @@ -2375,9 +2375,9 @@ export function keyed$char_2_keys_arrays_closure3(data: rt.ByteSlice, make: (a0: return make(b4); })); rt.byteVecPush(out, rt.hashAdd(options, _476) ? 1 : 0); - const _487: rt.char[] = make(b4).slice(); + const _487: rt.char[] = rt.vecExact(make(b4).slice(), 4); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(vecs, _487, i3 & 0xff), 204)); - const _498: rt.char[] = make(rt.u8Div(b4, 2)).slice(); + const _498: rt.char[] = rt.vecExact(make(rt.u8Div(b4, 2)).slice(), 4); rt.byteVecPush(out, rt.btreeAdd(lists, _498) ? 1 : 0); } rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); @@ -2631,9 +2631,9 @@ export function keyed$i32_2_keys_arrays_closure2(data: rt.ByteSlice, make: (a0: return make(b4); }); rt.byteVecPush(out, rt.hashAdd(options, _476) ? 1 : 0); - const _487: rt.i32[] = make(b4).slice(); + const _487: rt.i32[] = rt.vecExact(make(b4).slice(), 4); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(vecs, _487, i3 & 0xff), 204)); - const _498: rt.i32[] = make(rt.u8Div(b4, 2)).slice(); + const _498: rt.i32[] = rt.vecExact(make(rt.u8Div(b4, 2)).slice(), 4); rt.byteVecPush(out, rt.btreeAdd(lists, _498) ? 1 : 0); } rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); @@ -2886,9 +2886,9 @@ export function keyed$keys_Hop_2_keys_arrays_closure6(data: rt.ByteSlice, make: return make(b4); })); rt.byteVecPush(out, rt.hashAdd(options, _476) ? 1 : 0); - const _487: Hop.Hop[] = make(b4).map(copy$keys_Hop); + const _487: Hop.Hop[] = rt.vecExact(make(b4).map(copy$keys_Hop), 8); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(vecs, _487, i3 & 0xff), 204)); - const _498: Hop.Hop[] = make(rt.u8Div(b4, 2)).map(copy$keys_Hop); + const _498: Hop.Hop[] = rt.vecExact(make(rt.u8Div(b4, 2)).map(copy$keys_Hop), 8); rt.byteVecPush(out, rt.btreeAdd(lists, _498) ? 1 : 0); } rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); @@ -3142,9 +3142,9 @@ export function keyed$u16_2_keys_arrays_closure0(data: rt.ByteSlice, make: (a0: return make(b4); })); rt.byteVecPush(out, rt.hashAdd(options, _476) ? 1 : 0); - const _487: rt.u16[] = make(b4).slice(); + const _487: rt.u16[] = rt.vecExact(make(b4).slice(), 2); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(vecs, _487, i3 & 0xff), 204)); - const _498: rt.u16[] = make(rt.u8Div(b4, 2)).slice(); + const _498: rt.u16[] = rt.vecExact(make(rt.u8Div(b4, 2)).slice(), 2); rt.byteVecPush(out, rt.btreeAdd(lists, _498) ? 1 : 0); } rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); @@ -3398,9 +3398,9 @@ export function keyed$u32_0_keys_arrays_closure7(data: rt.ByteSlice, make: (a0: return make(b4); })); rt.byteVecPush(out, rt.hashAdd(options, _476) ? 1 : 0); - const _487: rt.u32[] = make(b4).slice(); + const _487: rt.u32[] = rt.vecExact(make(b4).slice(), 4); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(vecs, _487, i3 & 0xff), 204)); - const _498: rt.u32[] = make(rt.u8Div(b4, 2)).slice(); + const _498: rt.u32[] = rt.vecExact(make(rt.u8Div(b4, 2)).slice(), 4); rt.byteVecPush(out, rt.btreeAdd(lists, _498) ? 1 : 0); } rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); @@ -3654,9 +3654,9 @@ export function keyed$u32_275_keys_arrays_closure8(data: rt.ByteSlice, make: (a0 return make(b4); })); rt.byteVecPush(out, rt.hashAdd(options, _476) ? 1 : 0); - const _487: rt.u32[] = make(b4).slice(); + const _487: rt.u32[] = rt.vecExact(make(b4).slice(), 4); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(vecs, _487, i3 & 0xff), 204)); - const _498: rt.u32[] = make(rt.u8Div(b4, 2)).slice(); + const _498: rt.u32[] = rt.vecExact(make(rt.u8Div(b4, 2)).slice(), 4); rt.byteVecPush(out, rt.btreeAdd(lists, _498) ? 1 : 0); } rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); @@ -3910,9 +3910,9 @@ export function keyed$u64_2_keys_arrays_closure1(data: rt.ByteSlice, make: (a0: return make(b4); })); rt.byteVecPush(out, rt.hashAdd(options, _476) ? 1 : 0); - const _487: rt.u64[] = make(b4).slice(); + const _487: rt.u64[] = rt.vecExact(make(b4).slice(), 8); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(vecs, _487, i3 & 0xff), 204)); - const _498: rt.u64[] = make(rt.u8Div(b4, 2)).slice(); + const _498: rt.u64[] = rt.vecExact(make(rt.u8Div(b4, 2)).slice(), 8); rt.byteVecPush(out, rt.btreeAdd(lists, _498) ? 1 : 0); } rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); @@ -4081,7 +4081,7 @@ export function taken$0_keys_byte_refs_closure1(data: rt.ByteSlice, make: (a0: r rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([vec.length, deque.n, rt.hashLen(set), rt.btreeLen(ordered), rt.hashLen(map), rt.btreeLen(tree)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterSlice(vec.map(copy$array_u8)), rt.lending((p2: rt.ByteSlice): boolean => { + rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterSlice(rt.vecExact(vec.map(copy$array_u8), 0)), rt.lending((p2: rt.ByteSlice): boolean => { return rt.byteSliceFirst(p2) !== rt.byteSliceLast(p2); }, (f2) => (held5) => f2(rt.byteSliceFrom(held5))))) & 0xff); rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(rt.iterToArray(rt.iterFilter(rt.iterCopied(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray), rt.lending((p3: rt.ByteSlice): boolean => { @@ -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)), rt.lending((p4: rt.ByteSlice): boolean => { + const rest: rt.Peekable = rt.iterPeekable(rt.iterSkipWhile(rt.dequeIter(rt.dequeClone(deque, copy$array_u8, 0)), 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); @@ -4156,7 +4156,7 @@ export function taken$0_keys_byte_refs_closure1(data: rt.ByteSlice, make: (a0: r rt.byteVecPush(_307.value, (sorted ? 1 : 0) | 128); rt.refMutRelease(_307); const second: Dropped.Dropped = new Dropped.Dropped(2, log); - const _314: rt.Iter = rt.iterSlice(vec.map(copy$array_u8)); + const _314: rt.Iter = rt.iterSlice(rt.vecExact(vec.map(copy$array_u8), 0)); const make2 = (captured2: Dropped.Dropped): (a0: rt.ByteSlice) => boolean => { return rt.closure(rt.cloning((p10: rt.ByteSlice): boolean => { if (!Dropped.live(captured2)) { @@ -4382,7 +4382,7 @@ export function taken$2_keys_byte_refs_closure0(data: rt.ByteSlice, make: (a0: r rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([vec.length, deque.n, rt.hashLen(set), rt.btreeLen(ordered), rt.hashLen(map), rt.btreeLen(tree)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterSlice(vec.map(copy$array_u8)), rt.lending((p2: rt.ByteSlice): boolean => { + rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterSlice(rt.vecExact(vec.map(copy$array_u8), 2)), rt.lending((p2: rt.ByteSlice): boolean => { return rt.byteSliceFirst(p2) !== rt.byteSliceLast(p2); }, (f2) => (held5) => f2(rt.byteSliceFrom(held5))))) & 0xff); rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(rt.iterToArray(rt.iterFilter(rt.iterCopied(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray), rt.lending((p3: rt.ByteSlice): boolean => { @@ -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)), rt.lending((p4: rt.ByteSlice): boolean => { + const rest: rt.Peekable = rt.iterPeekable(rt.iterSkipWhile(rt.dequeIter(rt.dequeClone(deque, copy$array_u8, 2)), 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); @@ -4457,7 +4457,7 @@ export function taken$2_keys_byte_refs_closure0(data: rt.ByteSlice, make: (a0: r rt.byteVecPush(_307.value, (sorted ? 1 : 0) | 128); rt.refMutRelease(_307); const second: Dropped.Dropped = new Dropped.Dropped(2, log); - const _314: rt.Iter = rt.iterSlice(vec.map(copy$array_u8)); + const _314: rt.Iter = rt.iterSlice(rt.vecExact(vec.map(copy$array_u8), 2)); const make2 = (captured2: Dropped.Dropped): (a0: rt.ByteSlice) => boolean => { return rt.closure(rt.cloning((p10: rt.ByteSlice): boolean => { if (!Dropped.live(captured2)) { diff --git a/ts/fixtures/lang/expected/lengths.ts b/ts/fixtures/lang/expected/lengths.ts index 83a3dd69f..3b2c3347f 100644 --- a/ts/fixtures/lang/expected/lengths.ts +++ b/ts/fixtures/lang/expected/lengths.ts @@ -30,7 +30,7 @@ export function each$0(data: rt.ByteSlice, out: rt.ByteVec): void { return (((((b as rt.u32)) << 8) >>> 0) | 1) >>> 0; }); }), undefined, 0, true); - joined$0(data, rows.map(copy$array_u8), out); + joined$0(data, rt.vecExact(rows.map(copy$array_u8), 0), out); joined$0(data, copy$array_array0_u8([rt.bytes(0).fill(165), rt.bytesFromFn(0, (i2: rt.usize): rt.u8 => { return i2 & 0xff; })]).map(copy$array_u8), out); @@ -62,7 +62,7 @@ export function each$1(data: rt.ByteSlice, out: rt.ByteVec): void { return (((((b as rt.u32)) << 8) >>> 0) | 1) >>> 0; }); }), undefined, 4, true); - joined$1(data, rows.map(copy$array_u8), out); + joined$1(data, rt.vecExact(rows.map(copy$array_u8), 1), out); joined$1(data, copy$array_array1_u8([rt.bytes(1).fill(165), rt.bytesFromFn(1, (i2: rt.usize): rt.u8 => { return i2 & 0xff; })]).map(copy$array_u8), out); @@ -94,7 +94,7 @@ export function each$17(data: rt.ByteSlice, out: rt.ByteVec): void { return (((((b as rt.u32)) << 8) >>> 0) | 1) >>> 0; }); }), undefined, 68, true); - joined$17(data, rows.map(copy$array_u8), out); + joined$17(data, rt.vecExact(rows.map(copy$array_u8), 17), out); joined$17(data, copy$array_array17_u8([rt.bytes(17).fill(165), rt.bytesFromFn(17, (i2: rt.usize): rt.u8 => { return i2 & 0xff; })]).map(copy$array_u8), out); @@ -126,7 +126,7 @@ export function each$3(data: rt.ByteSlice, out: rt.ByteVec): void { return (((((b as rt.u32)) << 8) >>> 0) | 1) >>> 0; }); }), undefined, 12, true); - joined$3(data, rows.map(copy$array_u8), out); + joined$3(data, rt.vecExact(rows.map(copy$array_u8), 3), out); joined$3(data, copy$array_array3_u8([rt.bytes(3).fill(165), rt.bytesFromFn(3, (i2: rt.usize): rt.u8 => { return i2 & 0xff; })]).map(copy$array_u8), out); diff --git a/ts/fixtures/lang/expected/lib.ts b/ts/fixtures/lang/expected/lib.ts index 70fe8186f..996feba46 100644 --- a/ts/fixtures/lang/expected/lib.ts +++ b/ts/fixtures/lang/expected/lib.ts @@ -732,6 +732,10 @@ export function copy$tuple2_u64_u64(v: [rt.u64, rt.u64]): [rt.u64, rt.u64] { return [v[0], v[1]]; } +export function copy$tuple2_u64_u8(v: [rt.u64, rt.u8]): [rt.u64, rt.u8] { + return [v[0], v[1]]; +} + export function copy$tuple2_u8_String(v: [rt.u8, string]): [rt.u8, string] { return [v[0], v[1]]; } diff --git a/ts/fixtures/lang/expected/nested.ts b/ts/fixtures/lang/expected/nested.ts index d0dbb0d74..ff178e363 100644 --- a/ts/fixtures/lang/expected/nested.ts +++ b/ts/fixtures/lang/expected/nested.ts @@ -494,7 +494,7 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { const at: rt.usize = option_mapOr$1t0muvr(rt.byteSliceFirst(data), 0, (b2: rt.u8): rt.usize => { return rt.usizeRem(b2 as rt.usize, 8); }); - const v: Array = items.slice(); + const v: Array = rt.vecExact(items.slice(), 2); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.sliceFirst(v, rt.None)), code(rt.sliceLast(v, rt.None)), code(rt.sliceGet(v, at, rt.None)))), undefined, true); const part = at; rt.byteVecPush(out, code(option_andThen$0ocv8av(rt.sliceGetRange(rt.sliceRange(v, 0), part), (s: Array): rt.u8 | undefined | rt.None => { @@ -593,8 +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 _260: undefined[] = rt.vecFromElem(undefined, rt.usizeMul(data.length, 2), undefined); - const unitQ: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_260), undefined, 0, true); + const unitQ: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(undefined, rt.usizeMul(data.length, 2), undefined)) 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))); @@ -747,8 +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 _7: rt.Iter = rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), (_22: rt.u8): undefined => {}); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _7, 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 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 dd236aa1c..ab7b20790 100644 --- a/ts/fixtures/lang/expected/objects.ts +++ b/ts/fixtures/lang/expected/objects.ts @@ -187,8 +187,7 @@ export function refill(v: rt.Arc[], bytes: rt.ByteVec, with_: rt.Arc, map: rt.HashMap, n: rt.u8): rt.usize { - const _6: rt.Range = new rt.Range(0, rt.u8Rem(n, 5)); - const old: rt.VecDeque = rt.replaceIn(q, rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _6, undefined, 1, true)); + 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); 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; } diff --git a/ts/fixtures/lang/expected/orders.ts b/ts/fixtures/lang/expected/orders.ts index c9074b7fe..0c9a4a0b7 100644 --- a/ts/fixtures/lang/expected/orders.ts +++ b/ts/fixtures/lang/expected/orders.ts @@ -241,7 +241,7 @@ export function heaps(data: rt.ByteSlice, out: rt.ByteVec): void { let _127: boolean = false; let _128: boolean = false; let heap: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; - const other: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; + const other: rt.BinaryHeap = rt.heapWithCapacity(4, 2) as rt.BinaryHeap; const ops: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); while (true) { const _8: [rt.usize, rt.u8] | rt.Done = ops.next(); @@ -379,13 +379,13 @@ export function heaps(data: rt.ByteSlice, out: rt.ByteVec): void { * and tuples, built every way, and their vectors, slices, clones, and debug form. */ export function values(data: rt.ByteSlice, out: rt.ByteVec): void { - const bytes: rt.BinaryHeap = rt.heapFrom(Array.from(rt.byteVecView(rt.byteSliceToByteVec(data))), rt.le, rt.ge, rt.lt); + 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.byteVecFrom(Uint8Array.from(rt.heapIntoSortedVec(rt.heapClone(bytes), rt.le, rt.ge, rt.lt))))), 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); 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.byteVecFrom(Uint8Array.from(bytes.d)))), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(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))); @@ -403,7 +403,7 @@ export function values(data: rt.ByteSlice, out: rt.ByteVec): void { } const _51: rt.usize = data.length; const strings: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterSlice(["pear", "apple", rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(_51, f))]), undefined, 12, true), rt.cmpLe(rt.cmpStr), rt.cmpGe(rt.cmpStr), rt.cmpLt(rt.cmpStr)); - const copy: rt.BinaryHeap = rt.heapClone(strings); + const copy: rt.BinaryHeap = rt.heapClone(strings, undefined, 12); const _56: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b4: rt.u8): string => { const _43: rt.u8 = rt.u8Rem(b4, 10); return rt.fmtToString((f: rt.Formatter) => rt.u8Display(_43, f)); @@ -749,10 +749,9 @@ export function deque$orders_Part_orders_held_closure3(sData: Uint8Array, sStart rt.panic("mid > len"); } const _17: rt.usize = at; - const _12: rt.Iter = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rt.usize, rt.u8]): Part.Part => { + 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]); - }); - const d: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _12, undefined, 2, true); + }), undefined, 2, 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(); @@ -780,10 +779,9 @@ export function deque$orders_Part_orders_part(sData: Uint8Array, sStart: number, rt.panic("mid > len"); } const _17: rt.usize = at; - const _12: rt.Iter = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rt.usize, rt.u8]): Part.Part => { + 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]); - }); - const d: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _12, undefined, 2, true); + }), undefined, 2, 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(); @@ -811,10 +809,9 @@ export function deque$u8_orders_held_closure11(sData: Uint8Array, sStart: number rt.panic("mid > len"); } const _17: rt.usize = at; - const _12: rt.Iter = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rt.usize, rt.u8]): rt.u8 => { + 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]); - }); - const d: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _12, undefined, 1, true); + }), undefined, 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(); @@ -842,10 +839,9 @@ export function deque$u8_orders_held_closure8(sData: Uint8Array, sStart: number, rt.panic("mid > len"); } const _17: rt.usize = at; - const _12: rt.Iter = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rt.usize, rt.u8]): rt.u8 => { + 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]); - }); - const d: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _12, undefined, 1, true); + }), undefined, 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(); @@ -891,13 +887,12 @@ export function held(data: rt.ByteSlice, out: rt.ByteVec): void { return rt.Pending; }; const _296: (a0: rt.VecDeque) => rt.VecDeque = (d3: rt.VecDeque): rt.VecDeque => { - const _38: rt.Iter = rt.iterMap(rt.dequeIter(d3), (p2: Part.Part): rt.f64 => { + return rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.dequeIter(d3), (p2: Part.Part): rt.f64 => { if (!(p2.key === 7)) { return p2.key as rt.f64; } return NaN; - }); - return rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _38, undefined, 8, true); + }), undefined, 8, true)) as rt.VecDeque; }; const iter: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.byteSliceWindows(data, 2)); while (true) { @@ -1178,7 +1173,7 @@ export function btrees(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return !Torn.ne$cmp_PartialEq(a7, b8); })) & 0xff); const _94: rt.Iter = rt.iterMap(rt.sliceChunks(keys2, 2), (a017: Torn.Torn[]): Torn.Torn[] => { - return a017.slice(); + return rt.vecExact(a017.slice(), 3); }); rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeKeys(rt.btreeCollectKeys(rt.btreeNew(rt.cmpSlice(Torn.cmp$cmp_Ord)) as rt.BTreeSet, rt.iterToArray(_94, undefined, 12, true), rt.cmpLt(rt.cmpSlice(Torn.partialCmp$cmp_PartialOrd)), rt.eqSlice((a8: Torn.Torn, b9: Torn.Torn): boolean => { return !Torn.ne$cmp_PartialEq(a8, b9); diff --git a/ts/fixtures/lang/expected/shapes.ts b/ts/fixtures/lang/expected/shapes.ts index bc2897fd7..3810ca895 100644 --- a/ts/fixtures/lang/expected/shapes.ts +++ b/ts/fixtures/lang/expected/shapes.ts @@ -373,9 +373,9 @@ export function shares(data: rt.ByteSlice, out: rt.ByteVec): void { bump(copy5.slot); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(a, copy5.n))); rt.byteVecPush(out, lensBumped(lens)); - for (const _104 of Array.from({ length: 2 }, (): Lens.Lens => { + for (const _104 of rt.vecExact(Array.from({ length: 2 }, (): Lens.Lens => { return copy$shapes_Lens(lens); - }).map(copy$shapes_Lens)) { + }).map(copy$shapes_Lens), 8)) { bump(_104.slot); } const lenses: Lens.Lens[] = []; diff --git a/ts/fixtures/lang/expected/strs.ts b/ts/fixtures/lang/expected/strs.ts index 1b17eacab..f9aa54a2d 100644 --- a/ts/fixtures/lang/expected/strs.ts +++ b/ts/fixtures/lang/expected/strs.ts @@ -710,7 +710,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const _39: string | undefined = one; if (_39 === undefined) { - all = ["true", "false", "True", "FALSE", "", " true", "true ", "t", "truefalse", "a", "é", "ࠀ", "😀", "􏿿", "ab", "a😀", "😀a", "éé", "0", "+0", "-0", "000", "1", "+1", "-1", "+", "-", "--1", "+-1", "1_0", "0x1", "127", "128", "-128", "-129", "255", "256", "32767", "32768", "-32768", "-32769", "65535", "65536", "2147483647", "2147483648", "-2147483648", "-2147483649", "4294967295", "4294967296", "9223372036854775807", "9223372036854775808", "-9223372036854775808", "-9223372036854775809", "18446744073709551615", "18446744073709551616", "170141183460469231731687303715884105727", "170141183460469231731687303715884105728", "-170141183460469231731687303715884105728", "-170141183460469231731687303715884105729", "340282366920938463463374607431768211455", "340282366920938463463374607431768211456"].slice(); + all = rt.vecExact(["true", "false", "True", "FALSE", "", " true", "true ", "t", "truefalse", "a", "é", "ࠀ", "😀", "􏿿", "ab", "a😀", "😀a", "éé", "0", "+0", "-0", "000", "1", "+1", "-1", "+", "-", "--1", "+-1", "1_0", "0x1", "127", "128", "-128", "-129", "255", "256", "32767", "32768", "-32768", "-32769", "65535", "65536", "2147483647", "2147483648", "-2147483648", "-2147483649", "4294967295", "4294967296", "9223372036854775807", "9223372036854775808", "-9223372036854775808", "-9223372036854775809", "18446744073709551615", "18446744073709551616", "170141183460469231731687303715884105727", "170141183460469231731687303715884105728", "-170141183460469231731687303715884105728", "-170141183460469231731687303715884105729", "340282366920938463463374607431768211455", "340282366920938463463374607431768211456"].slice(), 8); } else { all = [_39]; } diff --git a/ts/fixtures/lang/expected/tuples.ts b/ts/fixtures/lang/expected/tuples.ts index 1c1813c14..54e14d022 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.byteVecFrom(Uint8Array.from(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.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); 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] => { @@ -122,7 +122,7 @@ export function ones(data: rt.ByteSlice, out: rt.ByteVec): void { 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.byteVecFrom(Uint8Array.from(heap2.d)))), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(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)); @@ -160,7 +160,7 @@ 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() as rt.VecDeque] as [rt.BinaryHeap, rt.VecDeque], _23, [rt.heapPart(rt.le, 1), rt.dequePart(2)]); const heap: rt.BinaryHeap = _22[0]; const q: rt.VecDeque = _22[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFrom(Uint8Array.from(heap.d)))), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(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); @@ -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.byteVecFrom(Uint8Array.from(heap.d)))), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(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]]; @@ -274,7 +274,7 @@ export function twelves(data: rt.ByteSlice, out: rt.ByteVec): void { 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.iterSlice(rt.byteVecView(rt.byteVecFrom(Uint8Array.from(heap.d)))), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(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 => { @@ -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.byteVecFrom(Uint8Array.from(t2[0].d)))), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFromVec(t2[0].d))), undefined, true); entries(t2[1], out); } diff --git a/ts/fixtures/lang/expected/wrappers.ts b/ts/fixtures/lang/expected/wrappers.ts index 5ddae29d1..1902bd177 100644 --- a/ts/fixtures/lang/expected/wrappers.ts +++ b/ts/fixtures/lang/expected/wrappers.ts @@ -342,8 +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); - const _176: rt.RangeInclusive = queued; - rt.byteVecPush(out, rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterBorrow(_176), undefined, 8, true).n & 0xff); + rt.byteVecPush(out, ((rt.dequeFromVec(rt.iterToArray(rt.iterBorrow(queued), undefined, 8, true)) 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/expected/zeros.ts b/ts/fixtures/lang/expected/zeros.ts index ab922d66c..fd2849c05 100644 --- a/ts/fixtures/lang/expected/zeros.ts +++ b/ts/fixtures/lang/expected/zeros.ts @@ -140,7 +140,7 @@ export function zeros(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.dropAll([new Quiet.Quiet(), new Quiet.Quiet()]); rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.atomicLoad(LOG, 0))), undefined, true); } else if (_8 === 5) { - const v2: undefined[] = []; + const v2: undefined[] = rt.vecWithCapacity(n, 0); const _154: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_28: rt.u8): undefined => {}); rt.iterExtend(v2, _154, undefined, 0, true); rt.byteVecPush(out, rt.vecFromElem({}, n, undefined).length & 0xff); @@ -293,7 +293,7 @@ export function impls(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0], " ", rt.fmtSpec({ alternate: true }, args4[0]), " ", rt.fmtSpec({ align: ">", width: 9 }, args4[1]), "|", rt.fmtSpec({ align: "<", width: 9 }, args4[2]), "|"])), undefined, true); rt.byteVecPush(out, rt.iterCount(rt.iterEmpty() as rt.Iter) & 0xff); } else if (_7 === 1) { - const sorted: zeros_Tagged.Tagged[] = tags.map(zeros_Tagged.clone$Clone_String); + const sorted: zeros_Tagged.Tagged[] = rt.vecExact(tags.map(zeros_Tagged.clone$Clone_String), 1); rt.sliceSort(sorted, rt.cmpLt(zeros_Tagged.partialCmp$cmp_PartialOrd_String)); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(sorted), (t3: zeros_Tagged.Tagged): rt.u8 => { return t3.n; diff --git a/ts/fixtures/lang/src/capacity.rs b/ts/fixtures/lang/src/capacity.rs new file mode 100644 index 000000000..76e49af0e --- /dev/null +++ b/ts/fixtures/lang/src/capacity.rs @@ -0,0 +1,462 @@ +//! 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. + +use std::collections::{BinaryHeap, VecDeque}; +use std::mem; + +/// 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 std fixes of a vector's capacity as steps change it: its value while `exact`, and +/// else that it holds at least the length and `floor`, the most `with_capacity` or +/// `reserve` asked for since a shrink. +struct Known { + exact: bool, + floor: usize, +} + +impl Known { + /// A vector just made, with room for at least `floor`. + fn new(floor: usize) -> Self { + Self { exact: true, floor } + } + + /// Whatever capacity a step left, holding at least `floor` still. + fn loose(&mut self) { + self.exact = false; + } + + /// A vector made anew, which holds what std guarantees of it. + fn remade(&mut self, exact: bool) { + *self = Self { exact, floor: 0 }; + } + + /// After `reserve` made room for `additional` past `len`. + fn reserved(&mut self, len: usize, additional: usize) { + self.floor = self.floor.max(len + additional); + } + + /// After `shrink_to` of `min`, holding `len`. + fn shrunk(&mut self, len: usize, min: usize) { + self.floor = self.floor.min(len.max(min)); + } + + /// `len` and what this fixes of `cap`. + fn put(&self, out: &mut Vec, len: usize, cap: usize) { + put(out, len); + match self.exact { + true => put(out, cap), + false => put(out, usize::from(cap >= len.max(self.floor))), + } + } +} + +/// How many to reserve by `arg`, beside `len` of `size`-byte elements: a few, or one to +/// eight past what a vector of them may hold, or within eight of `usize::MAX`, either of +/// which panics before it allocates. +fn amount(arg: u8, len: usize, size: usize) -> usize { + match arg >> 5 { + 7 => usize::MAX - usize::from(arg & 7), + 6 if size > 0 => isize::MAX as usize / size - len + 1 + usize::from(arg & 7), + _ => usize::from(arg & 0x1f), + } +} + +/// A test that keeps every other element it is asked about. +fn alternate() -> impl FnMut() -> bool { + let mut kept = false; + move || { + kept = !kept; + kept + } +} + +/// What the element type `kind` picks makes of a byte. +macro_rules! by_kind { + ($kind:expr, $f:ident, $data:expr, $out:expr) => { + match $kind % 5 { + 0 => $f($data, |b| b, $out), + 1 => $f($data, u16::from, $out), + 2 => $f($data, |b| (u64::from(b), b), $out), + 3 => $f($data, |b| [u64::from(b); 160], $out), + _ => $f($data, |_| (), $out), + } + }; +} + +/// A `Vec` that `data`'s first byte makes, by `with_capacity` if odd, and each pair after +/// it changes, its length and capacity after each. +pub fn vecs(kind: u8, data: &[u8], out: &mut Vec) { + by_kind!(kind, vec_steps, data, out); +} + +fn vec_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec) { + let size = size_of::(); + let (first, steps) = data.split_first().map_or((0, &[][..]), |(&b, rest)| (b, rest)); + let mut v: Vec = match first & 1 { + 1 => Vec::with_capacity(usize::from(first >> 3)), + _ => Vec::new(), + }; + let mut k = Known::new(v.capacity()); + 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 { + 0 | 1 => v.push(make(arg)), + 2 => { + drop(v.pop()); + k.loose(); + } + 3 | 4 => { + let additional = amount(arg, v.len(), size); + match op % 25 { + 3 => v.reserve(additional), + _ => v.reserve_exact(additional), + } + k.reserved(v.len(), additional); + } + 5 => { + v.shrink_to(usize::from(arg % 40)); + k.shrunk(v.len(), usize::from(arg % 40)); + } + 6 => { + v.shrink_to_fit(); + k.shrunk(v.len(), 0); + k.exact = true; + } + 7 => { + v.truncate(usize::from(arg % 8)); + k.loose(); + } + 8 => v.insert(usize::from(arg) % (v.len() + 1), make(arg)), + 9 if !v.is_empty() => { + drop(v.remove(usize::from(arg) % v.len())); + k.loose(); + } + // 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(); + } + 13 => { + v.clear(); + k.loose(); + } + 14 => { + let mut keep = alternate(); + v.retain(|_| keep()); + k.loose(); + } + 15 => { + drop(v.drain(..v.len().min(usize::from(arg % 4)))); + k.loose(); + } + 16 => { + v = v.clone(); + k.remade(true); + } + 17 => { + v = v.into_boxed_slice().into_vec(); + k.remade(false); + } + // 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); + } + 19 => { + let mut it = v.into_iter(); + for i in 0..arg % 8 { + drop(if i % 3 == 2 { it.next_back() } else { it.next() }); + } + v = it.collect(); + k.remade(false); + } + 20 => { + let mut taken = mem::take(&mut v); + taken.push(make(arg)); + k.put(out, taken.len(), taken.capacity()); + v = mem::replace(&mut taken, Vec::with_capacity(usize::from(arg % 6))); + Known::new(0).put(out, taken.len(), taken.capacity()); + } + 21 if !v.is_empty() => { + drop(v.swap_remove(usize::from(arg) % v.len())); + k.loose(); + } + 22 => { + v.dedup(); + k.loose(); + } + // A clone of one read from the front, a new `Vec` of what was left. + 23 => { + let mut it = v.into_iter(); + for _ in 0..arg % 4 { + drop(it.next()); + } + v = it.clone().collect(); + k.remade(true); + let rest = it.collect::>(); + Known { exact: false, floor: 0 }.put(out, rest.len(), rest.capacity()); + } + 24 => { + v = vec![make(arg); usize::from(arg % 6)]; + k.remade(false); + } + _ => {} + } + k.put(out, v.len(), v.capacity()); + } +} + +/// A `VecDeque`, as `vecs` steps a `Vec`. +pub fn deques(kind: u8, data: &[u8], out: &mut Vec) { + by_kind!(kind, deque_steps, data, out); +} + +fn deque_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec) { + let size = size_of::(); + let (first, steps) = data.split_first().map_or((0, &[][..]), |(&b, rest)| (b, rest)); + let mut q: VecDeque = match first & 1 { + 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(); + } + 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(); + } + 8 => q.insert(usize::from(arg) % (q.len() + 1), make(arg)), + 9 => { + drop(q.remove(usize::from(arg) % (q.len() + 1))); + k.loose(); + } + 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(); + } + 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); + } + // 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); + } + 18 => { + let mut keep = alternate(); + q = q.into_iter().filter(|_| keep()).collect(); + k.remade(true); + } + 19 => { + let mut it = q.into_iter(); + for _ in 0..arg % 4 { + 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); + } + } + k.put(out, q.len(), q.capacity()); + } +} + +/// A `BinaryHeap`, as `vecs` steps a `Vec`, and the `Vec` it gives up at the end. +pub fn heaps(kind: u8, data: &[u8], out: &mut Vec) { + by_kind!(kind, heap_steps, data, out); +} + +fn heap_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec) { + let size = size_of::(); + let (first, steps) = data.split_first().map_or((0, &[][..]), |(&b, rest)| (b, rest)); + let mut h: BinaryHeap = match first & 1 { + 1 => BinaryHeap::with_capacity(usize::from(first >> 3)), + _ => BinaryHeap::new(), + }; + let mut k = Known::new(h.capacity()); + put(out, h.capacity()); + let mut other = BinaryHeap::new(); + for step in steps.chunks(2) { + let (op, arg) = (step[0], step.get(1).copied().unwrap_or(0)); + match op % 13 { + 0 | 1 => h.push(make(arg)), + 2 => { + drop(h.pop()); + k.loose(); + } + 3 | 4 => { + let additional = amount(arg, h.len(), size); + match op % 13 { + 3 => h.reserve(additional), + _ => h.reserve_exact(additional), + } + k.reserved(h.len(), additional); + } + 5 => { + h.shrink_to(usize::from(arg % 40)); + k.shrunk(h.len(), usize::from(arg % 40)); + } + 6 => { + h.shrink_to_fit(); + k.shrunk(h.len(), 0); + k.exact = true; + } + 7 => { + h.clear(); + k.loose(); + } + 8 => h.extend((0..arg % 24).filter(|i| i % 3 != 0).map(make)), + // The larger of the two keeps its elements, and the other's join them. + 9 => { + other.push(make(arg)); + h.append(&mut other); + k.remade(false); + Known { exact: false, floor: 0 }.put(out, other.len(), other.capacity()); + } + 10 => { + drop(h.drain()); + k.loose(); + } + // A guard that hid all but the top, forgotten, which leaks the rest. + 11 => { + if let Some(mut top) = h.peek_mut() { + *top = make(arg); + mem::forget(top); + } + k.remade(false); + } + _ => h = BinaryHeap::from(h.into_vec()), + } + k.put(out, h.len(), h.capacity()); + } + let cloned = h.clone().into_vec(); + Known::new(0).put(out, cloned.len(), cloned.capacity()); + let sorted = h.into_sorted_vec(); + k.put(out, sorted.len(), sorted.capacity()); +} + +/// What collections each way std's makes them from an iterator hold room for: in place of +/// a `Vec` of elements of another size, by a tuple's `Extend`, by `vec!`, and by +/// `with_capacity` past what one may hold, which panics. +pub fn collects(kind: u8, data: &[u8], out: &mut Vec) { + let n = data.first().map_or(0, |&b| usize::from(b % 24)); + let pairs: Vec<(u32, u32)> = Vec::with_capacity(n + usize::from(kind % 4)); + let mut pairs = pairs; + pairs.extend((0..n as u32).map(|i| (i, i))); + let exact = Known::new(0); + let loose = Known { exact: false, floor: 0 }; + match kind % 8 { + // 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()); + } + // Bytes in place of bytes, and wider items than bytes, which collect anew. + 1 => { + let mut bytes = Vec::with_capacity(n + 3); + 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()); + let wide: Vec = bytes.into_iter().map(u16::from).collect(); + exact.put(out, wide.len(), wide.capacity()); + } + 2 => { + let (a, b): (Vec, VecDeque) = pairs.iter().filter(|(a, _)| a % 2 == 0).copied().unzip(); + exact.put(out, a.len(), a.capacity()); + exact.put(out, b.len(), b.capacity()); + let (c, d): (Vec, BinaryHeap) = pairs.iter().map(|&(a, b)| (a as u8, b)).unzip(); + exact.put(out, c.len(), c.capacity()); + exact.put(out, d.len(), d.capacity()); + } + 3 => { + let filled = vec![0u16; n]; + loose.put(out, filled.len(), filled.capacity()); + let units = vec![(); n]; + exact.put(out, units.len(), units.capacity()); + } + 4 => { + let v: Vec = Vec::with_capacity(usize::MAX - n); + put(out, v.capacity()); + } + 5 => { + let q: VecDeque<(u64, u64)> = VecDeque::with_capacity(0x1000_0000 + n); + put(out, q.capacity()); + } + // A deque and a heap in place of a `Vec` of bytes, and the bytes a heap gives up. + 6 => { + let mut bytes = Vec::with_capacity(n + 5); + bytes.extend_from_slice(&data[..n.min(data.len())]); + let q = VecDeque::from(bytes.clone()); + loose.put(out, q.len(), q.capacity()); + let heap = BinaryHeap::from(bytes); + loose.put(out, heap.len(), heap.capacity()); + let v = heap.into_vec(); + loose.put(out, v.len(), v.capacity()); + } + _ => { + let bytes = vec![7u8; n]; + let mut grown = bytes.clone(); + grown.extend((0..n as u8).filter(|b| b % 2 == 0)); + exact.put(out, grown.len(), grown.capacity()); + grown.shrink_to(n / 2); + exact.put(out, grown.len(), grown.capacity()); + } + } +} diff --git a/ts/fixtures/lang/src/harness.rs b/ts/fixtures/lang/src/harness.rs index 80884713f..e1583de67 100644 --- a/ts/fixtures/lang/src/harness.rs +++ b/ts/fixtures/lang/src/harness.rs @@ -2,11 +2,11 @@ //! case and the rest is its input. use crate::{ - args, arrays, ascii, atomics, borrows, bounds, boxes, captures, cells, chars, chunks, clones, collections, - combinators, 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, splits, statics, strs, tuples, - utf8, wrappers, wraps, zeros, + args, arrays, ascii, atomics, borrows, bounds, boxes, capacity, captures, cells, chars, chunks, clones, + collections, combinators, 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, splits, statics, + strs, tuples, utf8, wrappers, wraps, zeros, }; /// The native side's entry: [`run`], except that a case starting with 0xff prints a @@ -275,6 +275,10 @@ fn cases() -> Vec<(&'static str, Case)> { ("strs::gets", strs::gets), ("borrows::maps", |_, data, out| borrows::maps(data, out)), ("locks::mapped", |_, data, out| locks::mapped(data, out)), + ("capacity::vecs", capacity::vecs), + ("capacity::deques", capacity::deques), + ("capacity::heaps", capacity::heaps), + ("capacity::collects", capacity::collects), ] } diff --git a/ts/fixtures/lang/src/lib.rs b/ts/fixtures/lang/src/lib.rs index 0e0cead7d..e6c00b0f3 100644 --- a/ts/fixtures/lang/src/lib.rs +++ b/ts/fixtures/lang/src/lib.rs @@ -17,7 +17,8 @@ //! slices, the order, equality, and //! hashes of bytes, ranges of `Bound`s and of the crate's own `RangeBounds`, the equality //! of `Result`s and std's errors, inclusive ranges read through each adaptor, iterators' -//! size hints, the capacity overflows collections reserving by them panic with, tuples of +//! size hints, the capacity overflows collections reserving by them panic with, the +//! capacity of a `Vec`, `VecDeque`, and `BinaryHeap` as each grows and shrinks, tuples of //! collections collected and extended by their items, zero-sized values, which MIR //! never assigns, with std's impls of them, and functions generic over an array's length. //! @@ -40,6 +41,7 @@ mod atomics; mod borrows; mod bounds; mod boxes; +mod capacity; mod captures; mod cells; mod chars; diff --git a/ts/fixtures/task/expected/drops.ts b/ts/fixtures/task/expected/drops.ts index c3a20935f..3b9b5e76b 100644 --- a/ts/fixtures/task/expected/drops.ts +++ b/ts/fixtures/task/expected/drops.ts @@ -1391,7 +1391,7 @@ export function edited(log: Log.Log, id: rt.u32, arg: rt.u8): void { const _195: Key.Key = key(2); v8.push(_195); const v7: Key.Key[] = v8; - const _209: Key.Key[] = v7.map(Key.clone$Clone); + const _209: Key.Key[] = rt.vecExact(v7.map(Key.clone$Clone), 12); const part15 = ids(_209); const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part15)]; const _200: string = rt.fmtFormat(["cloned ", args14[0]]); diff --git a/ts/fixtures/task/expected/drops/folds.ts b/ts/fixtures/task/expected/drops/folds.ts index 37c30a472..143c50552 100644 --- a/ts/fixtures/task/expected/drops/folds.ts +++ b/ts/fixtures/task/expected/drops/folds.ts @@ -213,7 +213,7 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { const _199: rt.Iter = rt.iterSlice(guards(1, 4), rt.drop); _1090 = false; const captured54 = c; - const _198: rt.Iter = rt.iterMap(_199, rt.closure((g66: Guard.Guard): Guard.Guard => { + const queue: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(_199, rt.closure((g66: Guard.Guard): Guard.Guard => { const _974: rt.u32 = Guard.id(g66); const _1223: rt.u32 = Guard.id(captured54); const args100: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_974, f), (f: rt.Formatter) => rt.u32Display(_1223, f)]; @@ -221,8 +221,7 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { return g66; }, (): void => { captured54[Symbol.dispose](); - })); - const queue: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(rt.iterToArray(_198, "next", 8, true))); + })), "next", 8, true)) 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 95566a798..06049bc4d 100644 --- a/ts/fixtures/task/expected/drops/inside.ts +++ b/ts/fixtures/task/expected/drops/inside.ts @@ -70,8 +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 _147: rt.Iter = rt.iterMap(new rt.Range(6, 9), guard); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(rt.iterToArray(_147, undefined, 8, true))); + const q: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(new rt.Range(6, 9), guard), undefined, 8, true)) 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 42084ce05..6a423d68e 100644 --- a/ts/fixtures/task/expected/drops/iters.ts +++ b/ts/fixtures/task/expected/drops/iters.ts @@ -404,8 +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 _218: rt.Iter = rt.iterSlice(v9, rt.drop); - const queue: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(rt.iterToArray(_218, "next", 8, true))); + const queue: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterSlice(v9, rt.drop), "next", 8, true)) as rt.VecDeque; const v10: [rt.u32, Guard.Guard][] = []; const _237: [rt.u32, Guard.Guard] = [1, guard(21)]; v10.push(_237); diff --git a/ts/runtime/rt.ts b/ts/runtime/rt.ts index b93329416..605b72ce4 100644 --- a/ts/runtime/rt.ts +++ b/ts/runtime/rt.ts @@ -154,13 +154,14 @@ export function ptrWrite(p: T, value: T): void { /** * `mem::replace` of what a `&mut` to an object points at, in place: `value`'s fields, or - * its items for a JS array, moved into `p`, and what `p` held returned as an object of its own. + * its items and capacity for a JS array, moved into `p`, and what `p` held returned as an object of its own. */ export function replaceIn(p: T, value: T): T { if (Array.isArray(p)) { - const old = p.slice() as T; + const old: unknown[] & Capped = p.slice(); + if ((p as Capped).cap !== undefined) old.cap = (p as Capped).cap; vecAssign(p, value as unknown[]); - return old; + return old as T; } const old = Object.assign(Object.create(Object.getPrototypeOf(p)) as T, p); Object.assign(p, value); @@ -722,10 +723,11 @@ export function vecDedupByKeyMut(v: T[], key: (item: Place) => K, eq: ( vecDedupByMut(v, (a, b) => eq(key(a), key(b)), drop); } -/** `*v = value` through a `&mut` to a `Vec` other than of bytes, or to a boxed slice: `value`'s items, in place. */ -export function vecAssign(v: T[], value: T[]): void { +/** `*v = value` through a `&mut` to a `Vec` other than of bytes, or to a boxed slice: `value`'s items and capacity, in place. */ +export function vecAssign(v: T[] & Capped, value: T[] & Capped): void { v.length = value.length; for (let i = 0; i < value.length; i++) v[i] = value[i]!; + if (v.cap !== undefined || value.cap !== undefined) v.cap = value.cap; } /** `Vec::insert`: `item` at `i`, with those from `i` on moved up. */ @@ -993,11 +995,14 @@ export function byteSliceToByteVec(s: ByteSlice): ByteVec { return v; } -/** `vec![value; n]`: `n - 1` clones of `value`, in order, then `value` itself; `clone` is `undefined` where a clone is the value. */ +/** `vec![value; n]`: `n - 1` clones of `value`, in order, then `value` itself, with room for exactly them; `clone` is `undefined` where a clone is the value. */ export function vecFromElem(value: T, n: number, clone: ((value: T) => T) | undefined): T[] { - const v: T[] = []; + const v: T[] & Capped = []; for (let i = 1; i < n; i++) v.push(clone === undefined ? value : clone(value)); - if (n > 0) v.push(value); + if (n > 0) { + v.push(value); + v.cap = n; + } return v; } @@ -1201,6 +1206,149 @@ export function byteVecDedupByKeyMut(v: ByteVec, key: (byte: Place) = byteVecDedupByMut(v, (a, b) => eq(key(a), key(b))); } +// Capacity. std leaves a vector's growth unspecified past `capacity() >= len` and what +// `with_capacity` and `reserve` ask for, so a `Vec` or `VecDeque` holds one, as `cap`, +// only where an operation sets it, and a push never reads or writes it. Reading one +// doubles it while short of the length, from the least `RawVec` allocates, as std's +// pushes grow it. An `rt.ByteVec`'s is its buffer's length. + +/** wasm32's `isize::MAX`, the most bytes std's `Layout` describes. */ +const ISIZE_MAX = 0x7fffffff; + +/** wasm32's `usize::MAX`. */ +const USIZE_MAX = 0xffffffff; + +/** A vector's storage, and `cap`, the capacity an operation last set it to, if any. */ +export interface Capped { + cap?: number; +} + +/** How many `size`-byte elements a vector holds at most: `usize::MAX` of zero-sized ones. */ +export function vecMax(size: number): number { + return size === 0 ? USIZE_MAX : Math.floor(ISIZE_MAX / size); +} + +/** The capacity of a vector holding `len` of `size`-byte elements, from `cap`, the one last set, as pushes grow std's. */ +export function capOf(len: number, cap: number | undefined, size: number): number { + if (size === 0) return USIZE_MAX; + let c = cap ?? 0; + while (c < len) c = Math.max(c * 2, size === 1 ? 8 : size <= 1024 ? 4 : 1); + return c; +} + +/** `c`'s capacity set to `cap`, holding `len`, where reading it would not give that. */ +export function capSet(c: object & Capped, len: number, cap: number, size: number): void { + if (size !== 0 && (c.cap !== undefined || cap !== capOf(len, undefined, size))) c.cap = cap; +} + +/** `c`'s capacity set to `cap`, which `reserve` asked for, so it holds as the length drops. */ +export function capHold(c: object & Capped, cap: number, size: number): void { + if (size !== 0) c.cap = cap; +} + +/** + * The capacity `cap`, holding `len`, once `reserve` made room for `additional` more, as + * std's `RawVec::grow_amortized`: at least double, or a panic past what it may hold. + */ +export function capReserve(len: number, cap: number, additional: number, size: number): number { + if (additional <= cap - len) return cap; + const grown = Math.max(cap * 2, len + additional, size === 1 ? 8 : size <= 1024 ? 4 : 1); + if (grown > vecMax(size)) panic("capacity overflow"); + return grown; +} + +/** The capacity `cap`, holding `len`, once `reserve_exact` made room for `additional` more. */ +export function capReserveExact(len: number, cap: number, additional: number, size: number): number { + if (additional <= cap - len) return cap; + if (len + additional > vecMax(size)) panic("capacity overflow"); + return len + additional; +} + +/** The capacity `cap`, holding `len`, once `shrink_to` of `min` shrank it, as `shrink_to_fit` of 0 does. */ +export function capShrink(len: number, cap: number, min: number): number { + return cap > min ? Math.max(len, min) : cap; +} + +/** `Vec::with_capacity` of `size`-byte elements, which panics past what it may hold. */ +export function vecWithCapacity(n: number, size: number): T[] { + if (n > vecMax(size)) panic("capacity overflow"); + const v: T[] & Capped = []; + capSet(v, 0, n, size); + return v; +} + +/** `Vec::capacity` of `size`-byte elements. */ +export function vecCapacity(v: T[] & Capped, size: number): number { + return capOf(v.length, v.cap, size); +} + +/** `Vec::reserve` of `size`-byte elements. */ +export function vecReserve(v: T[] & Capped, additional: number, size: number): void { + capHold(v, capReserve(v.length, vecCapacity(v, size), additional, size), size); +} + +/** `Vec::reserve_exact` of `size`-byte elements. */ +export function vecReserveExact(v: T[] & Capped, additional: number, size: number): void { + capHold(v, capReserveExact(v.length, vecCapacity(v, size), additional, size), size); +} + +/** `Vec::shrink_to` of `size`-byte elements, and `shrink_to_fit` of 0. */ +export function vecShrinkTo(v: T[] & Capped, min: number, size: number): void { + capSet(v, v.length, capShrink(v.length, vecCapacity(v, size), min), size); +} + +/** `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); + return v; +} + +/** `v`'s storage moved to `cap` bytes. */ +function realloc(v: ByteVec, cap: number): void { + const data = bytes(cap); + data.set(v.data.subarray(0, v.length)); + v.data = data; +} + +/** The bytes of `v` as a `Vec`, with its capacity, as a deque or heap takes it. */ +export function byteVecToVec(v: ByteVec): number[] { + const out = Array.from(byteVecView(v)); + capSet(out, out.length, v.data.length, 1); + return out; +} + +/** A `Vec` of the bytes in `v`, with its capacity, as a heap gives them up. */ +export function byteVecFromVec(v: number[] & Capped): ByteVec { + const out = new ByteVec(capOf(v.length, v.cap, 1)); + out.data.set(v); + out.length = v.length; + return out; +} + +/** `Vec::with_capacity` of bytes, which panics past what it may hold. */ +export function byteVecWithCapacity(n: number): ByteVec { + if (n > ISIZE_MAX) panic("capacity overflow"); + return new ByteVec(n); +} + +/** `Vec::reserve` of bytes. */ +export function byteVecReserve(v: ByteVec, additional: number): void { + const cap = capReserve(v.length, v.data.length, additional, 1); + if (cap !== v.data.length) realloc(v, cap); +} + +/** `Vec::reserve_exact` of bytes. */ +export function byteVecReserveExact(v: ByteVec, additional: number): void { + const cap = capReserveExact(v.length, v.data.length, additional, 1); + if (cap !== v.data.length) realloc(v, cap); +} + +/** `Vec::shrink_to` of bytes, and `shrink_to_fit` of 0. */ +export function byteVecShrinkTo(v: ByteVec, min: number): void { + const cap = capShrink(v.length, v.data.length, min); + if (cap !== v.data.length) realloc(v, cap); +} + // Cows of slices. An owned one is its `Vec` and a borrowed one its slice, told apart by // class: a `Cow<[u8]>` is an `rt.ByteVec` or an `rt.ByteSlice`, and any other is an array // or the `rt.Borrowed` wrapping the array it borrows. diff --git a/ts/runtime/rt/collections.ts b/ts/runtime/rt/collections.ts index 541e1d5c7..47057b12b 100644 --- a/ts/runtime/rt/collections.ts +++ b/ts/runtime/rt/collections.ts @@ -14,7 +14,7 @@ // 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, type None, type Place, panic, type RangeBound, rangeCheck, sliceSort } from "../rt.ts"; +import { ByteSlice, ByteVec, byteVecPush, byteVecReserve, type Capped, capHold, capOf, capReserve, capReserveExact, capSet, capShrink, type None, type Place, panic, type RangeBound, rangeCheck, sliceSort, vecExact, vecMax, vecReserve, vecWithCapacity } from "../rt.ts"; import type { Hashing } from "./hash.ts"; import { type Limbs, lt } from "./int.ts"; import { @@ -34,12 +34,8 @@ import { rangeInclusiveStartBound, type SizeHint, type Take, - dequeReserve, - vecCapacity, - vecGrow, - vecPush, - vecReserve, - vecReserveExact, + capNext, + trustedUpper, } from "./iter.ts"; import { type Arc, drop as dispose, dropAll, dropRange } from "./task.ts"; @@ -909,22 +905,23 @@ 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: a `trusted` iterator up front, and any other by `next`, - * a `deque`'s at its first item too. + * 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. */ -function vecExtending(c: C, len: number, items: Iter, add: (item: T) => void, take?: Take, size?: number, trusted = false, deque = false): C { - if (size === undefined || trusted) { - if (size !== undefined) vecReserveExact(items, len, size); +function vecExtending(c: C, len: number, items: Iter, add: (item: T) => void, take?: Take, size?: number, trusted = false, at: object & Capped = {}, deque = false): C { + if (size === undefined) return extending(c, items, add, take); + let cap = capOf(len, at.cap, size); + if (trusted) { + capSet(at, len, capReserve(len, cap, trustedUpper(items), size), size); return extending(c, items, add, take); } - let cap = vecCapacity(len, size); for (let item = items.next(); item !== DONE; item = items.next()) { - if (deque) dequeReserve(items, len); + if (deque || len === cap) cap = capNext(items, len, cap, size); deque = false; - if (len === cap) cap = vecGrow(items, cap, size); add(item); len++; } + capSet(at, len, cap, size); if (take !== undefined) dispose(items); return c; } @@ -2359,19 +2356,55 @@ 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. + * from `h` on, wrapping past the end, and the capacity an operation set, as a `Vec`'s. */ -export interface VecDeque { +export interface VecDeque extends Capped { b: (T | undefined)[]; h: number; n: number; } -/** `VecDeque::new` and `with_capacity`. */ +/** `VecDeque::new`. */ export function dequeNew(): VecDeque { return { b: [], h: 0, n: 0 }; } +/** `VecDeque::with_capacity` of `size`-byte items, which panics past what it may hold. */ +export function dequeWithCapacity(n: number, size: number): VecDeque { + if (n > vecMax(size)) panic("capacity overflow"); + const q = dequeNew(); + capSet(q, 0, n, size); + 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; + return q; +} + +/** `VecDeque::capacity` of `size`-byte items. */ +export function dequeCapacity(q: VecDeque, size: number): number { + return capOf(q.n, q.cap, size); +} + +/** `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` 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` 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 of item `i`. */ function at(q: VecDeque, i: number): number { return (q.h + i) & (q.b.length - 1); @@ -2842,13 +2875,14 @@ class ByteVecDrain extends Iter implements Disposable { * 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, true); + return vecExtending(q, q.n, items, (item) => dequePushBack(q, item), take, size, trusted, q, true); } -/** `clone`, with each item through its `Clone`, or as itself without one. */ -export function dequeClone(q: VecDeque, item: (value: T) => T = itself): VecDeque { +/** `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); return out; } @@ -3175,11 +3209,16 @@ export interface BinaryHeap { d: T[]; } -/** `BinaryHeap::new`, `with_capacity`, and `default`. */ +/** `BinaryHeap::new` and `default`. */ export function heapNew(): BinaryHeap { return { d: [] }; } +/** `BinaryHeap::with_capacity` of `size`-byte elements: its `Vec`'s. */ +export function heapWithCapacity(n: number, size: number): BinaryHeap { + return { d: vecWithCapacity(n, size) }; +} + /** `From>`: the vector's elements, rebuilt into a heap in place, as std's are. */ export function heapFrom(d: T[], le: Test, ge: Test, lt: Test): BinaryHeap { rebuild(d, le, ge, lt); @@ -3221,12 +3260,12 @@ export function heapIntoSortedVec(h: BinaryHeap, le: Test, ge: Test, return d; } -/** `append`: `other`'s elements added to the larger of the two, which `h` then holds, and `other` left empty. */ +/** `append`: `other`'s elements added to the larger of the two, which `h` then holds, and `other` left empty, keeping its capacity. */ export function heapAppend(h: BinaryHeap, other: BinaryHeap, le: Test, ge: Test, lt: Test): void { if (h.d.length < other.d.length) [h.d, other.d] = [other.d, h.d]; const start = h.d.length; for (const item of other.d) h.d.push(item); - other.d = []; + other.d.length = 0; rebuildTail(h.d, start, le, ge, lt); } @@ -3236,7 +3275,7 @@ export function heapAppend(h: BinaryHeap, other: BinaryHeap, le: Test(h: BinaryHeap, items: Iter, le: Test, ge: Test, lt: Test, take?: Take, size?: number, trusted = false): BinaryHeap { const start = h.d.length; - vecExtending(h, start, items, (item) => h.d.push(item), take, size, trusted); + vecExtending(h, start, items, (item) => h.d.push(item), take, size, trusted, h.d); rebuildTail(h.d, start, le, ge, lt); return h; } @@ -3262,18 +3301,14 @@ export function heapRetain(h: BinaryHeap, f: (item: T) => boolean, le: Tes rebuildTail(d, from, le, ge, lt); } -/** `clear`, which leaves the heap empty and then drops each element in order. */ +/** `clear`, which leaves the heap empty, keeping its capacity, and then drops each element in order. */ export function heapClear(h: BinaryHeap, drop?: (item: T) => void): void { - const d = h.d; - h.d = []; - dropAll(d, drop); + dropAll(h.d.splice(0), drop); } -/** `drain`: an iterator of the elements in order, which leaves the heap empty and drops those it still holds by `drop`. */ +/** `drain`: an iterator of the elements in order, which leaves the heap empty, keeping its capacity, and drops those it still holds by `drop`. */ export function heapDrain(h: BinaryHeap, drop?: (item: T) => void): Iter { - const d = h.d; - h.d = []; - return iterSlice(d, drop); + return iterSlice(h.d.splice(0), drop); } /** `iter` and `into_iter`: the elements in order, any not read dropped by `drop` as the iterator drops. */ @@ -3286,9 +3321,9 @@ export function heapDrop(h: BinaryHeap, drop: (item: T) => void): void { dropAll(h.d, drop); } -/** `clone`, with each element through its `Clone`, or as itself without one. */ -export function heapClone(h: BinaryHeap, item: (value: T) => T = itself): BinaryHeap { - return { d: h.d.map((value) => item(value)) }; +/** `clone` of `size`-byte elements, with each through its `Clone`, or as itself without one, as its `Vec`'s. */ +export function heapClone(h: BinaryHeap, item: (value: T) => T = itself, size: number): BinaryHeap { + return { d: vecExact(h.d.map((value) => item(value)), size) }; } /** @@ -3483,22 +3518,11 @@ export function copiedPart(part: Part, copy: (item: T) => T): Part part.one(c, copy(item)) }; } -/** - * A collection kept in a vector, which holds `length(c)` of `size`-byte elements and - * `push` adds to: it reserves as `vecReserve`, and from what it reserved, grows by one as - * `vecPush` does, panicking past what it may hold. - */ -function vectorPart(length: (c: C) => number, push: (c: C, item: T) => void, size?: number): Part { - let cap: number | undefined; +/** A collection kept in a vector, which `push` adds to and `reserve` reserves in, where it knows its elements' size. */ +function vectorPart(push: (c: C, item: T) => void, reserve?: (c: C, additional: number) => void): Part { return { - reserve: - size === undefined - ? undefined - : (c, additional) => { - cap = vecReserve(length(c), additional, size, cap); - }, + reserve, one: (c, item) => { - if (size !== undefined) cap = vecPush(length(c), size, cap); push(c, item); return c; }, @@ -3508,20 +3532,19 @@ function vectorPart(length: (c: C) => number, push: (c: C, item: T) => voi /** A `Vec` of `size`-byte elements, which pushes each. */ export function vecPart(size?: number): Part { return vectorPart( - (v) => v.length, (v, item) => v.push(item), - size, + size === undefined ? undefined : (v, additional) => vecReserve(v, additional, size), ); } /** A `Vec`, as `vecPart`. */ export function byteVecPart(): Part { - return vectorPart((v) => v.length, byteVecPush, 1); + 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((q) => q.n, dequePushBack, size); + return vectorPart(dequePushBack, size === undefined ? undefined : (q, additional) => dequeReserve(q, additional, size)); } /** A `LinkedList`, which pushes each at the back, and never reserves. */ @@ -3537,9 +3560,8 @@ export function listPart(): Part, T> { /** A `BinaryHeap` of `size`-byte elements, which pushes each, sifting it up by `le`. */ export function heapPart(le: Test, size?: number): Part, T> { return vectorPart( - (h) => h.d.length, (h, item) => heapPush(h, item, le), - size, + size === undefined ? undefined : (h, additional) => vecReserve(h.d, additional, size), ); } diff --git a/ts/runtime/rt/iter.ts b/ts/runtime/rt/iter.ts index f800962e4..6f1c6437e 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, Err, type None, Ok, type Place, panic, place, type RangeBound, type Result, sliceView, vecExtendFromSlice } from "../rt.ts"; +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 { 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"; @@ -535,31 +535,18 @@ export function iterBorrow(it: Iter): Iter { // How std's `Vec` and `VecDeque` reserve for an iterator they collect or extend by, of // elements `size` bytes each, which panics past what they may hold: a `TrustedLen` one's // upper bound first, and else, after each item that finds them full, the lower bound and -// one more; as a tuple's part, the lower bound first. Their capacity is not modeled, so -// one they extend is taken as full, as one holding nothing is, and grows as std's would -// from there. +// one more; as a tuple's part, the lower bound first. -/** wasm32's `isize::MAX`, the most bytes std's `Layout` describes. */ -const ISIZE_MAX = 0x7fffffff; - -/** How many `size`-byte elements a `Vec` holds at most: `usize::MAX` of zero-sized ones. */ -function vecMax(size: number): number { - return size === 0 ? USIZE_MAX : Math.floor(ISIZE_MAX / size); -} - -/** - * std's reserve for a `TrustedLen` iterator `it`, in a `Vec` or `VecDeque` holding `len` - * of `size`-byte elements: its upper bound, which panics without one or past what it may - * hold. - */ -export function vecReserveExact(it: Iter, len: number, size: number): void { +/** The upper bound of a `TrustedLen` iterator `it`, which std's reserves, panicking without one. */ +export function trustedUpper(it: Iter): number { const upper = it.sizeHint()[1]; - if (upper === undefined || len + upper > vecMax(size)) panic("capacity overflow"); + if (upper === undefined) panic("capacity overflow"); + return upper; } -/** The capacity of a `Vec` or `VecDeque` holding `len` of `size`-byte elements: full, but for zero-sized ones. */ -export function vecCapacity(len: number, size: number): number { - return size === 0 ? USIZE_MAX : len; +/** The capacity `cap`, holding `len`, once it reserved for the next item of `it` and those it holds past it. */ +export function capNext(it: Iter, len: number, cap: number, size: number): number { + return capReserve(len, cap, satAdd(it.sizeHint()[0], 1), size); } /** @@ -609,60 +596,23 @@ function joinedLength(parts: readonly { length: number }[], sep: { length: numbe return length; } -/** - * The capacity a full `Vec` or `VecDeque` of `cap` `size`-byte elements grows to as it - * reserves for the next item of `it`, as std's `RawVec` amortizes it, or a panic past what - * it may hold. - */ -export function vecGrow(it: Iter, cap: number, size: number): number { - return grow(cap, cap + satAdd(it.sizeHint()[0], 1), size); -} - -/** The capacity `cap` of `size`-byte elements grows to as std's `RawVec` amortizes it to hold `required`, or a panic past what it may hold. */ -function grow(cap: number, required: number, size: number): number { - const grown = Math.max(cap * 2, required, size === 1 ? 8 : size <= 1024 ? 4 : 1); - if (grown > vecMax(size)) panic("capacity overflow"); - return grown; -} - -/** - * The capacity of a `Vec` or `VecDeque` of capacity `cap`, or else full, holding `len` of - * `size`-byte elements, once it reserved `additional` more, growing as `vecGrow` does. - */ -export function vecReserve(len: number, additional: number, size: number, cap = vecCapacity(len, size)): number { - return additional > cap - len ? grow(cap, len + additional, size) : cap; -} - -/** The capacity of one as `vecReserve` takes it once it pushed an item, growing by one as std's `grow_one` does once full. */ -export function vecPush(len: number, size: number, cap = vecCapacity(len, size)): number { - return len === cap ? grow(cap, len + 1, size) : cap; -} - -/** - * The reserve std's `VecDeque` makes at the first item it extends by, holding `len`, for - * what `it` holds past it, which panics past `usize::MAX` even where its zero-sized - * elements never fill it. - */ -export function dequeReserve(it: Iter, len: number): void { - if (len + satAdd(it.sizeHint()[0], 1) > USIZE_MAX) panic("capacity overflow"); -} - /** * `Extend::extend` of a `Vec`, which takes `items` as `take` says, and with elements * `size` bytes each, reserves as std's does for a `trusted`, `TrustedLen`, iterator or any * other. */ -export function iterExtend(v: T[], items: Iter, take?: Take, size?: number, trusted = false): T[] { +export function iterExtend(v: T[] & Capped, items: Iter, take?: Take, size?: number, trusted = false): T[] { if (size !== undefined && !trusted) { - let cap = vecCapacity(v.length, size); + let cap = vecCapacity(v, size); for (let item = items.next(); item !== DONE; item = items.next()) { - if (v.length === cap) cap = vecGrow(items, cap, size); + if (v.length === cap) cap = capNext(items, v.length, cap, size); v.push(item); } + capSet(v, v.length, cap, size); if (take !== undefined) dispose(items); return v; } - if (size !== undefined) vecReserveExact(items, v.length, size); + if (size !== undefined) capSet(v, v.length, capReserve(v.length, vecCapacity(v, size), trustedUpper(items), size), size); if (take === undefined) { const folded = items.folded(trusted); for (let item = folded.next(); item !== DONE; item = folded.next()) v.push(item); @@ -675,15 +625,14 @@ export function iterExtend(v: T[], items: Iter, take?: Take, size?: number /** `Extend::extend` of a `Vec`, reserving as `iterExtend` does. */ export function iterExtendBytes(v: ByteVec, items: Iter, take?: Take, trusted = false): ByteVec { if (!trusted) { - let cap = v.length; for (let item = items.next(); item !== DONE; item = items.next()) { - if (v.length === cap) cap = vecGrow(items, cap, 1); + if (v.length === v.data.length) byteVecReserve(v, satAdd(items.sizeHint()[0], 1)); byteVecPush(v, item); } if (take !== undefined) dispose(items); return v; } - vecReserveExact(items, v.length, 1); + byteVecReserve(v, trustedUpper(items)); if (take === undefined) { const folded = items.folded(true); for (let item = folded.next(); item !== DONE; item = folded.next()) byteVecPush(v, item); @@ -1259,17 +1208,19 @@ export function iterGe(a: Iter, b: Iter, cmp: (x: T, y: U) => Orderi /** `collect` into a `Vec`, as `iterExtend` of an empty one. */ export function iterToArray(it: Iter, take?: Take, size?: number, trusted = false): T[] { - const out: T[] = []; if (size !== undefined && !trusted) { - let cap = vecCapacity(0, size); + const out: T[] = []; + let cap = capOf(0, undefined, size); for (let item = it.next(); item !== DONE; item = it.next()) { - if (out.length === cap) cap = vecGrow(it, cap, size); + if (out.length === cap) cap = capNext(it, out.length, cap, size); out.push(item); } + capSet(out, out.length, cap, size); if (take !== undefined) dispose(it); return out; } - if (size !== undefined) vecReserveExact(it, 0, size); + // std's makes one with room for exactly the upper bound. + const out = size === undefined ? [] : vecWithCapacity(trustedUpper(it), size); if (take === undefined) { const folded = it.folded(trusted); for (let item = folded.next(); item !== DONE; item = folded.next()) out.push(item); @@ -1281,18 +1232,17 @@ export function iterToArray(it: Iter, take?: Take, size?: number, trusted /** `collect` into a `Vec`, as `iterExtendBytes` of an empty one. */ export function iterToByteVec(it: Iter, take?: Take, trusted = false): ByteVec { - const out = new ByteVec(); // Its own loops: through `iterExtendBytes`, JavaScriptCore took 1.9x as long. if (!trusted) { - let cap = 0; + const out = new ByteVec(); for (let item = it.next(); item !== DONE; item = it.next()) { - if (out.length === cap) cap = vecGrow(it, cap, 1); + if (out.length === out.data.length) byteVecReserve(out, satAdd(it.sizeHint()[0], 1)); byteVecPush(out, item); } if (take !== undefined) dispose(it); return out; } - vecReserveExact(it, 0, 1); + const out = byteVecWithCapacity(trustedUpper(it)); if (take === undefined) { const folded = it.folded(true); for (let item = folded.next(); item !== DONE; item = folded.next()) byteVecPush(out, item); diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index c22f253d6..cbede9d9d 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -209,9 +209,9 @@ pub fn call<'tcx>( let e = match std { Std::HashMap | Std::HashSet => hash(b, coll, call, owner, name, args, out), Std::BTreeMap | Std::BTreeSet => btree(b, coll, call, owner, name, args), - Std::VecDeque => deque(b, coll, call, owner, name, args, out), + Std::VecDeque => deque(b, coll, call, owner, name, args), Std::LinkedList => list(b, coll, call, owner, name, args), - Std::BinaryHeap => heap(b, coll, call, owner, name, args, out), + Std::BinaryHeap => heap(b, coll, call, owner, name, args), Std::PeekMut if name == "pop" => Some(Expr::rt("peekMutPop", args)), Std::Entry => entry(b, coll, name, args, span), Std::Ordering => ordering(name, args), @@ -1145,7 +1145,6 @@ fn deque<'tcx>( owner: &str, name: &str, args: Vec, - out: &mut Vec, ) -> Option { let span = call.span; let item = arg(coll, 0); @@ -1153,9 +1152,25 @@ fn deque<'tcx>( let none = library::sentinel_option(b.t, call).is_some(); let back = |values: Vec| flagged(values, true, none); let e = match (owner, name) { - (_, "new" | "with_capacity") | ("Default", "default") => { - discard(values, out); - deque_new(b, coll, span) + (_, "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)); + 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", + "reserve_exact" => "dequeReserveExact", + _ => "dequeShrinkTo", + }; + Expr::rt(f, values) } (_, "len") => values.pop()?.member("n"), (_, "is_empty") => values.pop()?.member("n").binary("===", Expr::lit("0")), @@ -1189,15 +1204,21 @@ fn deque<'tcx>( let droppers = entry_droppers(b, coll, span); ranged.after(Expr::rt("dequeDrain", super::iter::tail(values, droppers))) } - (_, "reserve" | "reserve_exact" | "shrink_to_fit") => { - discard(values, out); - Expr::undefined() - } ("Index" | "IndexMut", "index" | "index_mut") => Expr::rt("dequeIndex", values), ("Clone", "clone") => { values.push(clone_fn(b, item, span)); + values.push(super::iter::size_of(b, item, span)); Expr::rt("dequeClone", values) } + // `From>` keeps the vector's capacity. + ("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) + } ("Extend", "extend") | ("From", "from") => { let (source, iter) = extend_source(b, coll, call, owner, values.pop()?)?; let target = match owner { @@ -1308,16 +1329,32 @@ fn heap<'tcx>( owner: &str, name: &str, args: Vec, - out: &mut Vec, ) -> Option { let span = call.span; let item = arg(coll, 0); let bytes = matches!(item.kind(), ty::Uint(ty::UintTy::U8)); let mut values = args; let e = match (owner, name) { - (_, "new" | "with_capacity") | ("Default", "default") => { - discard(values, out); - empty(b, Expr::rt("heapNew", vec![]), coll, span) + (_, "new") | ("Default", "default") => empty(b, Expr::rt("heapNew", vec![]), coll, span), + // Its vector's, given the size of its elements, by which std's grows it. + (_, "with_capacity") => { + values.push(super::iter::size_of(b, item, span)); + empty(b, Expr::rt("heapWithCapacity", values), coll, span) + } + (_, "capacity" | "reserve" | "reserve_exact" | "shrink_to" | "shrink_to_fit") => { + let h = values.remove(0); + values.insert(0, h.member("d")); + if name == "shrink_to_fit" { + values.push(Expr::lit("0")); + } + values.push(super::iter::size_of(b, item, span)); + let f = match name { + "capacity" => "vecCapacity", + "reserve" => "vecReserve", + "reserve_exact" => "vecReserveExact", + _ => "vecShrinkTo", + }; + Expr::rt(f, values) } (_, "len") => values.pop()?.member("d").member("length"), (_, "is_empty") => values.pop()?.member("d").member("length").binary("===", Expr::lit("0")), @@ -1352,22 +1389,17 @@ fn heap<'tcx>( Expr::rt("heapDrain", super::iter::tail(values, droppers)) } (_, "iter") => Expr::rt("heapIter", values), - (_, "reserve" | "reserve_exact" | "shrink_to_fit" | "shrink_to") => { - discard(values, out); - Expr::undefined() - } ("Clone", "clone") => { - let clone = clone_fn(b, item, span); - Expr::rt("heapClone", super::iter::tail(values, vec![clone])) + values.push(clone_fn(b, item, span)); + values.push(super::iter::size_of(b, item, span)); + Expr::rt("heapClone", values) } // `From>` rebuilds the vector in place, and `From<[T; N]>` collects the array // into one first. ("From", "from") if b.t.std_of(library::targ(call.args, 1)) == Some(Std::Vec) => { let v = values.pop()?; let d = match bytes { - true => Expr::ident("Array") - .member("from") - .call(vec![Expr::rt("byteVecView", vec![v])]), + true => Expr::rt("byteVecToVec", vec![v]), false => v, }; Expr::rt("heapFrom", [vec![d], heap_tests(b, item, true, span)].concat()) @@ -1389,13 +1421,10 @@ fn heap<'tcx>( Some(e) } -/// A `Vec` of a heap's elements `d`, an `rt.ByteVec` of bytes. +/// A `Vec` of a heap's elements `d`, an `rt.ByteVec` of bytes, with its capacity. pub fn heap_vec(d: Expr, bytes: bool) -> Expr { match bytes { - true => Expr::rt( - "byteVecFrom", - vec![Expr::ident("Uint8Array").member("from").call(vec![d])], - ), + true => Expr::rt("byteVecFromVec", vec![d]), false => d, } } @@ -2634,23 +2663,10 @@ 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. + // std's collects into a `Vec` first, whose capacity it keeps. Std::VecDeque => { - let target = deque_new(b, ty, span); - let item = arg(ty, 0); - if !b.t.drops(item) { - let folds = super::iter::implements(b.t, from, "TrustedLen"); - let take = super::iter::iter_take(b, from, folds, span); - let reserve = vec![ - take, - super::iter::size_of(b, item, span), - Expr::lit(trusted.to_string()), - ]; - Expr::rt("dequeExtend", super::iter::tail(vec![target, iter], reserve)) - } else { - let items = super::iter::to_array(b, iter, from, item, trusted, span); - Expr::rt("dequeExtend", vec![target, Expr::rt("iterSlice", vec![items])]) - } + let items = super::iter::to_array(b, iter, from, arg(ty, 0), trusted, span); + empty(b, Expr::rt("dequeFromVec", vec![items]), ty, span) } _ => return None, }) diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index 5240052c3..e3a3635bc 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -1987,10 +1987,28 @@ fn mapping<'tcx>( true => Expr::New(Box::new(Expr::Rt("ByteVec".into())), Vec::new()), false => Expr::Array(Vec::new()), }, - ("Vec", "with_capacity") => match is_u8(targ(gargs, 0)) { - true => Expr::New(Box::new(Expr::Rt("ByteVec".into())), args), - false => Expr::Array(Vec::new()), - }, + // What reads or sets a capacity is given the size of the elements, by which std's + // grows it. + ("Vec", "with_capacity") if is_u8(targ(gargs, 0)) => Expr::rt("byteVecWithCapacity", args), + ("Vec", "capacity") if is_u8(targ(gargs, 0)) => args.pop()?.member("data").member("length"), + ("Vec", "reserve" | "reserve_exact" | "shrink_to") if is_u8(targ(gargs, 0)) => { + rt2(args, "byteVec", &super::camel(&name)) + } + ("Vec", "shrink_to_fit") if is_u8(targ(gargs, 0)) => { + Expr::rt("byteVecShrinkTo", vec![args.pop()?, Expr::lit("0")]) + } + ("Vec", "with_capacity" | "capacity" | "reserve" | "reserve_exact" | "shrink_to" | "shrink_to_fit") => { + let mut values = args; + if name == "shrink_to_fit" { + values.push(Expr::lit("0")); + } + values.push(super::iter::size_of(b, targ(gargs, 0), span)); + let f = match name.as_str() { + "shrink_to_fit" => "shrinkTo".to_string(), + _ => super::camel(&name), + }; + rt2(values, "vec", &f) + } ("Vec", "push") => { let mut values = args; match is_u8(targ(gargs, 0)) { @@ -2534,14 +2552,20 @@ pub fn cow_cloned<'tcx>(b: &mut Body<'_, '_, 'tcx>, op: &str, cow: Expr, elem: T Expr::rt(format!("cow{op}"), args) } -/// A clone of `value`, a slice, array, or `Vec` of `elem` other than bytes, as a `Vec`: a -/// copy of the array if each element's clone is itself, or else each element cloned. +/// A clone of `value`, a slice, array, or `Vec` of `elem` other than bytes, as a `Vec` with +/// room for exactly its elements, as std's allocates one. fn vec_clone<'tcx>(b: &mut Body<'_, '_, 'tcx>, value: Expr, elem: Ty<'tcx>, span: Span) -> Option { - let clone = super::collections::clone_fn(b, elem, span); - if matches!(&clone, Expr::Lit(l) if l == "undefined") { - return Some(value.method("slice", Vec::new())); + let v = slice_clone(b, value, elem, span); + Some(Expr::rt("vecExact", vec![v, super::iter::size_of(b, elem, span)])) +} + +/// A clone of `value`, a slice, array, or `Vec` of `elem` other than bytes, as an array: a +/// copy of it if each element's clone is itself, or else each element cloned. +fn slice_clone<'tcx>(b: &mut Body<'_, '_, 'tcx>, value: Expr, elem: Ty<'tcx>, span: Span) -> Expr { + match super::collections::clone_fn(b, elem, span) { + Expr::Lit(l) if l == "undefined" => value.method("slice", Vec::new()), + clone => value.method("map", vec![clone]), } - Some(value.method("map", vec![clone])) } /// A `Box<[elem]>` of clones of the elements of `slice`, as std's `From<&[T]>` and `Clone` @@ -2552,7 +2576,7 @@ fn slice_boxed<'tcx>(b: &mut Body<'_, '_, 'tcx>, slice: Expr, elem: Ty<'tcx>, sp "byteSliceFrom", vec![Expr::rt("byteSliceToArray", vec![slice])], )), - _ => vec_clone(b, slice, elem, span), + _ => Some(slice_clone(b, slice, elem, span)), } }