From fba0d3ad4f800d1d3261467519f2e154055fd138 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 19:50:35 -0700 Subject: [PATCH 01/14] chore(quest): claim quest/m2/ts-model/std-rest.md Quest-Claim: a936fed93dbf727b From db802a8fc559e6275e0b26e4d126c47f2bbfdae4 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 20:34:01 -0700 Subject: [PATCH 02/14] feat(ts): carry std's capacity through every Vec, VecDeque, and BinaryHeap Co-Authored-By: Claude Opus 5.5 --- quest/m2/ts-model/README.md | 1 - quest/m2/ts-model/hashbrown.md | 6 +- quest/m2/ts-model/std-rest.md | 29 - quest/m3/ts-buf-mut-forward.md | 4 +- quest/m3/ts-deque-slices.md | 4 - ts/README.md | 16 +- ts/bench/moq.ts | 3 + ts/bench/push.ts | 16 + ts/bench/workloads.ts | 7 +- ts/fixtures/codec/expected/bench.ts | 42 +- .../codec/expected/coding/version.Versions.ts | 2 +- ts/fixtures/codec/expected/core/option.ts | 7 + ts/fixtures/codec/expected/harness.ts | 8 +- ts/fixtures/codec/src/bench.rs | 32 +- ts/fixtures/lang/caller.ts | 21 +- ts/fixtures/lang/expected/arrays.ts | 2 +- ts/fixtures/lang/expected/bounds.ts | 4 +- ts/fixtures/lang/expected/boxes.ts | 24 +- ts/fixtures/lang/expected/capacity.ts | 1702 +++++++++++++++++ ts/fixtures/lang/expected/chars.ts | 6 +- ts/fixtures/lang/expected/clones.ts | 47 +- ts/fixtures/lang/expected/collections.ts | 118 +- ts/fixtures/lang/expected/core/option.ts | 7 + ts/fixtures/lang/expected/counts.ts | 52 +- ts/fixtures/lang/expected/cows.ts | 10 +- ts/fixtures/lang/expected/cycles.ts | 2 +- ts/fixtures/lang/expected/dyns.ts | 10 +- ts/fixtures/lang/expected/edits.ts | 15 +- ts/fixtures/lang/expected/errors.ts | 4 +- ts/fixtures/lang/expected/fmt.ts | 31 +- ts/fixtures/lang/expected/generics.ts | 2 +- ts/fixtures/lang/expected/harness.ts | 9 +- ts/fixtures/lang/expected/hints.ts | 265 ++- ts/fixtures/lang/expected/holds.ts | 28 +- ts/fixtures/lang/expected/ints.ts | 2 +- ts/fixtures/lang/expected/iters.ts | 108 +- ts/fixtures/lang/expected/joins.ts | 14 +- ts/fixtures/lang/expected/keys.ts | 28 +- ts/fixtures/lang/expected/lists.ts | 6 +- ts/fixtures/lang/expected/locals.ts | 8 +- ts/fixtures/lang/expected/nested.ts | 16 +- ts/fixtures/lang/expected/objects.ts | 8 +- ts/fixtures/lang/expected/orders.ts | 53 +- ts/fixtures/lang/expected/pointers.ts | 10 +- ts/fixtures/lang/expected/refs.ts | 14 +- ts/fixtures/lang/expected/shapes.ts | 6 +- ts/fixtures/lang/expected/slices.ts | 8 +- ts/fixtures/lang/expected/strs.ts | 14 +- ts/fixtures/lang/expected/tuples.ts | 56 +- ts/fixtures/lang/expected/wrappers.ts | 5 +- ts/fixtures/lang/expected/zeros.ts | 6 +- ts/fixtures/lang/src/capacity.rs | 264 +++ ts/fixtures/lang/src/harness.rs | 6 +- ts/fixtures/lang/src/lib.rs | 4 +- ts/fixtures/stock/expected/buf.ts | 12 +- ts/fixtures/stock/expected/harness.ts | 2 +- ts/fixtures/task/expected/drops.ts | 106 +- ts/fixtures/task/expected/drops/closures.ts | 42 +- ts/fixtures/task/expected/drops/folds.ts | 41 +- ts/fixtures/task/expected/drops/inside.ts | 3 +- ts/fixtures/task/expected/drops/iters.ts | 205 +- ts/fixtures/task/expected/drops/objects.ts | 28 +- ts/fixtures/task/expected/drops/once.ts | 6 +- ts/fixtures/task/expected/kio.Producer.ts | 2 +- ts/fixtures/task/expected/kio.WaiterList.ts | 4 +- ts/fixtures/task/expected/log.Log.ts | 2 +- ts/fixtures/task/expected/model.Channel.ts | 6 +- ts/fixtures/task/expected/model.ts | 8 +- ts/runtime/rt.ts | 262 ++- ts/runtime/rt/bytes.ts | 31 +- ts/runtime/rt/collections.ts | 298 ++- ts/runtime/rt/iter.ts | 204 +- ts/src/lower/collections.rs | 123 +- ts/src/lower/iter.rs | 108 +- ts/src/lower/library.rs | 62 +- ts/src/lower/mir/step.rs | 7 +- ts/src/lower/stock.rs | 2 +- 77 files changed, 3573 insertions(+), 1163 deletions(-) delete mode 100644 quest/m2/ts-model/std-rest.md create mode 100644 ts/bench/push.ts create mode 100644 ts/fixtures/lang/expected/capacity.ts create mode 100644 ts/fixtures/lang/src/capacity.rs diff --git a/quest/m2/ts-model/README.md b/quest/m2/ts-model/README.md index af15a9765..f80a6b974 100644 --- a/quest/m2/ts-model/README.md +++ b/quest/m2/ts-model/README.md @@ -47,6 +47,5 @@ Public API: the translator's output for moq-net's model. ## Required - [Shared ownership](/quest/m2/ts-shared.md) - kio's waiters are `Arc`/`Weak` with observable counts, and its atomics and locks are plain values -- [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 - [Async in the TypeScript translator](/quest/m2/ts-async.md) - kio's producers and consumers are futures diff --git a/quest/m2/ts-model/hashbrown.md b/quest/m2/ts-model/hashbrown.md index de552b951..1f491b214 100644 --- a/quest/m2/ts-model/hashbrown.md +++ b/quest/m2/ts-model/hashbrown.md @@ -16,12 +16,8 @@ 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. + `Vec`'s capacity follows `RawVec`'s. - `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/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..7b0b803c2 100644 --- a/quest/m3/ts-deque-slices.md +++ b/quest/m3/ts-deque-slices.md @@ -24,7 +24,3 @@ the rest of std's iterators' `Debug`. 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/ts/README.md b/ts/README.md index 0d9bf44a2..07e101749 100644 --- a/ts/README.md +++ b/ts/README.md @@ -259,8 +259,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), @@ -688,7 +687,16 @@ 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 std's + capacity, apart from the array's length: `RawVec`'s amortized growth and its least + allocation by element size, `with_capacity`, `reserve`, `reserve_exact`, `shrink_to`, + and what `collect`, `extend`, `clone`, and `From` allocate, a `collect` in place of a + `Vec`'s `into_iter` included, so `capacity` reads std's and each grows and panics where + std's does. An array's `cap` property is its capacity where that differs from its + length, and an `rt.ByteVec`'s is its buffer's length. A `Vec` taken from a `Bytes` + or a shared `BytesMut` holds what `bytes` gave it, which nothing here counts: reading + its capacity, or keeping it in place, throws until a `shrink_to` at most its length + sets it. 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 @@ -748,7 +756,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 e77639d01..64c08c8dd 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); } @@ -346,12 +348,12 @@ export function order(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi } else { const heap: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; for (const _87 of rt.replaceIn(v, [])) { - rt.heapPush(heap, _87, rt.le); + rt.heapPush(heap, _87, rt.le, 4); } while (true) { const _93: rt.u32 | undefined = rt.heapPop(heap, rt.le); if (_93 !== undefined) { - v.push(_93); + rt.vecPush(v, _93, 4); } else { break; } @@ -372,6 +374,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, 4); + } + _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) { + rt.vecPush(v, _37, 4); + } + _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 666469815..b2a7cd209 100644 --- a/ts/fixtures/codec/expected/coding/version.Versions.ts +++ b/ts/fixtures/codec/expected/coding/version.Versions.ts @@ -34,7 +34,7 @@ export function decode$coding_decode_Decode_coding_varint_Form(r: Decoder.Decode while (iter.next() !== rt.DONE) { const _15: rt.Result = coding_version_Version.decode$coding_decode_Decode_coding_varint_Form(r, version); if (_15.ok) { - vs.push(_15.value); + rt.vecPush(vs, _15.value, 8); } else { return _15; } 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/expected/harness.ts b/ts/fixtures/codec/expected/harness.ts index 92ecb977c..ce7c898f9 100644 --- a/ts/fixtures/codec/expected/harness.ts +++ b/ts/fixtures/codec/expected/harness.ts @@ -352,10 +352,10 @@ export function encodeScript(data: rt.ByteSlice, out: rt.ByteVec): void { } else { _74 = Encoder.prefixU16(w); } - prefixes.push(_74); + rt.vecPush(prefixes, _74, 8); result = rt.OK as rt.Result; } else if (_33 === 8) { - const _79: Prefix.Prefix | undefined = prefixes.pop(); + const _79: Prefix.Prefix | undefined = rt.vecPop(prefixes); if (_79 === undefined) { result = rt.OK as rt.Result; } else { @@ -364,7 +364,7 @@ export function encodeScript(data: rt.ByteSlice, out: rt.ByteVec): void { result = Encoder.fill(w, prefix); } } else { - const _88: Prefix.Prefix | undefined = prefixes.pop(); + const _88: Prefix.Prefix | undefined = rt.vecPop(prefixes); if (_88 !== undefined) { Encoder.discard(w, _88); } @@ -375,7 +375,7 @@ export function encodeScript(data: rt.ByteSlice, out: rt.ByteVec): void { } } while (true) { - const _98: Prefix.Prefix | undefined = prefixes.pop(); + const _98: Prefix.Prefix | undefined = rt.vecPop(prefixes); if (_98 !== undefined) { const _102: rt.Result = Encoder.fill(w, _98); if (!_102.ok) { 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 c04f92d48..a0e77d554 100644 --- a/ts/fixtures/lang/caller.ts +++ b/ts/fixtures/lang/caller.ts @@ -723,4 +723,23 @@ const asciiCases = [ Uint8Array.of(op("ascii::chars"), 0, ...[0xd7ff, 0xd800, 0xdfff, 0xe000, 0x1f600, 0x10ffff, 0x110000].flatMap((n) => [n >>> 24, (n >>> 16) & 0xff, (n >>> 8) & 0xff, n & 0xff])), ]; -export const cases: Uint8Array[] = [...loops, ...durations, ...ints(), ...utf8, ...floats, ...formats, ...parsed, ...singlesCases, ...singlesFormats, ...singlesParsed, ...dyns, ...cells, ...shared, ...locks, ...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]; +/** + * `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`; a run of pushes and pops that + * grows and shrinks it; and each way `collects` makes one, of each length it tries. + */ +const capacityCases = [ + ...[["capacity::vecs", 24], ["capacity::deques", 20], ["capacity::heaps", 12]].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", "capacity::deques", "capacity::heaps"].flatMap((name) => + Array.from({ length: 5 }, (_, kind) => Uint8Array.of(op(name), kind, 0, ...Array.from({ length: 40 }, (_, p) => [p % 3 === 2 ? 2 : 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, ...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, ...capacityCases]; diff --git a/ts/fixtures/lang/expected/arrays.ts b/ts/fixtures/lang/expected/arrays.ts index 93a77cdea..88c6d6c3f 100644 --- a/ts/fixtures/lang/expected/arrays.ts +++ b/ts/fixtures/lang/expected/arrays.ts @@ -16,7 +16,7 @@ export function fromFns(data: rt.ByteSlice, out: rt.ByteVec): void { if (_10 === 0) { const seen: rt.usize[] = []; const bytes: Uint8Array = rt.bytesFromFn(4, (i6: rt.usize): rt.u8 => { - seen.push(i6); + rt.vecPush(seen, i6, 4); return rt.u8WrappingMul(op, rt.u8Add(i6 & 0xff, 1)); }); const wide: rt.u64[] = rt.arrayFromFn(3, (i7: rt.usize): rt.u64 => { diff --git a/ts/fixtures/lang/expected/bounds.ts b/ts/fixtures/lang/expected/bounds.ts index 11be217b4..270b11d26 100644 --- a/ts/fixtures/lang/expected/bounds.ts +++ b/ts/fixtures/lang/expected/bounds.ts @@ -189,9 +189,9 @@ export function bounds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const n: rt.usize = _104[0]; const tag: rt.u8 = _104[1]; if (rt.usizeRem(n, 2) === 0) { - rt.dequePushBack(queue, new bounds_Item.Item(tag)); + rt.dequePushBack(queue, new bounds_Item.Item(tag), 1); } else { - rt.dequePushFront(queue, new bounds_Item.Item(tag)); + rt.dequePushFront(queue, new bounds_Item.Item(tag), 1); } } const _117: [rt.RangeBound, rt.RangeBound] = [bound$usize(s, i), bound$usize(e, j)]; diff --git a/ts/fixtures/lang/expected/boxes.ts b/ts/fixtures/lang/expected/boxes.ts index 745dd00c2..64dfa88f1 100644 --- a/ts/fixtures/lang/expected/boxes.ts +++ b/ts/fixtures/lang/expected/boxes.ts @@ -131,7 +131,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)); @@ -236,7 +236,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.vecIntoBoxed(wide.slice()); const _295: rt.Place | undefined = rt.sliceLastMut(fromVec2); if (_295 !== undefined) { _295.v = 48879; @@ -248,9 +248,9 @@ export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fromArray2[2] = 7; wides(fromArray2, out); wides(array2, out); - const collected2: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(wide), (_26: rt.u16): rt.u16 => { + const collected2: rt.u16[] = rt.vecIntoBoxed(rt.iterToArray(rt.iterMap(rt.iterSlice(wide), (_26: rt.u16): rt.u16 => { return rt.intRotateLeft(_26, 3, 16, false); - }), undefined, 2, true); + }), undefined, 2, true)); const cloned2: rt.u16[] = collected2.slice(); rt.sliceSort(cloned2, rt.lt); wides(cloned2, out); @@ -263,7 +263,7 @@ export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(collected2, f, rt.u16Debug)]; fmt_put(out, rt.fmtFormat([args4[0]])); const v3: rt.u16[] = fromVec2; - v3.push(5); + rt.vecPush(v3, 5, 2); wides(v3, out); let slot2: rt.u16[] = fromArray2; const _372: rt.u16[] = collected2.slice(); @@ -272,7 +272,7 @@ export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const taken = slot2; slot2 = []; wides(taken, out); - const it: rt.Iter = rt.iterSlice(wide); + const it: rt.Iter = rt.iterSlice(rt.vecIntoBoxed(wide)); rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(option_unwrapOr$1j4op5y(rt.iterToOption(it.nextBack()), 0)).reverse()), undefined, true); rt.byteVecPush(out, it.len() & 0xff); rt.iterExtendBytes(out, rt.iterMap(it, (x4: rt.u16): rt.u8 => { @@ -283,9 +283,9 @@ export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const logged: (a0: rt.u8) => boxes_Logged.Logged = (id: rt.u8): boxes_Logged.Logged => { return new boxes_Logged.Logged(id, rt.arcClone(log)); }; - const boxed2: boxes_Logged.Logged[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_22: rt.u8): boxes_Logged.Logged => { + const boxed2: boxes_Logged.Logged[] = rt.vecIntoBoxed(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_22: rt.u8): boxes_Logged.Logged => { return logged(_22 & 126); - }), undefined, 8, true); + }), undefined, 8, true)); ids(boxed2, out); const cloned3: boxes_Logged.Logged[] = boxed2.map(boxes_Logged.clone$Clone); flush(log.value, out); @@ -293,9 +293,9 @@ export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { flush(log.value, out); const fromRef3: boxes_Logged.Logged[] = rt.sliceRange(cloned3, 0).map(boxes_Logged.clone$Clone); flush(log.value, out); - let collected3: boxes_Logged.Logged[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_23: rt.u8): boxes_Logged.Logged => { + let collected3: boxes_Logged.Logged[] = rt.vecIntoBoxed(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_23: rt.u8): boxes_Logged.Logged => { return logged(_23 | 1); - }), undefined, 8, true); + }), undefined, 8, true)); ids(collected3, out); const _433: boxes_Logged.Logged[] = [logged(16), logged(18)]; rt.dropAll(collected3); @@ -359,12 +359,12 @@ export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const fromArray3: [rt.u8, rt.u16][] = copy$array_tuple2_u8_u16(array3); rt.idx(fromArray3, 0); fromArray3[0][0] = 9; - const quads: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceChunksExact(data2, 2), (c: rt.ByteSlice): Uint8Array => { + const quads: Uint8Array[] = rt.vecIntoBoxed(rt.iterToArray(rt.iterMap(rt.byteSliceChunksExact(data2, 2), (c: rt.ByteSlice): Uint8Array => { rt.idx(c, 0); const _3: rt.u8 = c.data[c.start]; rt.idx(c, 1); return Uint8Array.of(_3, c.data[c.start + 1]); - }), undefined, 2, true); + }), undefined, 2, true)); const quadsV: Uint8Array[] = quads.map(copy$array_u8); const _554: rt.ByteSlice | undefined = rt.optionMap(rt.sliceFirst(quadsV), rt.byteSliceFrom); if (_554 !== undefined) { diff --git a/ts/fixtures/lang/expected/capacity.ts b/ts/fixtures/lang/expected/capacity.ts new file mode 100644 index 000000000..53a1c077d --- /dev/null +++ b/ts/fixtures/lang/expected/capacity.ts @@ -0,0 +1,1702 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import { copy$array_u64, copy$tuple2_u32_u32 } from "./lib.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, data: rt.ByteSlice, out: rt.ByteVec): void { + const _5: rt.u8 = rt.u8Rem(kind, 5); + if (_5 === 0) { + vecSteps$u8(data, (b3: rt.u8): rt.u8 => { + return b3; + }, out); + } else if (_5 === 1) { + vecSteps$u16(data, (a0: rt.u8): rt.u16 => { + return a0 as rt.u16; + }, out); + } else if (_5 === 2) { + vecSteps$tuple2_u64_u8(data, (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(data, (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(data, (_2: rt.u8): undefined => {}, out); + } +} + +export function vecSteps$array160_u64(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u64[], out: rt.ByteVec): void { + let v!: rt.u64[][]; + let _131!: 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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 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 = []; + } + put(out, rt.vecCapacity(v, 1280)); + const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + while (true) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { + break; + } + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + b3: { + const _39: rt.u8 = rt.u8Rem(op, 24); + if (_39 === 0 || _39 === 1) { + rt.vecPush(v, copy$array_u64(make(arg)), 1280); + break b3; + } + if (_39 === 2) { + rt.vecPop(v); + break b3; + } + if (_39 === 3) { + rt.vecReserve(v, amount(arg, v.length, size), 1280); + break b3; + } + if (_39 === 4) { + rt.vecReserveExact(v, amount(arg, v.length, size), 1280); + break b3; + } + if (_39 === 5) { + rt.vecShrinkTo(v, rt.u8Rem(arg, 40) as rt.usize, 1280); + break b3; + } + if (_39 === 6) { + rt.vecShrinkTo(v, 0, 1280); + break b3; + } + if (_39 === 7) { + rt.vecTruncate(v, rt.u8Rem(arg, 8) as rt.usize); + break b3; + } + if (_39 === 8) { + rt.vecInsert(v, rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.length, 1)), copy$array_u64(make(arg)), 1280); + break b3; + } + if (_39 === 9) { + if (!((v.length === 0))) { + rt.vecRemove(v, rt.usizeRem(arg as rt.usize, v.length)); + break b3; + } + } else { + if (_39 === 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); + break b3; + } + if (_39 === 11) { + rt.iterExtend(v, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 1280, true); + break b3; + } + if (_39 === 12) { + rt.vecExtendFromSlice(v, [make(arg), make(arg)], copy$array_u64, 1280); + break b3; + } + if (_39 === 13) { + rt.vecTruncate(v, 0); + break b3; + } + if (_39 === 14) { + const keep: () => boolean = alternate(); + rt.vecRetain(v, (_25: rt.u64[]): boolean => { + return keep(); + }); + break b3; + } + if (_39 === 15) { + rt.drop(rt.vecDrain(v, { end: rt.min(v.length, rt.u8Rem(arg, 4) as rt.usize) })); + break b3; + } + if (_39 === 16) { + v = v.map(copy$array_u64); + break b3; + } + if (_39 === 17) { + v = rt.vecIntoBoxed(v); + break b3; + } + if (_39 === 18) { + const keep2: () => boolean = alternate(); + v = rt.iterToArrayInPlace(rt.iterFilter(rt.iterSlice(v), (_23: rt.u64[]): boolean => { + return keep2(); + }), 1280, 1280, false, "next"); + break b3; + } + if (_39 === 19) { + const it: rt.Iter = rt.iterSlice(v); + const _128: rt.u8 = rt.u8Rem(arg, 8); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _128; + while ((_131 = iterStart++) < iterEnd) { + if (!(rt.u8Rem(_131, 3) === 2)) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + } + v = rt.iterToArrayInPlace(it, 1280, 1280, true, "next", true); + break b3; + } + if (_39 === 20) { + let taken: rt.u64[][] = rt.replaceIn(v, []); + const _148: rt.u64[] = copy$array_u64(make(arg)); + rt.vecPush(taken, _148, 1280); + put(out, rt.vecCapacity(taken, 1280)); + const _154: rt.u64[][] = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 1280); + const old = taken; + taken = _154; + v = old; + put(out, rt.vecCapacity(taken, 1280)); + break b3; + } + if (_39 === 21) { + if (!((v.length === 0))) { + rt.vecSwapRemove(v, rt.usizeRem(arg as rt.usize, v.length)); + break b3; + } + } else if (_39 === 22) { + rt.vecDedupBy(v, rt.eqSlice(rt.u64Eq)); + break b3; + } + } + v = rt.vecFromElem(copy$array_u64(make(arg)), rt.u8Rem(arg, 6) as rt.usize, copy$array_u64, 1280); + } + put(out, v.length); + put(out, rt.vecCapacity(v, 1280)); + } +} + +export function vecSteps$tuple2_u64_u8(data: rt.ByteSlice, make: (a0: rt.u8) => [rt.u64, rt.u8], out: rt.ByteVec): void { + let v!: [rt.u64, rt.u8][]; + let _131!: 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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 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 = []; + } + put(out, rt.vecCapacity(v, 16)); + const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + while (true) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { + break; + } + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + b3: { + const _39: rt.u8 = rt.u8Rem(op, 24); + if (_39 === 0 || _39 === 1) { + rt.vecPush(v, make(arg), 16); + break b3; + } + if (_39 === 2) { + rt.vecPop(v); + break b3; + } + if (_39 === 3) { + rt.vecReserve(v, amount(arg, v.length, size), 16); + break b3; + } + if (_39 === 4) { + rt.vecReserveExact(v, amount(arg, v.length, size), 16); + break b3; + } + if (_39 === 5) { + rt.vecShrinkTo(v, rt.u8Rem(arg, 40) as rt.usize, 16); + break b3; + } + if (_39 === 6) { + rt.vecShrinkTo(v, 0, 16); + break b3; + } + if (_39 === 7) { + rt.vecTruncate(v, rt.u8Rem(arg, 8) as rt.usize); + break b3; + } + if (_39 === 8) { + rt.vecInsert(v, rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.length, 1)), make(arg), 16); + break b3; + } + if (_39 === 9) { + if (!((v.length === 0))) { + rt.vecRemove(v, rt.usizeRem(arg as rt.usize, v.length)); + break b3; + } + } else { + if (_39 === 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); + break b3; + } + if (_39 === 11) { + rt.iterExtend(v, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 16, true); + break b3; + } + if (_39 === 12) { + rt.vecExtendFromSlice(v, [make(arg), make(arg)], undefined, 16); + break b3; + } + if (_39 === 13) { + rt.vecTruncate(v, 0); + break b3; + } + if (_39 === 14) { + const keep: () => boolean = alternate(); + rt.vecRetain(v, (_25: [rt.u64, rt.u8]): boolean => { + return keep(); + }); + break b3; + } + if (_39 === 15) { + rt.drop(rt.vecDrain(v, { end: rt.min(v.length, rt.u8Rem(arg, 4) as rt.usize) })); + break b3; + } + if (_39 === 16) { + v = v.slice(); + break b3; + } + if (_39 === 17) { + v = rt.vecIntoBoxed(v); + break b3; + } + if (_39 === 18) { + const keep2: () => boolean = alternate(); + v = rt.iterToArrayInPlace(rt.iterFilter(rt.iterSlice(v), (_23: [rt.u64, rt.u8]): boolean => { + return keep2(); + }), 16, 16, false, "next"); + break b3; + } + if (_39 === 19) { + const it: rt.Iter<[rt.u64, rt.u8]> = rt.iterSlice(v); + const _128: rt.u8 = rt.u8Rem(arg, 8); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _128; + while ((_131 = iterStart++) < iterEnd) { + if (!(rt.u8Rem(_131, 3) === 2)) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + } + v = rt.iterToArrayInPlace(it, 16, 16, true, "next", true); + break b3; + } + if (_39 === 20) { + let taken: [rt.u64, rt.u8][] = rt.replaceIn(v, []); + const _148: [rt.u64, rt.u8] = make(arg); + rt.vecPush(taken, _148, 16); + put(out, rt.vecCapacity(taken, 16)); + const _154: [rt.u64, rt.u8][] = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 16); + const old = taken; + taken = _154; + v = old; + put(out, rt.vecCapacity(taken, 16)); + break b3; + } + if (_39 === 21) { + if (!((v.length === 0))) { + rt.vecSwapRemove(v, rt.usizeRem(arg as rt.usize, v.length)); + break b3; + } + } else if (_39 === 22) { + rt.vecDedupBy(v, rt.eqTuple([rt.u64Eq, rt.same])); + break b3; + } + } + v = rt.vecFromElem(make(arg), rt.u8Rem(arg, 6) as rt.usize, undefined, 16); + } + put(out, v.length); + put(out, rt.vecCapacity(v, 16)); + } +} + +export function vecSteps$u16(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u16, out: rt.ByteVec): void { + let v!: rt.u16[]; + let _131!: 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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 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 = []; + } + put(out, rt.vecCapacity(v, 2)); + const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + while (true) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { + break; + } + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + b3: { + const _39: rt.u8 = rt.u8Rem(op, 24); + if (_39 === 0 || _39 === 1) { + rt.vecPush(v, make(arg), 2); + break b3; + } + if (_39 === 2) { + rt.vecPop(v); + break b3; + } + if (_39 === 3) { + rt.vecReserve(v, amount(arg, v.length, size), 2); + break b3; + } + if (_39 === 4) { + rt.vecReserveExact(v, amount(arg, v.length, size), 2); + break b3; + } + if (_39 === 5) { + rt.vecShrinkTo(v, rt.u8Rem(arg, 40) as rt.usize, 2); + break b3; + } + if (_39 === 6) { + rt.vecShrinkTo(v, 0, 2); + break b3; + } + if (_39 === 7) { + rt.vecTruncate(v, rt.u8Rem(arg, 8) as rt.usize); + break b3; + } + if (_39 === 8) { + rt.vecInsert(v, rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.length, 1)), make(arg), 2); + break b3; + } + if (_39 === 9) { + if (!((v.length === 0))) { + rt.vecRemove(v, rt.usizeRem(arg as rt.usize, v.length)); + break b3; + } + } else { + if (_39 === 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); + break b3; + } + if (_39 === 11) { + rt.iterExtend(v, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 2, true); + break b3; + } + if (_39 === 12) { + rt.vecExtendFromSlice(v, [make(arg), make(arg)], undefined, 2); + break b3; + } + if (_39 === 13) { + rt.vecTruncate(v, 0); + break b3; + } + if (_39 === 14) { + const keep: () => boolean = alternate(); + rt.vecRetain(v, (_25: rt.u16): boolean => { + return keep(); + }); + break b3; + } + if (_39 === 15) { + rt.drop(rt.vecDrain(v, { end: rt.min(v.length, rt.u8Rem(arg, 4) as rt.usize) })); + break b3; + } + if (_39 === 16) { + v = v.slice(); + break b3; + } + if (_39 === 17) { + v = rt.vecIntoBoxed(v); + break b3; + } + if (_39 === 18) { + const keep2: () => boolean = alternate(); + v = rt.iterToArrayInPlace(rt.iterFilter(rt.iterSlice(v), (_23: rt.u16): boolean => { + return keep2(); + }), 2, 2, false, "next"); + break b3; + } + if (_39 === 19) { + const it: rt.Iter = rt.iterSlice(v); + const _128: rt.u8 = rt.u8Rem(arg, 8); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _128; + while ((_131 = iterStart++) < iterEnd) { + if (!(rt.u8Rem(_131, 3) === 2)) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + } + v = rt.iterToArrayInPlace(it, 2, 2, true, "next", true); + break b3; + } + if (_39 === 20) { + let taken: rt.u16[] = rt.replaceIn(v, []); + const _148: rt.u16 = make(arg); + rt.vecPush(taken, _148, 2); + put(out, rt.vecCapacity(taken, 2)); + const _154: rt.u16[] = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 2); + const old = taken; + taken = _154; + v = old; + put(out, rt.vecCapacity(taken, 2)); + break b3; + } + if (_39 === 21) { + if (!((v.length === 0))) { + rt.vecSwapRemove(v, rt.usizeRem(arg as rt.usize, v.length)); + break b3; + } + } else if (_39 === 22) { + rt.vecDedupBy(v, rt.same); + break b3; + } + } + v = rt.vecFromElem(make(arg), rt.u8Rem(arg, 6) as rt.usize, undefined, 2); + } + put(out, v.length); + put(out, rt.vecCapacity(v, 2)); + } +} + +export function vecSteps$u8(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { + let v!: rt.ByteVec; + let _131!: 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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 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(); + } + put(out, rt.byteVecCapacity(v)); + const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + while (true) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { + break; + } + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + b3: { + const _39: rt.u8 = rt.u8Rem(op, 24); + if (_39 === 0 || _39 === 1) { + rt.byteVecPush(v, make(arg)); + break b3; + } + if (_39 === 2) { + rt.byteVecPop(v); + break b3; + } + if (_39 === 3) { + rt.byteVecReserve(v, amount(arg, v.length, size)); + break b3; + } + if (_39 === 4) { + rt.byteVecReserveExact(v, amount(arg, v.length, size)); + break b3; + } + if (_39 === 5) { + rt.byteVecShrinkTo(v, rt.u8Rem(arg, 40) as rt.usize); + break b3; + } + if (_39 === 6) { + rt.byteVecShrinkTo(v, 0); + break b3; + } + if (_39 === 7) { + rt.byteVecTruncate(v, rt.u8Rem(arg, 8) as rt.usize); + break b3; + } + if (_39 === 8) { + rt.byteVecInsert(v, rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.length, 1)), make(arg)); + break b3; + } + if (_39 === 9) { + if (!((v.length === 0))) { + rt.byteVecRemove(v, rt.usizeRem(arg as rt.usize, v.length)); + break b3; + } + } else { + if (_39 === 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"); + break b3; + } + if (_39 === 11) { + rt.iterExtendBytes(v, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, true); + break b3; + } + if (_39 === 12) { + rt.byteVecExtendFromSlice(v, rt.byteSliceFrom(Uint8Array.of(make(arg), make(arg)))); + break b3; + } + if (_39 === 13) { + rt.byteVecClear(v); + break b3; + } + if (_39 === 14) { + const keep: () => boolean = alternate(); + rt.byteVecRetain(v, (_25: rt.u8): boolean => { + return keep(); + }); + break b3; + } + if (_39 === 15) { + rt.drop(rt.byteVecDrain(v, { end: rt.min(v.length, rt.u8Rem(arg, 4) as rt.usize) })); + break b3; + } + if (_39 === 16) { + v = rt.byteVecFrom(rt.byteVecView(v)); + break b3; + } + if (_39 === 17) { + v = rt.byteSliceToByteVec(rt.byteVecSlice(v)); + break b3; + } + if (_39 === 18) { + const keep2: () => boolean = alternate(); + v = rt.iterToByteVecInPlace(rt.iterFilter(rt.byteVecIntoIter(v), (_23: rt.u8): boolean => { + return keep2(); + }), 1, false, "next"); + break b3; + } + if (_39 === 19) { + const it: rt.Iter = rt.byteVecIntoIter(v); + const _128: rt.u8 = rt.u8Rem(arg, 8); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _128; + while ((_131 = iterStart++) < iterEnd) { + if (!(rt.u8Rem(_131, 3) === 2)) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + } + v = rt.iterToByteVecInPlace(it, 1, true, "next", true); + break b3; + } + if (_39 === 20) { + let taken: rt.ByteVec = rt.replaceIn(v, new rt.ByteVec()); + const _148: rt.u8 = make(arg); + rt.byteVecPush(taken, _148); + put(out, rt.byteVecCapacity(taken)); + const _154: rt.ByteVec = rt.byteVecWithCapacity(rt.u8Rem(arg, 6) as rt.usize); + const old = taken; + taken = _154; + v = old; + put(out, rt.byteVecCapacity(taken)); + break b3; + } + if (_39 === 21) { + if (!((v.length === 0))) { + rt.byteVecSwapRemove(v, rt.usizeRem(arg as rt.usize, v.length)); + break b3; + } + } else if (_39 === 22) { + rt.byteVecDedup(v); + break b3; + } + } + v = rt.byteVecOf(make(arg), rt.u8Rem(arg, 6) as rt.usize); + } + put(out, v.length); + put(out, rt.byteVecCapacity(v)); + } +} + +export function vecSteps$unit(data: rt.ByteSlice, make: (a0: rt.u8) => undefined, out: rt.ByteVec): void { + let v!: undefined[]; + let _131!: 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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 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 = []; + } + put(out, rt.vecCapacity(v, 0)); + const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + while (true) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { + break; + } + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + b3: { + const _39: rt.u8 = rt.u8Rem(op, 24); + if (_39 === 0 || _39 === 1) { + const _41: undefined[] = v; + make(arg); + rt.vecPush(_41, undefined, 0); + break b3; + } + if (_39 === 2) { + rt.vecPop(v, rt.None); + break b3; + } + if (_39 === 3) { + rt.vecReserve(v, amount(arg, v.length, size), 0); + break b3; + } + if (_39 === 4) { + rt.vecReserveExact(v, amount(arg, v.length, size), 0); + break b3; + } + if (_39 === 5) { + rt.vecShrinkTo(v, rt.u8Rem(arg, 40) as rt.usize, 0); + break b3; + } + if (_39 === 6) { + rt.vecShrinkTo(v, 0, 0); + break b3; + } + if (_39 === 7) { + rt.vecTruncate(v, rt.u8Rem(arg, 8) as rt.usize); + break b3; + } + if (_39 === 8) { + const _62: undefined[] = v; + const _63: rt.usize = rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.length, 1)); + make(arg); + rt.vecInsert(_62, _63, undefined, 0); + break b3; + } + if (_39 === 9) { + if (!((v.length === 0))) { + rt.vecRemove(v, rt.usizeRem(arg as rt.usize, v.length)); + break b3; + } + } else { + if (_39 === 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); + break b3; + } + if (_39 === 11) { + rt.iterExtend(v, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 0, true); + break b3; + } + if (_39 === 12) { + const _91: undefined[] = v; + make(arg); + make(arg); + rt.vecExtendFromSlice(_91, [undefined, undefined], undefined, 0); + break b3; + } + if (_39 === 13) { + rt.vecTruncate(v, 0); + break b3; + } + if (_39 === 14) { + const keep: () => boolean = alternate(); + rt.vecRetain(v, (_25: undefined): boolean => { + return keep(); + }); + break b3; + } + if (_39 === 15) { + rt.drop(rt.vecDrain(v, { end: rt.min(v.length, rt.u8Rem(arg, 4) as rt.usize) })); + break b3; + } + if (_39 === 16) { + v = v.slice(); + break b3; + } + if (_39 === 17) { + v = rt.vecIntoBoxed(v); + break b3; + } + if (_39 === 18) { + const keep2: () => boolean = alternate(); + v = rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_23: undefined): boolean => { + return keep2(); + }), "next", 0); + break b3; + } + if (_39 === 19) { + const it: rt.Iter = rt.iterSlice(v); + const _128: rt.u8 = rt.u8Rem(arg, 8); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _128; + while ((_131 = iterStart++) < iterEnd) { + if (!(rt.u8Rem(_131, 3) === 2)) { + rt.iterToOption(it.next(), rt.None); + } else { + rt.iterToOption(it.nextBack(), rt.None); + } + } + v = rt.iterToArrayInPlace(it, 0, 0, true, undefined, true); + break b3; + } + if (_39 === 20) { + let taken: undefined[] = rt.replaceIn(v, []); + make(arg); + rt.vecPush(taken, undefined, 0); + put(out, rt.vecCapacity(taken, 0)); + const _154: undefined[] = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 0); + const old = taken; + taken = _154; + v = old; + put(out, rt.vecCapacity(taken, 0)); + break b3; + } + if (_39 === 21) { + if (!((v.length === 0))) { + rt.vecSwapRemove(v, rt.usizeRem(arg as rt.usize, v.length)); + break b3; + } + } else if (_39 === 22) { + rt.vecDedupBy(v, rt.same); + break b3; + } + } + make(arg); + v = rt.vecFromElem(undefined, rt.u8Rem(arg, 6) as rt.usize, undefined, 0); + } + put(out, v.length); + put(out, rt.vecCapacity(v, 0)); + } +} + +/** A `VecDeque`, as `vecs` steps a `Vec`. */ +export function deques(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + const _5: rt.u8 = rt.u8Rem(kind, 5); + if (_5 === 0) { + dequeSteps$u8(data, (b3: rt.u8): rt.u8 => { + return b3; + }, out); + } else if (_5 === 1) { + dequeSteps$u16(data, (a0: rt.u8): rt.u16 => { + return a0 as rt.u16; + }, out); + } else if (_5 === 2) { + dequeSteps$tuple2_u64_u8(data, (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(data, (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(data, (_2: rt.u8): undefined => {}, out); + } +} + +export function dequeSteps$array160_u64(data: rt.ByteSlice, 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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 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; + } + put(out, rt.dequeCapacity(q, 1280)); + const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + while (true) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { + break; + } + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + const _39: rt.u8 = rt.u8Rem(op, 20); + if (_39 === 0) { + rt.dequePushBack(q, copy$array_u64(make(arg)), 1280); + } else if (_39 === 1) { + rt.dequePushFront(q, copy$array_u64(make(arg)), 1280); + } else if (_39 === 2) { + rt.dequePopFront(q); + } else if (_39 === 3) { + rt.dequeReserve(q, amount(arg, q.n, size), 1280); + } else if (_39 === 4) { + rt.dequeReserveExact(q, amount(arg, q.n, size), 1280); + } else if (_39 === 5) { + rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize, 1280); + } else if (_39 === 6) { + rt.dequeShrinkTo(q, 0, 1280); + } else if (_39 === 7) { + rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); + } else if (_39 === 8) { + rt.dequeInsert(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), copy$array_u64(make(arg)), 1280); + } else if (_39 === 9) { + rt.dequeRemove(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1))); + } else if (_39 === 10) { + rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { + return rt.u8Rem(i, 3) !== 0; + }), make), "next", 1280); + } else if (_39 === 11) { + rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 1280, true); + } else if (_39 === 12) { + rt.dequeClear(q); + } else if (_39 === 13) { + const keep: () => boolean = alternate(); + rt.dequeRetain(q, (_25: rt.u64[]): boolean => { + return keep(); + }); + } else if (_39 === 14) { + rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) }); + } else if (_39 === 15) { + q = rt.dequeClone(q, copy$array_u64); + } else if (_39 === 16) { + q = rt.dequeFromIntoIter(rt.dequeIter(q), 1280) as rt.VecDeque; + } else if (_39 === 17) { + q = rt.dequeFromVec(rt.iterToArray(rt.dequeIter(q), undefined, 1280, true), 1280) as rt.VecDeque; + } else if (_39 === 18) { + const keep2: () => boolean = alternate(); + q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_23: rt.u64[]): boolean => { + return keep2(); + }), "next", 1280), 1280) as rt.VecDeque; + } else { + q = rt.dequeFromVec([copy$array_u64(make(arg)), copy$array_u64(make(arg)), copy$array_u64(make(arg))].map(copy$array_u64), 1280) as rt.VecDeque; + } + put(out, q.n); + put(out, rt.dequeCapacity(q, 1280)); + } +} + +export function dequeSteps$tuple2_u64_u8(data: rt.ByteSlice, 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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 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]>; + } + put(out, rt.dequeCapacity(q, 16)); + const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + while (true) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { + break; + } + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + const _39: rt.u8 = rt.u8Rem(op, 20); + if (_39 === 0) { + rt.dequePushBack(q, make(arg), 16); + } else if (_39 === 1) { + rt.dequePushFront(q, make(arg), 16); + } else if (_39 === 2) { + rt.dequePopFront(q); + } else if (_39 === 3) { + rt.dequeReserve(q, amount(arg, q.n, size), 16); + } else if (_39 === 4) { + rt.dequeReserveExact(q, amount(arg, q.n, size), 16); + } else if (_39 === 5) { + rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize, 16); + } else if (_39 === 6) { + rt.dequeShrinkTo(q, 0, 16); + } else if (_39 === 7) { + rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); + } else if (_39 === 8) { + rt.dequeInsert(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), make(arg), 16); + } else if (_39 === 9) { + rt.dequeRemove(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1))); + } else if (_39 === 10) { + rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { + return rt.u8Rem(i, 3) !== 0; + }), make), "next", 16); + } else if (_39 === 11) { + rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 16, true); + } else if (_39 === 12) { + rt.dequeClear(q); + } else if (_39 === 13) { + const keep: () => boolean = alternate(); + rt.dequeRetain(q, (_25: [rt.u64, rt.u8]): boolean => { + return keep(); + }); + } else if (_39 === 14) { + rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) }); + } else if (_39 === 15) { + q = rt.dequeClone(q, undefined); + } else if (_39 === 16) { + q = rt.dequeFromIntoIter(rt.dequeIter(q), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + } else if (_39 === 17) { + q = rt.dequeFromVec(rt.iterToArray(rt.dequeIter(q), undefined, 16, true), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + } else if (_39 === 18) { + const keep2: () => boolean = alternate(); + q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_23: [rt.u64, rt.u8]): boolean => { + return keep2(); + }), "next", 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + } else { + q = rt.dequeFromVec([make(arg), make(arg), make(arg)], 16) as rt.VecDeque<[rt.u64, rt.u8]>; + } + put(out, q.n); + put(out, rt.dequeCapacity(q, 16)); + } +} + +export function dequeSteps$u16(data: rt.ByteSlice, 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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 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; + } + put(out, rt.dequeCapacity(q, 2)); + const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + while (true) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { + break; + } + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + const _39: rt.u8 = rt.u8Rem(op, 20); + if (_39 === 0) { + rt.dequePushBack(q, make(arg), 2); + } else if (_39 === 1) { + rt.dequePushFront(q, make(arg), 2); + } else if (_39 === 2) { + rt.dequePopFront(q); + } else if (_39 === 3) { + rt.dequeReserve(q, amount(arg, q.n, size), 2); + } else if (_39 === 4) { + rt.dequeReserveExact(q, amount(arg, q.n, size), 2); + } else if (_39 === 5) { + rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize, 2); + } else if (_39 === 6) { + rt.dequeShrinkTo(q, 0, 2); + } else if (_39 === 7) { + rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); + } else if (_39 === 8) { + rt.dequeInsert(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), make(arg), 2); + } else if (_39 === 9) { + rt.dequeRemove(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1))); + } else if (_39 === 10) { + rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { + return rt.u8Rem(i, 3) !== 0; + }), make), "next", 2); + } else if (_39 === 11) { + rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 2, true); + } else if (_39 === 12) { + rt.dequeClear(q); + } else if (_39 === 13) { + const keep: () => boolean = alternate(); + rt.dequeRetain(q, (_25: rt.u16): boolean => { + return keep(); + }); + } else if (_39 === 14) { + rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) }); + } else if (_39 === 15) { + q = rt.dequeClone(q, undefined); + } else if (_39 === 16) { + q = rt.dequeFromIntoIter(rt.dequeIter(q), 2) as rt.VecDeque; + } else if (_39 === 17) { + q = rt.dequeFromVec(rt.iterToArray(rt.dequeIter(q), undefined, 2, true), 2) as rt.VecDeque; + } else if (_39 === 18) { + const keep2: () => boolean = alternate(); + q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_23: rt.u16): boolean => { + return keep2(); + }), "next", 2), 2) as rt.VecDeque; + } else { + q = rt.dequeFromVec([make(arg), make(arg), make(arg)], 2) as rt.VecDeque; + } + put(out, q.n); + put(out, rt.dequeCapacity(q, 2)); + } +} + +export function dequeSteps$u8(data: rt.ByteSlice, 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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 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; + } + put(out, rt.dequeCapacity(q, 1)); + const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + while (true) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { + break; + } + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + const _39: rt.u8 = rt.u8Rem(op, 20); + if (_39 === 0) { + rt.dequePushBack(q, make(arg), 1); + } else if (_39 === 1) { + rt.dequePushFront(q, make(arg), 1); + } else if (_39 === 2) { + rt.dequePopFront(q); + } else if (_39 === 3) { + rt.dequeReserve(q, amount(arg, q.n, size), 1); + } else if (_39 === 4) { + rt.dequeReserveExact(q, amount(arg, q.n, size), 1); + } else if (_39 === 5) { + rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize, 1); + } else if (_39 === 6) { + rt.dequeShrinkTo(q, 0, 1); + } else if (_39 === 7) { + rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); + } else if (_39 === 8) { + rt.dequeInsert(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), make(arg), 1); + } else if (_39 === 9) { + rt.dequeRemove(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1))); + } else if (_39 === 10) { + rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { + return rt.u8Rem(i, 3) !== 0; + }), make), "next", 1); + } else if (_39 === 11) { + rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 1, true); + } else if (_39 === 12) { + rt.dequeClear(q); + } else if (_39 === 13) { + const keep: () => boolean = alternate(); + rt.dequeRetain(q, (_25: rt.u8): boolean => { + return keep(); + }); + } else if (_39 === 14) { + rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) }); + } else if (_39 === 15) { + q = rt.dequeClone(q, undefined); + } else if (_39 === 16) { + q = rt.dequeFromIntoIter(rt.dequeIter(q), 1) as rt.VecDeque; + } else if (_39 === 17) { + q = rt.dequeFromVec(rt.byteVecToVec(rt.iterToByteVec(rt.dequeIter(q), undefined, true)), 1) as rt.VecDeque; + } else if (_39 === 18) { + const keep2: () => boolean = alternate(); + q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_23: rt.u8): boolean => { + return keep2(); + }), "next", 1), 1) as rt.VecDeque; + } else { + q = rt.dequeFromVec(Array.from(Uint8Array.of(make(arg), make(arg), make(arg))), 1) as rt.VecDeque; + } + put(out, q.n); + put(out, rt.dequeCapacity(q, 1)); + } +} + +export function dequeSteps$unit(data: rt.ByteSlice, 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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 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; + } + put(out, rt.dequeCapacity(q, 0)); + const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + while (true) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { + break; + } + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + const _39: rt.u8 = rt.u8Rem(op, 20); + if (_39 === 0) { + const _41: rt.VecDeque = q; + make(arg); + rt.dequePushBack(_41, undefined, 0); + } else if (_39 === 1) { + const _43: rt.VecDeque = q; + make(arg); + rt.dequePushFront(_43, undefined, 0); + } else if (_39 === 2) { + rt.dequePopFront(q, rt.None); + } else if (_39 === 3) { + rt.dequeReserve(q, amount(arg, q.n, size), 0); + } else if (_39 === 4) { + rt.dequeReserveExact(q, amount(arg, q.n, size), 0); + } else if (_39 === 5) { + rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize, 0); + } else if (_39 === 6) { + rt.dequeShrinkTo(q, 0, 0); + } else if (_39 === 7) { + rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); + } else if (_39 === 8) { + const _64: rt.VecDeque = q; + const _65: rt.usize = rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)); + make(arg); + rt.dequeInsert(_64, _65, undefined, 0); + } else if (_39 === 9) { + rt.dequeRemove(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), rt.None); + } else if (_39 === 10) { + rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { + return rt.u8Rem(i, 3) !== 0; + }), make), "next", 0); + } else if (_39 === 11) { + rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 0, true); + } else if (_39 === 12) { + rt.dequeClear(q); + } else if (_39 === 13) { + const keep: () => boolean = alternate(); + rt.dequeRetain(q, (_25: undefined): boolean => { + return keep(); + }); + } else if (_39 === 14) { + rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) }); + } else if (_39 === 15) { + q = rt.dequeClone(q, undefined); + } else if (_39 === 16) { + q = rt.dequeFromIntoIter(rt.dequeIter(q), 0) as rt.VecDeque; + } else if (_39 === 17) { + q = rt.dequeFromVec(rt.iterToArray(rt.dequeIter(q), undefined, 0, true), 0) as rt.VecDeque; + } else if (_39 === 18) { + const keep2: () => boolean = alternate(); + q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_23: undefined): boolean => { + return keep2(); + }), "next", 0), 0) as rt.VecDeque; + } else { + make(arg); + make(arg); + make(arg); + q = rt.dequeFromVec([undefined, undefined, undefined], 0) as rt.VecDeque; + } + put(out, q.n); + put(out, rt.dequeCapacity(q, 0)); + } +} + +/** A `BinaryHeap`, as `vecs` steps a `Vec`, and the `Vec` it gives up at the end. */ +export function heaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + const _5: rt.u8 = rt.u8Rem(kind, 5); + if (_5 === 0) { + heapSteps$u8(data, (b3: rt.u8): rt.u8 => { + return b3; + }, out); + } else if (_5 === 1) { + heapSteps$u16(data, (a0: rt.u8): rt.u16 => { + return a0 as rt.u16; + }, out); + } else if (_5 === 2) { + heapSteps$tuple2_u64_u8(data, (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(data, (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(data, (_2: rt.u8): undefined => {}, out); + } +} + +export function heapSteps$array160_u64(data: rt.ByteSlice, 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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 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; + } + 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 _25: rt.ByteSlice | rt.Done = iter.next(); + if (_25 === rt.DONE) { + break; + } + rt.idx(_25, 0); + const _31: [rt.u8, rt.u8] = [_25.data[_25.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_25, 1), 0)]; + const op: rt.u8 = _31[0]; + const arg: rt.u8 = _31[1]; + const _40: rt.u8 = rt.u8Rem(op, 12); + if (_40 === 0 || _40 === 1) { + rt.heapPush(h, copy$array_u64(make(arg)), rt.cmpLe(rt.cmpSlice(rt.cmp)), 1280); + } else if (_40 === 2) { + rt.heapPop(h, rt.cmpLe(rt.cmpSlice(rt.cmp))); + } else if (_40 === 3) { + const _46: rt.BinaryHeap = h; + const _47: rt.usize = amount(arg, h.d.length, size); + rt.vecReserve(_46.d, _47, 1280); + } else if (_40 === 4) { + const _50: rt.BinaryHeap = h; + const _51: rt.usize = amount(arg, h.d.length, size); + rt.vecReserveExact(_50.d, _51, 1280); + } else if (_40 === 5) { + rt.vecShrinkTo(h.d, rt.u8Rem(arg, 40) as rt.usize, 1280); + } else if (_40 === 6) { + rt.vecShrinkTo(h.d, 0, 1280); + } else if (_40 === 7) { + rt.heapClear(h); + } else if (_40 === 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 (_40 === 9) { + const _68: rt.u64[] = copy$array_u64(make(arg)); + rt.heapPush(other, _68, rt.cmpLe(rt.cmpSlice(rt.cmp)), 1280); + rt.heapAppend(h, other, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp)), 1280); + put(out, rt.vecCapacity(other.d, 1280)); + } else if (_40 === 10) { + rt.drop(rt.heapDrain(h)); + } else { + h = rt.heapFrom(h.d, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); + } + put(out, h.d.length); + put(out, rt.vecCapacity(h.d, 1280)); + } + put(out, rt.vecCapacity(rt.heapClone(h, copy$array_u64).d, 1280)); + put(out, rt.vecCapacity(rt.heapIntoSortedVec(h, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))), 1280)); +} + +export function heapSteps$tuple2_u64_u8(data: rt.ByteSlice, 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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 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]>; + } + 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 _25: rt.ByteSlice | rt.Done = iter.next(); + if (_25 === rt.DONE) { + break; + } + rt.idx(_25, 0); + const _31: [rt.u8, rt.u8] = [_25.data[_25.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_25, 1), 0)]; + const op: rt.u8 = _31[0]; + const arg: rt.u8 = _31[1]; + const _40: rt.u8 = rt.u8Rem(op, 12); + if (_40 === 0 || _40 === 1) { + rt.heapPush(h, make(arg), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), 16); + } else if (_40 === 2) { + rt.heapPop(h, rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))); + } else if (_40 === 3) { + const _46: rt.BinaryHeap<[rt.u64, rt.u8]> = h; + const _47: rt.usize = amount(arg, h.d.length, size); + rt.vecReserve(_46.d, _47, 16); + } else if (_40 === 4) { + const _50: rt.BinaryHeap<[rt.u64, rt.u8]> = h; + const _51: rt.usize = amount(arg, h.d.length, size); + rt.vecReserveExact(_50.d, _51, 16); + } else if (_40 === 5) { + rt.vecShrinkTo(h.d, rt.u8Rem(arg, 40) as rt.usize, 16); + } else if (_40 === 6) { + rt.vecShrinkTo(h.d, 0, 16); + } else if (_40 === 7) { + rt.heapClear(h); + } else if (_40 === 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 (_40 === 9) { + const _68: [rt.u64, rt.u8] = make(arg); + rt.heapPush(other, _68, rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), 16); + 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])), 16); + put(out, rt.vecCapacity(other.d, 16)); + } else if (_40 === 10) { + rt.drop(rt.heapDrain(h)); + } 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]))); + } + put(out, h.d.length); + put(out, rt.vecCapacity(h.d, 16)); + } + put(out, rt.vecCapacity(rt.heapClone(h).d, 16)); + put(out, rt.vecCapacity(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]))), 16)); +} + +export function heapSteps$u16(data: rt.ByteSlice, 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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 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; + } + 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 _25: rt.ByteSlice | rt.Done = iter.next(); + if (_25 === rt.DONE) { + break; + } + rt.idx(_25, 0); + const _31: [rt.u8, rt.u8] = [_25.data[_25.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_25, 1), 0)]; + const op: rt.u8 = _31[0]; + const arg: rt.u8 = _31[1]; + const _40: rt.u8 = rt.u8Rem(op, 12); + if (_40 === 0 || _40 === 1) { + rt.heapPush(h, make(arg), rt.le, 2); + } else if (_40 === 2) { + rt.heapPop(h, rt.le); + } else if (_40 === 3) { + const _46: rt.BinaryHeap = h; + const _47: rt.usize = amount(arg, h.d.length, size); + rt.vecReserve(_46.d, _47, 2); + } else if (_40 === 4) { + const _50: rt.BinaryHeap = h; + const _51: rt.usize = amount(arg, h.d.length, size); + rt.vecReserveExact(_50.d, _51, 2); + } else if (_40 === 5) { + rt.vecShrinkTo(h.d, rt.u8Rem(arg, 40) as rt.usize, 2); + } else if (_40 === 6) { + rt.vecShrinkTo(h.d, 0, 2); + } else if (_40 === 7) { + rt.heapClear(h); + } else if (_40 === 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 (_40 === 9) { + const _68: rt.u16 = make(arg); + rt.heapPush(other, _68, rt.le, 2); + rt.heapAppend(h, other, rt.le, rt.ge, rt.lt, 2); + put(out, rt.vecCapacity(other.d, 2)); + } else if (_40 === 10) { + rt.drop(rt.heapDrain(h)); + } else { + h = rt.heapFrom(h.d, rt.le, rt.ge, rt.lt); + } + put(out, h.d.length); + put(out, rt.vecCapacity(h.d, 2)); + } + put(out, rt.vecCapacity(rt.heapClone(h).d, 2)); + put(out, rt.vecCapacity(rt.heapIntoSortedVec(h, rt.le, rt.ge, rt.lt), 2)); +} + +export function heapSteps$u8(data: rt.ByteSlice, 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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 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; + } + 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 _25: rt.ByteSlice | rt.Done = iter.next(); + if (_25 === rt.DONE) { + break; + } + rt.idx(_25, 0); + const _31: [rt.u8, rt.u8] = [_25.data[_25.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_25, 1), 0)]; + const op: rt.u8 = _31[0]; + const arg: rt.u8 = _31[1]; + const _40: rt.u8 = rt.u8Rem(op, 12); + if (_40 === 0 || _40 === 1) { + rt.heapPush(h, make(arg), rt.le, 1); + } else if (_40 === 2) { + rt.heapPop(h, rt.le); + } else if (_40 === 3) { + const _46: rt.BinaryHeap = h; + const _47: rt.usize = amount(arg, h.d.length, size); + rt.vecReserve(_46.d, _47, 1); + } else if (_40 === 4) { + const _50: rt.BinaryHeap = h; + const _51: rt.usize = amount(arg, h.d.length, size); + rt.vecReserveExact(_50.d, _51, 1); + } else if (_40 === 5) { + rt.vecShrinkTo(h.d, rt.u8Rem(arg, 40) as rt.usize, 1); + } else if (_40 === 6) { + rt.vecShrinkTo(h.d, 0, 1); + } else if (_40 === 7) { + rt.heapClear(h); + } else if (_40 === 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 (_40 === 9) { + const _68: rt.u8 = make(arg); + rt.heapPush(other, _68, rt.le, 1); + rt.heapAppend(h, other, rt.le, rt.ge, rt.lt, 1); + put(out, rt.vecCapacity(other.d, 1)); + } else if (_40 === 10) { + rt.drop(rt.heapDrain(h)); + } else { + h = rt.heapFrom(rt.byteVecToVec(rt.byteVecFromVec(h.d)), rt.le, rt.ge, rt.lt); + } + put(out, h.d.length); + put(out, rt.vecCapacity(h.d, 1)); + } + put(out, rt.byteVecCapacity(rt.byteVecFromVec(rt.heapClone(h).d))); + put(out, rt.byteVecCapacity(rt.byteVecFromVec(rt.heapIntoSortedVec(h, rt.le, rt.ge, rt.lt)))); +} + +export function heapSteps$unit(data: rt.ByteSlice, 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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 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; + } + 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 _25: rt.ByteSlice | rt.Done = iter.next(); + if (_25 === rt.DONE) { + break; + } + rt.idx(_25, 0); + const _31: [rt.u8, rt.u8] = [_25.data[_25.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_25, 1), 0)]; + const op: rt.u8 = _31[0]; + const arg: rt.u8 = _31[1]; + const _40: rt.u8 = rt.u8Rem(op, 12); + if (_40 === 0 || _40 === 1) { + const _42: rt.BinaryHeap = h; + make(arg); + rt.heapPush(_42, undefined, rt.cmpLe(rt.cmpNothing), 0); + } else if (_40 === 2) { + rt.heapPop(h, rt.cmpLe(rt.cmpNothing), rt.None); + } else if (_40 === 3) { + const _46: rt.BinaryHeap = h; + const _47: rt.usize = amount(arg, h.d.length, size); + rt.vecReserve(_46.d, _47, 0); + } else if (_40 === 4) { + const _50: rt.BinaryHeap = h; + const _51: rt.usize = amount(arg, h.d.length, size); + rt.vecReserveExact(_50.d, _51, 0); + } else if (_40 === 5) { + rt.vecShrinkTo(h.d, rt.u8Rem(arg, 40) as rt.usize, 0); + } else if (_40 === 6) { + rt.vecShrinkTo(h.d, 0, 0); + } else if (_40 === 7) { + rt.heapClear(h); + } else if (_40 === 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 (_40 === 9) { + make(arg); + rt.heapPush(other, undefined, rt.cmpLe(rt.cmpNothing), 0); + rt.heapAppend(h, other, rt.cmpLe(rt.cmpNothing), rt.cmpGe(rt.cmpNothing), rt.cmpLt(rt.cmpNothing), 0); + put(out, rt.vecCapacity(other.d, 0)); + } else if (_40 === 10) { + rt.drop(rt.heapDrain(h)); + } else { + h = rt.heapFrom(h.d, rt.cmpLe(rt.cmpNothing), rt.cmpGe(rt.cmpNothing), rt.cmpLt(rt.cmpNothing)); + } + put(out, h.d.length); + put(out, rt.vecCapacity(h.d, 0)); + } + put(out, rt.vecCapacity(rt.heapClone(h).d, 0)); + put(out, rt.vecCapacity(rt.heapIntoSortedVec(h, rt.cmpLe(rt.cmpNothing), rt.cmpGe(rt.cmpNothing), rt.cmpLt(rt.cmpNothing)), 0)); +} + +/** + * 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 _18: rt.u8 = rt.u8Rem(kind, 8); + if (_18 === 0) { + put(out, rt.vecCapacity(rt.iterToArrayInPlace(rt.iterMap(rt.iterSlice(pairs2), (_27: [rt.u32, rt.u32]): rt.u32 => { + return _27[0]; + }), 8, 4, false, "next", true), 4)); + } else if (_18 === 1) { + const bytes: rt.ByteVec = rt.byteVecWithCapacity(rt.usizeAdd(n, 3)); + const _32: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(n, data.length)); + rt.byteVecExtendFromSlice(bytes, _32); + put(out, rt.byteVecCapacity(rt.iterToByteVecInPlace(rt.iterFilter(rt.byteVecIntoIter(rt.byteVecFrom(rt.byteVecView(bytes))), (b5: rt.u8): boolean => { + return rt.u8Rem(b5, 2) === 1; + }), 1, false, "next"))); + put(out, rt.vecCapacity(rt.iterToArray(rt.iterMap(rt.byteVecIntoIter(bytes), (a0: rt.u8): rt.u16 => { + return a0 as rt.u16; + }), undefined, 2, true), 2)); + } else if (_18 === 2) { + const _54: rt.Iter<[rt.u32, rt.u32]> = rt.iterCopied(rt.iterFilter(rt.iterSlice(pairs2), (_24: [rt.u32, rt.u32]): boolean => { + return rt.u32Rem(_24[0], 2) === 0; + }), copy$tuple2_u32_u32); + const _53: [rt.u32[], rt.VecDeque] = rt.tupleExtend([[], rt.dequeNew() as rt.VecDeque] as [rt.u32[], rt.VecDeque], _54, [rt.vecPart(4), rt.dequePart(4)]); + const a: rt.u32[] = _53[0]; + const b: rt.VecDeque = _53[1]; + put(out, rt.vecCapacity(a, 4)); + put(out, rt.dequeCapacity(b, 4)); + const _68: 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 _67: [rt.ByteVec, rt.BinaryHeap] = rt.tupleExtend([new rt.ByteVec(), rt.heapNew() as rt.BinaryHeap] as [rt.ByteVec, rt.BinaryHeap], _68, [rt.byteVecPart(), rt.heapPart(rt.le, 4)]); + const c: rt.ByteVec = _67[0]; + const d: rt.BinaryHeap = _67[1]; + put(out, rt.byteVecCapacity(c)); + put(out, rt.vecCapacity(d.d, 4)); + } else if (_18 === 3) { + put(out, rt.vecCapacity(rt.vecFromElem(0, n, undefined, 2), 2)); + put(out, rt.vecCapacity(rt.vecFromElem(undefined, n, undefined, 0), 0)); + } else if (_18 === 4) { + put(out, rt.vecCapacity(rt.vecWithCapacity(rt.usizeSub(4294967295, n), 8), 8)); + } else if (_18 === 5) { + put(out, rt.dequeCapacity(rt.dequeWithCapacity(rt.usizeAdd(268435456, n), 16) as rt.VecDeque<[rt.u64, rt.u64]>, 16)); + } else if (_18 === 6) { + const bytes2: rt.ByteVec = rt.byteVecWithCapacity(rt.usizeAdd(n, 5)); + const _103: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(n, data.length)); + rt.byteVecExtendFromSlice(bytes2, _103); + put(out, rt.dequeCapacity(rt.dequeFromVec(rt.byteVecToVec(rt.byteVecFrom(rt.byteVecView(bytes2))), 1) as rt.VecDeque, 1)); + const heap: rt.BinaryHeap = rt.heapFrom(rt.byteVecToVec(bytes2), rt.le, rt.ge, rt.lt); + put(out, rt.vecCapacity(heap.d, 1)); + put(out, rt.byteVecCapacity(rt.byteVecFromVec(heap.d))); + } else { + const grown: rt.ByteVec = rt.byteVecFrom(rt.byteVecView(rt.byteVecOf(7, n))); + const _127: rt.Iter = rt.iterFilter(new rt.Range(0, n & 0xff), (b3: rt.u8): boolean => { + return rt.u8Rem(b3, 2) === 0; + }); + rt.iterExtendBytes(grown, _127, "next"); + put(out, rt.byteVecCapacity(grown)); + rt.byteVecShrinkTo(grown, rt.usizeDiv(n, 2)); + put(out, rt.byteVecCapacity(grown)); + } +} + +//# sourceMappingURL=capacity.ts.map diff --git a/ts/fixtures/lang/expected/chars.ts b/ts/fixtures/lang/expected/chars.ts index 1fd6c6623..20a3b792e 100644 --- a/ts/fixtures/lang/expected/chars.ts +++ b/ts/fixtures/lang/expected/chars.ts @@ -13,7 +13,7 @@ export function scalars(data: rt.ByteSlice): rt.u32[] { const buf: Uint8Array = rt.bytes(4); const n: rt.usize = rt.min(rest.length, 4); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(rest, 0, n)); - all.push(rt.u32FromBeBytes(buf)); + rt.vecPush(all, rt.u32FromBeBytes(buf), 4); rest = rt.byteSliceRange(rest, n); } else { return all; @@ -92,9 +92,9 @@ export function chars(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(((c2 as rt.u32) & 0xff) as rt.u16))); } } else if (_4 === 2) { - const cs: rt.char[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(scalars(data)), (a0: rt.u32): rt.char | undefined => { + const cs: rt.char[] = rt.iterToArrayInPlace(rt.iterFilterMap(rt.iterSlice(scalars(data)), (a0: rt.u32): rt.char | undefined => { return rt.charFromU32(a0); - }), "next", 4); + }), 4, 4, false, "next"); const sorted: rt.BTreeSet = rt.btreeNew(rt.cmp) as rt.BTreeSet; const seen: rt.HashSet = rt.hashNew() as rt.HashSet; const iter3: rt.Iter<[rt.usize, rt.char]> = rt.iterEnumerate(rt.iterSlice(cs)); diff --git a/ts/fixtures/lang/expected/clones.ts b/ts/fixtures/lang/expected/clones.ts index 715d8b7ca..1004ffc59 100644 --- a/ts/fixtures/lang/expected/clones.ts +++ b/ts/fixtures/lang/expected/clones.ts @@ -6614,7 +6614,7 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }, plan, (x68: rt.u8): rt.u8 => { return x68; }, out); - turns$vec_IntoIter_u8_clones_iters_closure18_clones_iters_closure19(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(data))), (it76: rt.Iter): rt.u8 | undefined => { + turns$vec_IntoIter_u8_clones_iters_closure18_clones_iters_closure19(rt.byteVecIntoIter(rt.byteSliceToByteVec(data)), (it76: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it76.nextBack()); }, plan, (x69: rt.u8): rt.u8 => { return x69; @@ -6861,7 +6861,7 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }, out); turns$iter_Flatten_iter_Map_slice_Chunks_u8_clones_iters_closure89_clones_iters_closure90_clones_iters_closure91(rt.iterFlatten(rt.iterMap(rt.byteSliceChunks(data, n), (c3: rt.ByteSlice): rt.ByteVec => { return rt.byteSliceToByteVec(c3); - }), (value: rt.ByteVec) => rt.iterSlice(rt.byteVecView(value))), (it43: rt.Iter): rt.u8 | undefined => { + }), (value: rt.ByteVec) => rt.byteVecIntoIter(value)), (it43: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it43.nextBack()); }, plan, (x47: rt.u8): rt.u8 => { return x47; @@ -7005,7 +7005,7 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(zip3.clone(), zip3), (x29: rt.u8): rt.u8 => { return x29 ^ 64; }), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.refCellReplace(log, new rt.ByteVec()))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.refCellReplace(log, new rt.ByteVec())), undefined, true); } else if (_9 === 8) { it = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(data))); let iterStart5: rt.usize = 0; @@ -7148,9 +7148,9 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; for (const b6 of rt.byteSliceView(data)) { if (rt.u8Rem(b6, 2) === 0) { - rt.dequePushFront(q, b6); + rt.dequePushFront(q, b6, 1); } else { - rt.dequePushBack(q, b6); + rt.dequePushBack(q, b6, 1); } } turns$collections_vec_deque_Iter_u8_clones_iters_closure138_clones_iters_closure0(rt.dequeIter(q), (it7: rt.Iter): rt.u8 | undefined => { @@ -7252,9 +7252,9 @@ export function unordered$iter_Copied_collections_hash_map_Keys_u8_u8(it: rt.Ite const _16: [rt.ByteVec, rt.ByteVec] = [_17, rt.iterToByteVec(other, "next")]; const rest: rt.ByteVec = _17; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); - rt.iterExtendBytes(all, rt.iterSlice(rt.byteVecView(rest)), undefined, true); + rt.iterExtendBytes(all, rt.byteVecIntoIter(rest), undefined, true); rt.byteSliceView(rt.byteVecSlice(all)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(all)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(all), undefined, true); } /** @@ -7270,9 +7270,9 @@ export function unordered$iter_Copied_collections_hash_map_Values_u8_u8(it: rt.I const _16: [rt.ByteVec, rt.ByteVec] = [_17, rt.iterToByteVec(other, "next")]; const rest: rt.ByteVec = _17; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); - rt.iterExtendBytes(all, rt.iterSlice(rt.byteVecView(rest)), undefined, true); + rt.iterExtendBytes(all, rt.byteVecIntoIter(rest), undefined, true); rt.byteSliceView(rt.byteVecSlice(all)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(all)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(all), undefined, true); } /** @@ -7288,9 +7288,9 @@ export function unordered$iter_Copied_collections_hash_set_Difference_u8_hash_Ra const _16: [rt.ByteVec, rt.ByteVec] = [_17, rt.iterToByteVec(other, "next")]; const rest: rt.ByteVec = _17; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); - rt.iterExtendBytes(all, rt.iterSlice(rt.byteVecView(rest)), undefined, true); + rt.iterExtendBytes(all, rt.byteVecIntoIter(rest), undefined, true); rt.byteSliceView(rt.byteVecSlice(all)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(all)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(all), undefined, true); } /** @@ -7306,9 +7306,9 @@ export function unordered$iter_Copied_collections_hash_set_Intersection_u8_hash_ const _16: [rt.ByteVec, rt.ByteVec] = [_17, rt.iterToByteVec(other, "next")]; const rest: rt.ByteVec = _17; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); - rt.iterExtendBytes(all, rt.iterSlice(rt.byteVecView(rest)), undefined, true); + rt.iterExtendBytes(all, rt.byteVecIntoIter(rest), undefined, true); rt.byteSliceView(rt.byteVecSlice(all)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(all)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(all), undefined, true); } /** @@ -7324,9 +7324,9 @@ export function unordered$iter_Copied_collections_hash_set_Iter_u8(it: rt.Iter = 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), 8) as rt.VecDeque, rt.drop), (it7: rt.Iter): clones_Logged.Logged | undefined => { return rt.iterToOption(it7.nextBack()); }, plan, (x2: clones_Logged.Logged): rt.u8 => { const _07: rt.u8 = clones_Logged.id(x2); diff --git a/ts/fixtures/lang/expected/collections.ts b/ts/fixtures/lang/expected/collections.ts index 707a1791d..48179225c 100644 --- a/ts/fixtures/lang/expected/collections.ts +++ b/ts/fixtures/lang/expected/collections.ts @@ -922,7 +922,7 @@ export function btreeMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi /** Pushes an item, and gives back the deque. */ export function touch(q: rt.VecDeque): rt.VecDeque { - rt.dequePushBack(q, 66); + rt.dequePushBack(q, 66, 1); return q; } @@ -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) { @@ -938,16 +938,16 @@ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_12 === 1) { rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.dequePopBack(q), 237)); } else if (_12 === 2) { - rt.dequePushFront(q, b); + rt.dequePushFront(q, b, 1); } else if (_12 === 3) { rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.dequeEnd(q), 236)); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.dequeEnd(q, true), 235)); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.dequeGet(q, rt.usizeRem(b as rt.usize, 5)), 234)); } else { - rt.dequePushBack(q, b); + rt.dequePushBack(q, b, 1); } const _42: [rt.u8, rt.u8] = [b, q.n & 0xff]; - rt.dequePushBack(pairs, _42); + rt.dequePushBack(pairs, _42, 2); if (pairs.n > 3) { rt.dequePopFront(pairs); } @@ -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,10 +978,9 @@ 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); + }), undefined, 2, true), 2) as rt.VecDeque; const copy: rt.VecDeque = rt.dequeClone(tallies, copy$collections_Tally); const _115: collections_Tally.Tally | undefined = rt.dequeEnd(copy); if (_115 !== undefined) { @@ -1020,15 +1019,14 @@ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { }), undefined, true); const _162: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); rt.dequeExtend(q, _162, undefined, 1, true); - rt.dequeInsert(q, rt.usizeDiv(q.n, 2), 66); + rt.dequeInsert(q, rt.usizeDiv(q.n, 2), 66, 1); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.dequeRemove(q, 1), 233)); rt.dequeTruncate(q, 5); rt.byteVecPush(out, rt.dequeContains(q, 66, rt.same) ? 1 : 0); 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), 1) 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"); @@ -1060,7 +1058,7 @@ export function vecs(data: rt.ByteSlice, out: rt.ByteVec): void { const bytes: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(a, b, 66)); rt.byteVecExtendFromSlice(out, rt.byteVecSlice(bytes)); const pairs: [rt.u8, rt.u16][] = copy$array_tuple2_u8_u16([[a, b as rt.u16] as [rt.u8, rt.u16]]).map(copy$tuple2_u8_u16); - pairs.push([b, a as rt.u16] as [rt.u8, rt.u16]); + rt.vecPush(pairs, [b, a as rt.u16] as [rt.u8, rt.u16], 4); const at = rt.idx(pairs, 0); pairs[at][0] = pairs[at][0] ^ 255; for (const _39 of pairs) { @@ -1071,25 +1069,25 @@ export function vecs(data: rt.ByteSlice, out: rt.ByteVec): void { const one: Cloned.Cloned[] = [{ depth: a, name: name }]; rt.byteVecPush(out, one[rt.idx(one, 0)].depth); rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.byteVecOf(b, n))); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.vecFromElem(rt.u16Mul(a as rt.u16, 257), n, undefined)), (w: rt.u16): rt.u8 => { + rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.vecFromElem(rt.u16Mul(a as rt.u16, 257), n, undefined, 2)), (w: rt.u16): rt.u8 => { return rt.u16Shr(w, 4) & 0xff; }), undefined, true); - const tuples: [rt.u8, rt.u8][] = rt.vecFromElem([a, b] as [rt.u8, rt.u8], n, copy$tuple2_u8_u8); + const tuples: [rt.u8, rt.u8][] = rt.vecFromElem([a, b] as [rt.u8, rt.u8], n, copy$tuple2_u8_u8, 2); if (n > 0) { tuples[rt.idx(tuples, 0)][0] = 238; } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(tuples), (t: [rt.u8, rt.u8]): rt.u8 => { return t[0] ^ t[1]; }), undefined, true); - rt.byteVecPush(out, rt.vecFromElem(name, n, undefined).length & 0xff); - const cloned: Cloned.Cloned[] = rt.vecFromElem({ depth: 0, name }, n, Cloned.clone$Clone); + rt.byteVecPush(out, rt.vecFromElem(name, n, undefined, 12).length & 0xff); + const cloned: Cloned.Cloned[] = rt.vecFromElem({ depth: 0, name }, n, Cloned.clone$Clone, 16); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(cloned), (c: Cloned.Cloned): rt.u8 => { return c.depth; }), undefined, true); rt.byteVecPush(out, rt.iterAll(rt.iterSlice(cloned), (c2: Cloned.Cloned): boolean => { return rt.stringLen(c2.name) === data.length; }) ? 1 : 0); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.vecFromElem({ _0: b }, n, Bumped.clone$Clone)), (o: Bumped.Bumped): rt.u8 => { + rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.vecFromElem({ _0: b }, n, Bumped.clone$Clone, 1)), (o: Bumped.Bumped): rt.u8 => { return o._0; }), undefined, true); const pair: [rt.u8, rt.u8] = [a, b]; @@ -1097,10 +1095,10 @@ export function vecs(data: rt.ByteSlice, out: rt.ByteVec): void { const listed: [rt.u8, rt.u8][] = copy$array_tuple2_u8_u8([pair, pair]).map(copy$tuple2_u8_u8); const at4 = rt.idx(listed, 0); listed[at4][0] = listed[at4][0] ^ 255; - const repeated: [rt.u8, rt.u8][] = rt.vecFromElem(copy$tuple2_u8_u8(pair), n, copy$tuple2_u8_u8); - const again: [rt.u8, rt.u8][] = rt.vecFromElem(copy$tuple2_u8_u8(pair), n, copy$tuple2_u8_u8); - const bumps: Bumped.Bumped[] = rt.vecFromElem(copy$iters_Bumped(held), n, Bumped.clone$Clone); - const kept: Bumped.Bumped[] = rt.vecFromElem(copy$iters_Bumped(held), n, Bumped.clone$Clone); + const repeated: [rt.u8, rt.u8][] = rt.vecFromElem(copy$tuple2_u8_u8(pair), n, copy$tuple2_u8_u8, 2); + const again: [rt.u8, rt.u8][] = rt.vecFromElem(copy$tuple2_u8_u8(pair), n, copy$tuple2_u8_u8, 2); + const bumps: Bumped.Bumped[] = rt.vecFromElem(copy$iters_Bumped(held), n, Bumped.clone$Clone, 1); + const kept: Bumped.Bumped[] = rt.vecFromElem(copy$iters_Bumped(held), n, Bumped.clone$Clone, 1); if (n > 0) { const at5 = rt.idx(repeated, rt.usizeSub(n, 1)); repeated[at5][1] = repeated[at5][1] ^ 255; @@ -1125,7 +1123,7 @@ export function vecs(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, _183.length & 0xff); rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_183)); } - const wrapped: Wrap.Wrap[] = rt.vecFromElem(new Wrap.Wrap(a, b), n, copy$generics_Wrap_u8); + const wrapped: Wrap.Wrap[] = rt.vecFromElem(new Wrap.Wrap(a, b), n, copy$generics_Wrap_u8, 2); if (n > 0) { const _195: Wrap.Wrap[] = wrapped; const _197: rt.usize = rt.usizeSub(n, 1); @@ -1142,7 +1140,7 @@ export function vecs(data: rt.ByteSlice, out: rt.ByteVec): void { /** Stores `p` by value in `v`. */ export function keep(v: [rt.u8, rt.u8][], p: [rt.u8, rt.u8]): void { - v.push(copy$tuple2_u8_u8(p)); + rt.vecPush(v, copy$tuple2_u8_u8(p), 2); } /** Gives back what it was given. */ @@ -1172,11 +1170,11 @@ export function stores(data: rt.ByteSlice, out: rt.ByteVec): void { const changed: [rt.u8, rt.u8] = [b, a]; changed[0] = changed[0] ^ 16; const v: [rt.u8, rt.u8][] = []; - v.push(copy$tuple2_u8_u8(pair)); - v.push(copy$tuple2_u8_u8(pair)); + rt.vecPush(v, copy$tuple2_u8_u8(pair), 2); + rt.vecPush(v, copy$tuple2_u8_u8(pair), 2); const at = rt.idx(v, 0); v[at][0] = v[at][0] ^ 1; - v.push(copy$tuple2_u8_u8(changed)); + rt.vecPush(v, copy$tuple2_u8_u8(changed), 2); changed[1] = changed[1] ^ 32; const at2 = rt.idx(v, 2); v[at2][0] = v[at2][0] ^ 4; @@ -1184,7 +1182,7 @@ export function stores(data: rt.ByteSlice, out: rt.ByteVec): void { const at3 = rt.idx(v, 3); v[at3][1] = v[at3][1] ^ 8; const _30: [rt.u8, rt.u8] = copy$tuple2_u8_u8(same(pair)); - v.push(_30); + rt.vecPush(v, _30, 2); const at4 = rt.idx(v, 4); v[at4][0] = v[at4][0] ^ 64; const _36: [rt.u8, rt.u8] = copy$tuple2_u8_u8(changed); @@ -1205,9 +1203,9 @@ export function stores(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(changed[0], changed[1], old[0], old[1]))); const tally: collections_Tally.Tally = { n: a as rt.u16 }; const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; - rt.dequePushBack(q, copy$collections_Tally(tally)); - rt.dequePushFront(q, copy$collections_Tally(tally)); - rt.dequeInsert(q, 1, copy$collections_Tally(tally)); + rt.dequePushBack(q, copy$collections_Tally(tally), 2); + rt.dequePushFront(q, copy$collections_Tally(tally), 2); + rt.dequeInsert(q, 1, copy$collections_Tally(tally), 2); const _68: collections_Tally.Tally | undefined = rt.dequeEnd(q); if (_68 !== undefined) { _68.n = _68.n ^ 1; @@ -1247,7 +1245,7 @@ export function stores(data: rt.ByteSlice, out: rt.ByteVec): void { const boxed: [rt.u8, rt.u8] = copy$tuple2_u8_u8(pair); boxed[0] = boxed[0] ^ 1; const holders: Holder.Holder[] = [{ pair: copy$tuple2_u8_u8(pair) }]; - holders.push({ pair: copy$tuple2_u8_u8(pair) }); + rt.vecPush(holders, { pair: copy$tuple2_u8_u8(pair) }, 2); const at9 = rt.idx(holders, 1); holders[at9].pair[1] = holders[at9].pair[1] ^ 2; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(boxed[0], boxed[1], holders[rt.idx(holders, 0)].pair[1], holders[rt.idx(holders, 1)].pair[1]))); @@ -1255,7 +1253,7 @@ export function stores(data: rt.ByteSlice, out: rt.ByteVec): void { const held: Holder.Holder = hold(pair); held.pair[1] = held.pair[1] ^ 4; const _142: Holder.Holder = hold(pair); - holders.push(_142); + rt.vecPush(holders, _142, 2); const at12 = rt.idx(holders, 2); holders[at12].pair[0] = holders[at12].pair[0] ^ 8; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(held.pair[1], holders[rt.idx(holders, 2)].pair[0]))); @@ -3568,7 +3566,7 @@ export function rights(kind: rt.u8, data: rt.ByteSlice): Right.Right[] { return { _0: rt.u16Add(_2[1] as rt.u16, step(_2[0])) }; }), undefined, 2, true); if ((kind & 64) !== 0) { - rights.pop(); + rt.vecPop(rights); return rights; } return rights; @@ -3703,11 +3701,11 @@ export function unlikeEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi break; } const _232: Left.Left = { _0: _226 as rt.u16, _1: log }; - rt.dequePushFront(q, _232); + rt.dequePushFront(q, _232, 8); } for (const _239 of rt.byteSliceView(rt.byteSliceRange(data, half))) { const _245: Left.Left = { _0: _239 as rt.u16, _1: log }; - rt.dequePushBack(q, _245); + rt.dequePushBack(q, _245, 8); } const _252: Right.Right[] = rights_; putEq(rt.eqSeq((a26: Left.Left, b24: Right.Right): boolean => { @@ -3743,7 +3741,7 @@ export function unlikeEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi if (_305 === rt.DONE) { break; } - rt.dequePushFront(bytes, _305); + rt.dequePushFront(bytes, _305, 1); } const _313: rt.ByteSlice = rt.byteSliceRange(data, half); rt.dequeExtend(bytes, rt.iterSlice(rt.byteSliceView(_313)), undefined, 1, true); @@ -3754,10 +3752,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), 2) 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) { @@ -3765,7 +3762,7 @@ export function unlikeEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi if (_351 === rt.DONE) { break; } - rt.dequePushFront(wrapped, _351 as rt.u16); + rt.dequePushFront(wrapped, _351 as rt.u16, 2); } putEq(rt.eqSeq(rt.same)(wide, wrapped), log, out); const _366: rt.VecDeque[] = [rt.dequeClone(wide, undefined)]; @@ -3817,7 +3814,7 @@ export function wrapped$collections_Picky(v: collections_Picky.Picky[]): rt.VecD break; } const _18: collections_Picky.Picky = collections_Picky.clone$Clone(_12); - rt.dequePushFront(q, _18); + rt.dequePushFront(q, _18, 8); } const _21: rt.Iter = rt.iterMap(rt.iterSlice(rt.sliceRange(v, half)), collections_Picky.clone$Clone); rt.dequeExtend(q, _21, undefined, 8, true); @@ -3942,7 +3939,7 @@ export function ownNes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return { _0: rt.u16Add(_22[1] as rt.u16, step(_22[0])), _1: log }; }), undefined, 8, true); if ((kind & 64) !== 0) { - b.pop(); + rt.vecPop(b); } const one: (a0: collections_Picky.Picky[], a1: rt.usize) => collections_Picky.Picky = (v2: collections_Picky.Picky[], i4: rt.usize): collections_Picky.Picky => { return { _0: _34(v2, i4), _1: log }; @@ -4729,10 +4726,8 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_147, _152, !rt.eqSlice(ByRef.eq$cmp_PartialEq_ref)(_161, _164)], (a022: boolean): rt.u8 => { return a022 ? 1 : 0; })), undefined, true); - const _171: ByRef.ByRef[] = [a, b]; - const _170: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_171), undefined, 4, true); - const _174: ByRef.ByRef[] = [b, a]; - const _173: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_174), undefined, 4, true); + const _170: rt.VecDeque = rt.dequeFromVec([a, b], 4) as rt.VecDeque; + const _173: rt.VecDeque = rt.dequeFromVec([b, a], 4) as rt.VecDeque; rt.byteVecPush(out, rt.eqSeq(ByRef.eq$cmp_PartialEq_ref)(_170, _173) ? 1 : 0); const _180: ByRef.ByRef = a; const _182: ByRef.ByRef = b; @@ -4853,10 +4848,8 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_458, _463, !rt.eqSlice(ByRef.eq$cmp_PartialEq_ref)(_472, _475)], (a067: boolean): rt.u8 => { return a067 ? 1 : 0; })), undefined, true); - const _482: ByRef.ByRef[] = [a2, b2]; - const _481: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_482), undefined, 4, true); - const _485: ByRef.ByRef[] = [b2, a2]; - const _484: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_485), undefined, 4, true); + const _481: rt.VecDeque = rt.dequeFromVec([a2, b2], 4) as rt.VecDeque; + const _484: rt.VecDeque = rt.dequeFromVec([b2, a2], 4) as rt.VecDeque; rt.byteVecPush(out, rt.eqSeq(ByRef.eq$cmp_PartialEq_ref)(_481, _484) ? 1 : 0); const _491: ByRef.ByRef = a2; const _493: ByRef.ByRef = b2; @@ -4977,10 +4970,8 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_761, _766, !rt.eqSlice(ByVal.eq$cmp_PartialEq)(_775, _778)], (a0112: boolean): rt.u8 => { return a0112 ? 1 : 0; })), undefined, true); - const _785: ByVal.ByVal[] = [a3, b3]; - const _784: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_785), undefined, 4, true); - const _788: ByVal.ByVal[] = [b3, a3]; - const _787: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_788), undefined, 4, true); + const _784: rt.VecDeque = rt.dequeFromVec([a3, b3], 4) as rt.VecDeque; + const _787: rt.VecDeque = rt.dequeFromVec([b3, a3], 4) as rt.VecDeque; rt.byteVecPush(out, rt.eqSeq(ByVal.eq$cmp_PartialEq)(_784, _787) ? 1 : 0); const _794: ByVal.ByVal = a3; const _796: ByVal.ByVal = b3; @@ -5101,10 +5092,8 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_1068, _1073, !rt.eqSlice(ByVal.eq$cmp_PartialEq)(_1082, _1085)], (a0157: boolean): rt.u8 => { return a0157 ? 1 : 0; })), undefined, true); - const _1092: ByVal.ByVal[] = [a4, b4]; - const _1091: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_1092), undefined, 4, true); - const _1095: ByVal.ByVal[] = [b4, a4]; - const _1094: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_1095), undefined, 4, true); + const _1091: rt.VecDeque = rt.dequeFromVec([a4, b4], 4) as rt.VecDeque; + const _1094: rt.VecDeque = rt.dequeFromVec([b4, a4], 4) as rt.VecDeque; rt.byteVecPush(out, rt.eqSeq(ByVal.eq$cmp_PartialEq)(_1091, _1094) ? 1 : 0); const _1101: ByVal.ByVal = a4; const _1103: ByVal.ByVal = b4; @@ -5274,8 +5263,7 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo return rt.sliceContains(rt.sliceRange(xs, 1), first, ByRef.eq$cmp_PartialEq_ref) ? 1 : 0; })), undefined, true); rt.byteVecPush(out, rt.sliceIsSorted(xs, rt.cmpLe(ByRef.partialCmp$cmp_PartialOrd_ref)) ? 1 : 0); - 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(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(); @@ -5324,8 +5312,7 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo return rt.sliceContains(rt.sliceRange(xs2, 1), first2, ByVal.eq$cmp_PartialEq) ? 1 : 0; })), undefined, true); rt.byteVecPush(out, rt.sliceIsSorted(xs2, rt.cmpLe(ByVal.partialCmp$cmp_PartialOrd)) ? 1 : 0); - 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(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(); @@ -5374,8 +5361,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(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 7390470f2..e4e84a296 100644 --- a/ts/fixtures/lang/expected/core/option.ts +++ b/ts/fixtures/lang/expected/core/option.ts @@ -1341,6 +1341,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_; diff --git a/ts/fixtures/lang/expected/counts.ts b/ts/fixtures/lang/expected/counts.ts index 9381f6867..b7faa362a 100644 --- a/ts/fixtures/lang/expected/counts.ts +++ b/ts/fixtures/lang/expected/counts.ts @@ -38,13 +38,13 @@ export function arcs(data: rt.ByteSlice, out: rt.ByteVec): void { const _19: rt.u8 = rt.u8Rem(op, 12); if (_19 === 0) { const _22: rt.Arc = new rt.Arc(new counts_Noisy.Noisy(op, rt.arcClone(log))); - strong.push(_22); + rt.vecPush(strong, _22, 4); continue; } if (_19 === 1) { if (!((strong.length === 0))) { const again: rt.Arc = rt.arcClone(strong[rt.idx(strong, rt.usizeRem(pick, strong.length))]); - strong.push(again); + rt.vecPush(strong, again, 4); continue; } } else if (_19 === 2) { @@ -68,13 +68,13 @@ export function arcs(data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_19 === 3) { if (!((strong.length === 0))) { const _62: rt.Weak = new rt.Weak(strong[rt.idx(strong, rt.usizeRem(pick, strong.length))]); - weak.push(_62); + rt.vecPush(weak, _62, 4); continue; } } else if (_19 === 4) { if (!((weak.length === 0))) { const again2: rt.Weak = rt.weakClone(weak[rt.idx(weak, rt.usizeRem(pick, weak.length))]); - weak.push(again2); + rt.vecPush(weak, again2, 4); continue; } } else if (_19 === 5) { @@ -91,13 +91,13 @@ export function arcs(data: rt.ByteSlice, out: rt.ByteVec): void { } const up: rt.Arc = _90; rt.byteVecPush(out, up.value.id); - strong.push(up); + rt.vecPush(strong, up, 4); continue; } } else { if (_19 === 7) { const _106: rt.Weak = new rt.Weak(); - weak.push(_106); + rt.vecPush(weak, _106, 4); continue; } if (_19 === 8) { @@ -274,7 +274,7 @@ export function clonedArcs(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, handles[at].strong & 0xff); if (keep) { _191 = false; - lists.push(all); + rt.vecPush(lists, all, 12); } if (_191) { rt.dropAll(all); @@ -331,7 +331,7 @@ export function clonedArcs(data: rt.ByteSlice, out: rt.ByteVec): void { break b2; } } - rt.dropAll(lists.pop()); + rt.dropAll(rt.vecPop(lists)); } } rt.byteVecPush(out, handles[rt.idx(handles, rt.usizeRem(pick, handles.length))].strong & 0xff); @@ -413,10 +413,10 @@ export function cyclicArcs(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, node.weak & 0xff); const _69: rt.u8 = op >> 6; if (_69 === 0) { - kept.push(node); + rt.vecPush(kept, node, 4); } else if (_69 === 1) { const _76: rt.Weak = new rt.Weak(node); - outside.push(_76); + rt.vecPush(outside, _76, 4); node[Symbol.dispose](); } else { node[Symbol.dispose](); @@ -465,13 +465,13 @@ export function uniqueArcs(data: rt.ByteSlice, out: rt.ByteVec): void { const _24: rt.u8 = rt.u8Rem(op, 7); if (_24 === 0) { const _27: rt.Arc = new rt.Arc(op); - strong.push(_27); + rt.vecPush(strong, _27, 4); } else if (_24 === 1) { const again: rt.Arc = rt.arcClone(strong[rt.idx(strong, pick)]); - strong.push(again); + rt.vecPush(strong, again, 4); } else if (_24 === 2) { const _34: rt.Weak = new rt.Weak(strong[rt.idx(strong, pick)]); - weak.push(_34); + rt.vecPush(weak, _34, 4); } else if (_24 === 3) { if (strong.length > 1) { if ((op & 128) === 0) { @@ -631,7 +631,7 @@ export function clonedRcs(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, handles[at].strong & 0xff); if (keep) { _191 = false; - lists.push(all); + rt.vecPush(lists, all, 12); } if (_191) { rt.dropAll(all); @@ -688,7 +688,7 @@ export function clonedRcs(data: rt.ByteSlice, out: rt.ByteVec): void { break b2; } } - rt.dropAll(lists.pop()); + rt.dropAll(rt.vecPop(lists)); } } rt.byteVecPush(out, handles[rt.idx(handles, rt.usizeRem(pick, handles.length))].strong & 0xff); @@ -770,10 +770,10 @@ export function cyclicRcs(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, node.weak & 0xff); const _69: rt.u8 = op >> 6; if (_69 === 0) { - kept.push(node); + rt.vecPush(kept, node, 4); } else if (_69 === 1) { const _76: rt.Weak = new rt.Weak(node); - outside.push(_76); + rt.vecPush(outside, _76, 4); node[Symbol.dispose](); } else { node[Symbol.dispose](); @@ -806,13 +806,13 @@ export function rcs(data: rt.ByteSlice, out: rt.ByteVec): void { const _19: rt.u8 = rt.u8Rem(op, 12); if (_19 === 0) { const _22: rt.Arc = new rt.Arc(new counts_Noisy.Noisy(op, rt.arcClone(log))); - strong.push(_22); + rt.vecPush(strong, _22, 4); continue; } if (_19 === 1) { if (!((strong.length === 0))) { const again: rt.Arc = rt.arcClone(strong[rt.idx(strong, rt.usizeRem(pick, strong.length))]); - strong.push(again); + rt.vecPush(strong, again, 4); continue; } } else if (_19 === 2) { @@ -836,13 +836,13 @@ export function rcs(data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_19 === 3) { if (!((strong.length === 0))) { const _62: rt.Weak = new rt.Weak(strong[rt.idx(strong, rt.usizeRem(pick, strong.length))]); - weak.push(_62); + rt.vecPush(weak, _62, 4); continue; } } else if (_19 === 4) { if (!((weak.length === 0))) { const again2: rt.Weak = rt.weakClone(weak[rt.idx(weak, rt.usizeRem(pick, weak.length))]); - weak.push(again2); + rt.vecPush(weak, again2, 4); continue; } } else if (_19 === 5) { @@ -859,13 +859,13 @@ export function rcs(data: rt.ByteSlice, out: rt.ByteVec): void { } const up: rt.Arc = _90; rt.byteVecPush(out, up.value.id); - strong.push(up); + rt.vecPush(strong, up, 4); continue; } } else { if (_19 === 7) { const _106: rt.Weak = new rt.Weak(); - weak.push(_106); + rt.vecPush(weak, _106, 4); continue; } if (_19 === 8) { @@ -1000,13 +1000,13 @@ export function uniqueRcs(data: rt.ByteSlice, out: rt.ByteVec): void { const _24: rt.u8 = rt.u8Rem(op, 7); if (_24 === 0) { const _27: rt.Arc = new rt.Arc(op); - strong.push(_27); + rt.vecPush(strong, _27, 4); } else if (_24 === 1) { const again: rt.Arc = rt.arcClone(strong[rt.idx(strong, pick)]); - strong.push(again); + rt.vecPush(strong, again, 4); } else if (_24 === 2) { const _34: rt.Weak = new rt.Weak(strong[rt.idx(strong, pick)]); - weak.push(_34); + rt.vecPush(weak, _34, 4); } else if (_24 === 3) { if (strong.length > 1) { if ((op & 128) === 0) { diff --git a/ts/fixtures/lang/expected/cows.ts b/ts/fixtures/lang/expected/cows.ts index cfbfab9ce..eeb45d30d 100644 --- a/ts/fixtures/lang/expected/cows.ts +++ b/ts/fixtures/lang/expected/cows.ts @@ -239,7 +239,7 @@ export function slices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let c2: rt.Cow = cowOf(v, owned); const owned4 = rt.cowIntoOwned(c2); c2 = owned4; - owned4.push(7); + rt.vecPush(owned4, 7, 2); const owned5 = rt.cowIntoOwned(c2); c2 = owned5; const m: rt.u16[] = owned5; @@ -247,7 +247,7 @@ export function slices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (_119 !== undefined) { _119.v = _119.v ^ 65535; } - m.push(9); + rt.vecPush(m, 9, 2); putWords(out, rt.cowSlice(c2)); putWords(out, v); const cs: rt.Cow[] = [cowOf(half, owned), cowOf(v, !owned)]; @@ -314,7 +314,7 @@ export function slices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { putWords(out, c3 as rt.u16[]); } if (!(c3 instanceof rt.Borrowed)) { - (c3 as rt.u16[]).push(5); + rt.vecPush(c3 as rt.u16[], 5, 2); } putWords(out, rt.cowSlice(c3)); const kept: rt.Cow = rt.cowClone(c3); @@ -424,12 +424,12 @@ export function slices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _506: rt.Place> = rt.place(() => c4, (value2) => c4 = value2); const owned2 = rt.cowIntoOwned(_506.v, cows_Tally.clone$Clone); _506.v = owned2; - rt.drop(owned2.pop()); + rt.drop(rt.vecPop(owned2)); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.cellReplace(log, 0)))); const _515: rt.Place> = rt.place(() => c4, (value3) => c4 = value3); const owned3 = rt.cowIntoOwned(_515.v, cows_Tally.clone$Clone); _515.v = owned3; - owned3.push(new cows_Tally.Tally(9, log)); + rt.vecPush(owned3, new cows_Tally.Tally(9, log), 8); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.cellReplace(log, 0)))); const _524: rt.Place> = rt.place(() => c4, (value4) => c4 = value4); if (!(_524.v instanceof rt.Borrowed)) { diff --git a/ts/fixtures/lang/expected/cycles.ts b/ts/fixtures/lang/expected/cycles.ts index 3f2e05d0d..b87c7ad48 100644 --- a/ts/fixtures/lang/expected/cycles.ts +++ b/ts/fixtures/lang/expected/cycles.ts @@ -975,7 +975,7 @@ export function cycles(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return _22[0] ^ _22[1]; }), "next"); rt.iterExtendBytes(out, rt.iterTake(rt.iterStepBy(rt.iterSkip(rt.iterCycle(new rt.RangeInclusive(1, 3, rt.u8Step)), n), 2), m), "next"); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterTake(rt.iterCycle(rt.iterSlice(rt.byteSliceView(data))), m), "next"))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterTake(rt.iterCycle(rt.iterSlice(rt.byteSliceView(data))), m), "next")), undefined, true); rt.byteVecPush(out, rt.iterAny(rt.iterTake(rt.iterCycle(rt.iterSlice(rt.byteSliceView(data))), m), (_23: rt.u8): boolean => { return _23 === 7; }) ? 1 : 0); diff --git a/ts/fixtures/lang/expected/dyns.ts b/ts/fixtures/lang/expected/dyns.ts index 9551722b0..4c98de661 100644 --- a/ts/fixtures/lang/expected/dyns.ts +++ b/ts/fixtures/lang/expected/dyns.ts @@ -117,7 +117,7 @@ export function dyns(data: rt.ByteSlice, out: rt.ByteVec): void { const i: rt.usize = _94[0]; const x: rt.u8 = _94[1]; const _101: dyns_Named.Named = make(rt.u8WrappingAdd(x, i & 0xff), x); - shapes.push(_101); + rt.vecPush(shapes, _101, 8); } const _106: rt.usize = shapes.length; let iterStart: rt.usize = 0; @@ -469,7 +469,7 @@ export function anys(data: rt.ByteSlice, out: rt.ByteVec): void { } else { _237 = new Any.of$dyns_Square({ side: i & 0xffff }); } - boxes.push(_237); + rt.vecPush(boxes, _237, 8); } const kept: Any.Any[] = []; const iter5: rt.Iter<[rt.usize, Any.Any]> = rt.iterEnumerate(rt.iterSlice(boxes, rt.drop)); @@ -500,7 +500,7 @@ export function anys(data: rt.ByteSlice, out: rt.ByteVec): void { rt.drop(other3); } } else { - kept.push(_261.error); + rt.vecPush(kept, _261.error, 8); } } rt.drop(iter5); @@ -610,7 +610,7 @@ export function fns(data: rt.ByteSlice, out: rt.ByteVec): void { const _94: (a0: rt.u8) => rt.u8 = (x3: rt.u8): rt.u8 => { return rt.u8WrappingAdd(twice(halve, x3), captured); }; - fs.push(_94); + rt.vecPush(fs, _94, 8); rt.sliceSwap(fs, 0, rt.usizeRem(b as rt.usize, fs.length)); let captured2: rt.u8 = 0; const hook: Hook.Hook = new Hook.Hook((x4: rt.u8): rt.u32 => { @@ -645,7 +645,7 @@ export function fns(data: rt.ByteSlice, out: rt.ByteVec): void { }))(b); const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(part6), f, rt.u8Debug)]; fmt_put(out, rt.fmtFormat([args12[0], " "])); - const part7 = rt.once(rt.optionUnwrap(fs.pop()))(a); + const part7 = rt.once(rt.optionUnwrap(rt.vecPop(fs)))(a); const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(part7, f)]; fmt_put(out, rt.fmtFormat([args14[0], " "])); const captured4 = b; diff --git a/ts/fixtures/lang/expected/edits.ts b/ts/fixtures/lang/expected/edits.ts index 7579ae0b4..d053a56cd 100644 --- a/ts/fixtures/lang/expected/edits.ts +++ b/ts/fixtures/lang/expected/edits.ts @@ -51,7 +51,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const seen: rt.u16[] = []; rt.vecRetain(v, (_227: rt.u16): boolean => { const x4: rt.u16 = _227; - seen.push(x4); + rt.vecPush(seen, x4, 2); return rt.u16Rem(x4, 4) !== 0; }); putU16s(out, seen); @@ -132,8 +132,8 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }), undefined, 16, true); const seen2: rt.u16[] = []; rt.vecDedupBy(tested, (a3: edits_Named.Named, b10: edits_Named.Named): boolean => { - seen2.push(a3.id); - seen2.push(b10.id); + rt.vecPush(seen2, a3.id, 2); + rt.vecPush(seen2, b10.id, 2); return a3.name === b10.name; }); putU16s(out, seen2); @@ -250,7 +250,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, !rt.eqSlice(edits_Named.eq$cmp_PartialEq)(changed, named2) ? 1 : 0); rt.byteVecPush(out, rt.cmpSlice(edits_Named.partialCmp$cmp_PartialOrd)(changed, named2) === -1 ? 1 : 0); const _435: edits_Named.Named[] = rt.sliceRange(named2, 0, rt.usizeDiv(named2.length, 2)); - rt.vecExtendFromSlice(changed, _435, edits_Named.clone$Clone); + rt.vecExtendFromSlice(changed, _435, edits_Named.clone$Clone, 16); rt.byteVecPush(out, changed.length & 0xff); const nested: rt.u16[][] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): rt.u16[] => { const b5: rt.u8 = _29; @@ -272,7 +272,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _491: [rt.u8, rt.u8] = [at(1), at(0)]; rt.byteVecPush(out, rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])(_483, _491) === -1 ? 1 : 0); const grown: rt.u16[] = words.slice(); - rt.vecExtendFromSlice(grown, words); + rt.vecExtendFromSlice(grown, words, undefined, 2); putU16s(out, grown); } else if (_8 === 5) { let tally: edits_Tally.Tally = { n: at(0), names: [text(data)] }; @@ -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), 2) as rt.VecDeque; const default_2 = rt.dequeNew() as rt.VecDeque; const taken4 = queue; queue = default_2; @@ -316,7 +315,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }), undefined, 16, true); const _615: rt.usize = rt.usizeRem(at(0) as rt.usize, 8); const _621: edits_Named.Named = _604(511); - rt.vecInsert(v7, _615, _621); + rt.vecInsert(v7, _615, _621, 16); putU16s(out, _605(v7)); const _634: rt.usize = rt.usizeRem(at(1) as rt.usize, 8); const removed: edits_Named.Named = rt.vecRemove(v7, _634); diff --git a/ts/fixtures/lang/expected/errors.ts b/ts/fixtures/lang/expected/errors.ts index deedeaf61..a5e055840 100644 --- a/ts/fixtures/lang/expected/errors.ts +++ b/ts/fixtures/lang/expected/errors.ts @@ -437,9 +437,9 @@ export function eqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { 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(); - all.push(input); + rt.vecPush(all, input, 8); 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(); - bytes.push(data); + rt.vecPush(bytes, data, 8); const _32: rt.u8 = rt.u8Rem(kind, 15); if (_32 === 0) { pairs$Result_bool_str_ParseBoolError(parsed$bool(all), out); diff --git a/ts/fixtures/lang/expected/fmt.ts b/ts/fixtures/lang/expected/fmt.ts index 48bad6993..16bfec30b 100644 --- a/ts/fixtures/lang/expected/fmt.ts +++ b/ts/fixtures/lang/expected/fmt.ts @@ -727,15 +727,15 @@ 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) { const _15: rt.u8 | undefined = thenSome$0d5am30(rt.u8Rem(b, 3) !== 0, b); - rt.dequePushBack(q, _15); + rt.dequePushBack(q, _15, 2); } else if (_12 === 1) { const _20: rt.u8 | undefined = thenSome$0d5am30(rt.u8Rem(b, 3) !== 0, b); - rt.dequePushFront(q, _20); + rt.dequePushFront(q, _20, 2); } else if (_12 === 2) { rt.dequePopBack(q, rt.None); } else { @@ -744,12 +744,12 @@ 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); + rt.dequePushFront(wrapped, _48, 4); const _57: Hex.Hex = { _0: at(1) as rt.u32 }; - rt.dequePushFront(wrapped, _57); + rt.dequePushFront(wrapped, _57, 4); rt.dequePopBack(wrapped); const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.dequeIter(wrapped), f, (value: Hex.Hex, f: rt.Formatter) => Hex.fmt$fmt_Debug(value, f))]; const mid: string = rt.fmtFormat([args4[0]]); @@ -757,14 +757,10 @@ 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), 0) as rt.VecDeque; const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.dequeIter(empty), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.dequeIter(units), f, rt.fmtUnit)]; put(out, rt.fmtFormat([args8[0], "|", rt.fmtSpec({ alternate: true }, args8[0]), "|", args8[1]])); - const _114: rt.VecDeque = rt.dequeNew() as rt.VecDeque; - const _116: fmt_Pair.Pair[] = [{ _0: at(3), _1: -1 }, { _0: 2, _1: 3 }]; - const _113: rt.VecDeque[] = [_114, rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_116), undefined, 16, true)]; - const part = rt.dequeExtend(rt.dequeNew() as rt.VecDeque>, rt.iterSlice(_113), undefined, 16, true); + const part = rt.dequeFromVec([rt.dequeNew() as rt.VecDeque, rt.dequeFromVec([{ _0: at(3), _1: -1 }, { _0: 2, _1: 3 }], 16) as rt.VecDeque], 16) as rt.VecDeque>; const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.dequeIter(part), f, (value: rt.VecDeque, f: rt.Formatter) => rt.fmtList(rt.dequeIter(value), f, (value: fmt_Pair.Pair, f: rt.Formatter) => fmt_Pair.fmt$fmt_Debug(value, f)))]; put(out, rt.fmtFormat([args10[0], "|", rt.fmtSpec({ alternate: true }, args10[0])])); const _135: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): rt.u8 | undefined => { @@ -784,7 +780,7 @@ export function collections(data: rt.ByteSlice, out: rt.ByteVec): void { const b2: rt.u8 = _154; rt.dequePushFront(rt.entryOrInsertWith(rt.entry(map, rt.u8Rem(b2, 4)), (): rt.VecDeque => { return rt.dequeNew() as rt.VecDeque; - }), { _0: b2, _1: rt.i64Neg(b2 as rt.i64) }); + }), { _0: b2, _1: rt.i64Neg(b2 as rt.i64) }, 16); } const _176: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; const _178: rt.BTreeSet = rt.btreeNew(rt.cmp) as rt.BTreeSet; @@ -1008,7 +1004,7 @@ export function iters(data: rt.ByteSlice, out: rt.ByteVec): void { }), undefined, 16, true)), front, back); const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part3, f, (value: fmt_Pair.Pair, f: rt.Formatter) => fmt_Pair.fmt$fmt_Debug(value, f), ["IntoIter"])]; put(out, rt.fmtFormat([args6[0], "|", rt.fmtSpec({ alternate: true }, args6[0])])); - const part4 = ends$iters_vec_IntoIter_u8(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(data))), front, back); + const part4 = ends$iters_vec_IntoIter_u8(rt.byteVecIntoIter(rt.byteSliceToByteVec(data)), front, back); const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part4, f, rt.u8Debug, ["IntoIter"])]; put(out, rt.fmtFormat([rt.fmtSpec({ debugHex: "x" }, args8[0])])); const it4: rt.Iter = ends$iters_vec_Drain_fmt_Hex(rt.vecDrain(rt.iterToArray(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 5), (_23: rt.u8): Hex.Hex => { @@ -1037,7 +1033,7 @@ export function iters(data: rt.ByteSlice, out: rt.ByteVec): void { put(out, rt.fmtFormat([args16[0]])); const _165: Array = []; const _174: rt.Iter = rt.iterSlice(_165); - const _176: rt.Iter = rt.iterSlice(rt.byteVecView(new rt.ByteVec())); + const _176: rt.Iter = rt.byteVecIntoIter(new rt.ByteVec()); const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(_174, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), ["Iter"]), (f: rt.Formatter) => rt.fmtIter(_176, f, rt.u8Debug, ["IntoIter"])]; put(out, rt.fmtFormat([args18[0], "|", rt.fmtSpec({ alternate: true }, args18[1])])); const heap: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterSlice(rt.byteSliceView(data)), undefined, 1, true), rt.le, rt.ge, rt.lt); @@ -1051,11 +1047,10 @@ export function iters(data: rt.ByteSlice, out: rt.ByteVec): void { const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(it8, f, rt.u8Debug, [["Drain", "iter"], "Drain"])]; put(out, rt.fmtFormat([args24[0], "|", rt.fmtSpec({ alternate: true }, args24[0])])); rt.drop(it8); - const _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), 2) as rt.VecDeque), front, back); const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part9, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), ["IntoIter"])]; put(out, rt.fmtFormat([args26[0], "|", rt.fmtSpec({ alternate: true }, args26[0])])); const text: string = rt.stringExtendChars("", rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_28: rt.u8): rt.char => { diff --git a/ts/fixtures/lang/expected/generics.ts b/ts/fixtures/lang/expected/generics.ts index 92cdcd688..38d78e7c6 100644 --- a/ts/fixtures/lang/expected/generics.ts +++ b/ts/fixtures/lang/expected/generics.ts @@ -61,7 +61,7 @@ export function methods(data: rt.ByteSlice, out: rt.ByteVec): void { const _168: rt.u16[] = []; const list: Wrap.Wrap = new Wrap.Wrap(_168, 1); const _171: rt.u16 = at(10) as rt.u16; - list.value.push(_171); + rt.vecPush(list.value, _171, 2); Wrap.bump$Vec_u16(list); const none: Wrap.Wrap = new Wrap.Wrap(undefined, 0); const some: Wrap.Wrap = Wrap.new$Option_u8(rt.byteSliceGet(data, 11)); diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 6c513a9eb..79f567f65 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -7,12 +7,13 @@ import { atomics } from "./atomics.ts"; import { borrows as borrows_borrows } from "./borrows.ts"; import { bounds as bounds_bounds } from "./bounds.ts"; import { boxes } 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"; @@ -95,11 +96,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 => { @@ -238,7 +239,7 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) reattached(data86, out87); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::part_written", (_2187: rt.u8, data87: rt.ByteSlice, out88: rt.ByteVec): undefined => { partWritten(data87, out88); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::flattened", arrays_flattened as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::flattened", arrays_flattened as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["capacity::vecs", capacity_vecs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["capacity::deques", capacity_deques as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["capacity::heaps", capacity_heaps as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] 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..52934a9a7 100644 --- a/ts/fixtures/lang/expected/hints.ts +++ b/ts/fixtures/lang/expected/hints.ts @@ -1961,7 +1961,7 @@ export function hints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (_312 === 0) { walk$slice_Iter_u8(rt.iterSlice(rt.byteSliceView(bytes)), steps, out); } else if (_312 === 1) { - walk$vec_IntoIter_u8(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(bytes))), steps, out); + walk$vec_IntoIter_u8(rt.byteVecIntoIter(rt.byteSliceToByteVec(bytes)), steps, out); } else if (_312 === 2) { walk$array_IntoIter_u8_3(rt.iterSlice(Uint8Array.of(at(3), at(4), at(5))), steps, out); } else if (_312 === 3) { @@ -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), 1) 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); @@ -2620,20 +2619,19 @@ export function fill$array275_u32_iter_Filter_iter_Map_ops_RangeInclusive_u32_hi rt.iterExtend(v, items, "next", 1100); len = v.length; } else if (coll === 2) { - const v2: rt.u32[][] = rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32); + const v2: rt.u32[][] = rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32, 1100); 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), 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, 1100), 1100) as rt.VecDeque; rt.dequeExtend(q, items, "next", 1100); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32, 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); rt.heapExtend(h, items, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp)), "next", 1100); len = h.d.length; } else if (coll === 7) { @@ -2691,20 +2689,19 @@ export function fill$array275_u32_iter_Map_iter_Flatten_array_IntoIter_ops_Range rt.iterExtend(v, items, "next", 1100); len = v.length; } else if (coll === 2) { - const v2: rt.u32[][] = rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32); + const v2: rt.u32[][] = rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32, 1100); 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), 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, 1100), 1100) as rt.VecDeque; rt.dequeExtend(q, items, "next", 1100); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32, 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); rt.heapExtend(h, items, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp)), "next", 1100); len = h.d.length; } else if (coll === 7) { @@ -2762,20 +2759,19 @@ export function fill$array275_u32_iter_Map_iter_Flatten_array_IntoIter_ops_Range rt.iterExtend(v, items, "next", 1100); len = v.length; } else if (coll === 2) { - const v2: rt.u32[][] = rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32); + const v2: rt.u32[][] = rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32, 1100); 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), 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, 1100), 1100) as rt.VecDeque; rt.dequeExtend(q, items, "next", 1100); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32, 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); rt.heapExtend(h, items, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp)), "next", 1100); len = h.d.length; } else if (coll === 7) { @@ -2833,20 +2829,19 @@ export function fill$array275_u32_iter_Map_ops_RangeInclusive_u32_hints_typed_cl rt.iterExtend(v, items, undefined, 1100, true); len = v.length; } else if (coll === 2) { - const v2: rt.u32[][] = rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32); + const v2: rt.u32[][] = rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32, 1100); 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), 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, 1100), 1100) as rt.VecDeque; rt.dequeExtend(q, items, undefined, 1100, true); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, undefined, 1100, true), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32, 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); rt.heapExtend(h, items, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp)), undefined, 1100, true); len = h.d.length; } else if (coll === 7) { @@ -2904,20 +2899,19 @@ export function fill$array275_u32_iter_Skip_iter_Map_ops_RangeInclusive_u32_hint rt.iterExtend(v, items, "next", 1100); len = v.length; } else if (coll === 2) { - const v2: rt.u32[][] = rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32); + const v2: rt.u32[][] = rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32, 1100); 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), 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, 1100), 1100) as rt.VecDeque; rt.dequeExtend(q, items, "next", 1100); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32, 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); rt.heapExtend(h, items, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp)), "next", 1100); len = h.d.length; } else if (coll === 7) { @@ -2974,20 +2968,19 @@ export function fill$hints_Unit_iter_Filter_iter_Map_ops_RangeInclusive_u32_hint rt.iterExtend(v, items, "next", 0); len = v.length; } else if (coll === 2) { - const v2: hints_Unit.Unit[] = rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone); + const v2: hints_Unit.Unit[] = rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone, 0); 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), 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, 0), 0) as rt.VecDeque; rt.dequeExtend(q, items, "next", 0); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 0), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone, 0), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)); rt.heapExtend(h, items, rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd), "next", 0); len = h.d.length; } else if (coll === 7) { @@ -3044,20 +3037,19 @@ export function fill$hints_Unit_iter_Map_iter_Flatten_array_IntoIter_ops_RangeIn rt.iterExtend(v, items, "next", 0); len = v.length; } else if (coll === 2) { - const v2: hints_Unit.Unit[] = rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone); + const v2: hints_Unit.Unit[] = rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone, 0); 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), 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, 0), 0) as rt.VecDeque; rt.dequeExtend(q, items, "next", 0); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 0), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone, 0), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)); rt.heapExtend(h, items, rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd), "next", 0); len = h.d.length; } else if (coll === 7) { @@ -3114,20 +3106,19 @@ export function fill$hints_Unit_iter_Map_iter_Flatten_array_IntoIter_ops_RangeIn rt.iterExtend(v, items, "next", 0); len = v.length; } else if (coll === 2) { - const v2: hints_Unit.Unit[] = rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone); + const v2: hints_Unit.Unit[] = rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone, 0); 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), 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, 0), 0) as rt.VecDeque; rt.dequeExtend(q, items, "next", 0); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 0), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone, 0), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)); rt.heapExtend(h, items, rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd), "next", 0); len = h.d.length; } else if (coll === 7) { @@ -3184,20 +3175,19 @@ export function fill$hints_Unit_iter_Map_ops_RangeInclusive_u32_hints_typed_clos rt.iterExtend(v, items, undefined, 0, true); len = v.length; } else if (coll === 2) { - const v2: hints_Unit.Unit[] = rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone); + const v2: hints_Unit.Unit[] = rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone, 0); 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), 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, 0), 0) as rt.VecDeque; rt.dequeExtend(q, items, undefined, 0, true); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, undefined, 0, true), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone, 0), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)); rt.heapExtend(h, items, rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd), undefined, 0, true); len = h.d.length; } else if (coll === 7) { @@ -3254,20 +3244,19 @@ export function fill$hints_Unit_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_ rt.iterExtend(v, items, "next", 0); len = v.length; } else if (coll === 2) { - const v2: hints_Unit.Unit[] = rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone); + const v2: hints_Unit.Unit[] = rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone, 0); 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), 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, 0), 0) as rt.VecDeque; rt.dequeExtend(q, items, "next", 0); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 0), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone, 0), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)); rt.heapExtend(h, items, rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd), "next", 0); len = h.d.length; } else if (coll === 7) { @@ -3324,20 +3313,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(seed, 2, undefined, 16); 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), 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(seed, 2, undefined, 16), 16) 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(seed, 2, undefined, 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]))); 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) { @@ -3394,20 +3382,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(seed, 2, undefined, 16); 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), 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(seed, 2, undefined, 16), 16) 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(seed, 2, undefined, 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]))); 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) { @@ -3464,20 +3451,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(seed, 2, undefined, 16); 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), 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(seed, 2, undefined, 16), 16) 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(seed, 2, undefined, 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]))); 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) { @@ -3534,20 +3520,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(seed, 2, undefined, 16); 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), 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(seed, 2, undefined, 16), 16) 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(seed, 2, undefined, 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]))); 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) { @@ -3604,20 +3589,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(seed, 2, undefined, 16); 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), 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(seed, 2, undefined, 16), 16) 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(seed, 2, undefined, 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]))); 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) { @@ -3674,20 +3658,19 @@ export function fill$tuple3_u8_u8_u8_iter_Filter_iter_Map_ops_RangeInclusive_u32 rt.iterExtend(v, items, "next", 3); len = v.length; } else if (coll === 2) { - const v2: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + const v2: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined, 3); 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), 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, 3), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; rt.dequeExtend(q, items, "next", 3); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))); + const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined, 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))); rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), "next", 3); len = h.d.length; } else if (coll === 7) { @@ -3744,20 +3727,19 @@ export function fill$tuple3_u8_u8_u8_iter_Map_iter_Flatten_array_IntoIter_ops_Ra rt.iterExtend(v, items, "next", 3); len = v.length; } else if (coll === 2) { - const v2: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + const v2: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined, 3); 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), 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, 3), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; rt.dequeExtend(q, items, "next", 3); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))); + const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined, 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))); rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), "next", 3); len = h.d.length; } else if (coll === 7) { @@ -3814,20 +3796,19 @@ export function fill$tuple3_u8_u8_u8_iter_Map_iter_Flatten_array_IntoIter_ops_Ra rt.iterExtend(v, items, "next", 3); len = v.length; } else if (coll === 2) { - const v2: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + const v2: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined, 3); 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), 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, 3), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; rt.dequeExtend(q, items, "next", 3); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))); + const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined, 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))); rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), "next", 3); len = h.d.length; } else if (coll === 7) { @@ -3884,20 +3865,19 @@ export function fill$tuple3_u8_u8_u8_iter_Map_ops_RangeInclusive_u32_hints_typed rt.iterExtend(v, items, undefined, 3, true); len = v.length; } else if (coll === 2) { - const v2: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + const v2: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined, 3); 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), 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, 3), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; rt.dequeExtend(q, items, undefined, 3, true); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, undefined, 3, true), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))); + const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined, 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))); rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), undefined, 3, true); len = h.d.length; } else if (coll === 7) { @@ -3954,20 +3934,19 @@ export function fill$tuple3_u8_u8_u8_iter_Skip_iter_Map_ops_RangeInclusive_u32_h rt.iterExtend(v, items, "next", 3); len = v.length; } else if (coll === 2) { - const v2: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + const v2: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined, 3); 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), 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, 3), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; rt.dequeExtend(q, items, "next", 3); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))); + const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined, 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))); rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), "next", 3); len = h.d.length; } else if (coll === 7) { @@ -4024,20 +4003,19 @@ export function fill$u32_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed rt.iterExtend(v, items, "next", 4); len = v.length; } else if (coll === 2) { - const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined); + const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined, 4); 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), 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, 4), 4) as rt.VecDeque; rt.dequeExtend(q, items, "next", 4); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 4), rt.le, rt.ge, rt.lt).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.le, rt.ge, rt.lt); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined, 4), rt.le, rt.ge, rt.lt); rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 4); len = h.d.length; } else if (coll === 7) { @@ -4094,20 +4072,19 @@ export function fill$u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive rt.iterExtend(v, items, "next", 4); len = v.length; } else if (coll === 2) { - const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined); + const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined, 4); 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), 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, 4), 4) as rt.VecDeque; rt.dequeExtend(q, items, "next", 4); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 4), rt.le, rt.ge, rt.lt).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.le, rt.ge, rt.lt); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined, 4), rt.le, rt.ge, rt.lt); rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 4); len = h.d.length; } else if (coll === 7) { @@ -4164,20 +4141,19 @@ export function fill$u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive rt.iterExtend(v, items, "next", 4); len = v.length; } else if (coll === 2) { - const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined); + const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined, 4); 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), 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, 4), 4) as rt.VecDeque; rt.dequeExtend(q, items, "next", 4); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 4), rt.le, rt.ge, rt.lt).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.le, rt.ge, rt.lt); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined, 4), rt.le, rt.ge, rt.lt); rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 4); len = h.d.length; } else if (coll === 7) { @@ -4234,20 +4210,19 @@ export function fill$u32_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u3 rt.iterExtend(v, items, undefined, 4, true); len = v.length; } else if (coll === 2) { - const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined); + const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined, 4); 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), 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, 4), 4) as rt.VecDeque; rt.dequeExtend(q, items, undefined, 4, true); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, undefined, 4, true), rt.le, rt.ge, rt.lt).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.le, rt.ge, rt.lt); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined, 4), rt.le, rt.ge, rt.lt); rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, undefined, 4, true); len = h.d.length; } else if (coll === 7) { @@ -4304,20 +4279,19 @@ export function fill$u32_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_c rt.iterExtend(v, items, "next", 4); len = v.length; } else if (coll === 2) { - const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined); + const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined, 4); 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), 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, 4), 4) as rt.VecDeque; rt.dequeExtend(q, items, "next", 4); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 4), rt.le, rt.ge, rt.lt).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.le, rt.ge, rt.lt); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined, 4), rt.le, rt.ge, rt.lt); rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 4); len = h.d.length; } else if (coll === 7) { @@ -4378,16 +4352,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), 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)), 1) 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 +4421,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), 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)), 1) 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 +4490,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), 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)), 1) 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 +4559,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), 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)), 1) 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 +4628,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), 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)), 1) 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/holds.ts b/ts/fixtures/lang/expected/holds.ts index 1d231e71e..17e1e4996 100644 --- a/ts/fixtures/lang/expected/holds.ts +++ b/ts/fixtures/lang/expected/holds.ts @@ -112,7 +112,7 @@ export function indexed(data: rt.ByteSlice, out: rt.ByteVec): void { rt.idx(data, _9); i = rt.usizeAdd(i, 1); rt.byteVecPush(out, data.data[data.start + _9]); - kept.push(data.data[data.start + _9]); + rt.vecPush(kept, data.data[data.start + _9], 4); } rt.iterExtendBytes(out, rt.iterSlice(kept), undefined, true); const v: rt.ByteVec = rt.byteSliceToByteVec(data); @@ -123,7 +123,7 @@ export function indexed(data: rt.ByteSlice, out: rt.ByteVec): void { const _31: rt.u8 = rt.u8WrappingAdd(v.data[at], i2 & 0xff); v.data[at] = _31; } - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); } /** @@ -145,7 +145,7 @@ export function reborrows(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVe const s2: rt.u8 = r2; r2 = _25; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(s2, r2)), undefined, true); - kept.push(s2); + rt.vecPush(kept, s2, 4); } rt.iterExtendBytes(out, rt.iterSlice(kept), undefined, true); } @@ -160,7 +160,7 @@ export function copies(a: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { for (const _9 of rt.byteSliceView(data)) { const s: rt.u8 = r; r = _9; - kept.push(s); + rt.vecPush(kept, s, 4); } rt.iterExtendBytes(out, rt.iterSlice(kept), undefined, true); const range: rt.Range = new rt.Range(0, data.length); @@ -198,9 +198,9 @@ export function closures(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec const v: rt.ByteVec = rt.byteSliceToByteVec(data); const fs: Array<() => rt.u8> = []; for (const _17 of rt.byteSliceView(data)) { - fs.push((): rt.u8 => { + rt.vecPush(fs, (): rt.u8 => { return _17; - }); + }, 8); } const _28: rt.usize = v.length; let iterStart: rt.usize = 0; @@ -210,7 +210,7 @@ export function closures(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec const _39: () => rt.u8 = (): rt.u8 => { return rt.u8WrappingAdd(v.data[at], 1); }; - fs.push(_39); + rt.vecPush(fs, _39, 8); } const _43: rt.usize = rt.byteSliceFrom(arr).length; let rangeStart: rt.usize = 0; @@ -220,9 +220,9 @@ export function closures(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec if (!(i2 < 8)) { rt.panic("index out of bounds: the len is " + 8 + " but the index is " + i2); } - fs.push((): rt.u8 => { + rt.vecPush(fs, (): rt.u8 => { return arr[i2]; - }); + }, 8); } const iter3: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); while (true) { @@ -234,7 +234,7 @@ export function closures(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec const _68: () => rt.u8 = (): rt.u8 => { return rt.u8WrappingAdd(_61[1], captured & 0xff); }; - fs.push(_68); + rt.vecPush(fs, _68, 8); } const itS: Row.Row[] = rows; let itI: number = 0; @@ -242,9 +242,9 @@ export function closures(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec const _74: Row.Row | rt.Done = itI < itS.length ? itS[itI++] : rt.DONE; if (_74 !== rt.DONE) { const cells: rt.ByteSlice = rt.byteSliceFrom(_74.cells); - fs.push((): rt.u8 => { + rt.vecPush(fs, (): rt.u8 => { return cells.data[cells.start + 1]; - }); + }, 8); } else { break; } @@ -259,9 +259,9 @@ export function closures(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _96); } const captured2 = n; - fs.push((): rt.u8 => { + rt.vecPush(fs, (): rt.u8 => { return rows[_96].cells[0] ^ captured2; - }); + }, 8); } for (const _111 of fs) { rt.byteVecPush(out, _111()); diff --git a/ts/fixtures/lang/expected/ints.ts b/ts/fixtures/lang/expected/ints.ts index ee151318e..650798a2f 100644 --- a/ts/fixtures/lang/expected/ints.ts +++ b/ts/fixtures/lang/expected/ints.ts @@ -2869,7 +2869,7 @@ export function edges(max: rt.u128, min: rt.u128, bits: rt.usize, radix: rt.u32) if (_193 === rt.DONE) { break; } - all.push(_193); + rt.vecPush(all, _193, 12); } const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCharDisplay(stray, f)]; const _203: string = rt.fmtFormat(["1", args22[0]]); diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index 31b176778..109506c23 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -169,10 +169,10 @@ export function chunksByZero$iters_ChunksByZero_slice_u8(self: rt.ByteSlice): rt } else { const taken = word; word = new rt.ByteVec(); - words.push(taken); + rt.vecPush(words, taken, 12); } } - words.push(word); + rt.vecPush(words, word, 12); return words; } @@ -340,12 +340,12 @@ export function reducers(data: rt.ByteSlice, out: rt.ByteVec): void { }), 204, (v: rt.ByteVec): rt.u8 => { return v.length & 0xff; })); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(option_unwrapOrDefault$0wx44sw(rt.iterReduce(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_23: rt.u8): rt.ByteVec => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(option_unwrapOrDefault$0wx44sw(rt.iterReduce(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_23: rt.u8): rt.ByteVec => { return rt.byteVecFrom(Uint8Array.of(_23)); }), (a4: rt.ByteVec, b7: rt.ByteVec): rt.ByteVec => { - rt.iterExtendBytes(a4, rt.iterSlice(rt.byteVecView(b7)), undefined, true); + rt.iterExtendBytes(a4, rt.byteVecIntoIter(b7), undefined, true); return a4; - })))), undefined, true); + }))), undefined, true); const it: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(data))); const _38: rt.Place | undefined = rt.peekablePeekMut(it, true); if (_38 !== undefined) { @@ -367,7 +367,7 @@ export function reducers(data: rt.ByteSlice, out: rt.ByteVec): void { if (_73 !== undefined) { rt.byteVecPush(_73, 153); } - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(option_unwrapOrDefault$0wx44sw(rt.iterToOption(words.next())))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(option_unwrapOrDefault$0wx44sw(rt.iterToOption(words.next()))), undefined, true); const _87: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(first)); rt.byteVecPush(out, option_mapOr$1a3irjf(rt.peekableNextIfEq(words, _87, rt.eqBytes), 136, (w: rt.ByteVec): rt.u8 => { return w.data[rt.idx(w, 0)]; @@ -380,8 +380,8 @@ export function reducers(data: rt.ByteSlice, out: rt.ByteVec): void { if (_94 !== undefined) { _94.v = 119; } - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(log)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(bytes), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(log), undefined, true); } export function eq$cmp_PartialEq_iters_Quarter_u8(self: rt.u8, other: Quarter.Quarter): boolean { @@ -422,7 +422,7 @@ export function peekedOthers(data: rt.ByteSlice, out: rt.ByteVec): void { }); }; const _159: (a0: rt.u8) => rt.u16[] = (b2: rt.u8): rt.u16[] => { - return rt.vecFromElem((((rt.u8Rem(b2, 2) as rt.u16)) << 9) & 0xffff, rt.u8Rem(b2, 3) as rt.usize, undefined); + return rt.vecFromElem((((rt.u8Rem(b2, 2) as rt.u16)) << 9) & 0xffff, rt.u8Rem(b2, 3) as rt.usize, undefined, 2); }; const words: string[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): string => { return _3(_2); @@ -567,7 +567,7 @@ export function peekedOthers(data: rt.ByteSlice, out: rt.ByteVec): void { }), 170, (b9: rt.Place): rt.u8 => { return b9.v; })); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(bytes), undefined, true); const it11: rt.Peekable = rt.iterPeekable(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): Quarter.Quarter => { return { _0: _210, _1: calls }; })); @@ -1988,9 +1988,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2299[0] as rt.u32, _2299[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_41 === 4) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z, (_2298: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z, (_2298: [rt.u8, rt.u8]): rt.u8 => { return _2298[0] ^ _2298[1]; - }), undefined, true))), undefined, true); + }), undefined, true)), undefined, true); } else if (_41 === 5) { rt.byteVecPush(out, rt.iterFold(z, 0, (acc7: rt.u8, p20: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc7, 3) ^ _40(p20); @@ -2177,9 +2177,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2268[0] as rt.u32, _2268[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_202 === 4) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z3, (_2267: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z3, (_2267: [rt.u8, rt.u8]): rt.u8 => { return _2267[0] ^ _2267[1]; - }), undefined, true))), undefined, true); + }), undefined, true)), undefined, true); } else if (_202 === 5) { rt.byteVecPush(out, rt.iterFold(z3, 0, (acc6: rt.u8, p18: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc6, 3) ^ _201(p18); @@ -2364,9 +2364,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2237[0] as rt.u32, _2237[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_381 === 4) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z5, (_2236: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z5, (_2236: [rt.u8, rt.u8]): rt.u8 => { return _2236[0] ^ _2236[1]; - }), undefined, true))), undefined, true); + }), undefined, true)), undefined, true); } else if (_381 === 5) { rt.byteVecPush(out, rt.iterFold(z5, 0, (acc5: rt.u8, p16: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc5, 3) ^ _380(p16); @@ -2524,12 +2524,12 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_28 === 2) { if (!other) { if ((kind & 16) === 0) { - const z7: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x138: rt.u8): rt.u8 => { + const z7: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x138: rt.u8): rt.u8 => { const _6178: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6178.value, x138 ^ 7); rt.refMutRelease(_6178); return x138; - }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x139: rt.u8): rt.u8 => { + }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x139: rt.u8): rt.u8 => { const _6179: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6179.value, x139 ^ 8); rt.refMutRelease(_6179); @@ -2551,9 +2551,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2206[0] as rt.u32, _2206[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_574 === 4) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z7, (_2205: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVecInPlace(rt.iterMap(z7, (_2205: [rt.u8, rt.u8]): rt.u8 => { return _2205[0] ^ _2205[1]; - }), undefined, true))), undefined, true); + }), 1, false, undefined, true)), undefined, true); } else if (_574 === 5) { rt.byteVecPush(out, rt.iterFold(z7, 0, (acc4: rt.u8, p14: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc4, 3) ^ _573(p14); @@ -2586,12 +2586,12 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else { const _612: rt.usize = rt.usizeRem(data.length, 8); if (_612 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x135: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x135: rt.u8): rt.u8 => { const _6176: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6176.value, x135 ^ 7); rt.refMutRelease(_6176); return x135; - }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x136: rt.u8): rt.u8 => { + }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x136: rt.u8): rt.u8 => { const _6177: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6177.value, x136 ^ 8); rt.refMutRelease(_6177); @@ -2600,12 +2600,12 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u8Rem(_2198[0], 2) === 0; })) & 0xff); } else if (_612 === 1) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilterMap(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x132: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterFilterMap(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x132: rt.u8): rt.u8 => { const _6174: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6174.value, x132 ^ 7); rt.refMutRelease(_6174); return x132; - }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x133: rt.u8): rt.u8 => { + }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x133: rt.u8): rt.u8 => { const _6175: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6175.value, x133 ^ 8); rt.refMutRelease(_6175); @@ -2614,12 +2614,12 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u8CheckedSub(_2197[0], _2197[1]); })) & 0xff); } else if (_612 === 2) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkipWhile(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x129: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterSkipWhile(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x129: rt.u8): rt.u8 => { const _6172: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6172.value, x129 ^ 7); rt.refMutRelease(_6172); return x129; - }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x130: rt.u8): rt.u8 => { + }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x130: rt.u8): rt.u8 => { const _6173: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6173.value, x130 ^ 8); rt.refMutRelease(_6173); @@ -2628,12 +2628,12 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return _2196[0] < 128; })) & 0xff); } else if (_612 === 3) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(rt.iterMap(rt.iterEnumerate(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x127: rt.u8): rt.u8 => { + rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(rt.iterMap(rt.iterEnumerate(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x127: rt.u8): rt.u8 => { const _6170: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6170.value, x127 ^ 7); rt.refMutRelease(_6170); return x127; - }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x128: rt.u8): rt.u8 => { + }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x128: rt.u8): rt.u8 => { const _6171: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6171.value, x128 ^ 8); rt.refMutRelease(_6171); @@ -2642,48 +2642,48 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return _2195[0] & 0xff; })), 238)); } else if (_612 === 4) { - rt.byteVecPush(out, rt.iterCount(rt.iterChain(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x125: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterChain(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x125: rt.u8): rt.u8 => { const _6168: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6168.value, x125 ^ 7); rt.refMutRelease(_6168); return x125; - }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x126: rt.u8): rt.u8 => { + }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x126: rt.u8): rt.u8 => { const _6169: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6169.value, x126 ^ 8); rt.refMutRelease(_6169); return x126; }), "len"), rt.iterSlice([[1, 2] as [rt.u8, rt.u8]]))) & 0xff); } else if (_612 === 5) { - rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x123: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x123: rt.u8): rt.u8 => { const _6166: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6166.value, x123 ^ 7); rt.refMutRelease(_6166); return x123; - }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x124: rt.u8): rt.u8 => { + }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x124: rt.u8): rt.u8 => { const _6167: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6167.value, x124 ^ 8); rt.refMutRelease(_6167); return x124; }), "len"), n)) & 0xff); } else if (_612 === 6) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x121: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x121: rt.u8): rt.u8 => { const _6164: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6164.value, x121 ^ 7); rt.refMutRelease(_6164); return x121; - }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x122: rt.u8): rt.u8 => { + }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x122: rt.u8): rt.u8 => { const _6165: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6165.value, x122 ^ 8); rt.refMutRelease(_6165); return x122; }), "len"), n)) & 0xff); } else { - const p4: rt.Peekable<[rt.u8, rt.u8]> = rt.iterPeekable(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x119: rt.u8): rt.u8 => { + const p4: rt.Peekable<[rt.u8, rt.u8]> = rt.iterPeekable(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x119: rt.u8): rt.u8 => { const _6162: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6162.value, x119 ^ 7); rt.refMutRelease(_6162); return x119; - }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x120: rt.u8): rt.u8 => { + }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x120: rt.u8): rt.u8 => { const _6163: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6163.value, x120 ^ 8); rt.refMutRelease(_6163); @@ -2693,7 +2693,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } } else if ((kind & 16) === 0) { - const z9: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x107: rt.u8): rt.u8 => { + const z9: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x107: rt.u8): rt.u8 => { const _6158: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6158.value, x107 ^ 9); rt.refMutRelease(_6158); @@ -2721,9 +2721,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2193[0] as rt.u32, _2193[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_751 === 4) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z9, (_2192: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVecInPlace(rt.iterMap(z9, (_2192: [rt.u8, rt.u8]): rt.u8 => { return _2192[0] ^ _2192[1]; - }), undefined, true))), undefined, true); + }), 1, false, undefined, true)), undefined, true); } else if (_751 === 5) { rt.byteVecPush(out, rt.iterFold(z9, 0, (acc3: rt.u8, p12: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc3, 3) ^ _750(p12); @@ -2756,7 +2756,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else { const _789: rt.usize = rt.usizeRem(data.length, 8); if (_789 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x104: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x104: rt.u8): rt.u8 => { const _6156: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6156.value, x104 ^ 9); rt.refMutRelease(_6156); @@ -2771,7 +2771,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u8Rem(_2184[0], 2) === 0; })) & 0xff); } else if (_789 === 1) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilterMap(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x101: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterFilterMap(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x101: rt.u8): rt.u8 => { const _6154: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6154.value, x101 ^ 9); rt.refMutRelease(_6154); @@ -2786,7 +2786,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u8CheckedSub(_2182[0], _2182[1]); })) & 0xff); } else if (_789 === 2) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkipWhile(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x98: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterSkipWhile(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x98: rt.u8): rt.u8 => { const _6152: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6152.value, x98 ^ 9); rt.refMutRelease(_6152); @@ -2801,7 +2801,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return _2180[0] < 128; })) & 0xff); } else if (_789 === 3) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(rt.iterMap(rt.iterEnumerate(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x96: rt.u8): rt.u8 => { + rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(rt.iterMap(rt.iterEnumerate(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x96: rt.u8): rt.u8 => { const _6150: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6150.value, x96 ^ 9); rt.refMutRelease(_6150); @@ -2816,7 +2816,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return _2178[0] & 0xff; })), 238)); } else if (_789 === 4) { - rt.byteVecPush(out, rt.iterCount(rt.iterChain(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x94: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterChain(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x94: rt.u8): rt.u8 => { const _6148: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6148.value, x94 ^ 9); rt.refMutRelease(_6148); @@ -2829,7 +2829,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return x95; }), "len"), rt.iterSlice([[1, 2] as [rt.u8, rt.u8]]))) & 0xff); } else if (_789 === 5) { - rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x92: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x92: rt.u8): rt.u8 => { const _6146: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6146.value, x92 ^ 9); rt.refMutRelease(_6146); @@ -2842,7 +2842,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return x93; }), "len"), n)) & 0xff); } else if (_789 === 6) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x90: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x90: rt.u8): rt.u8 => { const _6144: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6144.value, x90 ^ 9); rt.refMutRelease(_6144); @@ -2855,7 +2855,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return x91; }), "len"), n)) & 0xff); } else { - const p5: rt.Peekable<[rt.u8, rt.u8]> = rt.iterPeekable(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x88: rt.u8): rt.u8 => { + const p5: rt.Peekable<[rt.u8, rt.u8]> = rt.iterPeekable(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x88: rt.u8): rt.u8 => { const _6142: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6142.value, x88 ^ 9); rt.refMutRelease(_6142); @@ -2903,9 +2903,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2171[0] as rt.u32, _2171[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_927 === 4) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z11, (_2170: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z11, (_2170: [rt.u8, rt.u8]): rt.u8 => { return _2170[0] ^ _2170[1]; - }), "next"))), undefined, true); + }), "next")), undefined, true); } else if (_927 === 5) { rt.byteVecPush(out, rt.iterFold(z11, 0, (acc2: rt.u8, p10: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc2, 3) ^ _926(p10); @@ -3114,9 +3114,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2131[0] as rt.u32, _2131[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_1102 === 4) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z13, (_2130: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z13, (_2130: [rt.u8, rt.u8]): rt.u8 => { return _2130[0] ^ _2130[1]; - }), undefined, true))), undefined, true); + }), undefined, true)), undefined, true); } else if (_1102 === 5) { rt.byteVecPush(out, rt.iterFold(z13, 0, (acc: rt.u8, p8: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc, 3) ^ _1101(p8); @@ -4608,7 +4608,7 @@ export function adapted(a: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const v: rt.ByteVec = new rt.ByteVec(); const _22: rt.Iter = rt.iterTake(new rt.RangeFrom(lo, rt.u8Step), 3); rt.iterExtendBytes(v, _22, undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.iterExtendBytes(out, rt.iterTake(rt.iterFlatten(rt.iterSlice([new rt.RangeFrom(lo, rt.u8Step), new rt.RangeFrom(rt.u8Div(b, 2), rt.u8Step)])), 5), "next"); rt.iterExtendBytes(out, rt.iterTake(rt.iterFlatMap(it(), (x: rt.u8): rt.RangeFrom => { return new rt.RangeFrom(rt.u8Div(x, 4), rt.u8Step); @@ -4623,7 +4623,7 @@ export function adapted(a: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterMap(rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _54, true, undefined, undefined, undefined, 8, true)), (_24: [rt.u8, rt.usize]): rt.u8 => { return _24[0] ^ (_24[1] & 0xff); }), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterTake(rt.iterStepBy(new rt.RangeFrom(lo, rt.u8Step), 3), 4), "next"))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterTake(rt.iterStepBy(new rt.RangeFrom(lo, rt.u8Step), 3), 4), "next")), undefined, true); rt.iterExtendBytes(out, rt.strBytes(rt.stringExtendChars("", rt.iterTake(new rt.RangeFrom(97, rt.charStep), rt.usizeRem(n, 6)))), undefined, true); const _77: [rt.usize, rt.usize | undefined] = rt.iterZip(it(), new rt.RangeFrom(lo, rt.u8Step), "len").sizeHint(); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_77[0] & 0xff, option_mapOr$02k4ito(_77[1], 238, (h: rt.usize): rt.u8 => { @@ -4689,7 +4689,7 @@ export function overflowed(a: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void return c & 0xff; })); } else { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(new rt.RangeFrom(top, rt.u8Step), undefined, true))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(new rt.RangeFrom(top, rt.u8Step), undefined, true)), undefined, true); } } diff --git a/ts/fixtures/lang/expected/joins.ts b/ts/fixtures/lang/expected/joins.ts index c77dc6bc8..5576b06a5 100644 --- a/ts/fixtures/lang/expected/joins.ts +++ b/ts/fixtures/lang/expected/joins.ts @@ -127,7 +127,7 @@ export function joins(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const boxed2: rt.u16[][] = rt.iterToArray(rt.iterMap(rt.iterMap(rt.iterSlice(wide), (a015: rt.u16[]): rt.u16[] => { return a015.slice(); }), (a016: rt.u16[]): rt.u16[] => { - return a016; + return rt.vecIntoBoxed(a016); }), undefined, 8, true); wides(rt.slicesJoin(boxed2, 2), out); wides(rt.slicesJoin(boxed2, 2, [sep2]), out); @@ -235,10 +235,10 @@ export function joins(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.strsJoin(texts, "--")); } else { const big: rt.ByteVec = rt.byteVecOf(1, 1 << 16); - const wide4: rt.u16[] = rt.vecFromElem(1, 1 << 16, undefined); + const wide4: rt.u16[] = rt.vecFromElem(1, 1 << 16, undefined, 2); const text_: string = text(rt.byteVecSlice(big)); const refs: (a0: rt.usize) => rt.ByteSlice[] = (n: rt.usize): rt.ByteSlice[] => { - return rt.vecFromElem(rt.byteSliceRange(rt.byteVecSlice(big), 0), n, undefined); + return rt.vecFromElem(rt.byteSliceRange(rt.byteVecSlice(big), 0), n, undefined, 8); }; const _512: rt.u8 = rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0), 7); if (_512 === 0) { @@ -248,17 +248,17 @@ export function joins(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_512 === 2) { bytes(rt.byteSlicesJoin(refs(rt.usizeAdd(1 << 14, 1)), rt.byteSliceRange(rt.byteVecSlice(big), 0)), out); } else if (_512 === 3) { - wides(rt.slicesJoin(rt.vecFromElem(rt.sliceRange(wide4, 0), rt.usizeAdd(1 << 14, 1), undefined), 2), out); + wides(rt.slicesJoin(rt.vecFromElem(rt.sliceRange(wide4, 0), rt.usizeAdd(1 << 14, 1), undefined, 8), 2), out); } else if (_512 === 4) { - fmt_put(out, rt.strsJoin(rt.vecFromElem(text_, rt.usizeAdd(1 << 15, 1), undefined), "")); + fmt_put(out, rt.strsJoin(rt.vecFromElem(text_, rt.usizeAdd(1 << 15, 1), undefined, 8), "")); } else if (_512 === 5) { - fmt_put(out, rt.strsJoin(rt.vecFromElem(text_, rt.usizeAdd(1 << 16, 1), undefined), "")); + fmt_put(out, rt.strsJoin(rt.vecFromElem(text_, rt.usizeAdd(1 << 16, 1), undefined, 8), "")); } else { const sep5: Sentinel.Sentinel[] = rt.iterToArray(rt.iterMap(new rt.Range(0, 1 << 16), (i: rt.i32): Sentinel.Sentinel => { return { _0: (i & 0xff) ^ 90 }; }), undefined, 1, true); const _597: Sentinel.Sentinel[] = []; - rt.slicesJoin(rt.vecFromElem(_597, rt.usizeAdd(1 << 16, 1), undefined), 1, rt.sliceRange(sep5, 0), undefined, Sentinel.clone$Clone); + rt.slicesJoin(rt.vecFromElem(_597, rt.usizeAdd(1 << 16, 1), undefined, 8), 1, rt.sliceRange(sep5, 0), undefined, Sentinel.clone$Clone); } } } diff --git a/ts/fixtures/lang/expected/keys.ts b/ts/fixtures/lang/expected/keys.ts index 7905703ec..3ee3ac7b4 100644 --- a/ts/fixtures/lang/expected/keys.ts +++ b/ts/fixtures/lang/expected/keys.ts @@ -1118,7 +1118,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void if (_120 === rt.DONE) { break; } - entries.push([rt.byteSliceToArray(_120[0]), _120[1]] as [Uint8Array, rt.u8]); + rt.vecPush(entries, [rt.byteSliceToArray(_120[0]), _120[1]] as [Uint8Array, rt.u8], 3); } rt.sliceSort(entries, rt.cmpLt(rt.cmpTuple<[Uint8Array, rt.u8], rt.Ordering | undefined>([rt.cmpBytes, rt.cmp]))); for (const _136 of entries) { @@ -1439,8 +1439,8 @@ export function lentValues(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo rt.hashInsert(map, rt.u8Rem(_11.data[_11.start], 8), copy$array_u8(value)); rt.idx(_11, 1); rt.btreeInsert(tree, rt.u8Rem(_11.data[_11.start + 1], 8), copy$array_u8(value)); - rt.dequePushBack(deque, copy$array_u8(value)); - rt.heapPush(heap, copy$array_u8(value), rt.cmpLe(rt.cmpBytes)); + rt.dequePushBack(deque, copy$array_u8(value), 2); + rt.heapPush(heap, copy$array_u8(value), rt.cmpLe(rt.cmpBytes), 2); } const at: rt.u8 = rt.u8Rem(kind, 8); rt.iterExtendBytes(out, rt.iterSlice(option_mapOr$0z7fb2w(rt.optionMap(rt.hashGet(map, at), rt.byteSliceFrom), rt.bytes(2).fill(221), (v2: rt.ByteSlice): Uint8Array => { @@ -1789,7 +1789,7 @@ export function keyed$Option_u8_2_keys_arrays_closure5(data: rt.ByteSlice, make: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -2045,7 +2045,7 @@ export function keyed$bool_2_keys_arrays_closure4(data: rt.ByteSlice, make: (a0: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -2300,7 +2300,7 @@ export function keyed$char_2_keys_arrays_closure3(data: rt.ByteSlice, make: (a0: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -2556,7 +2556,7 @@ export function keyed$i32_2_keys_arrays_closure2(data: rt.ByteSlice, make: (a0: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -2811,7 +2811,7 @@ export function keyed$keys_Hop_2_keys_arrays_closure6(data: rt.ByteSlice, make: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -3067,7 +3067,7 @@ export function keyed$u16_2_keys_arrays_closure0(data: rt.ByteSlice, make: (a0: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -3323,7 +3323,7 @@ export function keyed$u32_0_keys_arrays_closure7(data: rt.ByteSlice, make: (a0: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -3579,7 +3579,7 @@ export function keyed$u32_275_keys_arrays_closure8(data: rt.ByteSlice, make: (a0 rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -3835,7 +3835,7 @@ export function keyed$u64_2_keys_arrays_closure1(data: rt.ByteSlice, make: (a0: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -4168,7 +4168,7 @@ export function taken$0_keys_byte_refs_closure1(data: rt.ByteSlice, make: (a0: r const _332: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_332.value, counted2); rt.refMutRelease(_332); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.refCellReplace(log, new rt.ByteVec()))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.refCellReplace(log, new rt.ByteVec())), undefined, true); const lent: [rt.ByteSlice, rt.ByteSlice][] = rt.iterToArray(rt.iterMap(rt.iterLend(rt.hashIter(map), (held20): [rt.ByteSlice, rt.ByteSlice] => { return [rt.byteSliceFrom(held20[0]), rt.byteSliceFrom(held20[1])]; }), (_23: [rt.ByteSlice, rt.ByteSlice]): [rt.ByteSlice, rt.ByteSlice] => { @@ -4469,7 +4469,7 @@ export function taken$2_keys_byte_refs_closure0(data: rt.ByteSlice, make: (a0: r const _332: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_332.value, counted2); rt.refMutRelease(_332); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.refCellReplace(log, new rt.ByteVec()))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.refCellReplace(log, new rt.ByteVec())), undefined, true); const lent: [rt.ByteSlice, rt.ByteSlice][] = rt.iterToArray(rt.iterMap(rt.iterLend(rt.hashIter(map), (held20): [rt.ByteSlice, rt.ByteSlice] => { return [rt.byteSliceFrom(held20[0]), rt.byteSliceFrom(held20[1])]; }), (_23: [rt.ByteSlice, rt.ByteSlice]): [rt.ByteSlice, rt.ByteSlice] => { diff --git a/ts/fixtures/lang/expected/lists.ts b/ts/fixtures/lang/expected/lists.ts index c553e8c4b..33a583b7e 100644 --- a/ts/fixtures/lang/expected/lists.ts +++ b/ts/fixtures/lang/expected/lists.ts @@ -115,10 +115,10 @@ export function lists(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (_13 === 11) { l = rt.replaceIn(m, l); } else { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.listExtractIfMut(l, (x5: rt.Place): boolean => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.listExtractIfMut(l, (x5: rt.Place): boolean => { x5.v = rt.u8WrappingAdd(x5.v, 1); return rt.u8Rem(x5.v, 3) === 0; - }), "next"))), undefined, true); + }), "next")), undefined, true); } } } @@ -193,7 +193,7 @@ export function edges(data: rt.ByteSlice, out: rt.ByteVec): void { const _64: rt.LinkedList = rt.listClone(whole, undefined); rt.listAppend(from, _64); const _68: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(7, 8)); - rt.listExtend(from, rt.iterSlice(rt.byteVecView(_68))); + rt.listExtend(from, rt.byteVecIntoIter(_68)); items(from, out); const _75: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): [rt.u8, rt.u8] => { const b: rt.u8 = _2; diff --git a/ts/fixtures/lang/expected/locals.ts b/ts/fixtures/lang/expected/locals.ts index 3ce07f5df..93a7811eb 100644 --- a/ts/fixtures/lang/expected/locals.ts +++ b/ts/fixtures/lang/expected/locals.ts @@ -61,9 +61,9 @@ export function locals(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, ((a0: rt.Cell): rt.u32 => { return a0.v; })(COUNT.get()) & 0xff); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(withBorrow$1k8k9m1(LOG, (log2: rt.ByteVec): rt.ByteVec => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(withBorrow$1k8k9m1(LOG, (log2: rt.ByteVec): rt.ByteVec => { return rt.byteVecFrom(rt.byteVecView(log2)); - }))), undefined, true); + })), undefined, true); rt.byteVecPush(out, ((p: locals_Polling.Polling): rt.u8 => { return option_mapOr$0ucbp7g(copy$Option_tuple2_u64_u64(p.current.v), 253, (_2: [rt.u64, rt.u64]): rt.u8 => { return rt.u64Low(_2[0]) & 0xff; @@ -165,9 +165,9 @@ export function locals(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, withBorrow$0r4ucls(LOG, (log4: rt.ByteVec): rt.u8 => { return log4.length & 0xff; })); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(replace$1xk72wn(LOG, rt.byteVecFrom(Uint8Array.of(op))))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(replace$1xk72wn(LOG, rt.byteVecFrom(Uint8Array.of(op)))), undefined, true); rt.localKeyRefCellSet(LOG, rt.byteVecFrom(Uint8Array.of(op, op))); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(local_take$122f15k(LOG))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(local_take$122f15k(LOG)), undefined, true); rt.localKeyRefCellSet(LOG, rt.byteVecFrom(Uint8Array.of(1, 2, 3))); const _141: rt.LocalKey> = HELD; const _144: rt.Arc> = rt.arcClone(log); diff --git a/ts/fixtures/lang/expected/nested.ts b/ts/fixtures/lang/expected/nested.ts index c9527de6c..4335f51f0 100644 --- a/ts/fixtures/lang/expected/nested.ts +++ b/ts/fixtures/lang/expected/nested.ts @@ -431,7 +431,7 @@ export function closures(data: rt.ByteSlice, out: rt.ByteVec): void { }, undefined, rt.None), "next", 2)), (_222: rt.u8 | undefined): rt.u8 => { return code(_222); }), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(seen)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(seen), undefined, true); let steps: rt.u8 = 0; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.iterCount(rt.iterSuccessors(undefined, (_223: undefined): undefined | rt.None => { steps = rt.u8Add(steps, 1); @@ -526,7 +526,7 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.vecPop(v, rt.None)), code(rt.vecPopIfMut(v, (_213: rt.Place): boolean => { return true; }, undefined, rt.None)))), undefined, true); - const units: undefined[] = rt.vecFromElem(undefined, data.length, undefined); + const units: undefined[] = rt.vecFromElem(undefined, data.length, undefined, 0); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.sliceFirst(units, rt.None) !== rt.None ? 1 : 0, rt.sliceLast(units, rt.None) !== rt.None ? 1 : 0, rt.sliceGet(units, at, rt.None) !== rt.None ? 1 : 0)), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.sliceFirstMut(units) !== undefined ? 1 : 0, rt.sliceLastMut(units) !== undefined ? 1 : 0, rt.sliceGetMut(units, at) !== undefined ? 1 : 0)), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.vecPopIfMut(units, (_217: rt.Place): boolean => { @@ -547,9 +547,9 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { const i: rt.usize = _167[0]; const o2: rt.u8 | undefined = _167[1]; if (rt.usizeRem(i, 2) === 0) { - rt.dequePushBack(q, o2); + rt.dequePushBack(q, o2, 2); } else { - rt.dequePushFront(q, o2); + rt.dequePushFront(q, o2, 2); } } rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.dequeEnd(q, false, rt.None)), code(rt.dequeEnd(q, true, rt.None)), code(rt.dequeGet(q, at, rt.None)))), undefined, true); @@ -583,8 +583,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, 0), 0) as rt.VecDeque; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.dequeEnd(unitQ, false, rt.None) !== rt.None ? 1 : 0, rt.dequeEnd(unitQ, true, rt.None) !== rt.None ? 1 : 0, rt.dequeGet(unitQ, at, rt.None) !== rt.None ? 1 : 0)), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.dequePopBack(unitQ, rt.None) !== rt.None ? 1 : 0, rt.dequeRemove(unitQ, at, rt.None) !== rt.None ? 1 : 0, rt.dequeSwapRemove(unitQ, at, true, rt.None) !== rt.None ? 1 : 0, rt.dequeSwapRemove(unitQ, at, false, rt.None) !== rt.None ? 1 : 0, rt.dequePopFront(unitQ, rt.None) !== rt.None ? 1 : 0, unitQ.n & 0xff)), undefined, true); const heap: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterSlice(items), undefined, 2, true), rt.cmpLe(rt.cmpOption(rt.cmp)), rt.cmpGe(rt.cmpOption(rt.cmp)), rt.cmpLt(rt.cmpOption(rt.cmp))); @@ -737,8 +736,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), 0) as rt.VecDeque; const named: undefined[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), ignore as (a0: rt.u8) => undefined), undefined, 0, true); const _15: rt.u8 | undefined = rt.byteSliceFirst(data); b0: { @@ -753,7 +751,7 @@ export function units(data: rt.ByteSlice, out: rt.ByteVec): void { const byPointer: undefined[] = pointed(data, f); const generic: undefined[] = each$unit_nested_units_closure3(data, (_25: rt.u8): undefined => {}); const byName: undefined[] = each$unit_nested_ignore(data, ignore as (a0: rt.u8) => undefined); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(each$u8_nested_half(data, half))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(each$u8_nested_half(data, half)), undefined, true); const methods: undefined[] = madeAll$nested_Unit({}, data); const dynamic: undefined[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), rt.lent(ignore as (a0: rt.u8) => undefined)), undefined, 0, true); const iter: rt.Iter = rt.iterSlice([units, named, byPointer, generic, byName, methods, dynamic]); diff --git a/ts/fixtures/lang/expected/objects.ts b/ts/fixtures/lang/expected/objects.ts index dd236aa1c..8bf7cb270 100644 --- a/ts/fixtures/lang/expected/objects.ts +++ b/ts/fixtures/lang/expected/objects.ts @@ -134,7 +134,7 @@ export function swapWindows(a: objects_Window.Window, b: objects_Window.Window): export function swapIn(v: rt.Arc[], with_: rt.Arc): rt.Arc[] { const mine: rt.Arc[] = [rt.arcClone(with_)]; const swapped = rt.replaceIn(v, mine); - v.push(rt.arcClone(with_)); + rt.vecPush(v, rt.arcClone(with_), 4); return swapped; } @@ -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), 1) 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; } @@ -443,8 +442,7 @@ export function objects(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteVecSlice(bytes)); counts(out, [one, two], w.held); counts(out, [one, two], other); - const _515: Uint8Array = Uint8Array.of(by); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_515), undefined, 1, true); + const q: rt.VecDeque = rt.dequeFromVec(Array.from(Uint8Array.of(by)), 1) as rt.VecDeque; const map: rt.HashMap = rt.hashNew() as rt.HashMap; for (const _519 of rt.byteSliceView(data)) { rt.byteVecPush(out, requeue(q, map, _519) & 0xff); diff --git a/ts/fixtures/lang/expected/orders.ts b/ts/fixtures/lang/expected/orders.ts index b6b7e3245..1f5e5ecd3 100644 --- a/ts/fixtures/lang/expected/orders.ts +++ b/ts/fixtures/lang/expected/orders.ts @@ -237,7 +237,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(); @@ -251,7 +251,7 @@ export function heaps(data: rt.ByteSlice, out: rt.ByteVec): void { const _17: rt.u8 = rt.u8Rem(op, 12); if (0 <= _17) { if (_17 <= 2) { - rt.heapPush(heap, item(i, v), orders_Item.le$cmp_PartialOrd); + rt.heapPush(heap, item(i, v), orders_Item.le$cmp_PartialOrd, 2); break b2; } } @@ -306,9 +306,9 @@ export function heaps(data: rt.ByteSlice, out: rt.ByteVec): void { } } else if (_17 === 6) { const _57: orders_Item.Item = item(i, v); - rt.heapPush(other, _57, orders_Item.le$cmp_PartialOrd); + rt.heapPush(other, _57, orders_Item.le$cmp_PartialOrd, 2); } else if (_17 === 7) { - rt.heapAppend(heap, other, orders_Item.le$cmp_PartialOrd, orders_Item.ge$cmp_PartialOrd, orders_Item.lt$cmp_PartialOrd); + rt.heapAppend(heap, other, orders_Item.le$cmp_PartialOrd, orders_Item.ge$cmp_PartialOrd, orders_Item.lt$cmp_PartialOrd, 2); } else if (_17 === 8) { rt.heapRetain(heap, (x4: orders_Item.Item): boolean => { return x4.key !== rt.u8Rem(v, 8); @@ -375,13 +375,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); - rt.heapPush(bytes, data.length & 0xff, rt.le); + 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, 1); 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.byteVecIntoIter(rt.byteVecFromVec(rt.heapIntoSortedVec(rt.heapClone(bytes), 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.byteVecIntoIter(rt.byteVecFromVec(bytes.d)), undefined, true); const least: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u8 => { return _2; }), undefined, 1, true), rt.cmpLe(rt.cmpReverse(rt.cmp)), rt.cmpGe(rt.cmpReverse(rt.cmp)), rt.cmpLt(rt.cmpReverse(rt.cmp))); @@ -564,7 +564,7 @@ export function bytes(data: rt.ByteSlice, out: rt.ByteVec): void { } if (_228.length >= 2) { rt.idx(_228, 0); - refs.push([new rt.ByteSlice(_228.data, _228.start, 2), rt.u8Div(_228.data[_228.start], 64)] as [rt.ByteSlice, rt.u8]); + rt.vecPush(refs, [new rt.ByteSlice(_228.data, _228.start, 2), rt.u8Div(_228.data[_228.start], 64)] as [rt.ByteSlice, rt.u8], 8); } } rt.sliceSort(refs, rt.cmpLt(rt.cmpTuple<[rt.ByteSlice, rt.u8], rt.Ordering | undefined>([rt.cmpBytes, rt.cmp]))); @@ -745,10 +745,9 @@ export function deque$orders_Part_orders_held_closure3(s: rt.ByteSlice, wraps: b rt.panic("mid > len"); } const _17: rt.usize = at; - const _12: rt.Iter = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(s.data, s.start + mid, s.length - 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(s.data, s.start + mid, s.length - 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), 2) as rt.VecDeque; const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(s.data, s.start, mid))))); while (true) { const _23: [rt.usize, rt.u8] | rt.Done = iter.next(); @@ -756,7 +755,7 @@ export function deque$orders_Part_orders_held_closure3(s: rt.ByteSlice, wraps: b return d; } const _30: Part.Part = f(_23[0], _23[1]); - rt.dequePushFront(d, _30); + rt.dequePushFront(d, _30, 2); } } @@ -776,10 +775,9 @@ export function deque$orders_Part_orders_part(s: rt.ByteSlice, wraps: boolean, _ rt.panic("mid > len"); } const _17: rt.usize = at; - const _12: rt.Iter = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(s.data, s.start + mid, s.length - 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(s.data, s.start + mid, s.length - 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), 2) as rt.VecDeque; const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(s.data, s.start, mid))))); while (true) { const _23: [rt.usize, rt.u8] | rt.Done = iter.next(); @@ -787,7 +785,7 @@ export function deque$orders_Part_orders_part(s: rt.ByteSlice, wraps: boolean, _ return d; } const _30: Part.Part = part(_23[0], _23[1]); - rt.dequePushFront(d, _30); + rt.dequePushFront(d, _30, 2); } } @@ -807,10 +805,9 @@ export function deque$u8_orders_held_closure11(s: rt.ByteSlice, wraps: boolean, rt.panic("mid > len"); } const _17: rt.usize = at; - const _12: rt.Iter = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(s.data, s.start + mid, s.length - 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(s.data, s.start + mid, s.length - 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), 1) as rt.VecDeque; const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(s.data, s.start, mid))))); while (true) { const _23: [rt.usize, rt.u8] | rt.Done = iter.next(); @@ -818,7 +815,7 @@ export function deque$u8_orders_held_closure11(s: rt.ByteSlice, wraps: boolean, return d; } const _30: rt.u8 = f(_23[0], _23[1]); - rt.dequePushFront(d, _30); + rt.dequePushFront(d, _30, 1); } } @@ -838,10 +835,9 @@ export function deque$u8_orders_held_closure8(s: rt.ByteSlice, wraps: boolean, f rt.panic("mid > len"); } const _17: rt.usize = at; - const _12: rt.Iter = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(s.data, s.start + mid, s.length - 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(s.data, s.start + mid, s.length - 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), 1) as rt.VecDeque; const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(s.data, s.start, mid))))); while (true) { const _23: [rt.usize, rt.u8] | rt.Done = iter.next(); @@ -849,7 +845,7 @@ export function deque$u8_orders_held_closure8(s: rt.ByteSlice, wraps: boolean, f return d; } const _30: rt.u8 = f(_23[0], _23[1]); - rt.dequePushFront(d, _30); + rt.dequePushFront(d, _30, 1); } } @@ -887,13 +883,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), 8) as rt.VecDeque; }; const iter: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.byteSliceWindows(data, 2)); while (true) { @@ -1235,7 +1230,7 @@ export function btrees(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecClear(a034); }); } - const apart: Apart.Apart[] = rt.vecFromElem({}, short.length, undefined); + const apart: Apart.Apart[] = rt.vecFromElem({}, short.length, undefined, 0); const _183: rt.Iter = rt.iterSlice(apart); const set2: rt.BTreeSet = rt.btreeCollectKeys(rt.btreeNew(Apart.cmp$cmp_Ord) as rt.BTreeSet, rt.iterToArray(_183, undefined, 0, true), undefined, Apart.eq$cmp_PartialEq); const _188: rt.Iter<[Apart.Apart, undefined]> = rt.iterMap(rt.iterSlice(apart), (_211: Apart.Apart): [Apart.Apart, undefined] => { diff --git a/ts/fixtures/lang/expected/pointers.ts b/ts/fixtures/lang/expected/pointers.ts index e22c82f65..73511080f 100644 --- a/ts/fixtures/lang/expected/pointers.ts +++ b/ts/fixtures/lang/expected/pointers.ts @@ -641,7 +641,7 @@ export function lapsed(data: rt.ByteSlice, out: rt.ByteVec): void { const _33: Log.Log = { bytes: rt.byteVecFrom(Uint8Array.of(n, ~n & 0xff)) }; const old3 = log; log = _33; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(old3.bytes)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(old3.bytes), undefined, true); const old2: Duo.Duo = rt.replaceIn(pair, { _0: n, _1: n ^ 15 }); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(old2._0, old2._1)), undefined, true); } else if (_24 === 2) { @@ -671,7 +671,7 @@ export function lapsed(data: rt.ByteSlice, out: rt.ByteVec): void { } } rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(pair._0, pair._1)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(log.bytes)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(log.bytes), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(window), undefined, true); } @@ -773,11 +773,11 @@ export function segments(data: rt.ByteSlice, out: rt.ByteVec): void { if (!(rt.usizeRem(len, 8) === 0)) { if (rt.usizeRem(len, 4) === 0) { const _27: Segment.Segment = Segment.iterated(); - log.push(_27); + rt.vecPush(log, _27, 8); } } else { const _20: Segment.Segment = Segment.new(); - log.push(_20); + rt.vecPush(log, _20, 8); } const at5 = rt.idx(log, rt.usizeDiv(len, 4)); Lent.withMut$mem_MaybeUninit_tuple2_u8_u8_mut_tuple2_u8_u8_pointers_segments_closure0(Segment.slot(log[at5], log[at5].filled), (p3: [rt.u8, rt.u8]): [rt.u8, rt.u8] => { @@ -1065,7 +1065,7 @@ export function readBefore(n: rt.u8): Uint8Array { } export function keep(d: Duo.Duo, kept: Duo.Duo[]): void { - kept.push(d); + rt.vecPush(kept, d, 4); } export function perIteration(n: rt.u8, out: rt.ByteVec): void { diff --git a/ts/fixtures/lang/expected/refs.ts b/ts/fixtures/lang/expected/refs.ts index 132d76a47..be2ac00b3 100644 --- a/ts/fixtures/lang/expected/refs.ts +++ b/ts/fixtures/lang/expected/refs.ts @@ -466,7 +466,7 @@ export function lent(data: rt.ByteSlice, out: rt.ByteVec): void { break; } _126[1].v = _126[0] as rt.u32; - held.push(rt.place(() => _126[1].v as rt.u32, (value13) => (_126[1].v as rt.u32) = value13)); + rt.vecPush(held, rt.place(() => _126[1].v as rt.u32, (value13) => (_126[1].v as rt.u32) = value13), 4); } const iter4: rt.Iter> = rt.iterSlice(held); while (true) { @@ -570,11 +570,11 @@ export function taken(data: rt.ByteSlice, out: rt.ByteVec): void { const _34: rt.u32[] = []; const old2 = wide; wide = _34; - wide = rt.iterToArray(rt.iterMap(rt.iterFilter(rt.iterSlice(old2), (_25: rt.u32): boolean => { + wide = rt.iterToArrayInPlace(rt.iterMap(rt.iterFilter(rt.iterSlice(old2), (_25: rt.u32): boolean => { return _25 > ((b4 as rt.u32)); }), (x3: rt.u32): rt.u32 => { return rt.u32Div(x3, 2); - }), "next", 4); + }), 4, 4, false, "next"); })(); return held.length === 0; }) as rt.u32))); @@ -591,7 +591,7 @@ export function taken(data: rt.ByteSlice, out: rt.ByteVec): void { const swapped: rt.ByteVec = new rt.ByteVec(); for (const _39 of rt.byteSliceView(data)) { const _45: rt.ByteVec = swap(_39); - rt.iterExtendBytes(swapped, rt.iterSlice(rt.byteVecView(_45)), undefined, true); + rt.iterExtendBytes(swapped, rt.byteVecIntoIter(_45), undefined, true); } const list: (a0: rt.u8) => undefined = (b6: rt.u8): undefined => { const taken2 = pair[1].listed; @@ -604,7 +604,7 @@ export function taken(data: rt.ByteSlice, out: rt.ByteVec): void { }); for (const _57 of rt.byteSliceView(data)) { const _63: rt.ByteVec = option_unwrapOrDefault$0wx44sw(restock(pair[1], _57)); - rt.iterExtendBytes(swapped, rt.iterSlice(rt.byteVecView(_63)), undefined, true); + rt.iterExtendBytes(swapped, rt.byteVecIntoIter(_63), undefined, true); } const taken3 = pair[1].stale; pair[1].stale = new rt.ByteVec(); @@ -763,9 +763,9 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { return 0; }); _214.v = rt.u32Add(_214.v, _213); - rt.dequePushBack(queue, b2 as rt.u32); + rt.dequePushBack(queue, b2 as rt.u32, 4); if (rt.u8Rem(b2, 3) === 0) { - rt.dequePushFront(queue, rt.u32Add(b2 as rt.u32, 1)); + rt.dequePushFront(queue, rt.u32Add(b2 as rt.u32, 1), 4); } } const iter12: rt.Iter<[rt.u8, rt.u8]> = rt.hashValues(hash); diff --git a/ts/fixtures/lang/expected/shapes.ts b/ts/fixtures/lang/expected/shapes.ts index 9916540d2..3e5289aa3 100644 --- a/ts/fixtures/lang/expected/shapes.ts +++ b/ts/fixtures/lang/expected/shapes.ts @@ -378,7 +378,7 @@ export function shares(data: rt.ByteSlice, out: rt.ByteVec): void { bump(_104.slot); } const lenses: Lens.Lens[] = []; - lenses.push(copy$shapes_Lens(lens)); + rt.vecPush(lenses, copy$shapes_Lens(lens), 8); const _114: rt.Iter = rt.iterSlice([lens]); rt.iterExtend(lenses, rt.iterMap(_114, copy$shapes_Lens), undefined, 8, true); const iter4: rt.Iter = rt.iterCopied(rt.iterSlice(lenses), copy$shapes_Lens); @@ -417,7 +417,7 @@ export function shares(data: rt.ByteSlice, out: rt.ByteVec): void { }); rt.byteVecPush(out, writeAt(rt.byteSliceFrom(bytes), at, a)); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(bytes)); - const points: Point.Point[] = rt.vecFromElem(copy$shapes_Point(Point.new(a as rt.i32, 0)), 2, copy$shapes_Point); + const points: Point.Point[] = rt.vecFromElem(copy$shapes_Point(Point.new(a as rt.i32, 0)), 2, copy$shapes_Point, 8); movedAt(points, at); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(points[rt.idx(points, 0)].x & 0xff, points[rt.idx(points, 1)].x & 0xff, points[rt.idx(points, 1)].y & 0xff))); arc[Symbol.dispose](); @@ -2200,7 +2200,7 @@ export function closures(data: rt.ByteSlice, out: rt.ByteVec): void { const parsed: Array = []; for (const _53 of rt.byteSliceView(data)) { const _59: shapes_Dir.Dir | undefined = dir(_53); - parsed.push(_59); + rt.vecPush(parsed, _59, 1); } const tags: rt.ByteVec = new rt.ByteVec(); for (const _64 of parsed) { diff --git a/ts/fixtures/lang/expected/slices.ts b/ts/fixtures/lang/expected/slices.ts index c1505a94d..9e3d7659b 100644 --- a/ts/fixtures/lang/expected/slices.ts +++ b/ts/fixtures/lang/expected/slices.ts @@ -1208,7 +1208,7 @@ export function drains(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return x8.tag; }), undefined, true); rt.dropAll(taken); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.byteVecDrain(bytes, { end: b }), "fold", true))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.byteVecDrain(bytes, { end: b }), "fold", true)), undefined, true); rt.drop(rt.vecDrain(words, { end: b })); } else if (_31 === 3) { const drain4: rt.Iter = rt.vecDrain(items, new rt.RangeFrom(a, rt.usizeStep), rt.drop); @@ -1263,7 +1263,7 @@ export function drains(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const other: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(238)); const _195: rt.Iter = rt.iterRev(rt.byteVecDrain(bytes, new rt.Range(a, b))); rt.iterExtendBytes(other, _195, "fold", true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(other)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(other), undefined, true); rt.dropAll(kept); } flush(out); @@ -1275,7 +1275,7 @@ export function drains(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(words), (_26: rt.u32): rt.u8 => { return _26 & 0xff; }), undefined, true); - items.push(new slices_Item.Item(255)); + rt.vecPush(items, new slices_Item.Item(255), 1); rt.dropAll(items); flush(out); } @@ -1934,7 +1934,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }); rt.sliceCopyFromSlice(more, rt.sliceRange(array, 0, 3)); rt.sliceCopyFromSlice(rt.sliceRangeMut(array, 2), more); - const source: slices_Pair.Pair[] = rt.vecFromElem({ a: 4, b: 5 }, c, copy$slices_Pair); + const source: slices_Pair.Pair[] = rt.vecFromElem({ a: 4, b: 5 }, c, copy$slices_Pair, 4); rt.sliceCopyFromSlice(rt.sliceRangeMut(pairs, 0, b), source, copy$slices_Pair); } else if (_60 === 6) { const source2: slices_Noisy.Noisy[] = rt.iterToArray(rt.iterMap(new rt.Range(0, c), (tag3: rt.usize): slices_Noisy.Noisy => { diff --git a/ts/fixtures/lang/expected/strs.ts b/ts/fixtures/lang/expected/strs.ts index 8f0b26ea8..2c6462ec6 100644 --- a/ts/fixtures/lang/expected/strs.ts +++ b/ts/fixtures/lang/expected/strs.ts @@ -129,7 +129,7 @@ export function strs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (_13 === 2) { const seen: rt.char[] = []; const parts2: rt.Iter = rt.strSplit(s, (c9: rt.char): boolean => { - seen.push(c9); + rt.vecPush(seen, c9, 4); if (!(c9 === sep)) { return rt.isAsciiDigit(c9); } @@ -160,12 +160,12 @@ export function strs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_13 === 4) { const seen2: rt.char[] = []; fmt_put(out, rt.strTrimStartMatches(s, (c5: rt.char): boolean => { - seen2.push(c5); + rt.vecPush(seen2, c5, 4); return c5 === sep; })); putSeen(out, seen2); fmt_put(out, rt.strTrimEndMatches(s, (c6: rt.char): boolean => { - seen2.push(c6); + rt.vecPush(seen2, c6, 4); return c6 !== sep; })); putSeen(out, seen2); @@ -174,7 +174,7 @@ export function strs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }) ? 1 : 0); fmt_put(out, rt.strTrimStartMatches(s, digit)); putOffset(out, rt.strRfind(s, (c8: rt.char): boolean => { - seen2.push(c8); + rt.vecPush(seen2, c8, 4); return c8 === sep; })); putSeen(out, seen2); @@ -411,7 +411,7 @@ export function unescape(path: string): string[] { if (ch === 47) { const taken = part; part = ""; - parts.push(taken); + rt.vecPush(parts, taken, 12); } else if (ch === 92) { const _14: rt.char | rt.Done = chars.next(); if (_14 === rt.DONE) { @@ -430,7 +430,7 @@ export function unescape(path: string): string[] { break; } } - parts.push(part); + rt.vecPush(parts, part, 12); return parts; } return []; @@ -556,7 +556,7 @@ export function edit(s: rt.Place, op: rt.u8, a: rt.u8, b: rt.u8, out: rt if (!(rt.u8Rem(b, 2) === 1)) { const seen: rt.char[] = []; s.v = rt.stringRetain(s.v, (c: rt.char): boolean => { - seen.push(c); + rt.vecPush(seen, c, 4); return rt.u32Rem(c as rt.u32, 3) !== rt.u8Rem(a, 3) as rt.u32; }); putSeen(out, seen); diff --git a/ts/fixtures/lang/expected/tuples.ts b/ts/fixtures/lang/expected/tuples.ts index 1c1813c14..3a53d1215 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.byteVecIntoIter(rt.byteVecFromVec(rt.tupleExtendOne([rt.heapNew() as rt.BinaryHeap] as [rt.BinaryHeap], _22, (c3, items3) => rt.heapExtend(c3, items3, rt.le, rt.ge, rt.lt, undefined, 1, true))[0].d)), undefined, true); const _28: rt.Iter<[rt.u8]> = rt.iterMap(rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): boolean => { return (_210 & 1) === 0; }), (_211: rt.u8): [rt.u8] => { @@ -103,7 +103,7 @@ export function ones(data: rt.ByteSlice, out: rt.ByteVec): void { return [c7.data[c7.start]] as [rt.u8]; }); rt.tupleExtendOne(t, _48, (c8, items7) => rt.iterExtendBytes(c8, items7, undefined, true)); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(t[0])), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(t[0]), undefined, true); const t2: [string] = ["ab"]; const _56: rt.Iter<[string]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_214: rt.u8): [string] => { const _84: rt.usize = rt.u8Rem(_214, 3) as rt.usize; @@ -121,8 +121,8 @@ export function ones(data: rt.ByteSlice, out: rt.ByteVec): void { const _64: [[rt.ByteVec, rt.BinaryHeap]] = rt.tupleExtendOne([[new rt.ByteVec(), rt.heapNew() as rt.BinaryHeap]] as [[rt.ByteVec, rt.BinaryHeap]], _65, (c10, items9) => rt.tupleExtend(c10, items9, [rt.byteVecPart(), rt.heapPart(rt.le, 1)])); const v2: rt.ByteVec = _64[0][0]; const heap2: rt.BinaryHeap = _64[0][1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v2)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFrom(Uint8Array.from(heap2.d)))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v2), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(heap2.d)), undefined, true); rt.tupleExtendOne([undefined] as [undefined], rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_216: rt.u8): [undefined] => { return [undefined] as [undefined]; }), (_c11, items10) => rt.iterFold(items10, undefined, () => undefined)); @@ -142,7 +142,7 @@ export function pairs(data: rt.ByteSlice, out: rt.ByteVec): void { const _5: [rt.ByteVec, string] = rt.tupleExtend([new rt.ByteVec(), ""] as [rt.ByteVec, string], _6, [rt.byteVecPart(), rt.STRING_CHARS_PART]); const v: rt.ByteVec = _5[0]; const s: string = _5[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); const _16: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): [rt.u8, rt.u8] => { const b2: rt.u8 = _25; @@ -151,7 +151,7 @@ export function pairs(data: rt.ByteSlice, out: rt.ByteVec): void { const _15: [rt.ByteVec, rt.BTreeSet] = rt.tupleExtend([new rt.ByteVec(), rt.btreeNew(rt.cmp) as rt.BTreeSet] as [rt.ByteVec, rt.BTreeSet], _16, [rt.byteVecPart(), rt.btreeKeysPart()]); const v2: rt.ByteVec = _15[0]; const tree: rt.BTreeSet = _15[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v2)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v2), undefined, true); rt.iterExtendBytes(out, rt.btreeKeys(tree), undefined, true); const _23: rt.Iter<[rt.u8, rt.u16]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_27: rt.u8): [rt.u8, rt.u16] => { const b3: rt.u8 = _27; @@ -160,14 +160,14 @@ export function pairs(data: rt.ByteSlice, out: rt.ByteVec): void { const _22: [rt.BinaryHeap, rt.VecDeque] = rt.tupleExtend([rt.heapNew() as rt.BinaryHeap, rt.dequeNew() 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.byteVecIntoIter(rt.byteVecFromVec(heap.d)), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.dequeIter(q), (n: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n).reverse(); }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); const _33: rt.Iter<[undefined, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): [undefined, rt.u8] => { return [undefined, _210] as [undefined, rt.u8]; }); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.tupleExtend([undefined, new rt.ByteVec()] as [undefined, rt.ByteVec], _33, [rt.UNIT_PART, rt.byteVecPart()])[1])), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.tupleExtend([undefined, new rt.ByteVec()] as [undefined, rt.ByteVec], _33, [rt.UNIT_PART, rt.byteVecPart()])[1]), undefined, true); const _39: rt.Iter<[rt.u16, rt.u8]> = rt.iterMap(rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (_211: rt.u8): boolean => { return _211 > 64; }), (_212: rt.u8): [rt.u16, rt.u8] => { @@ -193,7 +193,7 @@ export function triples(data: rt.ByteSlice, out: rt.ByteVec): void { const v: rt.ByteVec = _6[0]; const q: rt.VecDeque = _6[1]; const s: string = _6[2]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.dequeIter(q), (n: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n).reverse(); }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); @@ -210,7 +210,7 @@ export function triples(data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeIter(tree), (_25: [rt.u8, rt.u16]): Uint8Array => { return Uint8Array.of(_25[0], _25[1] & 0xff); }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFrom(Uint8Array.from(heap.d)))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(heap.d)), undefined, true); const _35: rt.Iter<[rt.u8, [rt.char, rt.u16]]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_26: rt.u8): [rt.u8, [rt.char, rt.u16]] => { const b3: rt.u8 = _26; return [b3, [b3 as rt.char, rt.u16Add(b3 as rt.u16, 1)] as [rt.char, rt.u16]] as [rt.u8, [rt.char, rt.u16]]; @@ -219,7 +219,7 @@ export function triples(data: rt.ByteSlice, out: rt.ByteVec): void { const v2: rt.ByteVec = _34[0]; const s2: string = _34[1][0]; const w: rt.u16[] = _34[1][1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v2)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v2), undefined, true); rt.iterExtendBytes(out, rt.strBytes(s2), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(w), (n2: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n2).reverse(); @@ -231,7 +231,7 @@ export function triples(data: rt.ByteSlice, out: rt.ByteVec): void { const _49: [rt.ByteVec, [rt.BTreeSet]] = rt.tupleExtend([new rt.ByteVec(), [rt.btreeNew(rt.cmp) as rt.BTreeSet]] as [rt.ByteVec, [rt.BTreeSet]], _50, [rt.byteVecPart(), rt.tuplePart([rt.btreeKeysPart()])]); const v3: rt.ByteVec = _49[0]; const tree2: rt.BTreeSet = _49[1][0]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v3)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v3), undefined, true); rt.iterExtendBytes(out, rt.btreeKeys(tree2), undefined, true); } @@ -267,14 +267,14 @@ export function twelves(data: rt.ByteSlice, out: rt.ByteVec): void { const keys: rt.BTreeSet = _15[9]; const v: rt.ByteVec = _15[11][0]; const s: string = _15[11][1][0]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(bytes), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(wide), (n: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n).reverse(); }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); rt.iterExtendBytes(out, rt.strBytes(chars), undefined, true); rt.iterExtendBytes(out, rt.strBytes(texts), undefined, true); rt.iterExtendBytes(out, rt.dequeIter(q), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFrom(Uint8Array.from(heap.d)))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(heap.d)), undefined, true); entries(map, out); sorted(set, out); rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeIter(tree), (_210: [rt.u8, rt.u16]): Uint8Array => { @@ -284,7 +284,7 @@ export function twelves(data: rt.ByteSlice, out: rt.ByteVec): void { }); }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); rt.iterExtendBytes(out, rt.btreeKeys(keys), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); } @@ -293,7 +293,7 @@ export function twelves(data: rt.ByteSlice, out: rt.ByteVec): void { * and a map or set keeps an equal key already there. */ export function extended(data: rt.ByteSlice, out: rt.ByteVec): void { - const t: [rt.ByteVec, string, rt.BTreeMap, rt.VecDeque, rt.HashSet] = [rt.byteVecFrom(Uint8Array.of(9, 8)), "pre", rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterSlice([[3, 30] as [rt.u8, rt.u16]]), true, undefined, undefined, undefined, 4, true), rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice([1]), undefined, 2, true), rt.hashExtendKeys(rt.hashNew() as rt.HashSet, rt.iterSlice(Uint8Array.of(5)), undefined, undefined, 469762048)]; + const t: [rt.ByteVec, string, rt.BTreeMap, rt.VecDeque, rt.HashSet] = [rt.byteVecFrom(Uint8Array.of(9, 8)), "pre", rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterSlice([[3, 30] as [rt.u8, rt.u16]]), true, undefined, undefined, undefined, 4, true), rt.dequeFromVec([1], 2) as rt.VecDeque, rt.hashExtendKeys(rt.hashNew() as rt.HashSet, rt.iterSlice(Uint8Array.of(5)), undefined, undefined, 469762048)]; const _16: rt.Iter<[rt.u8, rt.char, [rt.u8, rt.u16], rt.u16, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): [rt.u8, rt.char, [rt.u8, rt.u16], rt.u16, rt.u8] => { const b: rt.u8 = _2; return [b, b as rt.char, [rt.u8Rem(b, 8), b as rt.u16] as [rt.u8, rt.u16], b as rt.u16, rt.u8Rem(b, 16)] as [rt.u8, rt.char, [rt.u8, rt.u16], rt.u16, rt.u8]; @@ -304,7 +304,7 @@ export function extended(data: rt.ByteSlice, out: rt.ByteVec): void { const tree: rt.BTreeMap = t[2]; const q: rt.VecDeque = t[3]; const set: rt.HashSet = t[4]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeIter(tree), (_22: [rt.u8, rt.u16]): Uint8Array => { return Uint8Array.of(_22[0], _22[1] & 0xff); @@ -319,7 +319,7 @@ export function extended(data: rt.ByteSlice, out: rt.ByteVec): void { return [b2, [rt.u8Rem(b2, 4), b2] as [rt.u8, rt.u8]] as [rt.u8, [rt.u8, rt.u8]]; }); rt.tupleExtend(t2, _45, [rt.heapPart(rt.le, 1), rt.hashPart(undefined, undefined, 469762048)]); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFrom(Uint8Array.from(t2[0].d)))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(t2[0].d)), undefined, true); entries(t2[1], out); } @@ -353,7 +353,7 @@ export function borrowed(data: rt.ByteSlice, out: rt.ByteVec): void { const copied: Spot.Spot[] = t[1]; const map: rt.HashMap = t[2]; const s: string = t[3]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterChain(rt.iterSlice(copied), rt.iterSlice(ones[0])), (p2: Spot.Spot): Uint8Array => { return Uint8Array.of(p2.x, p2.y & 0xff); }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); @@ -431,7 +431,7 @@ export function dropped(data: rt.ByteSlice, out: rt.ByteVec): void { const taken: tuples_Logged.Logged[] = _86[0]; const bytes: rt.ByteVec = _86[1]; flush(log.value, out); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(bytes), undefined, true); rt.dropAll(taken); flush(log.value, out); rt.hashDrop(keys, rt.drop); @@ -459,7 +459,7 @@ export function panicked(data: rt.ByteSlice, out: rt.ByteVec): void { const v: rt.ByteVec = _12[0]; const s: string = _12[1]; const w: rt.u16[] = _12[2]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(w), (n: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n).reverse(); @@ -525,7 +525,7 @@ export function shunted(data: rt.ByteSlice, out: rt.ByteVec): void { if (parsed.ok) { const v: rt.ByteVec = parsed.value[0]; const s: string = parsed.value[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); } else { rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(250, parsed.error)), undefined, true); @@ -621,7 +621,7 @@ export function own(data: rt.ByteSlice, out: rt.ByteVec): void { const _34: [rt.ByteVec, tuples_Tally.Tally] = rt.tupleExtend([new rt.ByteVec(), tuples_Tally.default$Default()] as [rt.ByteVec, tuples_Tally.Tally], _35, [rt.byteVecPart(), rt.ownPart(tuples_Tally.extend$iter_Extend_u8_Option_u8 as (a0: tuples_Tally.Tally, a1: rt.u8 | undefined) => undefined)]); const v: rt.ByteVec = _34[0]; const t2: tuples_Tally.Tally = _34[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.byteVecPush(out, t2.sum); calls(out); const _47: rt.Iter<[rt.u8, rt.u16]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(data2))), (_210: rt.u8): [rt.u8, rt.u16] => { @@ -667,7 +667,7 @@ export function own(data: rt.ByteSlice, out: rt.ByteVec): void { const _96: [rt.ByteVec, [tuples_Tally.Tally]] = rt.tupleExtend([new rt.ByteVec(), [tuples_Tally.default$Default()]] as [rt.ByteVec, [tuples_Tally.Tally]], _97, [rt.byteVecPart(), rt.tuplePart([rt.ownPart(tuples_Tally.extend$iter_Extend_u8_Option_u8 as (a0: tuples_Tally.Tally, a1: rt.u8 | undefined) => undefined)])]); const v2: rt.ByteVec = _96[0]; const t5: tuples_Tally.Tally = _96[1][0]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v2)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v2), undefined, true); rt.byteVecPush(out, t5.sum); calls(out); const _107: rt.Iter<[rt.char]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(data2))), (_216: rt.u8): [rt.char] => { @@ -685,7 +685,7 @@ export function own(data: rt.ByteSlice, out: rt.ByteVec): void { }); rt.tupleExtend(t6, _120, [rt.ownPart(tuples_Tally.extend$iter_Extend_u8_Option_u8 as (a0: tuples_Tally.Tally, a1: rt.u8 | undefined) => undefined), rt.byteVecPart(), rt.ownPart(Last.extend$iter_Extend_char_Option_char as (a0: rt.Place, a1: rt.char | undefined) => undefined, true)]); rt.byteVecPush(out, t6[0].sum); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(t6[1])), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(t6[1]), undefined, true); Last.put(t6[2], out); calls(out); const parsed: rt.Result<[tuples_Tally.Tally, rt.ByteVec], rt.u8> = rt.iterCollectResult(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(data2))), (_217: rt.u8): rt.Result<[rt.u8, rt.u8], rt.u8> => { @@ -699,7 +699,7 @@ export function own(data: rt.ByteSlice, out: rt.ByteVec): void { const t7: tuples_Tally.Tally = parsed.value[0]; const v3: rt.ByteVec = parsed.value[1]; rt.byteVecPush(out, t7.sum); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v3)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v3), undefined, true); } else { rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(250, parsed.error)), undefined, true); } @@ -715,7 +715,7 @@ export function own(data: rt.ByteSlice, out: rt.ByteVec): void { } else { const v4: rt.ByteVec = found[0]; const t8: tuples_Tally.Tally = found[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v4)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v4), undefined, true); rt.byteVecPush(out, t8.sum); } calls(out); @@ -798,7 +798,7 @@ export function ownPanicked(data: rt.ByteSlice, out: rt.ByteVec): void { const v: rt.ByteVec = _24[0]; const t: tuples_Tally.Tally = _24[1]; const s: string = _24[2]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.byteVecPush(out, t.sum); rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); } else { diff --git a/ts/fixtures/lang/expected/wrappers.ts b/ts/fixtures/lang/expected/wrappers.ts index 50ec0c951..5a73bfda7 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), 8) as rt.VecDeque)).n & 0xff); bounds$ops_RangeInclusive_u64(out, queued); const hashed: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u64Step); const _186: rt.RangeInclusive = hashed; @@ -355,7 +354,7 @@ export function wrappers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void rt.byteVecPush(out, held.length & 0xff); bounds$ops_RangeInclusive_u64(out, extended); const narrow: rt.RangeInclusive = new rt.RangeInclusive(rt.u64Low(lo) & 0xff, rt.u64Low(hi) & 0xff, rt.u8Step); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterBorrow(narrow), undefined, true))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterBorrow(narrow), undefined, true)), undefined, true); rt.byteVecPush(out, rt.rangeInclusiveStart(narrow)); rt.byteVecPush(out, rt.rangeInclusiveIsEmpty(narrow) ? 1 : 0); bounds$ops_RangeTo_u64(out, { end: b }); diff --git a/ts/fixtures/lang/expected/zeros.ts b/ts/fixtures/lang/expected/zeros.ts index cf38948c9..82453efee 100644 --- a/ts/fixtures/lang/expected/zeros.ts +++ b/ts/fixtures/lang/expected/zeros.ts @@ -140,10 +140,10 @@ 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); + rt.byteVecPush(out, rt.vecFromElem({}, n, undefined, 0).length & 0xff); rt.byteVecPush(out, v2.length & 0xff); } else { rt.iterFromFn((): rt.u8 | undefined => { @@ -541,7 +541,7 @@ export function writes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.cellReplace(_113, undefined); rt.cellSet(_113, undefined); rt.sliceSwap([undefined, undefined, undefined], 0, n as rt.usize); - const v: zeros_Unit.Unit[] = rt.vecFromElem({}, 2, undefined); + const v: zeros_Unit.Unit[] = rt.vecFromElem({}, 2, undefined, 0); rt.sliceSwap(v, 0, 1); rt.byteVecPush(out, ([undefined, undefined, undefined].length & 0xff) | (((v.length & 0xff) << 4) & 0xff)); const _141: rt.Cell = new rt.Cell(undefined); diff --git a/ts/fixtures/lang/src/capacity.rs b/ts/fixtures/lang/src/capacity.rs new file mode 100644 index 000000000..5aa5c138d --- /dev/null +++ b/ts/fixtures/lang/src/capacity.rs @@ -0,0 +1,264 @@ +//! 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. + +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()); +} + +/// 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(), + }; + put(out, v.capacity()); + for step in steps.chunks(2) { + let (op, arg) = (step[0], step.get(1).copied().unwrap_or(0)); + match op % 24 { + 0 | 1 => v.push(make(arg)), + 2 => drop(v.pop()), + 3 => v.reserve(amount(arg, v.len(), size)), + 4 => v.reserve_exact(amount(arg, v.len(), size)), + 5 => v.shrink_to(usize::from(arg % 40)), + 6 => v.shrink_to_fit(), + 7 => v.truncate(usize::from(arg % 8)), + 8 => v.insert(usize::from(arg) % (v.len() + 1), make(arg)), + 9 if !v.is_empty() => drop(v.remove(usize::from(arg) % v.len())), + // 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)]), + 13 => v.clear(), + 14 => { + let mut keep = alternate(); + v.retain(|_| keep()); + } + 15 => drop(v.drain(..v.len().min(usize::from(arg % 4)))), + 16 => v = v.clone(), + 17 => v = v.into_boxed_slice().into_vec(), + // 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(); + } + 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(); + } + 20 => { + let mut taken = mem::take(&mut v); + taken.push(make(arg)); + put(out, taken.capacity()); + v = mem::replace(&mut taken, Vec::with_capacity(usize::from(arg % 6))); + put(out, taken.capacity()); + } + 21 if !v.is_empty() => drop(v.swap_remove(usize::from(arg) % v.len())), + 22 => v.dedup(), + _ => v = vec![make(arg); usize::from(arg % 6)], + } + put(out, v.len()); + put(out, 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(), + }; + put(out, q.capacity()); + for step in steps.chunks(2) { + let (op, arg) = (step[0], step.get(1).copied().unwrap_or(0)); + match op % 20 { + 0 => q.push_back(make(arg)), + 1 => q.push_front(make(arg)), + 2 => drop(q.pop_front()), + 3 => q.reserve(amount(arg, q.len(), size)), + 4 => q.reserve_exact(amount(arg, q.len(), size)), + 5 => q.shrink_to(usize::from(arg % 40)), + 6 => q.shrink_to_fit(), + 7 => q.truncate(usize::from(arg % 8)), + 8 => q.insert(usize::from(arg) % (q.len() + 1), make(arg)), + 9 => drop(q.remove(usize::from(arg) % (q.len() + 1))), + 10 => q.extend((0..arg % 24).filter(|i| i % 3 != 0).map(make)), + 11 => q.extend((0..arg % 24).map(make)), + 12 => q.clear(), + 13 => { + let mut keep = alternate(); + q.retain(|_| keep()); + } + 14 => drop(q.drain(..q.len().min(usize::from(arg % 4)))), + 15 => q = q.clone(), + // Its own, and a `Vec`'s in place of one, and one it collects first. + 16 => q = q.into_iter().collect(), + 17 => q = VecDeque::from(q.into_iter().collect::>()), + 18 => { + let mut keep = alternate(); + q = q.into_iter().filter(|_| keep()).collect(); + } + _ => q = VecDeque::from([make(arg), make(arg), make(arg)]), + } + put(out, q.len()); + put(out, 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(), + }; + 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 % 12 { + 0 | 1 => h.push(make(arg)), + 2 => drop(h.pop()), + 3 => h.reserve(amount(arg, h.len(), size)), + 4 => h.reserve_exact(amount(arg, h.len(), size)), + 5 => h.shrink_to(usize::from(arg % 40)), + 6 => h.shrink_to_fit(), + 7 => h.clear(), + 8 => h.extend((0..arg % 24).filter(|i| i % 3 != 0).map(make)), + 9 => { + other.push(make(arg)); + h.append(&mut other); + put(out, other.capacity()); + } + 10 => drop(h.drain()), + _ => h = BinaryHeap::from(h.into_vec()), + } + put(out, h.len()); + put(out, h.capacity()); + } + put(out, h.clone().into_vec().capacity()); + put(out, h.into_sorted_vec().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))); + match kind % 8 { + // Two `u32`s to one, which fit twice as many. + 0 => { + let halves: Vec = pairs.into_iter().map(|(a, _)| a).collect(); + put(out, halves.capacity()); + } + // Bytes in place of bytes, and pairs of bytes in place of bytes, which fit half. + 1 => { + let mut bytes = Vec::with_capacity(n + 3); + bytes.extend_from_slice(&data[..n.min(data.len())]); + let odd: Vec = bytes.clone().into_iter().filter(|b| b % 2 == 1).collect(); + put(out, odd.capacity()); + let wide: Vec = bytes.into_iter().map(u16::from).collect(); + put(out, wide.capacity()); + } + 2 => { + let (a, b): (Vec, VecDeque) = pairs.iter().filter(|(a, _)| a % 2 == 0).copied().unzip(); + put(out, a.capacity()); + put(out, b.capacity()); + let (c, d): (Vec, BinaryHeap) = pairs.iter().map(|&(a, b)| (a as u8, b)).unzip(); + put(out, c.capacity()); + put(out, d.capacity()); + } + 3 => { + let filled = vec![0u16; n]; + put(out, filled.capacity()); + let units = vec![(); n]; + put(out, 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())]); + put(out, VecDeque::from(bytes.clone()).capacity()); + let heap = BinaryHeap::from(bytes); + put(out, heap.capacity()); + put(out, heap.into_vec().capacity()); + } + _ => { + let bytes = vec![7u8; n]; + let mut grown = bytes.clone(); + grown.extend((0..n as u8).filter(|b| b % 2 == 0)); + put(out, grown.capacity()); + grown.shrink_to(n / 2); + put(out, grown.capacity()); + } + } +} diff --git a/ts/fixtures/lang/src/harness.rs b/ts/fixtures/lang/src/harness.rs index 4c5f244ff..e1f040042 100644 --- a/ts/fixtures/lang/src/harness.rs +++ b/ts/fixtures/lang/src/harness.rs @@ -2,7 +2,7 @@ //! case and the rest is its input. use crate::{ - arrays, ascii, atomics, borrows, bounds, boxes, captures, cells, chars, chunks, clones, collections, combinators, + arrays, ascii, atomics, borrows, bounds, boxes, capacity, captures, cells, chars, chunks, clones, collections, combinators, counts, cows, cycles, defaults, durations, dyns, edits, errors, floats, fmt, folds, generics, hashes, hints, holds, ints, iters, joins, keys, lengths, lists, locals, locks, methods, nested, objects, orders, pointers, refs, saturates, separated, shapes, singles, slices, splits, statics, strs, tuples, utf8, wrappers, wraps, zeros, @@ -262,6 +262,10 @@ fn cases() -> Vec<(&'static str, Case)> { pointers::part_written(data, out) }), ("arrays::flattened", arrays::flattened), + ("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 b7d37569a..8df3423f4 100644 --- a/ts/fixtures/lang/src/lib.rs +++ b/ts/fixtures/lang/src/lib.rs @@ -16,7 +16,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. //! @@ -31,6 +32,7 @@ mod atomics; mod borrows; mod bounds; mod boxes; +mod capacity; mod captures; mod cells; mod chars; diff --git a/ts/fixtures/stock/expected/buf.ts b/ts/fixtures/stock/expected/buf.ts index cc03bd968..2a8332cfd 100644 --- a/ts/fixtures/stock/expected/buf.ts +++ b/ts/fixtures/stock/expected/buf.ts @@ -33,12 +33,12 @@ export function bytesMut(data: rt.ByteSlice, out: rt.ByteVec): void { rt.bytesMutPutWord(buf, rt.u16Mul(n & 0xffff, 257), 2, false); } else if (_20 === 3) { const _34: rt.BytesMut = rt.bytesMutSplitTo(buf, rt.usizeRem(n, rt.usizeAdd(buf.length, 2))); - pieces.push(_34); + rt.vecPush(pieces, _34, 16); } else if (_20 === 4) { - const _42: rt.BytesMut | undefined = pieces.pop(); + const _42: rt.BytesMut | undefined = rt.vecPop(pieces); if (_42 !== undefined) { const _48: rt.ByteSlice = rt.bytesMutFreeze(_42); - frozen.push(_48); + rt.vecPush(frozen, _48, 16); } } else if (_20 === 5) { rt.bytesMutTruncate(buf, rt.usizeRem(n, rt.usizeAdd(buf.length, 2))); @@ -63,7 +63,7 @@ export function bytesMut(data: rt.ByteSlice, out: rt.ByteVec): void { rt.bytesMutReserve(fresh, _80); } } else if (_20 === 8) { - const _95: rt.BytesMut | undefined = pieces.pop(); + const _95: rt.BytesMut | undefined = rt.vecPop(pieces); if (_95 !== undefined) { rt.bytesMutUnsplit(buf, _95); } @@ -76,10 +76,10 @@ export function bytesMut(data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_20 === 12) { const buf2 = buf; const _115: rt.BytesMut = rt.bytesMutSplitTo(buf2, buf2.length); - pieces.push(_115); + rt.vecPush(pieces, _115, 16); } else if (_20 === 13) { const _118: rt.ByteSlice = rt.bytesMutFreeze(rt.bytesMutSplitTo(buf, rt.usizeRem(n, rt.usizeAdd(buf.length, 2)))); - frozen.push(_118); + rt.vecPush(frozen, _118, 16); } else if (_20 === 14) { rt.bytesMutPutFill(buf, n & 0xff, rt.usizeRem(n, 9)); } else if (_20 === 15) { diff --git a/ts/fixtures/stock/expected/harness.ts b/ts/fixtures/stock/expected/harness.ts index 793b1d401..c39b65e87 100644 --- a/ts/fixtures/stock/expected/harness.ts +++ b/ts/fixtures/stock/expected/harness.ts @@ -92,7 +92,7 @@ export function slices(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, rt.byteSliceEq(part, bytes) ? 1 : 0); rt.byteVecPush(out, rt.byteSliceEq(part, rt.byteSliceRange(part, 0)) ? 1 : 0); rt.byteVecPush(out, rt.byteSliceEq(rt.bytesSlice(rt.bytesSlice(bytes, rt.min(a, data.length - 3)), 0, 0), rt.bytesNew()) ? 1 : 0); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.byteSliceToByteVec(part))); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.bytesToByteVec(part))); } } diff --git a/ts/fixtures/task/expected/drops.ts b/ts/fixtures/task/expected/drops.ts index 9241586ea..0a955e0b4 100644 --- a/ts/fixtures/task/expected/drops.ts +++ b/ts/fixtures/task/expected/drops.ts @@ -78,10 +78,10 @@ export function run(log: Log.Log, id: rt.u32, arg: rt.u8): void { } else if (_6 === 0) { const v: Held.Held[] = []; const _12 = { tag: "One", _0: guard(1) } as Held.Held; - v.push(_12); - v.push({ tag: "Empty" } as Held.Held); + rt.vecPush(v, _12, 20); + rt.vecPush(v, { tag: "Empty" } as Held.Held, 20); const _21 = { tag: "Two", _0: guard(2), _1: guard(3) } as Held.Held; - v.push(_21); + rt.vecPush(v, _21, 20); const held: Held.Held[] = v; const arc: rt.Arc = new rt.Arc({ tag: "One", _0: guard(4) } as Held.Held); const shared: rt.Arc = rt.arcClone(arc); @@ -96,7 +96,7 @@ export function run(log: Log.Log, id: rt.u32, arg: rt.u8): void { rt.arcDrop(cloned, lib_drop$drops_Held); const v2: Held.Held[] = []; const _70 = { tag: "One", _0: guard(5) } as Held.Held; - v2.push(_70); + rt.vecPush(v2, _70, 20); const mutex: rt.Mutex = new rt.Mutex(v2); const boxed: Held.Held = { tag: "Two", _0: guard(6), _1: guard(7) }; const maybe: Held.Held | undefined = { tag: "One", _0: guard(8) }; @@ -115,9 +115,9 @@ export function run(log: Log.Log, id: rt.u32, arg: rt.u8): void { const pair: Pair.Pair = new Pair.Pair({ tag: "Two", _0: guard(31), _1: guard(32) } as Held.Held, guard(33)); const v3: Pair.Pair[] = []; const _136: Pair.Pair = new Pair.Pair(guard(41), guard(42)); - v3.push(_136); + rt.vecPush(v3, _136, 16); const _145: Pair.Pair = new Pair.Pair(guard(43), guard(44)); - v3.push(_145); + rt.vecPush(v3, _145, 16); const pairs: Pair.Pair[] = v3; const _owned: Named.Named = new Named.Named({ tag: "Owned", _0: guard(45) } as Text.Text); const _161: rt.u32 = rt.u32Add(id, 50); @@ -125,7 +125,7 @@ export function run(log: Log.Log, id: rt.u32, arg: rt.u8): void { const v4: Wrap.Wrap[] = []; const _borrowed: Named.Named = new Named.Named({ tag: "Borrowed", _0: "text" } as Text.Text); const _168: Wrap.Wrap = new Wrap.Wrap(rt.u32Add(id, 60), Log.clone$Clone(log), { tag: "One", _0: guard(61) } as Held.Held); - v4.push(_168); + rt.vecPush(v4, _168, 28); const nested: Wrap.Wrap[]> = new Wrap.Wrap(_161, _163, v4); lib_drop$drops_Pair_drops_Held(pair); const _183: boolean = Held.isSome(wrapped.inner); @@ -143,9 +143,9 @@ export function run(log: Log.Log, id: rt.u32, arg: rt.u8): void { const shared2: rt.Arc>> = new rt.Arc(new Wrap.Wrap(rt.u32Add(id, 70), Log.clone$Clone(log), new Pair.Pair({ tag: "One", _0: guard(71) } as Held.Held, guard(72)))); const v5: rt.Arc>>[] = []; const _227: rt.Arc>> = rt.arcClone(shared2); - v5.push(_227); + rt.vecPush(v5, _227, 4); const _231: rt.Arc>> = rt.arcClone(shared2); - v5.push(_231); + rt.vecPush(v5, _231, 4); const clones: rt.Arc>>[] = v5; rt.arcDrop(shared2, lib_drop$drops_Wrap_drops_Pair_drops_Held); const part2 = clones.length; @@ -187,7 +187,7 @@ export function run(log: Log.Log, id: rt.u32, arg: rt.u8): void { export function bail(log: Log.Log, id: rt.u32, fails: boolean): rt.Result { const v: Held.Held[] = []; const _8 = { tag: "One", _0: Guard.new(rt.u32Add(id, 90), Log.clone$Clone(log)) } as Held.Held; - v.push(_8); + rt.vecPush(v, _8, 20); const held: Held.Held[] = v; const wrap: Wrap.Wrap = new Wrap.Wrap(rt.u32Add(id, 91), Log.clone$Clone(log), { tag: "Empty" } as Held.Held); const _18: rt.Result = failed(fails); @@ -257,8 +257,8 @@ export class heldFuture { this.#id = Guard.id(this.#guard); const v: Held.Held[] = []; const _9 = { tag: "One", _0: Guard.new(rt.u32Add(this.#id, 500), Log.clone$Clone(this.#log)) } as Held.Held; - v.push(_9); - v.push({ tag: "Empty" } as Held.Held); + rt.vecPush(v, _9, 20); + rt.vecPush(v, { tag: "Empty" } as Held.Held, 20); this.#held = v; this.#wrap = new Wrap.Wrap(rt.u32Add(this.#id, 510), Log.clone$Clone(this.#log), new rt.Arc({ tag: "One", _0: Guard.new(rt.u32Add(this.#id, 520), Log.clone$Clone(this.#log)) } as Held.Held)); this.#awaitee = new recvFuture$kio_Consumer(this.#rx); @@ -384,10 +384,10 @@ export function ordered(log: Log.Log, id: rt.u32): void { const iterEnd: rt.u32 = 26; while ((_208 = iterStart++) < iterEnd) { const _214: Guard.Guard = guard(_208); - rt.dequePushBack(queue, _214); + rt.dequePushBack(queue, _214, 8); } const _219: Guard.Guard = guard(19); - rt.dequePushFront(queue, _219); + rt.dequePushFront(queue, _219, 8); rt.dequeRetain(queue, (g: Guard.Guard): boolean => { return rt.u32Rem(Guard.id(g), 3) !== 0; }, rt.drop); @@ -811,11 +811,11 @@ export function elements(log: Log.Log, id: rt.u32): void { }; const v2: Array = []; const _12: Guard.Guard | undefined = guard(1); - v2.push(_12); - v2.push(undefined as Guard.Guard | undefined); + rt.vecPush(v2, _12, 8); + rt.vecPush(v2, undefined as Guard.Guard | undefined, 8); const _21: Guard.Guard | undefined = guard(2); - v2.push(_21); - v2.push(undefined as Guard.Guard | undefined); + rt.vecPush(v2, _21, 8); + rt.vecPush(v2, undefined as Guard.Guard | undefined, 8); const v: Array = v2; const _34: rt.u32 | undefined | rt.None = option_map$0ccnsmq(rt.sliceFirst(v, rt.None), (o5: Guard.Guard | undefined): rt.u32 | undefined => { return option_map$0lq7mno(o5, Guard.id); @@ -894,7 +894,7 @@ export function elements(log: Log.Log, id: rt.u32): void { const _145: string = rt.fmtFormat(["uncalled ", args12[0]]); rt.drop(_151); Log.note(log, _145); - v.push(undefined as Guard.Guard | undefined); + rt.vecPush(v, undefined as Guard.Guard | undefined, 8); const captured2 = guard(15); const part8 = option_map$0ccnsmq(rt.vecPopIfMut(v, rt.closure((o13: rt.Place): boolean => { const part6 = Guard.id(captured2); @@ -913,12 +913,12 @@ export function elements(log: Log.Log, id: rt.u32): void { const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part8, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; Log.note(log, rt.fmtFormat(["called ", args14[0]])); const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; - rt.dequePushBack(q, undefined as Guard.Guard | undefined); + rt.dequePushBack(q, undefined as Guard.Guard | undefined, 8); const _186: Guard.Guard | undefined = guard(4); - rt.dequePushBack(q, _186); + rt.dequePushBack(q, _186, 8); const _192: Guard.Guard | undefined = guard(5); - rt.dequePushFront(q, _192); - rt.dequePushBack(q, undefined as Guard.Guard | undefined); + rt.dequePushFront(q, _192, 8); + rt.dequePushBack(q, undefined as Guard.Guard | undefined, 8); const _205: rt.u32 | undefined | rt.None = option_map$0ccnsmq(rt.dequeEnd(q, false, rt.None), (o15: Guard.Guard | undefined): rt.u32 | undefined => { return option_map$0lq7mno(o15, Guard.id); }); @@ -948,10 +948,10 @@ export function elements(log: Log.Log, id: rt.u32): void { Log.note(log, rt.fmtFormat(["remove ", args18[0], " ", args18[1]])); rt.drop(removed); const _252: Guard.Guard | undefined = guard(6); - rt.dequePushBack(q, _252); + rt.dequePushBack(q, _252, 8); const _258: Guard.Guard | undefined = guard(13); - rt.dequePushBack(q, _258); - rt.dequePushFront(q, undefined as Guard.Guard | undefined); + rt.dequePushBack(q, _258, 8); + rt.dequePushFront(q, undefined as Guard.Guard | undefined, 8); const back: Guard.Guard | undefined | rt.None = rt.dequeSwapRemove(q, 0, true, rt.None); const _273: rt.u32 | undefined | rt.None = option_map$0ccnsmq(back, (o20: Guard.Guard | undefined): rt.u32 | undefined => { return option_map$0lq7mno(o20, Guard.id); @@ -1001,10 +1001,10 @@ export function elements(log: Log.Log, id: rt.u32): void { Log.note(log, rt.fmtFormat(["emptied ", args26[0], " ", args26[1]])); const heap: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; const _352: Key.Key | undefined = key(7); - rt.heapPush(heap, _352, rt.cmpLe(rt.cmpOption(Key.partialCmp$cmp_PartialOrd))); - rt.heapPush(heap, undefined as Key.Key | undefined, rt.cmpLe(rt.cmpOption(Key.partialCmp$cmp_PartialOrd))); + rt.heapPush(heap, _352, rt.cmpLe(rt.cmpOption(Key.partialCmp$cmp_PartialOrd)), 12); + rt.heapPush(heap, undefined as Key.Key | undefined, rt.cmpLe(rt.cmpOption(Key.partialCmp$cmp_PartialOrd)), 12); const _361: Key.Key | undefined = key(8); - rt.heapPush(heap, _361, rt.cmpLe(rt.cmpOption(Key.partialCmp$cmp_PartialOrd))); + rt.heapPush(heap, _361, rt.cmpLe(rt.cmpOption(Key.partialCmp$cmp_PartialOrd)), 12); const part17 = option_map$0hegtde(rt.heapPeek(heap, rt.None), (o26: Key.Key | undefined): rt.u32 | undefined => { return option_map$0782hf5(o26, (k2: Key.Key): rt.u32 => { return k2.id; @@ -1302,13 +1302,13 @@ export function edited(log: Log.Log, id: rt.u32, arg: rt.u8): void { if (_8 === 0) { const v2: Key.Key[] = []; const _14: Key.Key = key(1); - v2.push(_14); + rt.vecPush(v2, _14, 12); const _19: Key.Key = key(2); - v2.push(_19); + rt.vecPush(v2, _19, 12); const _24: Key.Key = key(3); - v2.push(_24); + rt.vecPush(v2, _24, 12); const _29: Key.Key = key(4); - v2.push(_29); + rt.vecPush(v2, _29, 12); const v: Key.Key[] = v2; rt.vecRetain(v, (k6: Key.Key): boolean => { return rt.u32Rem(rt.u32Sub(k6.id, id), 2) === 1; @@ -1326,15 +1326,15 @@ export function edited(log: Log.Log, id: rt.u32, arg: rt.u8): void { } else if (_8 === 1) { const v4: Key.Key[] = []; const _74: Key.Key = key(1); - v4.push(_74); + rt.vecPush(v4, _74, 12); const _79: Key.Key = key(1); - v4.push(_79); + rt.vecPush(v4, _79, 12); const _84: Key.Key = key(2); - v4.push(_84); + rt.vecPush(v4, _84, 12); const _89: Key.Key = key(2); - v4.push(_89); + rt.vecPush(v4, _89, 12); const _94: Key.Key = key(3); - v4.push(_94); + rt.vecPush(v4, _94, 12); const v3: Key.Key[] = v4; rt.vecDedupBy(v3, Key.eq$cmp_PartialEq, rt.drop); const part19 = ids(v3); @@ -1356,11 +1356,11 @@ export function edited(log: Log.Log, id: rt.u32, arg: rt.u8): void { } else if (_8 === 2) { const v6: Key.Key[] = []; const _152: Key.Key = key(1); - v6.push(_152); + rt.vecPush(v6, _152, 12); const _157: Key.Key = key(2); - v6.push(_157); + rt.vecPush(v6, _157, 12); const _162: Key.Key = key(3); - v6.push(_162); + rt.vecPush(v6, _162, 12); const v5: Key.Key[] = v6; rt.vecSwapRemove(v5, 0)[Symbol.dispose](); const part17 = ids(v5); @@ -1371,9 +1371,9 @@ export function edited(log: Log.Log, id: rt.u32, arg: rt.u8): void { } else if (_8 === 3) { const v8: Key.Key[] = []; const _190: Key.Key = key(1); - v8.push(_190); + rt.vecPush(v8, _190, 12); const _195: Key.Key = key(2); - v8.push(_195); + rt.vecPush(v8, _195, 12); const v7: Key.Key[] = v8; const _209: Key.Key[] = v7.map(Key.clone$Clone); const part15 = ids(_209); @@ -1389,14 +1389,14 @@ export function edited(log: Log.Log, id: rt.u32, arg: rt.u8): void { } else if (_8 === 5) { const v10: Key.Key[] = []; const _229: Key.Key = key(1); - v10.push(_229); + rt.vecPush(v10, _229, 12); const _234: Key.Key = key(2); - v10.push(_234); + rt.vecPush(v10, _234, 12); const _239: Key.Key = key(3); - v10.push(_239); + rt.vecPush(v10, _239, 12); const v9: Key.Key[] = v10; const _244: Key.Key = key(4); - rt.vecInsert(v9, 1, _244); + rt.vecInsert(v9, 1, _244, 12); const part9 = ids(v9); const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part9)]; Log.note(log, rt.fmtFormat(["inserted ", args16[0]])); @@ -1413,11 +1413,11 @@ export function edited(log: Log.Log, id: rt.u32, arg: rt.u8): void { } else if (_8 === 6) { const v11: Key.Key[] = []; const _305: Key.Key = key(1); - v11.push(_305); + rt.vecPush(v11, _305, 12); const _310: Key.Key = key(3); - v11.push(_310); + rt.vecPush(v11, _310, 12); const _315: Key.Key = key(5); - v11.push(_315); + rt.vecPush(v11, _315, 12); const part6 = option_mapOr$1w10sgd(rt.iterMaxByKey(rt.iterSlice(v11, rt.drop), (k2: Key.Key): rt.u32 => { return rt.u32Rem(rt.u32Sub(k2.id, id), 3); }, rt.lt, true, rt.drop), 0, (k3: Key.Key): rt.u32 => { @@ -1429,11 +1429,11 @@ export function edited(log: Log.Log, id: rt.u32, arg: rt.u8): void { Log.note(log, rt.fmtFormat(["max ", args22[0]])); const v12: Key.Key[] = []; const _339: Key.Key = key(3); - v12.push(_339); + rt.vecPush(v12, _339, 12); const _344: Key.Key = key(1); - v12.push(_344); + rt.vecPush(v12, _344, 12); const _349: Key.Key = key(2); - v12.push(_349); + rt.vecPush(v12, _349, 12); const part7 = option_mapOr$1w10sgd(rt.iterMin(rt.iterSlice(v12, rt.drop), rt.cmpLt(Key.partialCmp$cmp_PartialOrd), true, rt.drop), 0, (k4: Key.Key): rt.u32 => { const _06: rt.u32 = rt.u32Sub(k4.id, id); k4[Symbol.dispose](); diff --git a/ts/fixtures/task/expected/drops/closures.ts b/ts/fixtures/task/expected/drops/closures.ts index e0e53ec42..796881140 100644 --- a/ts/fixtures/task/expected/drops/closures.ts +++ b/ts/fixtures/task/expected/drops/closures.ts @@ -125,7 +125,7 @@ export function scoped(log: Log.Log, id: rt.u32): void { const held: Guard.Guard[] = []; let captured11 = held; const push: (a0: Guard.Guard) => rt.usize = rt.closure((g2: Guard.Guard): rt.usize => { - captured11.push(g2); + rt.vecPush(captured11, g2, 8); return captured11.length; }, (): void => { rt.dropAll(captured11); @@ -362,11 +362,11 @@ export function iterated(log: Log.Log, id: rt.u32): void { const a: Guard.Guard = guard(1); const v: Guard.Guard[] = []; const _14: Guard.Guard = guard(2); - v.push(_14); + rt.vecPush(v, _14, 8); const _19: Guard.Guard = guard(3); - v.push(_19); + rt.vecPush(v, _19, 8); const _24: Guard.Guard = guard(4); - v.push(_24); + rt.vecPush(v, _24, 8); const _9: rt.Iter = rt.iterSlice(v, rt.drop); const captured = a; const mapped: rt.Iter = rt.iterMap(_9, rt.closure((g3: Guard.Guard): rt.u32 => { @@ -384,11 +384,11 @@ export function iterated(log: Log.Log, id: rt.u32): void { const b: Guard.Guard = guard(5); const v2: Guard.Guard[] = []; const _56: Guard.Guard = guard(6); - v2.push(_56); + rt.vecPush(v2, _56, 8); const _61: Guard.Guard = guard(7); - v2.push(_61); + rt.vecPush(v2, _61, 8); const _66: Guard.Guard = guard(8); - v2.push(_66); + rt.vecPush(v2, _66, 8); const _51: rt.Iter = rt.iterSlice(v2, rt.drop); const captured2 = b; const iter: rt.Iter = rt.iterFilter(_51, rt.closure((g4: Guard.Guard): boolean => { @@ -419,13 +419,13 @@ export function iterated(log: Log.Log, id: rt.u32): void { const e: Guard.Guard = _95[2]; const v3: Guard.Guard[] = []; const _113: Guard.Guard = guard(12); - v3.push(_113); + rt.vecPush(v3, _113, 8); const _118: Guard.Guard = guard(13); - v3.push(_118); + rt.vecPush(v3, _118, 8); const _123: Guard.Guard = guard(14); - v3.push(_123); + rt.vecPush(v3, _123, 8); const _128: Guard.Guard = guard(15); - v3.push(_128); + rt.vecPush(v3, _128, 8); const _108: rt.Iter = rt.iterSlice(v3, rt.drop); const captured3 = c; const _107: rt.Iter = rt.iterSkipWhile(_108, rt.closure((g5: Guard.Guard): boolean => { @@ -467,9 +467,9 @@ export function iterated(log: Log.Log, id: rt.u32): void { f = _164[0]; const g2: Guard.Guard = _164[1]; const v4: rt.u32[] = []; - v4.push(1); - v4.push(2); - v4.push(3); + rt.vecPush(v4, 1, 4); + rt.vecPush(v4, 2, 4); + rt.vecPush(v4, 3, 4); const _173: rt.Iter = rt.iterSlice(v4); const captured6 = f; const _172: rt.Iter = rt.iterFilterMap(_173, rt.closure((n4: rt.u32): rt.u32 | undefined => { @@ -480,9 +480,9 @@ export function iterated(log: Log.Log, id: rt.u32): void { const captured7 = g2; const flat: rt.Iter = rt.iterFlatMap(_172, rt.closure((n5: rt.u32): rt.u32[] => { const v7: rt.u32[] = []; - v7.push(n5); + rt.vecPush(v7, n5, 4); const _8: rt.u32 = rt.u32Add(n5, Guard.id(captured7)); - v7.push(_8); + rt.vecPush(v7, _8, 4); return v7; }, (): void => { captured7[Symbol.dispose](); @@ -557,11 +557,11 @@ export function iterated(log: Log.Log, id: rt.u32): void { rt.drop(chain); const v5: Guard.Guard[] = []; const _297: Guard.Guard = guard(21); - v5.push(_297); + rt.vecPush(v5, _297, 8); const _302: Guard.Guard = guard(22); - v5.push(_302); + rt.vecPush(v5, _302, 8); const _307: Guard.Guard = guard(23); - v5.push(_307); + rt.vecPush(v5, _307, 8); const items: Guard.Guard[] = v5; const _313: [Guard.Guard, Guard.Guard, Guard.Guard] = [guard(24), guard(25), guard(26)]; const k: Guard.Guard = _313[0]; @@ -680,9 +680,9 @@ export function iterated(log: Log.Log, id: rt.u32): void { rt.dropAfter(_475, () => rt.btreeRetain(map, _475, undefined, rt.drop)); const queue: rt.VecDeque = rt.dequeNew() as rt.VecDeque; const _479: Guard.Guard = guard(33); - rt.dequePushBack(queue, _479); + rt.dequePushBack(queue, _479, 8); const _484: Guard.Guard = guard(34); - rt.dequePushBack(queue, _484); + rt.dequePushBack(queue, _484, 8); const captured24 = guard(35); const _492: (a0: Guard.Guard) => boolean = rt.closure((g19: Guard.Guard): boolean => { return rt.u32Add(Guard.id(g19), 2) !== Guard.id(captured24); diff --git a/ts/fixtures/task/expected/drops/folds.ts b/ts/fixtures/task/expected/drops/folds.ts index 37c30a472..f85fecc92 100644 --- a/ts/fixtures/task/expected/drops/folds.ts +++ b/ts/fixtures/task/expected/drops/folds.ts @@ -186,7 +186,7 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { const _169: rt.Iter = rt.iterSlice(guards(1, 4), rt.drop); _1090 = false; const captured56 = c; - const same: Guard.Guard[] = rt.iterToArray(rt.iterMap(_169, rt.closure((g68: Guard.Guard): Guard.Guard => { + const same: Guard.Guard[] = rt.iterToArrayInPlace(rt.iterMap(_169, rt.closure((g68: Guard.Guard): Guard.Guard => { const _976: rt.u32 = Guard.id(g68); const _1224: rt.u32 = Guard.id(captured56); const args102: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_976, f), (f: rt.Formatter) => rt.u32Display(_1224, f)]; @@ -194,7 +194,7 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { return g68; }, (): void => { captured56[Symbol.dispose](); - })), "next", 8, true); + })), 8, 8, false, "next", true); const _176: rt.Iter = rt.iterSlice(guards(4, 7), rt.drop); _1089 = false; const captured57 = d; @@ -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.iterToArrayInPlace(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))); + })), 8, 8, false, "next", true), 8) as rt.VecDeque; const _206: rt.Iter = rt.iterSlice(guards(4, 7), rt.drop); _1089 = false; const captured55 = d; @@ -524,9 +523,9 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { const n11: rt.usize = rt.ownedCount(rt.iterFlatMap(_553, rt.closure((n33: rt.u32): Guard.Guard[] => { const v6: Guard.Guard[] = []; const _659: Guard.Guard = captured29(n33); - v6.push(_659); + rt.vecPush(v6, _659, 8); const _1128: Guard.Guard = captured29(rt.u32Add(n33, 1)); - v6.push(_1128); + rt.vecPush(v6, _1128, 8); const _226: rt.u32 = Guard.id(captured30); const args88: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n33, f), (f: rt.Formatter) => rt.u32Display(_226, f)]; Log.note(log, rt.fmtFormat(["flat ", args88[0], " ", args88[1]])); @@ -545,9 +544,9 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { const captured25 = id; const flat: rt.Iter = rt.iterFlatten(rt.iterMap(_572, rt.closure((g35: Guard.Guard): Guard.Guard[] => { const v3: Guard.Guard[] = []; - v3.push(g35); + rt.vecPush(v3, g35, 8); const _818: Guard.Guard = captured23(rt.u32Add(rt.u32Sub(Guard.id(captured24), captured25), 1)); - v3.push(_818); + rt.vecPush(v3, _818, 8); return v3; }, (): void => { captured24[Symbol.dispose](); @@ -572,9 +571,9 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { const _606: rt.u32 | undefined = option_map$1raha9y(rt.ownedLast(rt.iterFlatMap(_597, rt.closure((n32: rt.u32): Guard.Guard[] => { const v4: Guard.Guard[] = []; const _658: Guard.Guard = captured26(n32); - v4.push(_658); + rt.vecPush(v4, _658, 8); const _1125: Guard.Guard = captured26(rt.u32Add(rt.u32Sub(Guard.id(captured27), captured28), n32)); - v4.push(_1125); + rt.vecPush(v4, _1125, 8); return v4; }, (): void => { captured27[Symbol.dispose](); @@ -591,7 +590,7 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { let captured19 = held; const captured20 = c; const n13: rt.usize = rt.ownedCount(rt.iterFromFn(rt.closure((): rt.u32 | undefined => { - const _336: Guard.Guard | undefined = captured19.pop(); + const _336: Guard.Guard | undefined = rt.vecPop(captured19); if (_336 !== undefined) { const g32: Guard.Guard = _336; const _034: rt.u32 | undefined = rt.u32Add(Guard.id(g32), Guard.id(captured20)); @@ -764,9 +763,9 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { const captured9 = id; const flat2: rt.Iter = rt.iterFlatten(rt.iterMap(_843, rt.closure((g14: Guard.Guard): Guard.Guard[] => { const v2: Guard.Guard[] = []; - v2.push(g14); + rt.vecPush(v2, g14, 8); const _86: Guard.Guard = captured7(rt.u32Add(rt.u32Sub(Guard.id(captured8), captured9), 1)); - v2.push(_86); + rt.vecPush(v2, _86, 8); return v2; }, (): void => { captured8[Symbol.dispose](); @@ -1239,8 +1238,8 @@ export function rfolded(log: Log.Log, id: rt.u32, arg: rt.u8): void { Log.note(log, rt.fmtFormat(["map ", args24[0], " ", args24[1]])); const v: Guard.Guard[] = []; const _225: Guard.Guard = captured2(rt.u32Add(rt.u32Sub(Guard.id(g), captured3), 3)); - v.push(_225); - v.push(g); + rt.vecPush(v, _225, 8); + rt.vecPush(v, g, 8); return v; }, (): void => { captured[Symbol.dispose](); @@ -1461,7 +1460,7 @@ export function closures(log: Log.Log, id: rt.u32): void { const _33: rt.Iter = rt.iterSlice(guards(1, 7), rt.drop); const captured = c; const captured2 = pick; - const part2 = rt.iterToArray(rt.iterMap(rt.iterFilterMap(_33, rt.closure((g2: Guard.Guard): Guard.Guard | undefined | rt.None => { + const part2 = rt.iterToArrayInPlace(rt.iterMap(rt.iterFilterMap(_33, rt.closure((g2: Guard.Guard): Guard.Guard | undefined | rt.None => { const _92: rt.u32 = Guard.id(g2); const _127: rt.u32 = Guard.id(captured); const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_92, f), (f: rt.Formatter) => rt.u32Display(_127, f)]; @@ -1475,7 +1474,7 @@ export function closures(log: Log.Log, id: rt.u32): void { g3[Symbol.dispose](); return _06; }); - }), "next", 8); + }), 8, 8, false, "next"); const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part2, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug))]; Log.note(log, rt.fmtFormat(["kept ", args2[0]])); const part3 = rt.iterFold(rt.iterFilterMap(rt.iterSlice(guards(1, 7), rt.drop), pick, rt.None), 0, (n3: rt.u32, o2: Guard.Guard | undefined): rt.u32 => { @@ -1542,7 +1541,7 @@ export function closures(log: Log.Log, id: rt.u32): void { let captured7 = guards(1, 6); const captured8 = f; const made: rt.Iter = rt.iterFromFn(rt.closure((): Guard.Guard | undefined | rt.None => { - const _310: Guard.Guard | undefined = captured7.pop(); + const _310: Guard.Guard | undefined = rt.vecPop(captured7); if (_310 !== undefined) { const g10: Guard.Guard = _310; const _144: rt.u32 = Guard.id(g10); @@ -1726,11 +1725,11 @@ export function zips(log: Log.Log, id: rt.u32, arg: rt.u8): void { })); const captured3 = d; const captured4 = id; - const kept: rt.u32[] = rt.iterToArray(rt.iterMap(_190, rt.closure((x2: rt.u32): rt.u32 => { + const kept: rt.u32[] = rt.iterToArrayInPlace(rt.iterMap(_190, rt.closure((x2: rt.u32): rt.u32 => { return rt.u32Sub(rt.u32Add(x2, Guard.id(captured3)), captured4); }, (): void => { captured3[Symbol.dispose](); - })), "next", 4, true); + })), 4, 4, false, "next", true); const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(n3, f), (f: rt.Formatter) => rt.fmtOption(at, f, rt.usizeDebug), (f: rt.Formatter) => rt.u32Display(sum, f), (f: rt.Formatter) => rt.usizeDisplay(skipped, f), (f: rt.Formatter) => rt.fmtList(kept, f, rt.u32Debug)]; Log.note(log, rt.fmtFormat(["no coerce ", args8[0], " ", args8[1], " ", args8[2], " ", args8[3], " ", args8[4]])); } else if (arg === 4) { diff --git a/ts/fixtures/task/expected/drops/inside.ts b/ts/fixtures/task/expected/drops/inside.ts index 95566a798..9238113f8 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), 8) as rt.VecDeque; const it: rt.Iter = rt.dropAfter(new Spent.Spent(guard(11), 0, 2), (range13) => rt.dequeDrain(q, rt.boundsOf(range13, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rt.drop), rt.drop); const part17 = option_map$1raha9y(rt.iterToOption(it.next()), (g12: Guard.Guard): rt.u32 => { const _012: rt.u32 = Guard.id(g12); diff --git a/ts/fixtures/task/expected/drops/iters.ts b/ts/fixtures/task/expected/drops/iters.ts index 42084ce05..55e410109 100644 --- a/ts/fixtures/task/expected/drops/iters.ts +++ b/ts/fixtures/task/expected/drops/iters.ts @@ -14,11 +14,11 @@ export function looped(log: Log.Log, id: rt.u32): void { }; const v: Guard.Guard[] = []; const _10: Guard.Guard = guard(1); - v.push(_10); + rt.vecPush(v, _10, 8); const _15: Guard.Guard = guard(2); - v.push(_15); + rt.vecPush(v, _15, 8); const _20: Guard.Guard = guard(3); - v.push(_20); + rt.vecPush(v, _20, 8); const iterS: Guard.Guard[] = v; let iterI: number = 0; while (true) { @@ -63,30 +63,30 @@ export function looped(log: Log.Log, id: rt.u32): void { rt.drop(iter3); const v2: Guard.Guard[] = []; const _90: Guard.Guard = guard(8); - v2.push(_90); + rt.vecPush(v2, _90, 8); const _95: Guard.Guard = guard(9); - v2.push(_95); + rt.vecPush(v2, _95, 8); const _100: Guard.Guard = guard(10); - v2.push(_100); + rt.vecPush(v2, _100, 8); const _105: Guard.Guard = guard(11); - v2.push(_105); - const even: Guard.Guard[] = rt.iterToArray(rt.iterFilter(rt.iterSlice(v2, rt.drop), (g4: Guard.Guard): boolean => { + rt.vecPush(v2, _105, 8); + const even: Guard.Guard[] = rt.iterToArrayInPlace(rt.iterFilter(rt.iterSlice(v2, rt.drop), (g4: Guard.Guard): boolean => { return rt.u32Rem(Guard.id(g4), 2) === 0; - }, rt.drop), "next", 8); + }, rt.drop), 8, 8, false, "next"); const part3 = even.length; const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part3, f)]; Log.note(log, rt.fmtFormat(["even ", args6[0]])); const v3: Guard.Guard[] = []; const _127: Guard.Guard = guard(12); - v3.push(_127); + rt.vecPush(v3, _127, 8); const _132: Guard.Guard = guard(13); - v3.push(_132); + rt.vecPush(v3, _132, 8); const _137: Guard.Guard = guard(14); - v3.push(_137); + rt.vecPush(v3, _137, 8); const _142: Guard.Guard = guard(15); - v3.push(_142); + rt.vecPush(v3, _142, 8); const _147: Guard.Guard = guard(16); - v3.push(_147); + rt.vecPush(v3, _147, 8); const rest: rt.Iter = rt.iterTake(rt.iterSkip(rt.iterSlice(v3, rt.drop), 1, rt.drop), 3, rt.drop); const part4 = option_mapOr$01ozsk3(rt.iterToOption(rest.next()), 0, (g5: Guard.Guard): rt.u32 => { const _03: rt.u32 = Guard.id(g5); @@ -100,9 +100,9 @@ export function looped(log: Log.Log, id: rt.u32): void { Log.note(log, rt.fmtFormat(["count ", args10[0]])); const v4: Guard.Guard[] = []; const _181: Guard.Guard = guard(17); - v4.push(_181); + rt.vecPush(v4, _181, 8); const _186: Guard.Guard = guard(18); - v4.push(_186); + rt.vecPush(v4, _186, 8); const peek: rt.Peekable = rt.iterPeekable(rt.iterSlice(v4, rt.drop), rt.drop); const first: Guard.Guard | undefined = rt.peekableNextIf(peek, (g6: Guard.Guard): boolean => { return Guard.id(g6) === rt.u32Add(id, 17); @@ -117,27 +117,27 @@ export function looped(log: Log.Log, id: rt.u32): void { rt.drop(peek); const v5: Guard.Guard[] = []; const _221: Guard.Guard = guard(20); - v5.push(_221); + rt.vecPush(v5, _221, 8); const _226: Guard.Guard = guard(21); - v5.push(_226); + rt.vecPush(v5, _226, 8); const _231: Guard.Guard = guard(22); - v5.push(_231); + rt.vecPush(v5, _231, 8); const _216: rt.Iter = rt.iterSlice(v5, rt.drop); const v6: Guard.Guard[] = []; const _238: Guard.Guard = guard(23); - v6.push(_238); + rt.vecPush(v6, _238, 8); const part6 = rt.ownedCount(rt.iterZip(_216, rt.iterSlice(v6, rt.drop), "len", rt.drop, rt.drop), lib_drop$tuple2_model_Guard_model_Guard); const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part6, f)]; Log.note(log, rt.fmtFormat(["zip ", args14[0]])); const v7: Guard.Guard[] = []; const _261: Guard.Guard = guard(24); - v7.push(_261); + rt.vecPush(v7, _261, 8); const _256: rt.Iter = rt.iterSlice(v7, rt.drop); const v8: Guard.Guard[] = []; const _268: Guard.Guard = guard(25); - v8.push(_268); + rt.vecPush(v8, _268, 8); const _273: Guard.Guard = guard(26); - v8.push(_273); + rt.vecPush(v8, _273, 8); const _254: rt.Iter = rt.iterRev(rt.iterChain(_256, rt.iterSlice(v8, rt.drop))); const nth: Guard.Guard | undefined = rt.iterNth(_254, 1, rt.drop); rt.drop(_254); @@ -150,22 +150,22 @@ export function looped(log: Log.Log, id: rt.u32): void { Log.note(log, rt.fmtFormat(["nth ", args16[0]])); const v9: Guard.Guard[] = []; const _293: Guard.Guard = guard(27); - v9.push(_293); + rt.vecPush(v9, _293, 8); const _298: Guard.Guard = guard(28); - v9.push(_298); + rt.vecPush(v9, _298, 8); const _303: Guard.Guard = guard(29); - v9.push(_303); + rt.vecPush(v9, _303, 8); const best: Guard.Guard | undefined = rt.iterMaxByKey(rt.iterSlice(v9, rt.drop), (g9: Guard.Guard): rt.u32 => { return rt.u32Rem(Guard.id(g9), 2); }, rt.lt, true, rt.drop); const v10: Array = []; const _314: Guard.Guard | undefined = guard(30); - v10.push(_314); - v10.push(undefined as Guard.Guard | undefined); + rt.vecPush(v10, _314, 8); + rt.vecPush(v10, undefined as Guard.Guard | undefined, 8); const _323: Guard.Guard | undefined = guard(31); - v10.push(_323); + rt.vecPush(v10, _323, 8); const _329: Guard.Guard | undefined = guard(32); - v10.push(_329); + rt.vecPush(v10, _329, 8); const _308: rt.Iter = rt.iterFlatten(rt.iterSlice(v10, rt.drop), (value: Guard.Guard | undefined) => rt.iterOption(value, rt.drop), true, undefined, true); const found: Guard.Guard | undefined = rt.iterFind(_308, (g10: Guard.Guard): boolean => { return Guard.id(g10) === rt.u32Add(id, 31); @@ -181,11 +181,11 @@ export function looped(log: Log.Log, id: rt.u32): void { Log.note(log, rt.fmtFormat(["found ", args18[0], " ", args18[1]])); const v11: Guard.Guard[] = []; const _356: Guard.Guard = guard(33); - v11.push(_356); + rt.vecPush(v11, _356, 8); const _361: Guard.Guard = guard(34); - v11.push(_361); + rt.vecPush(v11, _361, 8); const _366: Guard.Guard = guard(35); - v11.push(_366); + rt.vecPush(v11, _366, 8); const folded: rt.u32 = rt.iterFold(rt.iterSlice(v11, rt.drop), 0, (n2: rt.u32, g12: Guard.Guard): rt.u32 => { const _010: rt.u32 = rt.u32Sub(rt.u32Add(n2, Guard.id(g12)), id); g12[Symbol.dispose](); @@ -193,11 +193,11 @@ export function looped(log: Log.Log, id: rt.u32): void { }, true); const v12: Guard.Guard[] = []; const _378: Guard.Guard = guard(36); - v12.push(_378); + rt.vecPush(v12, _378, 8); const _383: Guard.Guard = guard(37); - v12.push(_383); + rt.vecPush(v12, _383, 8); const _388: Guard.Guard = guard(38); - v12.push(_388); + rt.vecPush(v12, _388, 8); const _397: rt.u32 = option_mapOr$01ozsk3(rt.ownedLast(rt.iterStepBy(rt.iterSlice(v12, rt.drop), 2, rt.drop), rt.drop), 0, (g13: Guard.Guard): rt.u32 => { const _011: rt.u32 = Guard.id(g13); g13[Symbol.dispose](); @@ -208,20 +208,20 @@ export function looped(log: Log.Log, id: rt.u32): void { const v13: Guard.Guard[][] = []; const v14: Guard.Guard[] = []; const _414: Guard.Guard = guard(39); - v14.push(_414); + rt.vecPush(v14, _414, 8); const _419: Guard.Guard = guard(40); - v14.push(_419); - v13.push(v14); + rt.vecPush(v14, _419, 8); + rt.vecPush(v13, v14, 12); const v15: Guard.Guard[] = []; const _428: Guard.Guard = guard(41); - v15.push(_428); - v13.push(v15); + rt.vecPush(v15, _428, 8); + rt.vecPush(v13, v15, 12); const v16: Guard.Guard[] = []; const _437: Guard.Guard = guard(42); - v16.push(_437); + rt.vecPush(v16, _437, 8); const _442: Guard.Guard = guard(43); - v16.push(_442); - v13.push(v16); + rt.vecPush(v16, _442, 8); + rt.vecPush(v13, v16, 12); const flat: rt.Iter = rt.iterFlatten(rt.iterSlice(v13, lib_drop$Vec_model_Guard), (value: Guard.Guard[]) => rt.iterSlice(value, rt.drop), true); const front: rt.u32 = option_mapOr$01ozsk3(rt.iterToOption(flat.next()), 0, (g14: Guard.Guard): rt.u32 => { const _012: rt.u32 = Guard.id(g14); @@ -239,15 +239,15 @@ export function looped(log: Log.Log, id: rt.u32): void { const five: (a0: rt.u32) => Guard.Guard[] = (n3: rt.u32): Guard.Guard[] => { const v17: Guard.Guard[] = []; const _610: Guard.Guard = guard(n3); - v17.push(_610); + rt.vecPush(v17, _610, 8); const _103: Guard.Guard = guard(rt.u32Add(n3, 1)); - v17.push(_103); + rt.vecPush(v17, _103, 8); const _162: Guard.Guard = guard(rt.u32Add(n3, 2)); - v17.push(_162); + rt.vecPush(v17, _162, 8); const _222: Guard.Guard = guard(rt.u32Add(n3, 3)); - v17.push(_222); + rt.vecPush(v17, _222, 8); const _283: Guard.Guard = guard(rt.u32Add(n3, 4)); - v17.push(_283); + rt.vecPush(v17, _283, 8); return v17; }; const _471: rt.Iter = rt.iterSkip(rt.iterSlice(five(44), rt.drop), 2, rt.drop); @@ -311,31 +311,31 @@ export function collected(log: Log.Log, id: rt.u32): void { }; const v: Guard.Guard[] = []; const _13: Guard.Guard = guard(1); - v.push(_13); + rt.vecPush(v, _13, 8); const _18: Guard.Guard = guard(2); - v.push(_18); + rt.vecPush(v, _18, 8); const _23: Guard.Guard = guard(3); - v.push(_23); - const same: Guard.Guard[] = rt.iterToArray(rt.iterSlice(v, rt.drop), "next", 8, true); + rt.vecPush(v, _23, 8); + const same: Guard.Guard[] = rt.iterToArrayInPlace(rt.iterSlice(v, rt.drop), 8, 8, true, "next", true); const v2: Guard.Guard[] = []; const _33: Guard.Guard = guard(4); - v2.push(_33); + rt.vecPush(v2, _33, 8); const _38: Guard.Guard = guard(5); - v2.push(_38); + rt.vecPush(v2, _38, 8); const _43: Guard.Guard = guard(6); - v2.push(_43); + rt.vecPush(v2, _43, 8); const wider: [Guard.Guard, rt.u32][] = rt.iterToArray(rt.iterMap(rt.iterSlice(v2, rt.drop), (g: Guard.Guard): [Guard.Guard, rt.u32] => { return [g, 0] as [Guard.Guard, rt.u32]; }), "fold", 12, true); const v3: Guard.Guard[] = []; const _53: Guard.Guard = guard(7); - v3.push(_53); + rt.vecPush(v3, _53, 8); const _48: rt.Iter = rt.iterSlice(v3, rt.drop); const v4: Guard.Guard[] = []; const _60: Guard.Guard = guard(8); - v4.push(_60); + rt.vecPush(v4, _60, 8); const _65: Guard.Guard = guard(9); - v4.push(_65); + rt.vecPush(v4, _65, 8); const chained: Guard.Guard[] = rt.iterToArray(rt.iterChain(_48, rt.iterSlice(v4, rt.drop)), "fold", 8, true); const _74: rt.usize = same.length; const _77: rt.usize = wider.length; @@ -344,31 +344,31 @@ export function collected(log: Log.Log, id: rt.u32): void { Log.note(log, rt.fmtFormat(["vecs ", args2[0], " ", args2[1], " ", args2[2]])); const v5: Guard.Guard[] = []; const _95: Guard.Guard = guard(10); - v5.push(_95); + rt.vecPush(v5, _95, 8); const _100: Guard.Guard = guard(11); - v5.push(_100); + rt.vecPush(v5, _100, 8); const _105: Guard.Guard = guard(12); - v5.push(_105); + rt.vecPush(v5, _105, 8); const results: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterSlice(v5, rt.drop), (g2: Guard.Guard): rt.Result => { if (!(Guard.id(g2) === rt.u32Add(id, 11))) { return rt.Ok(g2); } return rt.Err(g2); - }), (values: rt.Iter) => rt.iterToArray(values, "next", 8), lib_drop$Vec_model_Guard); + }), (values: rt.Iter) => rt.iterToArrayInPlace(values, 8, 8, false, "next"), lib_drop$Vec_model_Guard); const part = results.ok; const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part, f)]; Log.note(log, rt.fmtFormat(["result ", args4[0]])); lib_drop$Result_Vec_model_Guard_model_Guard(results); const v6: Guard.Guard[] = []; const _130: Guard.Guard = guard(13); - v6.push(_130); + rt.vecPush(v6, _130, 8); const _135: Guard.Guard = guard(14); - v6.push(_135); + rt.vecPush(v6, _135, 8); const _140: Guard.Guard = guard(15); - v6.push(_140); + rt.vecPush(v6, _140, 8); const part2 = option_mapOr$0vxyhav(rt.iterCollectOption(rt.iterMap(rt.iterSlice(v6, rt.drop), (g3: Guard.Guard): Guard.Guard | undefined => { return g3; - }), (values: rt.Iter) => rt.iterToArray(values, "next", 8), lib_drop$Vec_model_Guard), 0, (v12: Guard.Guard[]): rt.usize => { + }), (values: rt.Iter) => rt.iterToArrayInPlace(values, 8, 8, false, "next"), lib_drop$Vec_model_Guard), 0, (v12: Guard.Guard[]): rt.usize => { const _06: rt.usize = v12.length; rt.dropAll(v12); return _06; @@ -377,47 +377,46 @@ export function collected(log: Log.Log, id: rt.u32): void { Log.note(log, rt.fmtFormat(["option ", args6[0]])); const v7: [rt.u32, Guard.Guard][] = []; const _160: [rt.u32, Guard.Guard] = [2, guard(16)]; - v7.push(_160); + rt.vecPush(v7, _160, 12); const _166: [rt.u32, Guard.Guard] = [1, guard(17)]; - v7.push(_166); + rt.vecPush(v7, _166, 12); const _172: [rt.u32, Guard.Guard] = [2, guard(18)]; - v7.push(_172); + rt.vecPush(v7, _172, 12); const _155: rt.Iter<[rt.u32, Guard.Guard]> = rt.iterSlice(v7, lib_drop$tuple2_u32_model_Guard); - const tree: rt.BTreeMap = rt.btreeCollect(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterToArray(_155, "next", 12, true), true, undefined, undefined, rt.drop); + const tree: rt.BTreeMap = rt.btreeCollect(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterToArrayInPlace(_155, 12, 12, true, "next", true), true, undefined, undefined, rt.drop); const part3 = rt.btreeLen(tree); const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part3, f)]; Log.note(log, rt.fmtFormat(["tree ", args8[0]])); const v8: Guard.Guard[] = []; const _195: Guard.Guard = guard(24); - v8.push(_195); + rt.vecPush(v8, _195, 8); const _200: Guard.Guard = guard(25); - v8.push(_200); - const part4 = rt.iterToArray(rt.iterMap(rt.iterSlice(v8, rt.drop), (_2: Guard.Guard): Guard.Guard => { + rt.vecPush(v8, _200, 8); + const part4 = rt.iterToArrayInPlace(rt.iterMap(rt.iterSlice(v8, rt.drop), (_2: Guard.Guard): Guard.Guard => { const at = rt.idx(same, 0); _2[Symbol.dispose](); return same[at]; - }), "next", 4, true).length; + }), 8, 4, false, "next", true).length; const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part4, f)]; Log.note(log, rt.fmtFormat(["refs ", args10[0]])); const v9: Guard.Guard[] = []; const _223: Guard.Guard = guard(19); - v9.push(_223); + rt.vecPush(v9, _223, 8); 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))); + rt.vecPush(v9, _228, 8); + const queue: rt.VecDeque = rt.dequeFromIntoIter(rt.iterSlice(v9, rt.drop), 8, "fold") as rt.VecDeque; const v10: [rt.u32, Guard.Guard][] = []; const _237: [rt.u32, Guard.Guard] = [1, guard(21)]; - v10.push(_237); + rt.vecPush(v10, _237, 12); const _243: [rt.u32, Guard.Guard] = [1, guard(22)]; - v10.push(_243); + rt.vecPush(v10, _243, 12); const _232: rt.Iter<[rt.u32, Guard.Guard]> = rt.iterSlice(v10, lib_drop$tuple2_u32_model_Guard); const hashed: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, _232, undefined, rt.drop, "fold", 117440512); const v11: Key.Key[] = []; const _253: Key.Key = key(23); - v11.push(_253); + rt.vecPush(v11, _253, 12); const _258: Key.Key = key(23); - v11.push(_258); + rt.vecPush(v11, _258, 12); const _248: rt.Iter = rt.iterSlice(v11, rt.drop); const set: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rt.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rt.HashSet, _248, rt.drop, "fold", 117440512); const _267: rt.usize = queue.n; @@ -500,7 +499,7 @@ export function drained(log: Log.Log, id: rt.u32): void { const iterEnd: rt.u32 = 20; while ((_80 = iterStart++) < iterEnd) { const _86: Guard.Guard = guard(_80); - rt.dequePushBack(queue, _86); + rt.dequePushBack(queue, _86, 8); } const range: rt.Iter = rt.dequeDrain(queue, new rt.Range(1, 4), rt.drop); const part2 = option_mapOr$01ozsk3(rt.iterToOption(range.next()), 0, (g2: Guard.Guard): rt.u32 => { @@ -591,23 +590,23 @@ export function extended(log: Log.Log, id: rt.u32): void { }; const v: Guard.Guard[] = []; const _11: Guard.Guard = guard(1); - v.push(_11); + rt.vecPush(v, _11, 8); const list: Guard.Guard[] = v; const v2: Guard.Guard[] = []; const _20: Guard.Guard = guard(2); - v2.push(_20); + rt.vecPush(v2, _20, 8); const _25: Guard.Guard = guard(3); - v2.push(_25); + rt.vecPush(v2, _25, 8); const _30: Guard.Guard = guard(4); - v2.push(_30); + rt.vecPush(v2, _30, 8); rt.iterExtend(list, rt.iterSlice(v2, rt.drop), "fold", 8, true); const v3: Guard.Guard[] = []; const _41: Guard.Guard = guard(5); - v3.push(_41); + rt.vecPush(v3, _41, 8); const _46: Guard.Guard = guard(6); - v3.push(_46); + rt.vecPush(v3, _46, 8); const _51: Guard.Guard = guard(7); - v3.push(_51); + rt.vecPush(v3, _51, 8); const _35: rt.Iter = rt.iterFilter(rt.iterSlice(v3, rt.drop), (g: Guard.Guard): boolean => { return Guard.id(g) !== rt.u32Add(id, 5); }, rt.drop); @@ -621,18 +620,18 @@ export function extended(log: Log.Log, id: rt.u32): void { rt.drop(rt.hashInsert(map, _71, _74, rt.drop)); const v4: [Key.Key, Guard.Guard][] = []; const _83: [Key.Key, Guard.Guard] = [key(8), guard(9)]; - v4.push(_83); + rt.vecPush(v4, _83, 20); const _92: [Key.Key, Guard.Guard] = [key(8), guard(10)]; - v4.push(_92); + rt.vecPush(v4, _92, 20); rt.hashExtend(map, rt.iterSlice(v4, lib_drop$tuple2_drops_Key_model_Guard), rt.drop, rt.drop, "fold", 58720256); const set: rt.HashSet = rt.hashNew(rt.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rt.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rt.HashSet; const _102: Key.Key = key(11); rt.hashAdd(set, _102, rt.drop); const v5: Key.Key[] = []; const _111: Key.Key = key(11); - v5.push(_111); + rt.vecPush(v5, _111, 12); const _116: Key.Key = key(11); - v5.push(_116); + rt.vecPush(v5, _116, 12); rt.hashExtendKeys(set, rt.iterSlice(v5, rt.drop), rt.drop, "fold", 117440512); const _125: rt.usize = rt.hashLen(map); const _128: rt.usize = rt.hashLen(set); @@ -644,29 +643,29 @@ export function extended(log: Log.Log, id: rt.u32): void { rt.drop(rt.btreeInsert(tree, _138, _141, rt.drop)); const v6: [Key.Key, Guard.Guard][] = []; const _150: [Key.Key, Guard.Guard] = [key(13), guard(13)]; - v6.push(_150); + rt.vecPush(v6, _150, 20); const _159: [Key.Key, Guard.Guard] = [key(12), guard(14)]; - v6.push(_159); + rt.vecPush(v6, _159, 20); const _168: [Key.Key, Guard.Guard] = [key(15), guard(15)]; - v6.push(_168); + rt.vecPush(v6, _168, 20); rt.btreeExtend(tree, rt.iterSlice(v6, lib_drop$tuple2_drops_Key_model_Guard), false, rt.drop, rt.drop, "fold"); const ordered: rt.BTreeSet = rt.btreeNew(Key.cmp$cmp_Ord) as rt.BTreeSet; const _178: Key.Key = key(16); rt.btreeAdd(ordered, _178, rt.drop); const v7: Key.Key[] = []; const _187: Key.Key = key(17); - v7.push(_187); + rt.vecPush(v7, _187, 12); const _192: Key.Key = key(16); - v7.push(_192); + rt.vecPush(v7, _192, 12); rt.btreeExtendKeys(ordered, rt.iterSlice(v7, rt.drop), false, rt.drop, "fold"); const queue: rt.VecDeque = rt.dequeNew() as rt.VecDeque; const _198: Guard.Guard = guard(18); - rt.dequePushBack(queue, _198); + rt.dequePushBack(queue, _198, 8); const v8: Guard.Guard[] = []; const _207: Guard.Guard = guard(19); - v8.push(_207); + rt.vecPush(v8, _207, 8); const _212: Guard.Guard = guard(20); - v8.push(_212); + rt.vecPush(v8, _212, 8); rt.dequeExtend(queue, rt.iterSlice(v8, rt.drop), "fold", 8, true); const _221: rt.usize = rt.btreeLen(tree); const _224: rt.usize = rt.btreeLen(ordered); diff --git a/ts/fixtures/task/expected/drops/objects.ts b/ts/fixtures/task/expected/drops/objects.ts index e4a0269d0..e013f0765 100644 --- a/ts/fixtures/task/expected/drops/objects.ts +++ b/ts/fixtures/task/expected/drops/objects.ts @@ -28,13 +28,13 @@ export function boxed(log: Log.Log, id: rt.u32): void { const first: Part.Part = new Part.of$model_Guard(guard(1)); const parts: Part.Part[] = []; const _13: Part.Part = new Part.of$drops_Held({ tag: "Two", _0: guard(2), _1: guard(3) } as Held.Held); - parts.push(_13); + rt.vecPush(parts, _13, 8); const _24: Part.Part = new Part.of$u32(7); - parts.push(_24); + rt.vecPush(parts, _24, 8); const _28: Part.Part = new Part.of$drops_Wrap_u32(new Wrap.Wrap(rt.u32Add(id, 4), Log.clone$Clone(log), 0)); - parts.push(_28); + rt.vecPush(parts, _28, 8); const _36: Part.Part = new Part.of$drops_Held({ tag: "One", _0: guard(5) } as Held.Held); - parts.push(_36); + rt.vecPush(parts, _36, 8); rt.sliceSwap(parts, 2, 3); const part = rt.iterFold(rt.iterMap(rt.iterSlice(parts), (p: Part.Part): rt.u32 => { return p.id$Part(); @@ -59,7 +59,7 @@ export function boxed(log: Log.Log, id: rt.u32): void { const part4 = first.take$Part(); const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part4, f)]; Log.note(log, rt.fmtFormat(["took ", args8[0]])); - const part5 = option_map$0s8hob8(parts.pop(), (a02: Part.Part): rt.u32 => { + const part5 = option_map$0s8hob8(rt.vecPop(parts), (a02: Part.Part): rt.u32 => { return a02.take$Part(); }); const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part5, f, rt.u32Debug)]; @@ -102,13 +102,13 @@ export function shared(log: Log.Log, id: rt.u32): void { const wrap: rt.Arc> = new rt.Arc(new Wrap.Wrap(rt.u32Add(id, 4), Log.clone$Clone(log), 0)); const parts: rt.Arc[] = []; const _63: rt.Arc> = rt.arcClone(wrap); - parts.push(new rt.ArcDyn(_63, new Part.of$drops_Wrap_u32(_63.value))); + rt.vecPush(parts, new rt.ArcDyn(_63, new Part.of$drops_Wrap_u32(_63.value)), 8); const _68: rt.Arc = rt.arcClone(kept); - parts.push(new rt.ArcDyn(_68, new Part.of$model_Guard(_68.value))); + rt.vecPush(parts, new rt.ArcDyn(_68, new Part.of$model_Guard(_68.value)), 8); const _72: rt.Arc = rt.arcClone(second); - parts.push(_72); + rt.vecPush(parts, _72, 8); const _77: rt.Arc = new rt.Arc(7); - parts.push(new rt.ArcDyn(_77, new Part.of$u32(_77.value))); + rt.vecPush(parts, new rt.ArcDyn(_77, new Part.of$u32(_77.value)), 8); const weak: rt.Weak = new rt.Weak(parts[rt.idx(parts, 1)]); second[Symbol.dispose](); const part2 = rt.iterFold(rt.iterMap(rt.iterSlice(parts), (p: rt.Arc): rt.u32 => { @@ -180,14 +180,14 @@ export function anys(log: Log.Log, id: rt.u32): void { }; const boxes: Any.Any[] = []; const _8: Any.Any = new Any.of$model_Guard(guard(1)); - boxes.push(_8); + rt.vecPush(boxes, _8, 8); const _15: Any.Any = new Any.of$drops_Held({ tag: "Two", _0: guard(2), _1: guard(3) } as Held.Held); - boxes.push(_15); + rt.vecPush(boxes, _15, 8); const _26: Any.Any = new Any.of$u32(7); - boxes.push(_26); + rt.vecPush(boxes, _26, 8); const _30: Any.Any = new Any.of$model_Guard(guard(4)); - boxes.push(_30); - const last: rt.Result | undefined = option_map$09vq4lk(boxes.pop(), (b2: Any.Any): rt.Result => { + rt.vecPush(boxes, _30, 8); + const last: rt.Result | undefined = option_map$09vq4lk(rt.vecPop(boxes), (b2: Any.Any): rt.Result => { return b2 instanceof Any.of$model_Guard ? rt.Ok(b2.v) : rt.Err(b2); }); const part = option_map$19e1ji3(last, (g: rt.Result): boolean => { diff --git a/ts/fixtures/task/expected/drops/once.ts b/ts/fixtures/task/expected/drops/once.ts index 9854fd888..955013deb 100644 --- a/ts/fixtures/task/expected/drops/once.ts +++ b/ts/fixtures/task/expected/drops/once.ts @@ -154,11 +154,11 @@ export function run(log: Log.Log, id: rt.u32, arg: rt.u8): void { other2[Symbol.dispose](); const v: rt.OnceCell[] = []; const _274: rt.OnceCell = new rt.OnceCell(guard(63)); - v.push(_274); + rt.vecPush(v, _274, 8); const _280: rt.OnceCell = new rt.OnceCell(undefined); - v.push(_280); + rt.vecPush(v, _280, 8); const _283: rt.OnceCell = new rt.OnceCell(guard(64)); - v.push(_283); + rt.vecPush(v, _283, 8); const cells: rt.OnceCell[] = v; const part7 = cells.length; const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part7, f)]; diff --git a/ts/fixtures/task/expected/kio.Producer.ts b/ts/fixtures/task/expected/kio.Producer.ts index bcaef6f59..eab95def7 100644 --- a/ts/fixtures/task/expected/kio.Producer.ts +++ b/ts/fixtures/task/expected/kio.Producer.ts @@ -27,7 +27,7 @@ function new_(): Producer { /** Queue `value` and wake every consumer, after releasing the lock. */ export function send(self: Producer, value: rt.u64): void { const state: rt.Mutex = rt.mutexLock(self.state.value); - state.value.queue.push(value); + rt.vecPush(state.value.queue, value, 8); const waiters: WaiterList.WaiterList = WaiterList.take(state.value.waiters); rt.mutexUnlock(state); WaiterList.wake(waiters); diff --git a/ts/fixtures/task/expected/kio.WaiterList.ts b/ts/fixtures/task/expected/kio.WaiterList.ts index 73f50c762..153b69047 100644 --- a/ts/fixtures/task/expected/kio.WaiterList.ts +++ b/ts/fixtures/task/expected/kio.WaiterList.ts @@ -58,7 +58,7 @@ export function register(self: WaiterList, waiter: Waiter.Waiter): void { const entry: rt.Weak = _43; if (entry.arc.strong > 0) { _57 = false; - live.push(entry); + rt.vecPush(live, entry, 4); } if (_57) { entry[Symbol.dispose](); @@ -71,7 +71,7 @@ export function register(self: WaiterList, waiter: Waiter.Waiter): void { self.cursor = 0; } _58 = false; - self.entries.push(weak); + rt.vecPush(self.entries, weak, 4); _58 = false; break b0; } diff --git a/ts/fixtures/task/expected/log.Log.ts b/ts/fixtures/task/expected/log.Log.ts index c1fd2bbe9..3357e9417 100644 --- a/ts/fixtures/task/expected/log.Log.ts +++ b/ts/fixtures/task/expected/log.Log.ts @@ -27,7 +27,7 @@ function new_(): Log { /** Append one event. */ export function note(self: Log, event: string): void { const _6: rt.Mutex = rt.mutexLock(self._0.value); - _6.value.push(event); + rt.vecPush(_6.value, event, 12); rt.mutexUnlock(_6); } diff --git a/ts/fixtures/task/expected/model.Channel.ts b/ts/fixtures/task/expected/model.Channel.ts index fcbe16380..6b240cdbb 100644 --- a/ts/fixtures/task/expected/model.Channel.ts +++ b/ts/fixtures/task/expected/model.Channel.ts @@ -24,7 +24,7 @@ export function open(): Channel { const producer: Producer.Producer = Producer.new(); const consumer: Consumer.Consumer = Producer.consume(producer); const producers: Producer.Producer[] = []; - producers.push(producer); + rt.vecPush(producers, producer, 4); return new Channel(producers, consumer); } @@ -45,7 +45,7 @@ export function send(self: Channel, value: rt.u64): boolean { /** Drop the last producer, if one is open: the last closes the channel. */ export function close(self: Channel): boolean { - const _2: Producer.Producer | undefined = self.producers.pop(); + const _2: Producer.Producer | undefined = rt.vecPop(self.producers); if (_2 === undefined) { return false; } @@ -60,7 +60,7 @@ export function cloneProducer(self: Channel): boolean { return false; } const clone: Producer.Producer = Producer.clone$Clone(_3); - self.producers.push(clone); + rt.vecPush(self.producers, clone, 4); return true; } diff --git a/ts/fixtures/task/expected/model.ts b/ts/fixtures/task/expected/model.ts index b8738281b..2685cce50 100644 --- a/ts/fixtures/task/expected/model.ts +++ b/ts/fixtures/task/expected/model.ts @@ -376,8 +376,8 @@ export class frontFuture { this.#listing = Listing.default$Default(); } (this.#listing as Listing.Listing).last = value; - (this.#listing as Listing.Listing).listed.push(value); - this.#inFlight.push(value); + rt.vecPush((this.#listing as Listing.Listing).listed, value, 8); + rt.vecPush(this.#inFlight, value, 8); if (!(rt.u64Rem(value, 3) === 2)) { bb0 = 1; continue; @@ -407,7 +407,7 @@ export class frontFuture { if (next === undefined) { return this.#inFlight.length; } - this.#inFlight.push(next); + rt.vecPush(this.#inFlight, next, 8); } else { break; } @@ -419,7 +419,7 @@ export class frontFuture { if (half === 0) { Guard.note(this.#guard, "released"); } else { - this.#inFlight.push(half); + rt.vecPush(this.#inFlight, half, 8); } } return rt.Pending; diff --git a/ts/runtime/rt.ts b/ts/runtime/rt.ts index de59c53f1..99e5e5689 100644 --- a/ts/runtime/rt.ts +++ b/ts/runtime/rt.ts @@ -126,9 +126,10 @@ export function ptrWrite(p: T, value: T): void { */ export function replaceIn(p: T, value: T): T { if (Array.isArray(p)) { - const old = p.slice() as T; + const old: Vec = p.slice(); + vecSetCapacity(old, (p as Vec).cap ?? p.length); 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); @@ -660,77 +661,188 @@ function dedupAt(a: { [i: number]: T }, n: number, same: (i: number, kept: nu return write; } +// Capacity. A `Vec`, other than of bytes, is a JS array whose `cap` is std's capacity: +// `RawVec`'s, which `with_capacity` and `reserve_exact` make exactly what they ask for, +// and which grows as `grow_amortized` does. An array without one holds as many as its +// length, as one allocated for exactly its elements does, which `vec!`, a clone, and a +// `TrustedLen` collect make, so whatever drops its length keeps its capacity first. One +// of zero-sized elements holds `usize::MAX`, which it never fills. + +/** wasm32's `isize::MAX`, the most bytes std's `Layout` describes. */ +const ISIZE_MAX = 0x7fffffff; + +/** wasm32's `usize::MAX`. */ +const USIZE_MAX = 0xffffffff; + +/** A `Vec` other than of bytes: its elements, and its capacity where that may be past them. */ +export type Vec = T[] & { cap?: number }; + +/** How many `size`-byte elements a `Vec` 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 `cap` of `size`-byte elements grows to as std's `RawVec::grow_amortized` + * makes it to hold `required`: at least double, and at least the least it allocates for + * its size, or a panic past what it may hold. + */ +export function capGrow(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 `cap` of `size`-byte elements, holding `len`, once `reserve` made room for `additional` more. */ +export function capReserve(len: number, cap: number, additional: number, size: number): number { + return additional > cap - len ? capGrow(cap, len + additional, size) : cap; +} + +/** The capacity `cap` of `size`-byte elements, 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` of `size`-byte elements, holding `len`, once `shrink_to` of `min` shrank it: `shrink_to_fit`'s is 0. */ +export function capShrink(len: number, cap: number, min: number, size: number): number { + return size !== 0 && cap > min ? Math.max(len, min) : cap; +} + +/** `Vec::capacity` of `size`-byte elements. */ +export function vecCapacity(v: Vec, size: number): number { + return size === 0 ? USIZE_MAX : (v.cap ?? v.length); +} + +/** `v`'s capacity set to `cap`, which an array without one already has if it is its length. */ +export function vecSetCapacity(v: Vec, cap: number): void { + if (v.cap !== undefined || cap !== v.length) v.cap = cap; +} + +/** `v`'s capacity kept as its own, before its length drops. */ +export function vecHold(v: Vec): void { + v.cap ??= v.length; +} + +/** `Vec::with_capacity` of `size`-byte elements, which panics past what it may hold. */ +export function vecWithCapacity(n: number, size: number): Vec { + if (n > vecMax(size)) panic("capacity overflow"); + const v: Vec = []; + vecSetCapacity(v, n); + return v; +} + +/** `Vec::push` of `size`-byte elements, growing as `RawVec::grow_one` does once full. */ +export function vecPush(v: Vec, item: T, size: number): void { + const cap = vecCapacity(v, size); + if (v.length === cap) v.cap = capGrow(cap, cap + 1, size); + v.push(item); +} + +/** `Vec::reserve` of `size`-byte elements. */ +export function vecReserve(v: Vec, additional: number, size: number): void { + vecSetCapacity(v, capReserve(v.length, vecCapacity(v, size), additional, size)); +} + +/** `Vec::reserve_exact` of `size`-byte elements. */ +export function vecReserveExact(v: Vec, additional: number, size: number): void { + vecSetCapacity(v, capReserveExact(v.length, vecCapacity(v, size), additional, size)); +} + +/** `Vec::shrink_to` of `size`-byte elements, and `shrink_to_fit` to 0. */ +export function vecShrinkTo(v: Vec, min: number, size: number): void { + vecSetCapacity(v, capShrink(v.length, vecCapacity(v, size), min, size)); +} + +/** `Vec::into_boxed_slice`, which shrinks it to its elements. */ +export function vecIntoBoxed(v: Vec): T[] { + vecSetCapacity(v, v.length); + return v; +} + /** `Vec::retain`, and `retain_mut` of an element that is an object. */ -export function vecRetain(v: T[], f: (item: T) => boolean, drop?: (item: T) => void): void { +export function vecRetain(v: Vec, f: (item: T) => boolean, drop?: (item: T) => void): void { + vecHold(v); v.length = retainAt(v, v.length, (i) => f(v[i]), drop); } /** `Vec::retain_mut` of an element JS copies, which `f` takes the place of. */ -export function vecRetainMut(v: T[], f: (item: Place) => boolean, drop?: (item: T) => void): void { +export function vecRetainMut(v: Vec, f: (item: Place) => boolean, drop?: (item: T) => void): void { + vecHold(v); v.length = retainAt(v, v.length, (i) => f(new AtIndex(v, i)), drop); } /** `Vec::dedup_by`: drops each element `same(element, previous kept)` is true for, in order. */ -export function vecDedupBy(v: T[], same: (a: T, b: T) => boolean, drop?: (item: T) => void): void { +export function vecDedupBy(v: Vec, same: (a: T, b: T) => boolean, drop?: (item: T) => void): void { + vecHold(v); v.length = dedupAt(v, v.length, (i, j) => same(v[i], v[j]), drop); } /** `Vec::dedup_by` of an element JS copies, whose places `same` takes. */ -export function vecDedupByMut(v: T[], same: (a: Place, b: Place) => boolean, drop?: (item: T) => void): void { +export function vecDedupByMut(v: Vec, same: (a: Place, b: Place) => boolean, drop?: (item: T) => void): void { + vecHold(v); v.length = dedupAt(v, v.length, (i, j) => same(new AtIndex(v, i), new AtIndex(v, j)), drop); } /** `Vec::dedup_by_key`: as `vecDedupBy`, by `eq` of `key` of each element, then of the previous kept. */ -export function vecDedupByKey(v: T[], key: (item: T) => K, eq: (a: K, b: K) => boolean, drop?: (item: T) => void): void { +export function vecDedupByKey(v: Vec, key: (item: T) => K, eq: (a: K, b: K) => boolean, drop?: (item: T) => void): void { vecDedupBy(v, (a, b) => eq(key(a), key(b)), drop); } /** `Vec::dedup_by_key` of an element JS copies, whose places `key` takes. */ -export function vecDedupByKeyMut(v: T[], key: (item: Place) => K, eq: (a: K, b: K) => boolean, drop?: (item: T) => void): void { +export function vecDedupByKeyMut(v: Vec, key: (item: Place) => K, eq: (a: K, b: K) => boolean, drop?: (item: T) => void): void { 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: Vec, value: Vec): 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 ?? value.length; } -/** `Vec::insert`: `item` at `i`, with those from `i` on moved up. */ -export function vecInsert(v: T[], i: number, item: T): void { +/** `Vec::insert` of `size`-byte elements: `item` at `i`, with those from `i` on moved up. */ +export function vecInsert(v: Vec, i: number, item: T, size: number): void { if (i > v.length) panic(`insertion index (is ${i}) should be <= len (is ${v.length})`); + const cap = vecCapacity(v, size); + if (v.length === cap) v.cap = capGrow(cap, cap + 1, size); v.splice(i, 0, item); } -/** `Vec::pop` of an element that can be `undefined`: the last element, or `none` if empty. */ -export function vecPop(v: T[], none: None): T | None { - return v.length === 0 ? none : (v.pop() as T); +/** `Vec::pop`: the last element, or `none` if empty, which is `undefined` but where an element can be. */ +export function vecPop(v: Vec): T | undefined; +export function vecPop(v: Vec, none: None): T | None; +export function vecPop(v: Vec, none?: None): T | None | undefined { + if (v.length === 0) return none; + vecHold(v); + return v.pop() as T; } /** * `Vec::pop_if`: the last element if `f` takes it, given the element, or else `none`. An * empty `v` drops `f` by `dropF` uncalled. */ -export function vecPopIf(v: T[], f: (item: T) => boolean, dropF?: (f: (item: T) => boolean) => void): T | undefined; -export function vecPopIf(v: T[], f: (item: T) => boolean, dropF: ((f: (item: T) => boolean) => void) | undefined, none: None): T | None; -export function vecPopIf(v: T[], f: (item: T) => boolean, dropF?: (f: (item: T) => boolean) => void, none?: None): T | None | undefined { +export function vecPopIf(v: Vec, f: (item: T) => boolean, dropF?: (f: (item: T) => boolean) => void): T | undefined; +export function vecPopIf(v: Vec, f: (item: T) => boolean, dropF: ((f: (item: T) => boolean) => void) | undefined, none: None): T | None; +export function vecPopIf(v: Vec, f: (item: T) => boolean, dropF?: (f: (item: T) => boolean) => void, none?: None): T | None | undefined { if (v.length === 0) { dropF?.(f); return none; } - return f(v[v.length - 1]) ? (v.pop() as T) : none; + return f(v[v.length - 1]) ? vecPop(v) : none; } /** `Vec::pop_if` of an element JS copies, which `f` takes the place of. */ -export function vecPopIfMut(v: T[], f: (item: Place) => boolean, dropF?: (f: (item: Place) => boolean) => void): T | undefined; +export function vecPopIfMut(v: Vec, f: (item: Place) => boolean, dropF?: (f: (item: Place) => boolean) => void): T | undefined; export function vecPopIfMut( - v: T[], + v: Vec, f: (item: Place) => boolean, dropF: ((f: (item: Place) => boolean) => void) | undefined, none: None, ): T | None; export function vecPopIfMut( - v: T[], + v: Vec, f: (item: Place) => boolean, dropF?: (f: (item: Place) => boolean) => void, none?: None, @@ -739,33 +851,41 @@ export function vecPopIfMut( dropF?.(f); return none; } - return f(new AtIndex(v, v.length - 1)) ? (v.pop() as T) : none; + return f(new AtIndex(v, v.length - 1)) ? vecPop(v) : none; } /** `Vec::remove`: the element at `i`, with those after it moved down. */ -export function vecRemove(v: T[], i: number): T { +export function vecRemove(v: Vec, i: number): T { if (i >= v.length) panic(`removal index (is ${i}) should be < len (is ${v.length})`); + vecHold(v); return v.splice(i, 1)[0]; } /** `Vec::truncate`, and `clear` to 0: the first `len` elements, if there are more, and then each other drops in order. */ -export function vecTruncate(v: T[], len: number, drop?: (item: T) => void): void { +export function vecTruncate(v: Vec, len: number, drop?: (item: T) => void): void { if (len >= v.length) return; + vecHold(v); const cut = v.splice(len); if (drop !== undefined) dropAll(cut, drop); } /** `Vec::swap_remove`: the element at `i`, with the last moved into its place. */ -export function vecSwapRemove(v: T[], i: number): T { +export function vecSwapRemove(v: Vec, i: number): T { if (i >= v.length) panic(`swap_remove index (is ${i}) should be < len (is ${v.length})`); + vecHold(v); const item = v[i]; v[i] = v[v.length - 1]; v.pop(); return item; } -/** `Vec::extend_from_slice`: a clone of each element of `s`, pushed in order, as far as they clone. */ -export function vecExtendFromSlice(v: T[], s: ArrayLike, clone?: (item: T) => T): void { +/** + * `Vec::extend_from_slice`: a clone of each element of `s`, pushed in order, as far as + * they clone, once it reserved for them all as std's does where `size` is given. One made + * for exactly what it holds, as a `concat` reserves, takes none. + */ +export function vecExtendFromSlice(v: Vec, s: ArrayLike, clone?: (item: T) => T, size?: number): void { + if (size !== undefined) vecReserve(v, s.length, size); for (let i = 0; i < s.length; i++) v.push(clone === undefined ? s[i] : clone(s[i])); } @@ -961,8 +1081,13 @@ 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. */ -export function vecFromElem(value: T, n: number, clone: ((value: T) => T) | undefined): T[] { +/** + * `vec![value; n]` of `size`-byte elements: `n - 1` clones of `value`, in order, then + * `value` itself; `clone` is `undefined` where a clone is the value. Its capacity is `n`, + * which panics past what it may hold before anything clones. + */ +export function vecFromElem(value: T, n: number, clone: ((value: T) => T) | undefined, size: number): T[] { + if (n > vecMax(size)) panic("capacity overflow"); const v: T[] = []; for (let i = 1; i < n; i++) v.push(clone === undefined ? value : clone(value)); if (n > 0) v.push(value); @@ -1030,11 +1155,17 @@ export function arrayPlaces(a: { [i: number]: T; length: number }): Place[ return out; } -/** `Vec`: a growable byte buffer. */ +/** `Vec`: a growable byte buffer, whose storage's length is std's capacity. */ export class ByteVec { /** The storage; only the first `length` bytes are the vector. */ data: Uint8Array; length = 0; + /** + * Whether it was taken from `bytes`' storage, whose capacity, which `data` doesn't + * hold, depends on whether other handles of it dropped, until it shrinks to fit. + * Optional so that a `ByteSlice` still stands in for one, as a key it borrows as. + */ + unsure?: boolean; constructor(capacity = 0) { this.data = bytes(capacity); @@ -1049,22 +1180,67 @@ export function byteVecFrom(bytes: Uint8Array): ByteVec { return v; } +/** A `Vec` in place of the `Vec` of numbers `v`, of its capacity, as a heap's `into_vec` keeps it. */ +export function byteVecFromVec(v: Vec): ByteVec { + const out = new ByteVec(vecCapacity(v, 1)); + out.data.set(v); + out.length = v.length; + return out; +} + +/** A `Vec` of numbers in place of the `Vec` `v`, of its capacity, as a heap's or a deque's `From` keeps it. */ +export function byteVecToVec(v: ByteVec): Vec { + if (v.unsure) throw new Error("rust2-ts: a collection in place of a `Vec` taken from `bytes`' storage, whose capacity depends on whether other handles of it dropped"); + const out: Vec = Array.from(byteVecView(v)); + vecSetCapacity(out, v.data.length); + return out; +} + /** `vec![value; n]` of bytes. */ export function byteVecOf(value: number, n: number): ByteVec { - const v = new ByteVec(n); + const v = byteVecWithCapacity(n); v.data.fill(value); v.length = n; return v; } -/** Make room for `additional` more bytes. */ -function reserve(v: ByteVec, additional: number): void { - const needed = v.length + additional; - if (needed <= v.data.length) return; - const grown = bytes(Math.max(needed, v.data.length * 2, 8)); - // All of `data`, which costs less than making a view of its first `length` bytes. - grown.set(v.data); - v.data = grown; +/** `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::capacity` of bytes: its storage's length, which is std's. */ +export function byteVecCapacity(v: ByteVec): number { + if (v.unsure) throw new Error("rust2-ts: the capacity of a `Vec` taken from `bytes`' storage, which depends on whether other handles of it dropped"); + return v.data.length; +} + +/** Its storage moved to `cap` bytes, where that isn't its capacity. */ +function realloc(v: ByteVec, cap: number): void { + if (cap === v.data.length) return; + const data = bytes(cap); + // All of `data` where it fits, which costs less than making a view of its first `length` bytes. + if (cap >= v.data.length) data.set(v.data); + else copyBytes(data, 0, v.data, 0, v.length); + v.data = data; +} + +/** `Vec::reserve` of bytes. */ +export function byteVecReserve(v: ByteVec, additional: number): void { + if (additional > v.data.length - v.length) realloc(v, capGrow(v.data.length, v.length + additional, 1)); +} + +/** `Vec::reserve_exact` of bytes. */ +export function byteVecReserveExact(v: ByteVec, additional: number): void { + realloc(v, capReserveExact(v.length, v.data.length, additional, 1)); +} + +/** `Vec::shrink_to` of bytes, and `shrink_to_fit` to 0. */ +export function byteVecShrinkTo(v: ByteVec, min: number): void { + realloc(v, capShrink(v.length, v.data.length, min, 1)); + // Whatever it held, it now holds `length`. + if (min <= v.length) v.unsure = false; } /** The bytes, as a view that a later push may detach. */ @@ -1079,7 +1255,7 @@ export function byteVecSlice(v: ByteVec): ByteSlice { /** `Vec::push`. */ export function byteVecPush(v: ByteVec, byte: number): void { - reserve(v, 1); + byteVecReserve(v, 1); v.data[v.length++] = byte; } @@ -1103,7 +1279,7 @@ export function byteVecPopIf( /** `Vec::extend_from_slice`. */ export function byteVecExtendFromSlice(v: ByteVec, s: ByteSlice): void { - reserve(v, s.length); + byteVecReserve(v, s.length); copyBytes(v.data, v.length, s.data, s.start, s.length); v.length += s.length; } @@ -1121,7 +1297,7 @@ export function byteVecClear(v: ByteVec): void { /** `Vec::insert`: `byte` at `i`, with those from `i` on moved up. */ export function byteVecInsert(v: ByteVec, i: number, byte: number): void { if (i > v.length) panic(`insertion index (is ${i}) should be <= len (is ${v.length})`); - reserve(v, 1); + byteVecReserve(v, 1); v.data.copyWithin(i + 1, i, v.length); v.data[i] = byte; v.length++; diff --git a/ts/runtime/rt/bytes.ts b/ts/runtime/rt/bytes.ts index 4aa237388..b94cad4ca 100644 --- a/ts/runtime/rt/bytes.ts +++ b/ts/runtime/rt/bytes.ts @@ -10,6 +10,8 @@ import { bytes, byteVecExtendFromSlice, byteVecPush, + byteVecReserve, + byteVecWithCapacity, copyBytes, type FmtResult, type Formatter, @@ -322,9 +324,22 @@ export function bytesMutFreeze(b: BytesMut): Bytes { return new ByteSlice(b.data, b.start, b.length); } -/** `From for Vec`. */ +/** + * `From for Vec`: of a vector's own, the vector, holding as many as it did + * from its front, and else storage whose capacity is unsure. + */ export function bytesMutToByteVec(b: BytesMut): ByteVec { - return byteSliceToByteVec(bytesMutView(b)); + const v = byteVecWithCapacity(b.exact ? b.start + b.cap : b.length); + byteVecExtendFromSlice(v, bytesMutView(b)); + v.unsure = !b.exact; + return v; +} + +/** `From for Vec`: its bytes, in storage whose capacity is unsure. */ +export function bytesToByteVec(b: Bytes): ByteVec { + const v = byteSliceToByteVec(b); + v.unsure = true; + return v; } /** @@ -511,7 +526,7 @@ export function byteVecPutBuf( chunk: (src: B) => ByteSlice, advance: (src: B, cnt: usize) => void, ): void { - if (v.length + remaining(src) > ISIZE_MAX) panic("capacity overflow"); + byteVecReserve(v, remaining(src)); while (hasRemaining(src)) { const s = chunk(src); byteVecExtendFromSlice(v, s); @@ -519,13 +534,15 @@ export function byteVecPutBuf( } } -/** `BufMut::put_u8` and the other writes of a narrow integer to a `Vec`, as `bytesMutPutWord`. */ +/** `BufMut::put_u8` and the other writes of a narrow integer to a `Vec`, as `bytesMutPutWord`, which reserves for them all first. */ export function byteVecPutWord(v: ByteVec, value: number, n: number, le: boolean): void { + byteVecReserve(v, n); for (let i = 0; i < n; i++) byteVecPush(v, value >>> (8 * (le ? i : n - 1 - i))); } -/** `BufMut::put_*` of big-endian bytes to a `Vec`, reversed if `le`. */ +/** `BufMut::put_*` of big-endian bytes to a `Vec`, reversed if `le`, which reserves for them all first. */ export function byteVecPutBytes(v: ByteVec, be: Uint8Array, le: boolean): void { + byteVecReserve(v, be.length); for (let i = 0; i < be.length; i++) byteVecPush(v, be[le ? be.length - 1 - i : i]); } @@ -535,8 +552,8 @@ export function byteVecPutInt(v: ByteVec, be: Uint8Array, nbytes: usize, le: boo byteVecPutBytes(v, be.subarray(be.length - nbytes), le); } -/** `BufMut::put_bytes` to a `Vec`: its `resize`, which panics past what a vector holds. */ +/** `BufMut::put_bytes` to a `Vec`: its `resize`, which reserves for them all first. */ export function byteVecPutFill(v: ByteVec, val: number, cnt: usize): void { - if (v.length + cnt > ISIZE_MAX) panic("capacity overflow"); + byteVecReserve(v, cnt); for (let i = 0; i < cnt; i++) byteVecPush(v, val); } diff --git a/ts/runtime/rt/collections.ts b/ts/runtime/rt/collections.ts index 541e1d5c7..ffa92f16a 100644 --- a/ts/runtime/rt/collections.ts +++ b/ts/runtime/rt/collections.ts @@ -14,7 +14,32 @@ // 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, + capGrow, + capReserve, + capReserveExact, + capShrink, + type None, + type Place, + panic, + type RangeBound, + rangeCheck, + sliceSort, + type Vec, + vecCapacity, + vecExtendFromSlice, + vecHold, + vecMax, + vecPop, + vecPush, + vecReserve, + vecTruncate, + vecWithCapacity, +} from "../rt.ts"; import type { Hashing } from "./hash.ts"; import { type Limbs, lt } from "./int.ts"; import { @@ -34,12 +59,12 @@ import { rangeInclusiveStartBound, type SizeHint, type Take, - dequeReserve, - vecCapacity, - vecGrow, - vecPush, - vecReserve, - vecReserveExact, + capNext, + iterExtend, + iterToArray, + satAdd, + sourceCapacity, + trustedUpper, } from "./iter.ts"; import { type Arc, drop as dispose, dropAll, dropRange } from "./task.ts"; @@ -908,20 +933,19 @@ 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. + * `extending` a collection that std's collects into a `Vec` of `size`-byte elements first, + * which panics as that `Vec` does past what it may hold: for a `trusted` iterator up + * front, and for any other by `next` as it fills. */ -function vecExtending(c: C, len: number, items: Iter, add: (item: T) => void, take?: Take, size?: number, trusted = false, deque = false): C { +function vecCollecting(c: C, items: Iter, add: (item: T) => void, take?: Take, size?: number, trusted = false): C { if (size === undefined || trusted) { - if (size !== undefined) vecReserveExact(items, len, size); + if (size !== undefined) vecWithCapacity(trustedUpper(items), size); return extending(c, items, add, take); } - let cap = vecCapacity(len, size); + let cap = vecCapacity([], size); + let len = 0; for (let item = items.next(); item !== DONE; item = items.next()) { - if (deque) dequeReserve(items, len); - deque = false; - if (len === cap) cap = vecGrow(items, cap, size); + if (len === cap) cap = capNext(items, cap, size); add(item); len++; } @@ -1806,7 +1830,7 @@ export function btreeExtend( l.v[i] = item[1]; } }; - return vecExtending(m, 0, items, add, take, size, trusted); + return vecCollecting(m, items, add, take, size, trusted); } /** `extend` of a set with keys, and with `last`, `collect` and `from`, as `btreeExtend`. */ @@ -1821,7 +1845,7 @@ export function btreeExtendKeys(m: BTreeSet, keys: Iter, last = false, if (i < 0) insertAt(m, l, ~i, key, undefined); else l.k[i] = key; }; - return vecExtending(m, 0, keys, add, take, size, trusted); + return vecCollecting(m, keys, add, take, size, trusted); } /** @@ -2359,17 +2383,71 @@ 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 `c`, std's capacity, which holds `usize::MAX` + * of zero-sized items. */ export interface VecDeque { b: (T | undefined)[]; h: number; n: number; + c: number; } -/** `VecDeque::new` and `with_capacity`. */ +/** `VecDeque::new`. */ export function dequeNew(): VecDeque { - return { b: [], h: 0, n: 0 }; + return { b: [], h: 0, n: 0, c: 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"); + return { b: [], h: 0, n: 0, c: n }; +} + +/** A deque of `v`'s items, in place of the `Vec`, whose capacity it keeps: `From>`. */ +export function dequeFromVec(v: Vec, size: number): VecDeque { + const q = dequeNew(); + for (const item of v) dequePut(q, item); + q.c = vecCapacity(v, size); + return q; +} + +/** + * `collect` into a deque of `size`-byte items from `it`, a `vec::IntoIter` or a deque's + * `IntoIter`, taken as `take` says, which std's makes a deque of in place of what `it` + * reads, keeping its capacity. + */ +export function dequeFromIntoIter(it: Iter, size: number, take?: Take): VecDeque { + const cap = it instanceof DequeIter ? dequeCapacity(it.q, size) : sourceCapacity(it, size)[0]; + const q = dequeFromVec(iterToArray(it, take, undefined, true), size); + q.c = cap; + return q; +} + +/** `VecDeque::capacity` of `size`-byte items. */ +export function dequeCapacity(q: VecDeque, size: number): number { + return size === 0 ? vecMax(0) : q.c; +} + +/** `VecDeque::reserve` of `size`-byte items. */ +export function dequeReserve(q: VecDeque, additional: number, size: number): void { + q.c = capReserve(q.n, dequeCapacity(q, size), additional, size); +} + +/** `VecDeque::reserve_exact` of `size`-byte items. */ +export function dequeReserveExact(q: VecDeque, additional: number, size: number): void { + q.c = capReserveExact(q.n, dequeCapacity(q, size), additional, size); +} + +/** `VecDeque::shrink_to` of `size`-byte items, and `shrink_to_fit` to 0. */ +export function dequeShrinkTo(q: VecDeque, min: number, size: number): void { + q.c = capShrink(q.n, dequeCapacity(q, size), min, size); +} + +/** Room for one more of `size`-byte items, as std's `grow` makes once it is full. */ +function full(q: VecDeque, size: number): void { + const cap = dequeCapacity(q, size); + if (q.n === cap) q.c = capGrow(cap, cap + 1, size); } /** The slot of item `i`. */ @@ -2377,7 +2455,7 @@ function at(q: VecDeque, i: number): number { return (q.h + i) & (q.b.length - 1); } -/** Room for one more item. */ +/** Room in the buffer for one more item. */ function grow(q: VecDeque): void { if (q.n < q.b.length) return; const b = new Array(Math.max(4, q.b.length * 2)); @@ -2386,12 +2464,21 @@ function grow(q: VecDeque): void { q.h = 0; } -export function dequePushBack(q: VecDeque, item: T): void { +/** `item` added at the back, past what std's capacity says. */ +function dequePut(q: VecDeque, item: T): void { grow(q); q.b[at(q, q.n++)] = item; } -export function dequePushFront(q: VecDeque, item: T): void { +/** `push_back` of `size`-byte items. */ +export function dequePushBack(q: VecDeque, item: T, size: number): void { + full(q, size); + dequePut(q, item); +} + +/** `push_front` of `size`-byte items. */ +export function dequePushFront(q: VecDeque, item: T, size: number): void { + full(q, size); grow(q); q.h = (q.h - 1) & (q.b.length - 1); q.b[q.h] = item; @@ -2466,7 +2553,7 @@ export function dequeDrop(q: VecDeque, f: (item: T) => void): void { /** `clear`, which leaves the deque empty and then drops each item, front to back. */ export function dequeClear(q: VecDeque, f?: (item: T) => void): void { - const old: VecDeque = { b: q.b, h: q.h, n: q.n }; + const old: VecDeque = { b: q.b, h: q.h, n: q.n, c: q.c }; q.b = []; q.h = 0; q.n = 0; @@ -2541,10 +2628,10 @@ export function dequeRemove(q: VecDeque, i: number, none?: None): T | None return item; } -/** `insert`: `item` at `i`, with those from `i` on moved down. */ -export function dequeInsert(q: VecDeque, i: number, item: T): void { +/** `insert` of `size`-byte items: `item` at `i`, with those from `i` on moved down. */ +export function dequeInsert(q: VecDeque, i: number, item: T, size: number): void { if (i > q.n) panic("index out of bounds"); - dequePushBack(q, item); + dequePushBack(q, item, size); for (let j = q.n - 1; j > i; j--) q.b[at(q, j)] = q.b[at(q, j - 1)]; q.b[at(q, i)] = item; } @@ -2553,8 +2640,8 @@ export function dequeInsert(q: VecDeque, i: number, item: T): void { * An iterator of a deque's items from index `front` up to `back`, which drops those it * still holds by `drop` as it drops, if it owns them, as a `drain` does. */ -class DequeIter extends Iter implements Disposable { - private readonly q: VecDeque; +export class DequeIter extends Iter implements Disposable { + readonly q: VecDeque; private front: number; private back: number; private readonly drop: ((item: T) => void) | undefined; @@ -2610,8 +2697,10 @@ class DequeIter extends Iter implements Disposable { */ export function dequeIter(q: VecDeque, drop?: (item: T) => void): Iter { if (drop === undefined) return new DequeIter(q, 0, q.n); - const items: T[] = []; + // Of the deque's capacity, which a `collect` into another keeps. + const items: Vec = []; for (let i = 0; i < q.n; i++) items.push(q.b[at(q, i)] as T); + items.cap = q.c; return iterSlice(items, drop); } @@ -2652,8 +2741,8 @@ class DequePlaces extends Iter> { /** `drain`: the items within `r`, taken out at once, which drop by `drop` as `dequeIter`'s. */ export function dequeDrain(q: VecDeque, r: Bounds, drop?: (item: T) => void): Iter { const [start, end] = boundsRange(r, q.n); - const taken: VecDeque = { b: [], h: 0, n: 0 }; - for (let i = start; i < end; i++) dequePushBack(taken, q.b[at(q, i)] as T); + const taken = dequeNew(); + for (let i = start; i < end; i++) dequePut(taken, q.b[at(q, i)] as T); for (let i = end; i < q.n; i++) q.b[at(q, i - (end - start))] = q.b[at(q, i)]; dequeTruncate(q, q.n - (end - start)); return new DequeIter(taken, 0, taken.n, drop); @@ -2728,8 +2817,9 @@ function sliceIndexFail(start: number, end: number, n: number): never { * `Vec::drain`: the elements within `r`. Those it still holds as it drops each drop by * `drop`, front to back, before the tail moves back. */ -export function vecDrain(v: T[], r: Bounds, drop?: (item: T) => void): Iter { +export function vecDrain(v: Vec, r: Bounds, drop?: (item: T) => void): Iter { const [start, end] = boundsRange(r, v.length); + vecHold(v); return new VecDrain(v, v.splice(start), end - start, drop); } @@ -2838,17 +2928,30 @@ class ByteVecDrain extends Iter implements Disposable { } /** - * `extend`, and `collect` into a deque through `dequeNew`, which takes `items` as `take` - * says and reserves as `iterExtend` does. + * `extend` of `size`-byte items, which takes `items` as `take` says and reserves as std's + * does: a `trusted` iterator's upper bound, and any other's lower bound and one more at + * its first item and each that finds it full. */ 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); + if (size === undefined || trusted) { + if (size !== undefined) dequeReserve(q, trustedUpper(items), size); + return extending(q, items, (item) => dequePut(q, item), take); + } + let first = true; + for (let item = items.next(); item !== DONE; item = items.next()) { + if (first || q.n === dequeCapacity(q, size)) dequeReserve(q, satAdd(items.sizeHint()[0], 1), size); + first = false; + dequePut(q, item); + } + if (take !== undefined) dispose(items); + return q; } -/** `clone`, with each item through its `Clone`, or as itself without one. */ +/** `clone`, with each item through its `Clone`, or as itself without one, made for exactly as many. */ export function dequeClone(q: VecDeque, item: (value: T) => T = itself): VecDeque { const out = dequeNew(); - for (let i = 0; i < q.n; i++) dequePushBack(out, item(q.b[at(q, i)] as T)); + for (let i = 0; i < q.n; i++) dequePut(out, item(q.b[at(q, i)] as T)); + out.c = q.n; return out; } @@ -3170,25 +3273,30 @@ export function listCloneFrom(l: LinkedList, source: LinkedList, item: /** A `PartialOrd` test. */ type Test = (a: T, b: T) => boolean; -/** `BinaryHeap`: its elements in `d`, in std's order. */ +/** `BinaryHeap`: its elements in `d`, in std's order, a `Vec` with std's capacity. */ export interface BinaryHeap { - d: T[]; + d: Vec; } -/** `BinaryHeap::new`, `with_capacity`, and `default`. */ +/** `BinaryHeap::new` and `default`. */ export function heapNew(): BinaryHeap { return { d: [] }; } +/** `BinaryHeap::with_capacity` of `size`-byte elements. */ +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 { +export function heapFrom(d: Vec, le: Test, ge: Test, lt: Test): BinaryHeap { rebuild(d, le, ge, lt); return { d }; } -/** `push`: `item` sifted up from the end. */ -export function heapPush(h: BinaryHeap, item: T, le: Test): void { - h.d.push(item); +/** `push` of `size`-byte elements: `item` sifted up from the end. */ +export function heapPush(h: BinaryHeap, item: T, le: Test, size: number): void { + vecPush(h.d, item, size); siftUp(h.d, 0, h.d.length - 1, le); } @@ -3203,7 +3311,7 @@ export function heapPop(h: BinaryHeap, le: Test, none: None): T | None; export function heapPop(h: BinaryHeap, le: Test, none?: None): T | None | undefined { const d = h.d; if (d.length === 0) return none; - let item = d.pop() as T; + let item = vecPop(d) as T; if (d.length > 0) { [item, d[0]] = [d[0], item]; siftDownToBottom(d, 0, le); @@ -3212,7 +3320,7 @@ export function heapPop(h: BinaryHeap, le: Test, none?: None): T | None } /** `into_sorted_vec`: the elements in ascending order, each greatest swapped to the end and the rest sifted. */ -export function heapIntoSortedVec(h: BinaryHeap, le: Test, ge: Test, lt: Test): T[] { +export function heapIntoSortedVec(h: BinaryHeap, le: Test, ge: Test, lt: Test): Vec { const d = h.d; for (let end = d.length - 1; end > 0; end--) { [d[0], d[end]] = [d[end], d[0]]; @@ -3221,12 +3329,15 @@ 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. */ -export function heapAppend(h: BinaryHeap, other: BinaryHeap, le: Test, ge: Test, lt: Test): void { +/** + * `append` of `size`-byte elements: `other`'s elements added to the larger of the two, + * which `h` then holds, reserving for them all, and `other` left empty, keeping its capacity. + */ +export function heapAppend(h: BinaryHeap, other: BinaryHeap, le: Test, ge: Test, lt: Test, size: number): 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 = []; + vecExtendFromSlice(h.d, other.d, undefined, size); + vecTruncate(other.d, 0); rebuildTail(h.d, start, le, ge, lt); } @@ -3236,7 +3347,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); + iterExtend(h.d, items, take, size, trusted); rebuildTail(h.d, start, le, ge, lt); return h; } @@ -3250,6 +3361,7 @@ export function heapRetain(h: BinaryHeap, f: (item: T) => boolean, le: Tes const n = d.length; let from = n; let kept = 0; + vecHold(d); for (let i = 0; i < n; i++) { const item = d[i]; if (f(item)) d[kept++] = item; @@ -3262,17 +3374,15 @@ 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); + vecTruncate(h.d, 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 = []; + const d = h.d.slice(); + vecTruncate(h.d, 0); return iterSlice(d, drop); } @@ -3483,45 +3593,37 @@ 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 `Vec` of `size`-byte elements, which reserves and pushes each as its own `extend_reserve` and `extend_one` do. */ +export function vecPart(size: number): Part { return { - reserve: - size === undefined - ? undefined - : (c, additional) => { - cap = vecReserve(length(c), additional, size, cap); - }, - one: (c, item) => { - if (size !== undefined) cap = vecPush(length(c), size, cap); - push(c, item); - return c; + reserve: (v, additional) => vecReserve(v, additional, size), + one: (v, item) => { + vecPush(v, item, size); + return v; }, }; } -/** 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, - ); -} - /** A `Vec`, as `vecPart`. */ export function byteVecPart(): Part { - return vectorPart((v) => v.length, byteVecPush, 1); + return { + reserve: byteVecReserve, + one: (v, item) => { + byteVecPush(v, item); + return v; + }, + }; } -/** 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); +/** A `VecDeque` of `size`-byte elements, which pushes each at the back, as `vecPart`. */ +export function dequePart(size: number): Part, T> { + return { + reserve: (q, additional) => dequeReserve(q, additional, size), + one: (q, item) => { + dequePushBack(q, item, size); + return q; + }, + }; } /** A `LinkedList`, which pushes each at the back, and never reserves. */ @@ -3534,13 +3636,15 @@ 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, - ); +/** A `BinaryHeap` of `size`-byte elements, which pushes each, sifting it up by `le`, as `vecPart`. */ +export function heapPart(le: Test, size: number): Part, T> { + return { + reserve: (h, additional) => vecReserve(h.d, additional, size), + one: (h, item) => { + heapPush(h, item, le, size); + return h; + }, + }; } /** A `HashMap`, which inserts each entry as `hashExtend` does, and reserves as `hashReserve`. */ diff --git a/ts/runtime/rt/iter.ts b/ts/runtime/rt/iter.ts index 540bd402f..3815dafcd 100644 --- a/ts/runtime/rt/iter.ts +++ b/ts/runtime/rt/iter.ts @@ -22,7 +22,32 @@ // `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, + byteVecView, + byteVecWithCapacity, + capReserve, + Err, + type None, + Ok, + type Place, + panic, + place, + type RangeBound, + type Result, + sliceView, + type Vec, + vecCapacity, + vecExtendFromSlice, + vecMax, + vecReserve, + vecSetCapacity, + 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"; @@ -41,7 +66,7 @@ const USIZE_MAX = 0xffffffff; type Drop = (value: T) => void; /** `a + b`, saturating at `usize::MAX` as std's size hints do. */ -function satAdd(a: number, b: number): number { +export function satAdd(a: number, b: number): number { return Math.min(a + b, USIZE_MAX); } @@ -298,6 +323,11 @@ export function iterSlice(s: ArrayLike, drop?: Drop): Iter { return new SliceIter(s, drop); } +/** `IntoIterator::into_iter` of a `Vec`: its bytes, of the vector whose capacity a `collect` in place of it keeps. */ +export function byteVecIntoIter(v: ByteVec): Iter { + return new SliceIter(byteVecView(v), undefined, v); +} + /** `slice::IterMut` of elements JS copies: the place of each. */ export function iterSliceMut(s: { [i: number]: T; length: number }): Iter> { return new SliceMutIter(s); @@ -525,31 +555,19 @@ 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. - -/** wasm32's `isize::MAX`, the most bytes std's `Layout` describes. */ -const ISIZE_MAX = 0x7fffffff; +// one more; as a tuple's part, the lower bound first. A `Vec` that collects a `TrustedLen` +// one is made for exactly its upper bound. -/** 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`, full of `size`-byte elements, grows to as std's reserves for the next item of `it` and those it holds past it. */ +export function capNext(it: Iter, cap: number, size: number): number { + return capReserve(cap, cap, satAdd(it.sizeHint()[0], 1), size); } /** @@ -599,60 +617,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: Vec, 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, cap, size); v.push(item); } + vecSetCapacity(v, cap); if (take !== undefined) dispose(items); return v; } - if (size !== undefined) vecReserveExact(items, v.length, size); + if (size !== undefined) vecReserve(v, trustedUpper(items), size); if (take === undefined) { const folded = items.folded(trusted); for (let item = folded.next(); item !== DONE; item = folded.next()) v.push(item); @@ -665,15 +646,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); @@ -1247,42 +1227,85 @@ export function iterGe(a: Iter, b: Iter, cmp: (x: T, y: U) => Orderi return order !== undefined && order >= 0; } -/** `collect` into a `Vec`, as `iterExtend` of an empty one. */ +/** + * `collect` into a `Vec`: as `iterExtend` of an empty one, but for a `trusted` iterator, + * whose upper bound it is made for exactly. + */ export function iterToArray(it: Iter, take?: Take, size?: number, trusted = false): T[] { - const out: T[] = []; - if (size !== undefined && !trusted) { - let cap = vecCapacity(0, size); - for (let item = it.next(); item !== DONE; item = it.next()) { - if (out.length === cap) cap = vecGrow(it, cap, size); - out.push(item); - } - if (take !== undefined) dispose(it); - return out; + if (size !== undefined && trusted) { + const out = vecWithCapacity(trustedUpper(it), size); + return iterExtend(out, it, take, undefined, true); } - if (size !== undefined) vecReserveExact(it, 0, size); - if (take === undefined) { + return iterExtend([], it, take, size, trusted); +} + +/** + * The capacity of the `Vec` std's `SourceIter::as_inner` reaches from `it`, of `size`-byte + * elements, which a `collect` in place of it keeps, and whether that is unsure, as a + * `Vec`'s taken from `bytes`' storage is. + */ +export function sourceCapacity(it: Iter, size: number): [number, boolean] { + let at: Iter | undefined = it; + while (!(at instanceof SliceIter)) { + if (at instanceof Adaptor || at instanceof FuseIter) at = at.inner; + else if (at instanceof ZipIter) at = at.a; + else if (at instanceof FlattenIter) at = at.outer; + else at = undefined; + if (at === undefined) throw new Error("rust2-ts: a `collect` in place of an iterator whose `Vec` it can't find"); + } + if (at.bytes !== undefined) return [at.bytes.data.length, at.bytes.unsure === true]; + return [vecCapacity(at.s as Vec, size), false]; +} + +/** + * How many of `size`-byte elements a `collect` keeps room for in place of the `Vec` of + * `srcSize`-byte ones `it` reads, as std's does where its adaptors let it: as many as fit + * in that one's bytes. Of a `vec::IntoIter` itself, if `bare`, it keeps that one unless it + * read from the front and less than half of it is left, and else reserves for what is. + */ +function inPlace(it: Iter, srcSize: number, size: number, bare: boolean): [number, boolean] { + const [cap, unsure] = sourceCapacity(it, srcSize); + if (!bare) return [Math.floor((cap * srcSize) / size), unsure]; + const src = it as SliceIter; + const len = src.back - src.front; + if (src.front === 0 || len >= Math.floor(cap / 2)) return [cap, unsure]; + return [capReserve(0, 0, len, size), false]; +} + +/** `collect` into a `Vec` of `size`-byte elements in place of the one `it` reads, as `inPlace` says. */ +export function iterToArrayInPlace(it: Iter, srcSize: number, size: number, bare: boolean, take?: Take, trusted = false): T[] { + const [cap, unsure] = inPlace(it, srcSize, size, bare); + if (unsure) throw new Error("rust2-ts: a `collect` in place of a `Vec` taken from `bytes`' storage, whose capacity depends on whether other handles of it dropped"); + const out = iterToArray(it, take, undefined, trusted); + vecSetCapacity(out, cap); + return out; +} + +/** `collect` into a `Vec` in place of the one `it` reads, as `inPlace` says. */ +export function iterToByteVecInPlace(it: Iter, srcSize: number, bare: boolean, take?: Take, trusted = false): ByteVec { + const [cap, unsure] = inPlace(it, srcSize, 1, bare); + const out = byteVecWithCapacity(cap); + out.unsure = unsure; + if (take !== undefined) each(it, (item) => byteVecPush(out, item), take); + else { const folded = it.folded(trusted); - for (let item = folded.next(); item !== DONE; item = folded.next()) out.push(item); - return out; + for (let item = folded.next(); item !== DONE; item = folded.next()) byteVecPush(out, item); } - each(it, (item) => out.push(item), take); return out; } -/** `collect` into a `Vec`, as `iterExtendBytes` of an empty one. */ +/** `collect` into a `Vec`, as `iterToArray`. */ export function iterToByteVec(it: Iter, take?: Take, trusted = false): ByteVec { - const out = new ByteVec(); + const out = trusted ? byteVecWithCapacity(trustedUpper(it)) : new ByteVec(); // Its own loops: through `iterExtendBytes`, JavaScriptCore took 1.9x as long. if (!trusted) { - let cap = 0; 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); if (take === undefined) { const folded = it.folded(true); for (let item = folded.next(); item !== DONE; item = folded.next()) byteVecPush(out, item); @@ -1508,12 +1531,15 @@ class SliceIter extends Iter implements Disposable { back: number; /** What drops each item it still holds, if it owns them. */ private readonly drop: Drop | undefined; + /** The `Vec` whose bytes `s` views, which its `into_iter` owns. */ + readonly bytes: ByteVec | undefined; - constructor(s: ArrayLike, drop?: Drop) { + constructor(s: ArrayLike, drop?: Drop, bytes?: ByteVec) { super(); this.s = s; this.back = s.length; this.drop = drop; + this.bytes = bytes; } next(): T | Done { diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index f13ea9099..1606e94b3 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -208,9 +208,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), @@ -1144,7 +1144,6 @@ fn deque<'tcx>( owner: &str, name: &str, args: Vec, - out: &mut Vec, ) -> Option { let span = call.span; let item = arg(coll, 0); @@ -1152,15 +1151,32 @@ 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 changes or reads a capacity is given the size of its 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" | "push_back" | "push_front" | "insert" | "reserve" | "reserve_exact" | "shrink_to" | "shrink_to_fit") => { + let f = match name { + "capacity" => "dequeCapacity", + "push_back" => "dequePushBack", + "push_front" => "dequePushFront", + "insert" => "dequeInsert", + "reserve" => "dequeReserve", + "reserve_exact" => "dequeReserveExact", + _ => "dequeShrinkTo", + }; + if name == "shrink_to_fit" { + values.push(Expr::lit("0")); + } + values.push(super::iter::size_of(b, item, span)); + Expr::rt(f, values) } (_, "len") => values.pop()?.member("n"), (_, "is_empty") => values.pop()?.member("n").binary("===", Expr::lit("0")), (_, "clear") => Expr::rt("dequeClear", values), - (_, "push_back") => Expr::rt("dequePushBack", values), - (_, "push_front") => Expr::rt("dequePushFront", values), (_, "pop_back") => Expr::rt("dequePopBack", values), (_, "pop_front") => Expr::rt("dequePopFront", values), (_, "front_mut") if b.t.needs_place(item) => Expr::rt("dequeEndMut", values), @@ -1175,7 +1191,6 @@ fn deque<'tcx>( (_, "retain_mut") if b.t.needs_place(item) => Expr::rt("dequeRetainMut", values), (_, "retain" | "retain_mut") => Expr::rt("dequeRetain", values), (_, "remove") => Expr::rt("dequeRemove", values), - (_, "insert") => Expr::rt("dequeInsert", values), (_, "contains") => { values.push(eq_fn(b, item, span)); Expr::rt("dequeContains", values) @@ -1188,15 +1203,24 @@ 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)); Expr::rt("dequeClone", values) } + // `From>` keeps the vector's capacity, and `From<[T; N]>` has room for `N`. + ("From", "from") if matches!(library::targ(call.args, 1).kind(), ty::Array(..)) || b.t.std_of(library::targ(call.args, 1)) == Some(Std::Vec) => { + let from = library::targ(call.args, 1); + let bytes = matches!(item.kind(), ty::Uint(ty::UintTy::U8)); + let v = match (bytes, from.is_array(), b.t.copy_fn(item, span)) { + (true, true, _) => Expr::ident("Array").member("from").call(vec![values.pop()?]), + (true, false, _) => Expr::rt("byteVecToVec", vec![values.pop()?]), + (false, true, Some(copy)) => values.pop()?.member("map").call(vec![copy]), + _ => values.pop()?, + }; + let size = super::iter::size_of(b, item, span); + empty(b, Expr::rt("dequeFromVec", vec![v, size]), coll, span) + } ("Extend", "extend") | ("From", "from") => { let (source, iter) = extend_source(b, coll, call, owner, values.pop()?)?; let target = match owner { @@ -1307,16 +1331,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).member("d"); + let mut values = [vec![h], values].concat(); + 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")), @@ -1325,6 +1365,9 @@ fn heap<'tcx>( (_, "peek") => values.pop()?.member("d").index(Expr::lit("0")), (_, "push" | "pop" | "peek_mut" | "append" | "retain" | "into_sorted_vec") => { values.extend(heap_tests(b, item, !matches!(name, "push" | "pop"), span)); + if matches!(name, "push" | "append") { + values.push(super::iter::size_of(b, item, span)); + } let f = match name { "push" => "heapPush", "pop" => "heapPop", @@ -1351,10 +1394,6 @@ 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])) @@ -1364,9 +1403,7 @@ fn heap<'tcx>( ("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()) @@ -1388,13 +1425,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, } } @@ -2633,23 +2667,24 @@ 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 makes one in place of a `vec::IntoIter`'s `Vec` or an `IntoIter`'s deque, + // whose capacity it keeps, and else collects into a `Vec` first. 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 size = super::iter::size_of(b, item, span); + let into_iter = super::iter::is_vec_into_iter(b.t.tcx, from) + || matches!(from.kind(), ty::Adt(adt, _) if library::std_path(b.t.tcx, adt.did()) == ["collections", "vec_deque", "into_iter", "IntoIter"]); + let q = match into_iter { + true => { + let take = super::iter::iter_take(b, from, true, span); + Expr::rt("dequeFromIntoIter", super::iter::tail(vec![iter, size], vec![take])) + } + false => { + let items = super::iter::to_array(b, iter, from, item, trusted, span); + Expr::rt("dequeFromVec", vec![items, size]) + } + }; + empty(b, q, ty, span) } _ => return None, }) diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index 8d56fb345..8e72cdbae 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -180,6 +180,10 @@ pub fn into_iter<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr, sp Std::Vec if places(b, args.type_at(0)) => { Some(Expr::rt("iterSliceMut", vec![library::elements(value, ty)])) } + // An owned one's bytes, of the vector whose capacity a `collect` in place of it keeps. + Std::Vec if owned && matches!(args.type_at(0).kind(), ty::Uint(ty::UintTy::U8)) => { + Some(Expr::rt("byteVecIntoIter", vec![value])) + } Std::Vec => { let values = each(b, args.type_at(0), vec![library::elements(value, ty)]); Some(items(Expr::rt("iterSlice", values), args.type_at(0))) @@ -1206,17 +1210,8 @@ fn collect<'tcx>( _ => library::cow_slice(tcx, ty).or(boxed), }; if let Some(elem) = elem { - let v = match elem.kind() { - ty::Uint(ty::UintTy::U8) => { - let (folds, by_index) = collect_folds(b, from, elem, span); - let take = iter_take(b, from, folds, span); - Expr::rt( - "iterToByteVec", - tail(vec![iter], vec![take, Expr::lit((trusted || by_index).to_string())]), - ) - } - _ => to_array(b, iter, from, elem, trusted, span), - }; + let bytes = matches!(elem.kind(), ty::Uint(ty::UintTy::U8)); + let v = collected(b, iter, from, elem, trusted, bytes, span); return Some(match boxed { Some(elem) => library::vec_boxed(v, elem), None => v, @@ -1375,9 +1370,10 @@ fn drops_iter<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> boo true } -/// `rt.iterToArray` of `iter`, an iterator of type `from`, collected into a `Vec` as -/// `collect_folds` says std's reads it. It reserves as std's does for a `TrustedLen` -/// iterator if `trusted`. +/// `iter`, an iterator of type `from`, collected into a `Vec` as `collect_folds` says +/// std's reads it, a JS array even of bytes. It reserves as std's does for a `TrustedLen` +/// iterator if `trusted`, and keeps the capacity of the `Vec` it reads where std's collects +/// in place of it. pub(super) fn to_array<'tcx>( b: &mut Body<'_, '_, 'tcx>, iter: Expr, @@ -1385,17 +1381,56 @@ pub(super) fn to_array<'tcx>( elem: Ty<'tcx>, trusted: bool, span: Span, +) -> Expr { + collected(b, iter, from, elem, trusted, false, span) +} + +/// As `to_array`, an `rt.ByteVec` if `bytes`. +fn collected<'tcx>( + b: &mut Body<'_, '_, 'tcx>, + iter: Expr, + from: Ty<'tcx>, + elem: Ty<'tcx>, + trusted: bool, + bytes: bool, + span: Span, ) -> Expr { let (folds, by_index) = collect_folds(b, from, elem, span); let take = iter_take(b, from, folds, span); - let size = size_of(b, elem, span); - Expr::rt( - "iterToArray", - tail( - vec![iter], - vec![take, size, Expr::lit((trusted || by_index).to_string())], - ), - ) + let trusted = Expr::lit((trusted || by_index).to_string()); + if let Some(src) = in_place_source(b.t, from, elem) { + let bare = Expr::lit(is_vec_into_iter(b.t.tcx, from).to_string()); + let src_size = size_of(b, src, span); + return match bytes { + true => Expr::rt("iterToByteVecInPlace", tail(vec![iter, src_size, bare], vec![take, trusted])), + false => { + let size = size_of(b, elem, span); + Expr::rt("iterToArrayInPlace", tail(vec![iter, src_size, size, bare], vec![take, trusted])) + } + }; + } + match bytes { + true => Expr::rt("iterToByteVec", tail(vec![iter], vec![take, trusted])), + false => { + let size = size_of(b, elem, span); + Expr::rt("iterToArray", tail(vec![iter], vec![take, size, trusted])) + } + } +} + +/// Whether `ty` is a `vec::IntoIter`, whose `collect` into a `Vec` std's specializes. +pub(super) fn is_vec_into_iter(tcx: ty::TyCtxt<'_>, ty: Ty<'_>) -> bool { + matches!(ty.kind(), ty::Adt(adt, _) if library::std_path(tcx, adt.did()) == ["vec", "into_iter", "IntoIter"]) +} + +/// The element type of the `Vec` std's `collect` of an iterator of type `iter` into a +/// `Vec` writes in place of, if it does: a `vec::IntoIter`'s own, which std's keeps +/// whatever its elements, or an adaptor's source where each item's layout leaves room. +fn in_place_source<'tcx>(t: &Translator<'_, 'tcx>, iter: Ty<'tcx>, elem: Ty<'tcx>) -> Option> { + if is_vec_into_iter(t.tcx, iter) { + return Some(elem); + } + in_place(t, iter, elem) } /// Whether std's `collect` of an iterator of type `from` into a `Vec` folds it, and @@ -1407,7 +1442,7 @@ pub(super) fn to_array<'tcx>( /// as each fold ends. Elsewhere, it folds a `TrustedLen` one by its own `fold`, which drops /// them first, and reads any other by `next`. fn collect_folds<'tcx>(b: &mut Body<'_, '_, 'tcx>, from: Ty<'tcx>, elem: Ty<'tcx>, span: Span) -> (bool, bool) { - if !in_place(b.t, from, elem) { + if in_place(b.t, from, elem).is_none() { return (implements(b.t, from, "TrustedLen"), false); } let zips = from.walk().filter_map(|arg| arg.as_type()).any(|t| { @@ -1425,17 +1460,17 @@ fn collect_folds<'tcx>(b: &mut Body<'_, '_, 'tcx>, from: Ty<'tcx>, elem: Ty<'tcx (by_index, by_index) } -/// Whether std's `collect` of an iterator of type `iter` into a `Vec` writes in place -/// of the `Vec` its items come from, as its adaptors let it where each item's layout leaves -/// room. -fn in_place<'tcx>(t: &Translator<'_, 'tcx>, iter: Ty<'tcx>, elem: Ty<'tcx>) -> bool { +/// The element type of the `Vec` std's `collect` of an iterator of type `iter` into a +/// `Vec` writes in place of, as its adaptors let it where each item's layout leaves +/// room, if it does. +fn in_place<'tcx>(t: &Translator<'_, 'tcx>, iter: Ty<'tcx>, elem: Ty<'tcx>) -> Option> { let tcx = t.tcx; let env = t.typing_env_pub(); let (Some(steps), Some(source)) = (core_trait(tcx, "InPlaceIterable"), core_trait(tcx, "SourceIter")) else { - return false; + return None; }; if !implements(t, iter, "InPlaceIterable") || !implements(t, iter, "SourceIter") { - return false; + return None; } let assoc = |tr: DefId, name: &str| { tcx.associated_items(tr) @@ -1449,13 +1484,13 @@ fn in_place<'tcx>(t: &Translator<'_, 'tcx>, iter: Ty<'tcx>, elem: Ty<'tcx>) -> b tcx.try_normalize_erasing_regions(env, ty::Unnormalized::new_wip(projection)) .ok() }) else { - return false; + return None; }; let ty::Adt(adt, src_args) = src.kind() else { - return false; + return None; }; if library::std_path(tcx, adt.did()) != ["vec", "into_iter", "IntoIter"] { - return false; + return None; } // `MERGE_BY` and `EXPAND_BY`: how many source items make how many it collects, if known. let step = |name: &str| -> Option { @@ -1465,19 +1500,20 @@ fn in_place<'tcx>(t: &Translator<'_, 'tcx>, iter: Ty<'tcx>, elem: Ty<'tcx>) -> b Some(value.try_to_scalar_int()?.to_bits_unchecked()) }; let (Some(merge), Some(expand)) = (step("MERGE_BY"), step("EXPAND_BY")) else { - return false; + return None; }; let layout = |ty: Ty<'tcx>| tcx.layout_of(env.as_query_input(ty)).ok(); let (Some(from), Some(to)) = (layout(src_args.type_at(0)), layout(elem)) else { - return false; + return None; }; // As std's `in_place_collectible`, where `None`, an overflow, is 0. - !from.is_zst() + let collectible = !from.is_zst() && !to.is_zst() && from.align.abi == to.align.abi && merge > 0 && expand > 0 - && u128::from(from.size.bytes()) * merge >= u128::from(to.size.bytes()) * expand + && u128::from(from.size.bytes()) * merge >= u128::from(to.size.bytes()) * expand; + collectible.then(|| src_args.type_at(0)) } /// Whether the crate's own `Ord` of `ty` has its own `max` or `min`, by `name`, which diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index 0dab06b5f..cad3463be 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -1956,6 +1956,7 @@ fn mapping<'tcx>( true => Expr::rt("byteVecOf", values), false => { values.push(super::collections::clone_fn(b, elem, span)); + values.push(super::iter::size_of(b, elem, span)); Expr::rt("vecFromElem", values) } } @@ -1966,24 +1967,32 @@ 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()), - }, - ("Vec", "push") => { + ("Vec", "with_capacity") if is_u8(targ(gargs, 0)) => Expr::rt("byteVecWithCapacity", args), + ("Vec", "capacity") if is_u8(targ(gargs, 0)) => Expr::rt("byteVecCapacity", args), + ("Vec", "push" | "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")]) + } + // What changes or reads a capacity is given the size of its elements, by which + // std's grows it. + ("Vec", "with_capacity" | "capacity" | "push" | "reserve" | "reserve_exact" | "shrink_to" | "shrink_to_fit") => { let mut values = args; - match is_u8(targ(gargs, 0)) { - true => Expr::rt("byteVecPush", values), - false => { - let v = values.remove(0); - v.method("push", values) - } + 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", "pop") if is_u8(targ(gargs, 0)) => Expr::rt("byteVecPop", args), - // JS's `pop` returns `undefined` for no element, where an `rt.None` must follow. - ("Vec", "pop") if sentinel_option(b.t, call).is_some() => Expr::rt("vecPop", args), - ("Vec", "pop") => args.pop()?.method("pop", vec![]), + // Its capacity is kept as its length drops, and an `rt.None` follows where an + // element can be `undefined`. + ("Vec", "pop") => Expr::rt("vecPop", args), // The last element is lent to the test as its place where JS copies it. ("Vec", "pop_if") if is_u8(targ(gargs, 0)) => Expr::rt("byteVecPopIf", args), ("Vec", "pop_if") if b.t.needs_place(targ(gargs, 0)) => Expr::rt("vecPopIfMut", args), @@ -1995,16 +2004,19 @@ fn mapping<'tcx>( ("Vec", "extend_from_slice") if is_u8(targ(gargs, 0)) => Expr::rt("byteVecExtendFromSlice", args), ("Vec", "extend_from_slice") => { let mut values = args; - let clone = super::collections::clone_fn(b, targ(gargs, 0), span); - if !matches!(&clone, Expr::Lit(l) if l == "undefined") { - values.push(clone); - } + values.push(super::collections::clone_fn(b, targ(gargs, 0), span)); + values.push(super::iter::size_of(b, targ(gargs, 0), span)); Expr::rt("vecExtendFromSlice", values) } ("Vec", "insert" | "remove" | "swap_remove") if is_u8(targ(gargs, 0)) => { rt2(args, "byteVec", &super::camel(&name)) } - ("Vec", "insert" | "remove" | "swap_remove" | "truncate") => rt2(args, "vec", &super::camel(&name)), + ("Vec", "insert") => { + let mut values = args; + values.push(super::iter::size_of(b, targ(gargs, 0), span)); + Expr::rt("vecInsert", values) + } + ("Vec", "remove" | "swap_remove" | "truncate") => rt2(args, "vec", &super::camel(&name)), ("Vec", "clear") => { let mut values = args; values.push(Expr::lit("0")); @@ -2420,7 +2432,8 @@ fn clone_into<'tcx>(b: &mut Body<'_, '_, 'tcx>, elem: Ty<'tcx>, name: &str, span /// Whether `clone_from` of `ty` clones, and drops what it writes over, as /// `*self = source.clone()` would: `Clone`'s own, and std's own over such types, where it -/// only reuses memory, if nothing drops or it is an `Option`'s. +/// only reuses memory, if nothing drops or it is an `Option`'s, but for a vector's, which +/// keeps its capacity where that holds the clones. pub(super) fn clone_from_clones<'tcx>(t: &mut Translator<'_, 'tcx>, ty: Ty<'tcx>) -> bool { let tcx = t.tcx; let clone_from = super::collections::trait_fn(tcx, "Clone", "clone_from"); @@ -2431,6 +2444,9 @@ pub(super) fn clone_from_clones<'tcx>(t: &mut Translator<'_, 'tcx>, ty: Ty<'tcx> if instance.def_id() == clone_from { return true; } + if matches!(t.std_of(ty), Some(Std::Vec | Std::VecDeque | Std::BinaryHeap)) { + return false; + } let inner: Vec> = match ty.kind() { ty::Adt(adt, args) if is_std(tcx, adt.did()) => args.types().collect(), ty::Array(elem, _) => vec![*elem], @@ -2535,12 +2551,12 @@ fn slice_boxed<'tcx>(b: &mut Body<'_, '_, 'tcx>, slice: Expr, elem: Ty<'tcx>, sp } } -/// The `Box<[elem]>` that a `Vec`, `v`, becomes: its elements, as many as it holds. -/// std's shrinks its capacity to them, which no translated `Vec` reports. +/// The `Box<[elem]>` that a `Vec`, `v`, becomes: its elements, as many as it holds, +/// to which std's shrinks its capacity. pub(super) fn vec_boxed(v: Expr, elem: Ty<'_>) -> Expr { match elem.kind() { ty::Uint(ty::UintTy::U8) => Expr::rt("byteVecSlice", vec![v]), - _ => v, + _ => Expr::rt("vecIntoBoxed", vec![v]), } } diff --git a/ts/src/lower/mir/step.rs b/ts/src/lower/mir/step.rs index 58119d720..bbbfd93c5 100644 --- a/ts/src/lower/mir/step.rs +++ b/ts/src/lower/mir/step.rs @@ -271,8 +271,8 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { /// An iterator stepped in place, from the `rt.Iter` its mapping makes: `{ s, i: 0 }` /// from `rt.iterSlice(s)`, or `rt.iterSlice(s, drop)` of items it owns, which its drop - /// drops again, and `{ start, end }` from `new rt.Range(start, end)`. A moved one is - /// already made. + /// drops again, or `rt.byteVecIntoIter(v)` of a `Vec`'s bytes, and `{ start, end }` + /// from `new rt.Range(start, end)`. A moved one is already made. pub(super) fn stepped_make(&mut self, value: Expr, span: rustc_span::Span) -> Expr { let rt = |f: &Expr, name: &str| matches!(f, Expr::Rt(n) if n == name); let object = |fields: [(&str, Expr); 2]| { @@ -283,6 +283,9 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { args.truncate(1); object([("s", args.pop().unwrap()), ("i", Expr::lit("0"))]) } + Expr::Call(f, args) if rt(&f, "byteVecIntoIter") && args.len() == 1 => { + object([("s", Expr::rt("byteVecView", args)), ("i", Expr::lit("0"))]) + } Expr::New(f, args) if rt(&f, "Range") && args.len() == 2 => { let [start, end] = <[Expr; 2]>::try_from(args).expect("checked above"); object([("start", start), ("end", end)]) diff --git a/ts/src/lower/stock.rs b/ts/src/lower/stock.rs index 3fb9441e0..689dbfdc9 100644 --- a/ts/src/lower/stock.rs +++ b/ts/src/lower/stock.rs @@ -309,7 +309,7 @@ fn from<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Vec) -> }; return Ok(Some(bytes)); } - (_, Some(Std::Bytes)) if byte_vec(to) => "byteSliceToByteVec", + (_, Some(Std::Bytes)) if byte_vec(to) => "bytesToByteVec", (_, Some(Std::BytesMut)) if byte_vec(to) => "bytesMutToByteVec", (_, Some(Std::Bytes | Std::BytesMut)) => return Ok(None), _ => return Err(args.collect()), From 512d8c79fc70642626762ccd2fc6c316e53ee7b7 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 21:08:48 -0700 Subject: [PATCH 03/14] perf(ts): keep a push's check for room small enough to inline Co-Authored-By: Claude Opus 5.5 --- ts/README.md | 3 ++- ts/runtime/rt.ts | 8 ++++++++ ts/runtime/rt/collections.ts | 4 ++-- 3 files changed, 12 insertions(+), 3 deletions(-) diff --git a/ts/README.md b/ts/README.md index 07e101749..efb29a37d 100644 --- a/ts/README.md +++ b/ts/README.md @@ -696,7 +696,8 @@ they need. length, and an `rt.ByteVec`'s is its buffer's length. A `Vec` taken from a `Bytes` or a shared `BytesMut` holds what `bytes` gave it, which nothing here counts: reading its capacity, or keeping it in place, throws until a `shrink_to` at most its length - sets it. A `LinkedList` is nodes linked both ways, as std's are, + sets it. On `just ts bench`'s `push/` workloads a push takes 1.2-2x the time JS's own + `push` did, Bun the most, for reading the capacity it checks. 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 diff --git a/ts/runtime/rt.ts b/ts/runtime/rt.ts index 99e5e5689..94d467cf5 100644 --- a/ts/runtime/rt.ts +++ b/ts/runtime/rt.ts @@ -735,6 +735,14 @@ export function vecWithCapacity(n: number, size: number): Vec { /** `Vec::push` of `size`-byte elements, growing as `RawVec::grow_one` does once full. */ export function vecPush(v: Vec, item: T, size: number): void { + // Kept small for engines to inline, as most pushes find room: on `just ts bench`'s + // `push/vec`, Bun took twice as long with the growth in line. + if (v.cap !== undefined && v.length < v.cap) v.push(item); + else vecGrowPush(v, item, size); +} + +/** `vecPush` where `v` may be full. */ +function vecGrowPush(v: Vec, item: T, size: number): void { const cap = vecCapacity(v, size); if (v.length === cap) v.cap = capGrow(cap, cap + 1, size); v.push(item); diff --git a/ts/runtime/rt/collections.ts b/ts/runtime/rt/collections.ts index ffa92f16a..9b8fe6e71 100644 --- a/ts/runtime/rt/collections.ts +++ b/ts/runtime/rt/collections.ts @@ -2472,13 +2472,13 @@ function dequePut(q: VecDeque, item: T): void { /** `push_back` of `size`-byte items. */ export function dequePushBack(q: VecDeque, item: T, size: number): void { - full(q, size); + if (q.n === q.c) full(q, size); dequePut(q, item); } /** `push_front` of `size`-byte items. */ export function dequePushFront(q: VecDeque, item: T, size: number): void { - full(q, size); + if (q.n === q.c) full(q, size); grow(q); q.h = (q.h - 1) & (q.b.length - 1); q.b[q.h] = item; From 5941b401fbb7883f0904e797f46e01c9be7b2c63 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 21:11:42 -0700 Subject: [PATCH 04/14] style(ts): clippy and fmt Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/src/harness.rs | 8 ++++---- ts/src/lower/collections.rs | 11 +++++++++-- ts/src/lower/iter.rs | 16 ++++++++++------ ts/src/lower/library.rs | 5 ++++- 4 files changed, 27 insertions(+), 13 deletions(-) diff --git a/ts/fixtures/lang/src/harness.rs b/ts/fixtures/lang/src/harness.rs index e1f040042..e6cd8a0e7 100644 --- a/ts/fixtures/lang/src/harness.rs +++ b/ts/fixtures/lang/src/harness.rs @@ -2,10 +2,10 @@ //! case and the rest is its input. use crate::{ - arrays, ascii, atomics, borrows, bounds, boxes, capacity, captures, cells, chars, chunks, clones, collections, combinators, - counts, cows, cycles, defaults, durations, dyns, edits, errors, floats, fmt, folds, generics, hashes, hints, holds, - ints, iters, joins, keys, lengths, lists, locals, locks, methods, nested, objects, orders, pointers, refs, - saturates, separated, shapes, singles, slices, splits, statics, strs, tuples, utf8, wrappers, wraps, zeros, + arrays, ascii, atomics, borrows, bounds, boxes, capacity, captures, cells, chars, chunks, clones, collections, + combinators, counts, cows, cycles, defaults, durations, dyns, edits, errors, floats, fmt, folds, generics, hashes, + hints, holds, ints, iters, joins, keys, lengths, lists, locals, locks, methods, nested, objects, orders, pointers, + refs, saturates, separated, shapes, singles, slices, splits, statics, strs, tuples, utf8, wrappers, wraps, zeros, }; /// The native side's entry: [`run`], except that a case starting with 0xff prints a diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index 1606e94b3..1eddb5fbe 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -1158,7 +1158,11 @@ fn deque<'tcx>( values.push(super::iter::size_of(b, item, span)); empty(b, Expr::rt("dequeWithCapacity", values), coll, span) } - (_, "capacity" | "push_back" | "push_front" | "insert" | "reserve" | "reserve_exact" | "shrink_to" | "shrink_to_fit") => { + ( + _, + "capacity" | "push_back" | "push_front" | "insert" | "reserve" | "reserve_exact" | "shrink_to" + | "shrink_to_fit", + ) => { let f = match name { "capacity" => "dequeCapacity", "push_back" => "dequePushBack", @@ -1209,7 +1213,10 @@ fn deque<'tcx>( Expr::rt("dequeClone", values) } // `From>` keeps the vector's capacity, and `From<[T; N]>` has room for `N`. - ("From", "from") if matches!(library::targ(call.args, 1).kind(), ty::Array(..)) || b.t.std_of(library::targ(call.args, 1)) == Some(Std::Vec) => { + ("From", "from") + if matches!(library::targ(call.args, 1).kind(), ty::Array(..)) + || b.t.std_of(library::targ(call.args, 1)) == Some(Std::Vec) => + { let from = library::targ(call.args, 1); let bytes = matches!(item.kind(), ty::Uint(ty::UintTy::U8)); let v = match (bytes, from.is_array(), b.t.copy_fn(item, span)) { diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index 8e72cdbae..5afb2773f 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -1402,10 +1402,16 @@ fn collected<'tcx>( let bare = Expr::lit(is_vec_into_iter(b.t.tcx, from).to_string()); let src_size = size_of(b, src, span); return match bytes { - true => Expr::rt("iterToByteVecInPlace", tail(vec![iter, src_size, bare], vec![take, trusted])), + true => Expr::rt( + "iterToByteVecInPlace", + tail(vec![iter, src_size, bare], vec![take, trusted]), + ), false => { let size = size_of(b, elem, span); - Expr::rt("iterToArrayInPlace", tail(vec![iter, src_size, size, bare], vec![take, trusted])) + Expr::rt( + "iterToArrayInPlace", + tail(vec![iter, src_size, size, bare], vec![take, trusted]), + ) } }; } @@ -1479,13 +1485,11 @@ fn in_place<'tcx>(t: &Translator<'_, 'tcx>, iter: Ty<'tcx>, elem: Ty<'tcx>) -> O .map(|item| item.def_id) }; // `::Source`, a `vec::IntoIter` of what it collects in place of. - let Some(src) = assoc(source, "Source").and_then(|item| { + let src = assoc(source, "Source").and_then(|item| { let projection = Ty::new_projection(tcx, ty::IsRigid::No, item, [iter]); tcx.try_normalize_erasing_regions(env, ty::Unnormalized::new_wip(projection)) .ok() - }) else { - return None; - }; + })?; let ty::Adt(adt, src_args) = src.kind() else { return None; }; diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index cad3463be..c15175f09 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -1977,7 +1977,10 @@ fn mapping<'tcx>( } // What changes or reads a capacity is given the size of its elements, by which // std's grows it. - ("Vec", "with_capacity" | "capacity" | "push" | "reserve" | "reserve_exact" | "shrink_to" | "shrink_to_fit") => { + ( + "Vec", + "with_capacity" | "capacity" | "push" | "reserve" | "reserve_exact" | "shrink_to" | "shrink_to_fit", + ) => { let mut values = args; if name == "shrink_to_fit" { values.push(Expr::lit("0")); From c3daa4f0a5312d286a48badded8c1c5a5ea6b4ed Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 21:36:56 -0700 Subject: [PATCH 05/14] test(ts): refresh snapshots after merging main Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/expected/args.ts | 2 +- ts/fixtures/lang/expected/capacity.ts | 96 +++++++++++++-------------- ts/fixtures/lang/expected/harness.ts | 15 +++-- ts/fixtures/lang/expected/orders.ts | 53 +++++++-------- ts/fixtures/stock/expected/harness.ts | 2 +- 5 files changed, 85 insertions(+), 83 deletions(-) diff --git a/ts/fixtures/lang/expected/args.ts b/ts/fixtures/lang/expected/args.ts index aa5376bef..e1162486e 100644 --- a/ts/fixtures/lang/expected/args.ts +++ b/ts/fixtures/lang/expected/args.ts @@ -53,7 +53,7 @@ export function kept(data: rt.ByteSlice, n: rt.u8): rt.ByteSlice[] { if (!(iterStart++ < iterEnd)) { return all; } - all.push(data); + rt.vecPush(all, data, 8); } } diff --git a/ts/fixtures/lang/expected/capacity.ts b/ts/fixtures/lang/expected/capacity.ts index 53a1c077d..bcb7800f5 100644 --- a/ts/fixtures/lang/expected/capacity.ts +++ b/ts/fixtures/lang/expected/capacity.ts @@ -40,38 +40,38 @@ export function alternate(): () => boolean { * 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, data: rt.ByteSlice, out: rt.ByteVec): void { +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(data, (b3: rt.u8): rt.u8 => { + vecSteps$u8(dataData, dataStart, dataLen, (b3: rt.u8): rt.u8 => { return b3; }, out); } else if (_5 === 1) { - vecSteps$u16(data, (a0: rt.u8): rt.u16 => { + vecSteps$u16(dataData, dataStart, dataLen, (a0: rt.u8): rt.u16 => { return a0 as rt.u16; }, out); } else if (_5 === 2) { - vecSteps$tuple2_u64_u8(data, (b2: rt.u8): [rt.u64, rt.u8] => { + 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(data, (b: rt.u8): rt.u64[] => { + 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(data, (_2: rt.u8): undefined => {}, out); + vecSteps$unit(dataData, dataStart, dataLen, (_2: rt.u8): undefined => {}, out); } } -export function vecSteps$array160_u64(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u64[], out: rt.ByteVec): void { +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 _131!: 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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + 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]; @@ -219,12 +219,12 @@ export function vecSteps$array160_u64(data: rt.ByteSlice, make: (a0: rt.u8) => r } } -export function vecSteps$tuple2_u64_u8(data: rt.ByteSlice, make: (a0: rt.u8) => [rt.u64, rt.u8], out: rt.ByteVec): void { +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 _131!: 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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + 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]; @@ -372,12 +372,12 @@ export function vecSteps$tuple2_u64_u8(data: rt.ByteSlice, make: (a0: rt.u8) => } } -export function vecSteps$u16(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u16, out: rt.ByteVec): void { +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 _131!: 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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + 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]; @@ -525,12 +525,12 @@ export function vecSteps$u16(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u16, ou } } -export function vecSteps$u8(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +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 _131!: 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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + 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]; @@ -678,12 +678,12 @@ export function vecSteps$u8(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u8, out: } } -export function vecSteps$unit(data: rt.ByteSlice, make: (a0: rt.u8) => undefined, out: rt.ByteVec): void { +export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => undefined, out: rt.ByteVec): void { let v!: undefined[]; let _131!: 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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + 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]; @@ -841,37 +841,37 @@ export function vecSteps$unit(data: rt.ByteSlice, make: (a0: rt.u8) => undefined } /** A `VecDeque`, as `vecs` steps a `Vec`. */ -export function deques(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +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(data, (b3: rt.u8): rt.u8 => { + dequeSteps$u8(dataData, dataStart, dataLen, (b3: rt.u8): rt.u8 => { return b3; }, out); } else if (_5 === 1) { - dequeSteps$u16(data, (a0: rt.u8): rt.u16 => { + dequeSteps$u16(dataData, dataStart, dataLen, (a0: rt.u8): rt.u16 => { return a0 as rt.u16; }, out); } else if (_5 === 2) { - dequeSteps$tuple2_u64_u8(data, (b2: rt.u8): [rt.u64, rt.u8] => { + 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(data, (b: rt.u8): rt.u64[] => { + 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(data, (_2: rt.u8): undefined => {}, out); + dequeSteps$unit(dataData, dataStart, dataLen, (_2: rt.u8): undefined => {}, out); } } -export function dequeSteps$array160_u64(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u64[], out: rt.ByteVec): void { +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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + 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]; @@ -946,11 +946,11 @@ export function dequeSteps$array160_u64(data: rt.ByteSlice, make: (a0: rt.u8) => } } -export function dequeSteps$tuple2_u64_u8(data: rt.ByteSlice, make: (a0: rt.u8) => [rt.u64, rt.u8], out: rt.ByteVec): void { +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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + 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]; @@ -1025,11 +1025,11 @@ export function dequeSteps$tuple2_u64_u8(data: rt.ByteSlice, make: (a0: rt.u8) = } } -export function dequeSteps$u16(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u16, out: rt.ByteVec): void { +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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + 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]; @@ -1104,11 +1104,11 @@ export function dequeSteps$u16(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u16, } } -export function dequeSteps$u8(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + 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]; @@ -1183,11 +1183,11 @@ export function dequeSteps$u8(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u8, ou } } -export function dequeSteps$unit(data: rt.ByteSlice, make: (a0: rt.u8) => undefined, out: rt.ByteVec): void { +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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + 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]; @@ -1273,37 +1273,37 @@ export function dequeSteps$unit(data: rt.ByteSlice, make: (a0: rt.u8) => undefin } /** A `BinaryHeap`, as `vecs` steps a `Vec`, and the `Vec` it gives up at the end. */ -export function heaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +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(data, (b3: rt.u8): rt.u8 => { + heapSteps$u8(dataData, dataStart, dataLen, (b3: rt.u8): rt.u8 => { return b3; }, out); } else if (_5 === 1) { - heapSteps$u16(data, (a0: rt.u8): rt.u16 => { + heapSteps$u16(dataData, dataStart, dataLen, (a0: rt.u8): rt.u16 => { return a0 as rt.u16; }, out); } else if (_5 === 2) { - heapSteps$tuple2_u64_u8(data, (b2: rt.u8): [rt.u64, rt.u8] => { + 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(data, (b: rt.u8): rt.u64[] => { + 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(data, (_2: rt.u8): undefined => {}, out); + heapSteps$unit(dataData, dataStart, dataLen, (_2: rt.u8): undefined => {}, out); } } -export function heapSteps$array160_u64(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u64[], out: rt.ByteVec): void { +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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + 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]; @@ -1364,11 +1364,11 @@ export function heapSteps$array160_u64(data: rt.ByteSlice, make: (a0: rt.u8) => put(out, rt.vecCapacity(rt.heapIntoSortedVec(h, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))), 1280)); } -export function heapSteps$tuple2_u64_u8(data: rt.ByteSlice, make: (a0: rt.u8) => [rt.u64, rt.u8], out: rt.ByteVec): void { +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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + 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]; @@ -1429,11 +1429,11 @@ export function heapSteps$tuple2_u64_u8(data: rt.ByteSlice, make: (a0: rt.u8) => put(out, rt.vecCapacity(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]))), 16)); } -export function heapSteps$u16(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u16, out: rt.ByteVec): void { +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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + 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]; @@ -1494,11 +1494,11 @@ export function heapSteps$u16(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u16, o put(out, rt.vecCapacity(rt.heapIntoSortedVec(h, rt.le, rt.ge, rt.lt), 2)); } -export function heapSteps$u8(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + 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]; @@ -1559,11 +1559,11 @@ export function heapSteps$u8(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u8, out put(out, rt.byteVecCapacity(rt.byteVecFromVec(rt.heapIntoSortedVec(h, rt.le, rt.ge, rt.lt)))); } -export function heapSteps$unit(data: rt.ByteSlice, make: (a0: rt.u8) => undefined, out: rt.ByteVec): void { +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((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + 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]; diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index d0cf80185..1d4c9ebbd 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 } from "./borrows.ts"; import { bounds as bounds_bounds } from "./bounds.ts"; import { boxes } 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"; @@ -97,11 +98,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 => { @@ -248,7 +249,13 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) reattached(data86, out87); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::part_written", (_2187: rt.u8, data87: rt.ByteSlice, out88: rt.ByteVec): undefined => { partWritten(data87, out88); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::flattened", arrays_flattened as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["args::args", args as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["returns::returns", returns as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::flattened", arrays_flattened as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["args::args", args as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["returns::returns", returns as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["capacity::vecs", (a0147: rt.u8, a1147: rt.ByteSlice, a2147: rt.ByteVec): undefined => { + capacity_vecs(a0147, a1147.data, a1147.start, a1147.length, a2147); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["capacity::deques", (a0148: rt.u8, a1148: rt.ByteSlice, a2148: rt.ByteVec): undefined => { + capacity_deques(a0148, a1148.data, a1148.start, a1148.length, a2148); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["capacity::heaps", (a0149: rt.u8, a1149: rt.ByteSlice, a2149: rt.ByteVec): undefined => { + capacity_heaps(a0149, a1149.data, a1149.start, a1149.length, a2149); + }] 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/orders.ts b/ts/fixtures/lang/expected/orders.ts index c9074b7fe..c13233ff8 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(); @@ -255,7 +255,7 @@ export function heaps(data: rt.ByteSlice, out: rt.ByteVec): void { const _17: rt.u8 = rt.u8Rem(op, 12); if (0 <= _17) { if (_17 <= 2) { - rt.heapPush(heap, item(i, v), orders_Item.le$cmp_PartialOrd); + rt.heapPush(heap, item(i, v), orders_Item.le$cmp_PartialOrd, 2); break b2; } } @@ -310,9 +310,9 @@ export function heaps(data: rt.ByteSlice, out: rt.ByteVec): void { } } else if (_17 === 6) { const _57: orders_Item.Item = item(i, v); - rt.heapPush(other, _57, orders_Item.le$cmp_PartialOrd); + rt.heapPush(other, _57, orders_Item.le$cmp_PartialOrd, 2); } else if (_17 === 7) { - rt.heapAppend(heap, other, orders_Item.le$cmp_PartialOrd, orders_Item.ge$cmp_PartialOrd, orders_Item.lt$cmp_PartialOrd); + rt.heapAppend(heap, other, orders_Item.le$cmp_PartialOrd, orders_Item.ge$cmp_PartialOrd, orders_Item.lt$cmp_PartialOrd, 2); } else if (_17 === 8) { rt.heapRetain(heap, (x4: orders_Item.Item): boolean => { return x4.key !== rt.u8Rem(v, 8); @@ -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); - rt.heapPush(bytes, data.length & 0xff, rt.le); + 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, 1); 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.byteVecIntoIter(rt.byteVecFromVec(rt.heapIntoSortedVec(rt.heapClone(bytes), 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.byteVecIntoIter(rt.byteVecFromVec(bytes.d)), undefined, true); const least: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u8 => { return _2; }), undefined, 1, true), rt.cmpLe(rt.cmpReverse(rt.cmp)), rt.cmpGe(rt.cmpReverse(rt.cmp)), rt.cmpLt(rt.cmpReverse(rt.cmp))); @@ -568,7 +568,7 @@ export function bytes(data: rt.ByteSlice, out: rt.ByteVec): void { } if (_228.length >= 2) { rt.idx(_228, 0); - refs.push([new rt.ByteSlice(_228.data, _228.start, 2), rt.u8Div(_228.data[_228.start], 64)] as [rt.ByteSlice, rt.u8]); + rt.vecPush(refs, [new rt.ByteSlice(_228.data, _228.start, 2), rt.u8Div(_228.data[_228.start], 64)] as [rt.ByteSlice, rt.u8], 8); } } rt.sliceSort(refs, rt.cmpLt(rt.cmpTuple<[rt.ByteSlice, rt.u8], rt.Ordering | undefined>([rt.cmpBytes, rt.cmp]))); @@ -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), 2) as rt.VecDeque; const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart, mid))))); while (true) { const _23: [rt.usize, rt.u8] | rt.Done = iter.next(); @@ -760,7 +759,7 @@ export function deque$orders_Part_orders_held_closure3(sData: Uint8Array, sStart return d; } const _30: Part.Part = f(_23[0], _23[1]); - rt.dequePushFront(d, _30); + rt.dequePushFront(d, _30, 2); } } @@ -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), 2) as rt.VecDeque; const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart, mid))))); while (true) { const _23: [rt.usize, rt.u8] | rt.Done = iter.next(); @@ -791,7 +789,7 @@ export function deque$orders_Part_orders_part(sData: Uint8Array, sStart: number, return d; } const _30: Part.Part = part(_23[0], _23[1]); - rt.dequePushFront(d, _30); + rt.dequePushFront(d, _30, 2); } } @@ -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), 1) 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(); @@ -822,7 +819,7 @@ export function deque$u8_orders_held_closure11(sData: Uint8Array, sStart: number return d; } const _30: rt.u8 = f(_23[0], _23[1]); - rt.dequePushFront(d, _30); + rt.dequePushFront(d, _30, 1); } } @@ -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), 1) 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(); @@ -853,7 +849,7 @@ export function deque$u8_orders_held_closure8(sData: Uint8Array, sStart: number, return d; } const _30: rt.u8 = f(_23[0], _23[1]); - rt.dequePushFront(d, _30); + rt.dequePushFront(d, _30, 1); } } @@ -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), 8) as rt.VecDeque; }; const iter: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.byteSliceWindows(data, 2)); while (true) { @@ -1242,7 +1237,7 @@ export function btrees(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecClear(a034); }); } - const apart: Apart.Apart[] = rt.vecFromElem({}, short.length, undefined); + const apart: Apart.Apart[] = rt.vecFromElem({}, short.length, undefined, 0); const _183: rt.Iter = rt.iterSlice(apart); const set2: rt.BTreeSet = rt.btreeCollectKeys(rt.btreeNew(Apart.cmp$cmp_Ord) as rt.BTreeSet, rt.iterToArray(_183, undefined, 0, true), undefined, Apart.eq$cmp_PartialEq); const _188: rt.Iter<[Apart.Apart, undefined]> = rt.iterMap(rt.iterSlice(apart), (_211: Apart.Apart): [Apart.Apart, undefined] => { diff --git a/ts/fixtures/stock/expected/harness.ts b/ts/fixtures/stock/expected/harness.ts index 4209af111..dc7ad7a99 100644 --- a/ts/fixtures/stock/expected/harness.ts +++ b/ts/fixtures/stock/expected/harness.ts @@ -106,7 +106,7 @@ export function slices(dataData: Uint8Array, dataStart: number, dataLen: number, rt.byteVecPush(out, rt.byteSliceEq(part, bytes) ? 1 : 0); rt.byteVecPush(out, rt.byteSliceEq(part, rt.byteSliceRange(part, 0)) ? 1 : 0); rt.byteVecPush(out, rt.byteSliceEq(rt.bytesSlice(rt.bytesSlice(bytes, rt.min(a, dataLen - 3)), 0, 0), rt.bytesNew()) ? 1 : 0); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.byteSliceToByteVec(part))); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.bytesToByteVec(part))); } } From 7e2866a4176e766ced710c09a31c48042bddf09a Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 21:57:03 -0700 Subject: [PATCH 06/14] fix(ts): a clone of an owning iterator, a forgotten PeekMut, and an unsure deque source keep std's capacity Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/caller.ts | 2 +- ts/fixtures/lang/expected/capacity.ts | 250 +++++++++++++++++++++----- ts/fixtures/lang/expected/hints.ts | 37 ++-- ts/fixtures/lang/expected/lib.ts | 4 + ts/fixtures/lang/src/capacity.rs | 30 +++- ts/runtime/rt/collections.ts | 14 +- ts/runtime/rt/iter.ts | 12 +- 7 files changed, 280 insertions(+), 69 deletions(-) diff --git a/ts/fixtures/lang/caller.ts b/ts/fixtures/lang/caller.ts index a0e77d554..498341f91 100644 --- a/ts/fixtures/lang/caller.ts +++ b/ts/fixtures/lang/caller.ts @@ -730,7 +730,7 @@ const asciiCases = [ * grows and shrinks it; and each way `collects` makes one, of each length it tries. */ const capacityCases = [ - ...[["capacity::vecs", 24], ["capacity::deques", 20], ["capacity::heaps", 12]].flatMap(([name, steps]) => + ...[["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); diff --git a/ts/fixtures/lang/expected/capacity.ts b/ts/fixtures/lang/expected/capacity.ts index bcb7800f5..db45db914 100644 --- a/ts/fixtures/lang/expected/capacity.ts +++ b/ts/fixtures/lang/expected/capacity.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; -import { copy$array_u64, copy$tuple2_u32_u32 } from "./lib.ts"; +import { copy$array_u64, copy$tuple2_u32_u32, copy$tuple2_u64_u8 } from "./lib.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. */ @@ -92,7 +92,7 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d const op: rt.u8 = _30[0]; const arg: rt.u8 = _30[1]; b3: { - const _39: rt.u8 = rt.u8Rem(op, 24); + const _39: rt.u8 = rt.u8Rem(op, 25); if (_39 === 0 || _39 === 1) { rt.vecPush(v, copy$array_u64(make(arg)), 1280); break b3; @@ -207,9 +207,23 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d rt.vecSwapRemove(v, rt.usizeRem(arg as rt.usize, v.length)); break b3; } - } else if (_39 === 22) { - rt.vecDedupBy(v, rt.eqSlice(rt.u64Eq)); - break b3; + } else { + if (_39 === 22) { + rt.vecDedupBy(v, rt.eqSlice(rt.u64Eq)); + break b3; + } + if (_39 === 23) { + const it2: rt.Iter = rt.iterSlice(v); + const _175: rt.u8 = rt.u8Rem(arg, 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _175; + while (iterStart2++ < iterEnd2) { + rt.iterToOption(it2.next()); + } + v = rt.iterToArrayInPlace(it2.clone({ v: copy$array_u64 }), 1280, 1280, true, "next", true); + put(out, rt.vecCapacity(rt.iterToArrayInPlace(it2, 1280, 1280, true, "next", true), 1280)); + break b3; + } } } v = rt.vecFromElem(copy$array_u64(make(arg)), rt.u8Rem(arg, 6) as rt.usize, copy$array_u64, 1280); @@ -245,9 +259,9 @@ export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, const op: rt.u8 = _30[0]; const arg: rt.u8 = _30[1]; b3: { - const _39: rt.u8 = rt.u8Rem(op, 24); + const _39: rt.u8 = rt.u8Rem(op, 25); if (_39 === 0 || _39 === 1) { - rt.vecPush(v, make(arg), 16); + rt.vecPush(v, copy$tuple2_u64_u8(make(arg)), 16); break b3; } if (_39 === 2) { @@ -275,7 +289,7 @@ export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, break b3; } if (_39 === 8) { - rt.vecInsert(v, rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.length, 1)), make(arg), 16); + rt.vecInsert(v, rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.length, 1)), copy$tuple2_u64_u8(make(arg)), 16); break b3; } if (_39 === 9) { @@ -295,7 +309,7 @@ export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, break b3; } if (_39 === 12) { - rt.vecExtendFromSlice(v, [make(arg), make(arg)], undefined, 16); + rt.vecExtendFromSlice(v, [make(arg), make(arg)], copy$tuple2_u64_u8, 16); break b3; } if (_39 === 13) { @@ -314,7 +328,7 @@ export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, break b3; } if (_39 === 16) { - v = v.slice(); + v = v.map(copy$tuple2_u64_u8); break b3; } if (_39 === 17) { @@ -345,7 +359,7 @@ export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, } if (_39 === 20) { let taken: [rt.u64, rt.u8][] = rt.replaceIn(v, []); - const _148: [rt.u64, rt.u8] = make(arg); + const _148: [rt.u64, rt.u8] = copy$tuple2_u64_u8(make(arg)); rt.vecPush(taken, _148, 16); put(out, rt.vecCapacity(taken, 16)); const _154: [rt.u64, rt.u8][] = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 16); @@ -360,12 +374,26 @@ export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, rt.vecSwapRemove(v, rt.usizeRem(arg as rt.usize, v.length)); break b3; } - } else if (_39 === 22) { - rt.vecDedupBy(v, rt.eqTuple([rt.u64Eq, rt.same])); - break b3; + } else { + if (_39 === 22) { + rt.vecDedupBy(v, rt.eqTuple([rt.u64Eq, rt.same])); + break b3; + } + if (_39 === 23) { + const it2: rt.Iter<[rt.u64, rt.u8]> = rt.iterSlice(v); + const _175: rt.u8 = rt.u8Rem(arg, 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _175; + while (iterStart2++ < iterEnd2) { + rt.iterToOption(it2.next()); + } + v = rt.iterToArrayInPlace(it2.clone({ v: copy$tuple2_u64_u8 }), 16, 16, true, "next", true); + put(out, rt.vecCapacity(rt.iterToArrayInPlace(it2, 16, 16, true, "next", true), 16)); + break b3; + } } } - v = rt.vecFromElem(make(arg), rt.u8Rem(arg, 6) as rt.usize, undefined, 16); + v = rt.vecFromElem(copy$tuple2_u64_u8(make(arg)), rt.u8Rem(arg, 6) as rt.usize, copy$tuple2_u64_u8, 16); } put(out, v.length); put(out, rt.vecCapacity(v, 16)); @@ -398,7 +426,7 @@ export function vecSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: n const op: rt.u8 = _30[0]; const arg: rt.u8 = _30[1]; b3: { - const _39: rt.u8 = rt.u8Rem(op, 24); + const _39: rt.u8 = rt.u8Rem(op, 25); if (_39 === 0 || _39 === 1) { rt.vecPush(v, make(arg), 2); break b3; @@ -513,9 +541,23 @@ export function vecSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: n rt.vecSwapRemove(v, rt.usizeRem(arg as rt.usize, v.length)); break b3; } - } else if (_39 === 22) { - rt.vecDedupBy(v, rt.same); - break b3; + } else { + if (_39 === 22) { + rt.vecDedupBy(v, rt.same); + break b3; + } + if (_39 === 23) { + const it2: rt.Iter = rt.iterSlice(v); + const _175: rt.u8 = rt.u8Rem(arg, 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _175; + while (iterStart2++ < iterEnd2) { + rt.iterToOption(it2.next()); + } + v = rt.iterToArrayInPlace(it2.clone(), 2, 2, true, "next", true); + put(out, rt.vecCapacity(rt.iterToArrayInPlace(it2, 2, 2, true, "next", true), 2)); + break b3; + } } } v = rt.vecFromElem(make(arg), rt.u8Rem(arg, 6) as rt.usize, undefined, 2); @@ -551,7 +593,7 @@ export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: nu const op: rt.u8 = _30[0]; const arg: rt.u8 = _30[1]; b3: { - const _39: rt.u8 = rt.u8Rem(op, 24); + const _39: rt.u8 = rt.u8Rem(op, 25); if (_39 === 0 || _39 === 1) { rt.byteVecPush(v, make(arg)); break b3; @@ -666,9 +708,23 @@ export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: nu rt.byteVecSwapRemove(v, rt.usizeRem(arg as rt.usize, v.length)); break b3; } - } else if (_39 === 22) { - rt.byteVecDedup(v); - break b3; + } else { + if (_39 === 22) { + rt.byteVecDedup(v); + break b3; + } + if (_39 === 23) { + const it2: rt.Iter = rt.byteVecIntoIter(v); + const _175: rt.u8 = rt.u8Rem(arg, 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _175; + while (iterStart2++ < iterEnd2) { + rt.iterToOption(it2.next()); + } + v = rt.iterToByteVecInPlace(it2.clone(), 1, true, "next", true); + put(out, rt.byteVecCapacity(rt.iterToByteVecInPlace(it2, 1, true, "next", true))); + break b3; + } } } v = rt.byteVecOf(make(arg), rt.u8Rem(arg, 6) as rt.usize); @@ -704,7 +760,7 @@ export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: const op: rt.u8 = _30[0]; const arg: rt.u8 = _30[1]; b3: { - const _39: rt.u8 = rt.u8Rem(op, 24); + const _39: rt.u8 = rt.u8Rem(op, 25); if (_39 === 0 || _39 === 1) { const _41: undefined[] = v; make(arg); @@ -827,9 +883,23 @@ export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: rt.vecSwapRemove(v, rt.usizeRem(arg as rt.usize, v.length)); break b3; } - } else if (_39 === 22) { - rt.vecDedupBy(v, rt.same); - break b3; + } else { + if (_39 === 22) { + rt.vecDedupBy(v, rt.same); + break b3; + } + if (_39 === 23) { + const it2: rt.Iter = rt.iterSlice(v); + const _175: rt.u8 = rt.u8Rem(arg, 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _175; + while (iterStart2++ < iterEnd2) { + rt.iterToOption(it2.next(), rt.None); + } + v = rt.iterToArrayInPlace(it2.clone(), 0, 0, true, undefined, true); + put(out, rt.vecCapacity(rt.iterToArrayInPlace(it2, 0, 0, true, undefined, true), 0)); + break b3; + } } } make(arg); @@ -891,7 +961,7 @@ export function dequeSteps$array160_u64(dataData: Uint8Array, dataStart: number, const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; const op: rt.u8 = _30[0]; const arg: rt.u8 = _30[1]; - const _39: rt.u8 = rt.u8Rem(op, 20); + const _39: rt.u8 = rt.u8Rem(op, 21); if (_39 === 0) { rt.dequePushBack(q, copy$array_u64(make(arg)), 1280); } else if (_39 === 1) { @@ -938,6 +1008,16 @@ export function dequeSteps$array160_u64(dataData: Uint8Array, dataStart: number, q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_23: rt.u64[]): boolean => { return keep2(); }), "next", 1280), 1280) as rt.VecDeque; + } else if (_39 === 19) { + const it: rt.Iter = rt.dequeIter(q); + const _128: rt.u8 = rt.u8Rem(arg, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _128; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + q = rt.dequeFromIntoIter(it.clone({ v: copy$array_u64 }), 1280) as rt.VecDeque; + put(out, rt.dequeCapacity(rt.dequeFromIntoIter(it, 1280) as rt.VecDeque, 1280)); } else { q = rt.dequeFromVec([copy$array_u64(make(arg)), copy$array_u64(make(arg)), copy$array_u64(make(arg))].map(copy$array_u64), 1280) as rt.VecDeque; } @@ -970,11 +1050,11 @@ export function dequeSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; const op: rt.u8 = _30[0]; const arg: rt.u8 = _30[1]; - const _39: rt.u8 = rt.u8Rem(op, 20); + const _39: rt.u8 = rt.u8Rem(op, 21); if (_39 === 0) { - rt.dequePushBack(q, make(arg), 16); + rt.dequePushBack(q, copy$tuple2_u64_u8(make(arg)), 16); } else if (_39 === 1) { - rt.dequePushFront(q, make(arg), 16); + rt.dequePushFront(q, copy$tuple2_u64_u8(make(arg)), 16); } else if (_39 === 2) { rt.dequePopFront(q); } else if (_39 === 3) { @@ -988,7 +1068,7 @@ export function dequeSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number } else if (_39 === 7) { rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); } else if (_39 === 8) { - rt.dequeInsert(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), make(arg), 16); + rt.dequeInsert(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), copy$tuple2_u64_u8(make(arg)), 16); } else if (_39 === 9) { rt.dequeRemove(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1))); } else if (_39 === 10) { @@ -1007,7 +1087,7 @@ export function dequeSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number } else if (_39 === 14) { rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) }); } else if (_39 === 15) { - q = rt.dequeClone(q, undefined); + q = rt.dequeClone(q, copy$tuple2_u64_u8); } else if (_39 === 16) { q = rt.dequeFromIntoIter(rt.dequeIter(q), 16) as rt.VecDeque<[rt.u64, rt.u8]>; } else if (_39 === 17) { @@ -1017,8 +1097,18 @@ export function dequeSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_23: [rt.u64, rt.u8]): boolean => { return keep2(); }), "next", 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + } else if (_39 === 19) { + const it: rt.Iter<[rt.u64, rt.u8]> = rt.dequeIter(q); + const _128: rt.u8 = rt.u8Rem(arg, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _128; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + q = rt.dequeFromIntoIter(it.clone({ v: copy$tuple2_u64_u8 }), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + put(out, rt.dequeCapacity(rt.dequeFromIntoIter(it, 16) as rt.VecDeque<[rt.u64, rt.u8]>, 16)); } else { - q = rt.dequeFromVec([make(arg), make(arg), make(arg)], 16) as rt.VecDeque<[rt.u64, rt.u8]>; + q = rt.dequeFromVec([copy$tuple2_u64_u8(make(arg)), copy$tuple2_u64_u8(make(arg)), copy$tuple2_u64_u8(make(arg))].map(copy$tuple2_u64_u8), 16) as rt.VecDeque<[rt.u64, rt.u8]>; } put(out, q.n); put(out, rt.dequeCapacity(q, 16)); @@ -1049,7 +1139,7 @@ export function dequeSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; const op: rt.u8 = _30[0]; const arg: rt.u8 = _30[1]; - const _39: rt.u8 = rt.u8Rem(op, 20); + const _39: rt.u8 = rt.u8Rem(op, 21); if (_39 === 0) { rt.dequePushBack(q, make(arg), 2); } else if (_39 === 1) { @@ -1096,6 +1186,16 @@ export function dequeSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_23: rt.u16): boolean => { return keep2(); }), "next", 2), 2) as rt.VecDeque; + } else if (_39 === 19) { + const it: rt.Iter = rt.dequeIter(q); + const _128: rt.u8 = rt.u8Rem(arg, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _128; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + q = rt.dequeFromIntoIter(it.clone(), 2) as rt.VecDeque; + put(out, rt.dequeCapacity(rt.dequeFromIntoIter(it, 2) as rt.VecDeque, 2)); } else { q = rt.dequeFromVec([make(arg), make(arg), make(arg)], 2) as rt.VecDeque; } @@ -1128,7 +1228,7 @@ export function dequeSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; const op: rt.u8 = _30[0]; const arg: rt.u8 = _30[1]; - const _39: rt.u8 = rt.u8Rem(op, 20); + const _39: rt.u8 = rt.u8Rem(op, 21); if (_39 === 0) { rt.dequePushBack(q, make(arg), 1); } else if (_39 === 1) { @@ -1175,6 +1275,16 @@ export function dequeSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_23: rt.u8): boolean => { return keep2(); }), "next", 1), 1) as rt.VecDeque; + } else if (_39 === 19) { + const it: rt.Iter = rt.dequeIter(q); + const _128: rt.u8 = rt.u8Rem(arg, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _128; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + q = rt.dequeFromIntoIter(it.clone(), 1) as rt.VecDeque; + put(out, rt.dequeCapacity(rt.dequeFromIntoIter(it, 1) as rt.VecDeque, 1)); } else { q = rt.dequeFromVec(Array.from(Uint8Array.of(make(arg), make(arg), make(arg))), 1) as rt.VecDeque; } @@ -1207,7 +1317,7 @@ export function dequeSteps$unit(dataData: Uint8Array, dataStart: number, dataLen const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; const op: rt.u8 = _30[0]; const arg: rt.u8 = _30[1]; - const _39: rt.u8 = rt.u8Rem(op, 20); + const _39: rt.u8 = rt.u8Rem(op, 21); if (_39 === 0) { const _41: rt.VecDeque = q; make(arg); @@ -1261,6 +1371,16 @@ export function dequeSteps$unit(dataData: Uint8Array, dataStart: number, dataLen q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_23: undefined): boolean => { return keep2(); }), "next", 0), 0) as rt.VecDeque; + } else if (_39 === 19) { + const it: rt.Iter = rt.dequeIter(q); + const _128: rt.u8 = rt.u8Rem(arg, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _128; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next(), rt.None); + } + q = rt.dequeFromIntoIter(it.clone(), 0) as rt.VecDeque; + put(out, rt.dequeCapacity(rt.dequeFromIntoIter(it, 0) as rt.VecDeque, 0)); } else { make(arg); make(arg); @@ -1324,7 +1444,7 @@ export function heapSteps$array160_u64(dataData: Uint8Array, dataStart: number, const _31: [rt.u8, rt.u8] = [_25.data[_25.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_25, 1), 0)]; const op: rt.u8 = _31[0]; const arg: rt.u8 = _31[1]; - const _40: rt.u8 = rt.u8Rem(op, 12); + const _40: rt.u8 = rt.u8Rem(op, 13); if (_40 === 0 || _40 === 1) { rt.heapPush(h, copy$array_u64(make(arg)), rt.cmpLe(rt.cmpSlice(rt.cmp)), 1280); } else if (_40 === 2) { @@ -1354,6 +1474,14 @@ export function heapSteps$array160_u64(dataData: Uint8Array, dataStart: number, put(out, rt.vecCapacity(other.d, 1280)); } else if (_40 === 10) { rt.drop(rt.heapDrain(h)); + } else if (_40 === 11) { + const _77: 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 (_77 !== undefined) { + const top: rt.PeekMut = _77; + const _81: rt.u64[] = copy$array_u64(make(arg)); + rt.peekMutDerefMut(top); + Object.assign(top.v, _81); + } } else { h = rt.heapFrom(h.d, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); } @@ -1389,9 +1517,9 @@ export function heapSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, const _31: [rt.u8, rt.u8] = [_25.data[_25.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_25, 1), 0)]; const op: rt.u8 = _31[0]; const arg: rt.u8 = _31[1]; - const _40: rt.u8 = rt.u8Rem(op, 12); + const _40: rt.u8 = rt.u8Rem(op, 13); if (_40 === 0 || _40 === 1) { - rt.heapPush(h, make(arg), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), 16); + rt.heapPush(h, copy$tuple2_u64_u8(make(arg)), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), 16); } else if (_40 === 2) { rt.heapPop(h, rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))); } else if (_40 === 3) { @@ -1413,19 +1541,27 @@ export function heapSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, 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 (_40 === 9) { - const _68: [rt.u64, rt.u8] = make(arg); + const _68: [rt.u64, rt.u8] = copy$tuple2_u64_u8(make(arg)); rt.heapPush(other, _68, rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), 16); 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])), 16); put(out, rt.vecCapacity(other.d, 16)); } else if (_40 === 10) { rt.drop(rt.heapDrain(h)); + } else if (_40 === 11) { + const _77: 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 (_77 !== undefined) { + const top: rt.PeekMut<[rt.u64, rt.u8]> = _77; + const _81: [rt.u64, rt.u8] = copy$tuple2_u64_u8(make(arg)); + rt.peekMutDerefMut(top); + Object.assign(top.v, _81); + } } 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]))); } put(out, h.d.length); put(out, rt.vecCapacity(h.d, 16)); } - put(out, rt.vecCapacity(rt.heapClone(h).d, 16)); + put(out, rt.vecCapacity(rt.heapClone(h, copy$tuple2_u64_u8).d, 16)); put(out, rt.vecCapacity(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]))), 16)); } @@ -1454,7 +1590,7 @@ export function heapSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: const _31: [rt.u8, rt.u8] = [_25.data[_25.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_25, 1), 0)]; const op: rt.u8 = _31[0]; const arg: rt.u8 = _31[1]; - const _40: rt.u8 = rt.u8Rem(op, 12); + const _40: rt.u8 = rt.u8Rem(op, 13); if (_40 === 0 || _40 === 1) { rt.heapPush(h, make(arg), rt.le, 2); } else if (_40 === 2) { @@ -1484,6 +1620,14 @@ export function heapSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: put(out, rt.vecCapacity(other.d, 2)); } else if (_40 === 10) { rt.drop(rt.heapDrain(h)); + } else if (_40 === 11) { + const _77: rt.PeekMut | undefined = rt.heapPeekMut(h, rt.le, rt.ge, rt.lt); + if (_77 !== undefined) { + const top: rt.PeekMut = _77; + const _81: rt.u16 = make(arg); + rt.peekMutDerefMut(top); + top.v = _81; + } } else { h = rt.heapFrom(h.d, rt.le, rt.ge, rt.lt); } @@ -1519,7 +1663,7 @@ export function heapSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: n const _31: [rt.u8, rt.u8] = [_25.data[_25.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_25, 1), 0)]; const op: rt.u8 = _31[0]; const arg: rt.u8 = _31[1]; - const _40: rt.u8 = rt.u8Rem(op, 12); + const _40: rt.u8 = rt.u8Rem(op, 13); if (_40 === 0 || _40 === 1) { rt.heapPush(h, make(arg), rt.le, 1); } else if (_40 === 2) { @@ -1549,6 +1693,14 @@ export function heapSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: n put(out, rt.vecCapacity(other.d, 1)); } else if (_40 === 10) { rt.drop(rt.heapDrain(h)); + } else if (_40 === 11) { + const _77: rt.PeekMut | undefined = rt.heapPeekMut(h, rt.le, rt.ge, rt.lt); + if (_77 !== undefined) { + const top: rt.PeekMut = _77; + const _81: rt.u8 = make(arg); + rt.peekMutDerefMut(top); + top.v = _81; + } } else { h = rt.heapFrom(rt.byteVecToVec(rt.byteVecFromVec(h.d)), rt.le, rt.ge, rt.lt); } @@ -1584,7 +1736,7 @@ export function heapSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: const _31: [rt.u8, rt.u8] = [_25.data[_25.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_25, 1), 0)]; const op: rt.u8 = _31[0]; const arg: rt.u8 = _31[1]; - const _40: rt.u8 = rt.u8Rem(op, 12); + const _40: rt.u8 = rt.u8Rem(op, 13); if (_40 === 0 || _40 === 1) { const _42: rt.BinaryHeap = h; make(arg); @@ -1616,6 +1768,14 @@ export function heapSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: put(out, rt.vecCapacity(other.d, 0)); } else if (_40 === 10) { rt.drop(rt.heapDrain(h)); + } else if (_40 === 11) { + const _77: rt.PeekMut | undefined = rt.heapPeekMut(h, rt.cmpLe(rt.cmpNothing), rt.cmpGe(rt.cmpNothing), rt.cmpLt(rt.cmpNothing)); + if (_77 !== undefined) { + const top: rt.PeekMut = _77; + make(arg); + rt.peekMutDerefMut(top); + top.v = undefined; + } } else { h = rt.heapFrom(h.d, rt.cmpLe(rt.cmpNothing), rt.cmpGe(rt.cmpNothing), rt.cmpLt(rt.cmpNothing)); } diff --git a/ts/fixtures/lang/expected/hints.ts b/ts/fixtures/lang/expected/hints.ts index 52934a9a7..7f87fd350 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"; @@ -3306,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) { @@ -3313,19 +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, 16); + const v2: [rt.u64, rt.u8][] = rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8, 16); rt.iterExtend(v2, items, "next", 16); len = v2.length; } else if (coll === 3) { len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined, 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8, 16), 16) 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, 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]))); + 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, 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]))); 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) { @@ -3375,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) { @@ -3382,19 +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, 16); + const v2: [rt.u64, rt.u8][] = rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8, 16); rt.iterExtend(v2, items, "next", 16); len = v2.length; } else if (coll === 3) { len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined, 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8, 16), 16) 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, 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]))); + 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, 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]))); 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) { @@ -3444,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) { @@ -3451,19 +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, 16); + const v2: [rt.u64, rt.u8][] = rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8, 16); rt.iterExtend(v2, items, "next", 16); len = v2.length; } else if (coll === 3) { len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined, 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8, 16), 16) 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, 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]))); + 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, 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]))); 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) { @@ -3513,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) { @@ -3520,19 +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, 16); + const v2: [rt.u64, rt.u8][] = rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8, 16); rt.iterExtend(v2, items, undefined, 16, true); len = v2.length; } else if (coll === 3) { len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 16, true), 16) as rt.VecDeque<[rt.u64, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined, 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8, 16), 16) 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, 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]))); + 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, 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]))); 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) { @@ -3582,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) { @@ -3589,19 +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, 16); + const v2: [rt.u64, rt.u8][] = rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8, 16); rt.iterExtend(v2, items, "next", 16); len = v2.length; } else if (coll === 3) { len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined, 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8, 16), 16) 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, 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]))); + 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, 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]))); 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) { diff --git a/ts/fixtures/lang/expected/lib.ts b/ts/fixtures/lang/expected/lib.ts index 20f73a816..7d869d950 100644 --- a/ts/fixtures/lang/expected/lib.ts +++ b/ts/fixtures/lang/expected/lib.ts @@ -641,6 +641,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/src/capacity.rs b/ts/fixtures/lang/src/capacity.rs index 5aa5c138d..947d59bb3 100644 --- a/ts/fixtures/lang/src/capacity.rs +++ b/ts/fixtures/lang/src/capacity.rs @@ -59,7 +59,7 @@ fn vec_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec) put(out, v.capacity()); for step in steps.chunks(2) { let (op, arg) = (step[0], step.get(1).copied().unwrap_or(0)); - match op % 24 { + match op % 25 { 0 | 1 => v.push(make(arg)), 2 => drop(v.pop()), 3 => v.reserve(amount(arg, v.len(), size)), @@ -102,6 +102,15 @@ fn vec_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec) } 21 if !v.is_empty() => drop(v.swap_remove(usize::from(arg) % v.len())), 22 => v.dedup(), + // 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(); + put(out, it.collect::>().capacity()); + } _ => v = vec![make(arg); usize::from(arg % 6)], } put(out, v.len()); @@ -124,7 +133,7 @@ fn deque_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec put(out, q.capacity()); for step in steps.chunks(2) { let (op, arg) = (step[0], step.get(1).copied().unwrap_or(0)); - match op % 20 { + match op % 21 { 0 => q.push_back(make(arg)), 1 => q.push_front(make(arg)), 2 => drop(q.pop_front()), @@ -151,6 +160,14 @@ fn deque_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec let mut keep = alternate(); q = q.into_iter().filter(|_| keep()).collect(); } + 19 => { + let mut it = q.into_iter(); + for _ in 0..arg % 4 { + drop(it.next()); + } + q = it.clone().collect(); + put(out, it.collect::>().capacity()); + } _ => q = VecDeque::from([make(arg), make(arg), make(arg)]), } put(out, q.len()); @@ -174,7 +191,7 @@ fn heap_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec) 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 % 12 { + match op % 13 { 0 | 1 => h.push(make(arg)), 2 => drop(h.pop()), 3 => h.reserve(amount(arg, h.len(), size)), @@ -189,6 +206,13 @@ fn heap_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec) put(out, other.capacity()); } 10 => drop(h.drain()), + // A guard that hid all but the top, forgotten, which leaves the allocation. + 11 => { + if let Some(mut top) = h.peek_mut() { + *top = make(arg); + mem::forget(top); + } + } _ => h = BinaryHeap::from(h.into_vec()), } put(out, h.len()); diff --git a/ts/runtime/rt/collections.ts b/ts/runtime/rt/collections.ts index 9b8fe6e71..2d4929863 100644 --- a/ts/runtime/rt/collections.ts +++ b/ts/runtime/rt/collections.ts @@ -31,6 +31,7 @@ import { sliceSort, type Vec, vecCapacity, + vecSetCapacity, vecExtendFromSlice, vecHold, vecMax, @@ -2418,7 +2419,8 @@ export function dequeFromVec(v: Vec, size: number): VecDeque { * reads, keeping its capacity. */ export function dequeFromIntoIter(it: Iter, size: number, take?: Take): VecDeque { - const cap = it instanceof DequeIter ? dequeCapacity(it.q, size) : sourceCapacity(it, size)[0]; + const [cap, unsure] = it instanceof DequeIter ? [it.cap ?? dequeCapacity(it.q, size), false] : sourceCapacity(it, size); + if (unsure) throw new Error("rust2-ts: a `VecDeque` in place of a `Vec` taken from `bytes`' storage, whose capacity depends on whether other handles of it dropped"); const q = dequeFromVec(iterToArray(it, take, undefined, true), size); q.c = cap; return q; @@ -2645,6 +2647,8 @@ export class DequeIter extends Iter implements Disposable { private front: number; private back: number; private readonly drop: ((item: T) => void) | undefined; + /** The capacity of the deque a clone of `into_iter` owns, a new one of what was left, if not `q`'s. */ + cap: number | undefined; constructor(q: VecDeque, front: number, back: number, drop?: (item: T) => void) { super(); @@ -2664,7 +2668,11 @@ export class DequeIter extends Iter implements Disposable { /** std's: where it is, or of `into_iter`, what it has left, each cloned in order by `h.v`. */ override clone(h?: Clones): Iter { - if (h?.v === undefined) return new DequeIter(this.q, this.front, this.back, this.drop); + if (h?.v === undefined) { + const it = new DequeIter(this.q, this.front, this.back, this.drop); + it.cap = this.back - this.front; + return it; + } const clone = h.v as (item: T) => T; const items: T[] = []; for (let i = this.front; i < this.back; i++) items.push(clone(this.q.b[at(this.q, i)] as T)); @@ -3439,7 +3447,9 @@ export function peekMutDerefMut(p: PeekMut): void { const d = p.h.d; if (d.length > 1) { p.t = d; + // std's sets the length to 1, keeping the allocation, which a forgotten guard leaves. p.h.d = [d[0]]; + vecSetCapacity(p.h.d, d.cap ?? d.length); } } diff --git a/ts/runtime/rt/iter.ts b/ts/runtime/rt/iter.ts index 3815dafcd..0cd12f0bf 100644 --- a/ts/runtime/rt/iter.ts +++ b/ts/runtime/rt/iter.ts @@ -1253,6 +1253,7 @@ export function sourceCapacity(it: Iter, size: number): [number, boolea else at = undefined; if (at === undefined) throw new Error("rust2-ts: a `collect` in place of an iterator whose `Vec` it can't find"); } + if (at.cap !== undefined) return [at.cap, false]; if (at.bytes !== undefined) return [at.bytes.data.length, at.bytes.unsure === true]; return [vecCapacity(at.s as Vec, size), false]; } @@ -1268,7 +1269,7 @@ function inPlace(it: Iter, srcSize: number, size: number, bare: boolean if (!bare) return [Math.floor((cap * srcSize) / size), unsure]; const src = it as SliceIter; const len = src.back - src.front; - if (src.front === 0 || len >= Math.floor(cap / 2)) return [cap, unsure]; + if (src.front === src.start || len >= Math.floor(cap / 2)) return [cap, unsure]; return [capReserve(0, 0, len, size), false]; } @@ -1533,6 +1534,12 @@ class SliceIter extends Iter implements Disposable { private readonly drop: Drop | undefined; /** The `Vec` whose bytes `s` views, which its `into_iter` owns. */ readonly bytes: ByteVec | undefined; + /** + * Where in `s` the `Vec` it owns starts, and that one's capacity if not `s`'s: a clone's + * is a new one of what was left, which it shares `s` for rather than copy. + */ + start = 0; + cap: number | undefined; constructor(s: ArrayLike, drop?: Drop, bytes?: ByteVec) { super(); @@ -1570,8 +1577,9 @@ class SliceIter extends Iter implements Disposable { return new SliceIter(items, this.drop); } const it = new SliceIter(this.s, this.drop); - it.front = this.front; + it.front = it.start = this.front; it.back = this.back; + it.cap = this.back - this.front; return it; } From ec84a92845c9798592f9f4a1d87dae403d4236a7 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 22:06:20 -0700 Subject: [PATCH 07/14] test(ts): refresh the lang harness snapshot after merging main Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/expected/harness.ts | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 0cc9bc362..392ec5f16 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 } from "./borrows.ts"; import { bounds as bounds_bounds } from "./bounds.ts"; import { boxes } 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"; @@ -97,11 +98,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 => { @@ -248,7 +249,13 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) reattached(data86, out87); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::part_written", (_2187: rt.u8, data87: rt.ByteSlice, out88: rt.ByteVec): undefined => { partWritten(data87, out88); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ascii::parts", ascii_parts as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::flattened", arrays_flattened as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["args::args", args as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["returns::returns", returns as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ascii::parts", ascii_parts as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::flattened", arrays_flattened as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["args::args", args as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["returns::returns", returns as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["capacity::vecs", (a0148: rt.u8, a1148: rt.ByteSlice, a2148: rt.ByteVec): undefined => { + capacity_vecs(a0148, a1148.data, a1148.start, a1148.length, a2148); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["capacity::deques", (a0149: rt.u8, a1149: rt.ByteSlice, a2149: rt.ByteVec): undefined => { + capacity_deques(a0149, a1149.data, a1149.start, a1149.length, a2149); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["capacity::heaps", (a0150: rt.u8, a1150: rt.ByteSlice, a2150: rt.ByteVec): undefined => { + capacity_heaps(a0150, a1150.data, a1150.start, a1150.length, a2150); + }] 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. */ From c4b42f0b1026ecb06866bd7b0aef1a8d4ffa0eff Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 22:16:35 -0700 Subject: [PATCH 08/14] docs(ts): migrate notes for the runtime's capacity arguments Co-Authored-By: Claude Opus 5.5 --- ts/MIGRATE.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/ts/MIGRATE.md b/ts/MIGRATE.md index f32e271fd..8c2c2de19 100644 --- a/ts/MIGRATE.md +++ b/ts/MIGRATE.md @@ -2,6 +2,11 @@ ## Unreleased +- A `Vec`, `VecDeque`, and `BinaryHeap` hold std's capacity. An `rt.VecDeque` holds it + as `c`, so one made by hand is `rt.dequeNew()` or `{ b, h, n, c }`, and a JS array as a + `Vec` holds it as `cap` where it differs from its length. The runtime's functions that + grow, shrink, or read one take its element size in bytes last, as in + `rt.vecPush(v, item, 4)`, `rt.dequePushBack(q, item, 4)`, and `rt.heapPush(h, item, le, 4)`. - A function the config's roots don't name takes each `&[u8]` or `&[u8; N]` parameter whose object its body never makes as its `data`, `start`, and `length`: `read(buf, form)` is `read(buf.data, buf.start, buf.length, form)`. A caller takes From b8d6db6c991cd2837fa61269d57f41662584d89d Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sat, 31 Oct 2026 22:19:06 -0700 Subject: [PATCH 09/14] chore(quest): plan the rest of a vector's methods Co-Authored-By: Claude Opus 5.5 --- quest/m3/README.md | 1 + quest/m3/ts-vec-rest.md | 22 ++++++++++++++++++++++ 2 files changed, 23 insertions(+) create mode 100644 quest/m3/ts-vec-rest.md diff --git a/quest/m3/README.md b/quest/m3/README.md index ad818f883..d7e263164 100644 --- a/quest/m3/README.md +++ b/quest/m3/README.md @@ -35,4 +35,5 @@ generic std gap is planned here even when moq never calls it. - [A &mut into a Box of a value JS copies](/quest/m3/ts-box-places.md) - a write through `&mut *b` of a `Box`, a `Box`, or a `Box` reaches the box's place - [A str's checked and inclusive parts](/quest/m3/ts-str-get.md) - `str::get` and indexing a `str` by `a..=b` or `..=b` 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) - `clone_from`, `append`, `resize`, `split_off`, `try_reserve`, and `Vec::from(VecDeque)` translate with std's capacity - [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-vec-rest.md b/quest/m3/ts-vec-rest.md new file mode 100644 index 000000000..7578b2115 --- /dev/null +++ b/quest/m3/ts-vec-rest.md @@ -0,0 +1,22 @@ +# [M] The rest of a vector's methods + +## Goal + +[rust2-ts](/ts/README.md) translates the `Vec`, `VecDeque`, and `BinaryHeap` methods still +refused, each holding std's capacity, proven by differential tests against native Rust. + +## Plan + +Found carrying std's capacity through every vector: these have no mapping, and std's +bodies move elements through raw pointers, so each refuses with its span: + +- `Clone::clone_from` of a vector, which keeps its capacity where that holds the clones, + and so `slice::fill`, `clone_from_slice`, and `LinkedList::clone_from` of vectors, + which call it on each slot. +- `Vec::append`, `resize`, `resize_with`, `split_off`, `extend_from_within`, and + `try_reserve`, and `VecDeque`'s `append`, `resize`, and `split_off`. +- `From>` for `Vec`, which keeps the deque's capacity. + +No consumer calls them yet; they are planned here as part of std. + +Public API: the translator's output. From 093e491751a92213836ba6e510a730ad4d4cd9d1 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sun, 1 Nov 2026 06:01:03 -0800 Subject: [PATCH 10/14] feat(ts): hold std's capacity guarantees, with pushes untouched Rework of #372 to the 2026-11-01 maintainer decision: a Vec, VecDeque, or BinaryHeap stores a capacity only where an operation sets one, and reading it doubles the stored value while short of the length, so a run of pushes reads std's doubling without push touching it. Co-Authored-By: Claude Opus 5.5 --- quest/m2/ts-model/hashbrown.md | 5 +- quest/m3/README.md | 2 +- quest/m3/ts-deque-slices.md | 3 + quest/m3/ts-vec-rest.md | 19 +- ts/MIGRATE.md | 5 + ts/README.md | 19 +- ts/fixtures/lang/caller.ts | 6 +- ts/fixtures/lang/expected/args.ts | 2 +- ts/fixtures/lang/expected/arrays.ts | 2 +- ts/fixtures/lang/expected/ascii.ts | 4 +- ts/fixtures/lang/expected/bounds.ts | 4 +- ts/fixtures/lang/expected/boxes.ts | 22 +- ts/fixtures/lang/expected/capacity.Known.ts | 53 + ts/fixtures/lang/expected/capacity.ts | 2434 ++++++++++--------- ts/fixtures/lang/expected/chars.ts | 8 +- ts/fixtures/lang/expected/clones.ts | 50 +- ts/fixtures/lang/expected/collections.ts | 132 +- ts/fixtures/lang/expected/counts.ts | 60 +- ts/fixtures/lang/expected/cows.ts | 22 +- ts/fixtures/lang/expected/cycles.ts | 2 +- ts/fixtures/lang/expected/dyns.ts | 10 +- ts/fixtures/lang/expected/edits.ts | 50 +- ts/fixtures/lang/expected/errors.ts | 8 +- ts/fixtures/lang/expected/fmt.ts | 35 +- ts/fixtures/lang/expected/generics.ts | 4 +- ts/fixtures/lang/expected/harness.ts | 15 +- ts/fixtures/lang/expected/hints.ts | 224 +- ts/fixtures/lang/expected/holds.ts | 28 +- ts/fixtures/lang/expected/ints.ts | 2 +- ts/fixtures/lang/expected/iters.ts | 114 +- ts/fixtures/lang/expected/joins.ts | 18 +- ts/fixtures/lang/expected/keys.ts | 76 +- ts/fixtures/lang/expected/lengths.ts | 8 +- ts/fixtures/lang/expected/lists.ts | 6 +- ts/fixtures/lang/expected/locals.ts | 8 +- ts/fixtures/lang/expected/nested.ts | 16 +- ts/fixtures/lang/expected/objects.ts | 7 +- ts/fixtures/lang/expected/orders.ts | 38 +- ts/fixtures/lang/expected/pointers.ts | 10 +- ts/fixtures/lang/expected/refs.ts | 14 +- ts/fixtures/lang/expected/shapes.ts | 10 +- ts/fixtures/lang/expected/slices.ts | 8 +- ts/fixtures/lang/expected/strs.ts | 16 +- ts/fixtures/lang/expected/tuples.ts | 56 +- ts/fixtures/lang/expected/wrappers.ts | 4 +- ts/fixtures/lang/expected/zeros.ts | 6 +- ts/fixtures/lang/src/capacity.rs | 306 ++- ts/runtime/rt.ts | 415 ++-- ts/runtime/rt/bytes.ts | 31 +- ts/runtime/rt/collections.ts | 276 +-- ts/runtime/rt/iter.ts | 146 +- ts/src/lower/collections.rs | 76 +- ts/src/lower/iter.rs | 118 +- ts/src/lower/library.rs | 75 +- ts/src/lower/mir/step.rs | 7 +- ts/src/lower/stock.rs | 2 +- 56 files changed, 2577 insertions(+), 2520 deletions(-) create mode 100644 ts/fixtures/lang/expected/capacity.Known.ts diff --git a/quest/m2/ts-model/hashbrown.md b/quest/m2/ts-model/hashbrown.md index 1f491b214..8aae1c57b 100644 --- a/quest/m2/ts-model/hashbrown.md +++ b/quest/m2/ts-model/hashbrown.md @@ -15,8 +15,9 @@ 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 - `Vec`'s capacity follows `RawVec`'s. +- `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. diff --git a/quest/m3/README.md b/quest/m3/README.md index f34c9f6bf..9f7e1d377 100644 --- a/quest/m3/README.md +++ b/quest/m3/README.md @@ -32,7 +32,7 @@ generic std gap is planned here even when moq never calls it. - [std's sorts call their tests in std's order](/quest/m3/ts-sort-order.md) - `slice::sort` and a B-tree's `collect` call `lt` or `cmp` as std's driftsort does past 16 elements - [A B-tree's searches call Ord as std's do](/quest/m3/ts-btree-search-order.md) - a B-tree's lookups and inserts call a key's own `Ord` in std's order and number - [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) - `clone_from`, `append`, `resize`, `split_off`, `try_reserve`, and `Vec::from(VecDeque)` translate with std's capacity +- [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-deque-slices.md b/quest/m3/ts-deque-slices.md index 7b0b803c2..89405b040 100644 --- a/quest/m3/ts-deque-slices.md +++ b/quest/m3/ts-deque-slices.md @@ -20,6 +20,9 @@ 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. diff --git a/quest/m3/ts-vec-rest.md b/quest/m3/ts-vec-rest.md index 7578b2115..56f4ea908 100644 --- a/quest/m3/ts-vec-rest.md +++ b/quest/m3/ts-vec-rest.md @@ -2,21 +2,22 @@ ## Goal -[rust2-ts](/ts/README.md) translates the `Vec`, `VecDeque`, and `BinaryHeap` methods still -refused, each holding std's capacity, proven by differential tests against native Rust. +[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 std's capacity through every vector: these have no mapping, and std's -bodies move elements through raw pointers, so each refuses with its span: +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: -- `Clone::clone_from` of a vector, which keeps its capacity where that holds the clones, - and so `slice::fill`, `clone_from_slice`, and `LinkedList::clone_from` of vectors, - which call it on each slot. - `Vec::append`, `resize`, `resize_with`, `split_off`, `extend_from_within`, and `try_reserve`, and `VecDeque`'s `append`, `resize`, and `split_off`. -- `From>` for `Vec`, which keeps the deque's capacity. +- `From>` for `Vec`. -No consumer calls them yet; they are planned here as part of std. +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 53c0f3e15..3f7d6d9d7 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 7bdb3176d..8d3ded873 100644 --- a/ts/README.md +++ b/ts/README.md @@ -729,17 +729,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 `Vec`, `VecDeque`, and `BinaryHeap` hold std's - capacity, apart from the array's length: `RawVec`'s amortized growth and its least - allocation by element size, `with_capacity`, `reserve`, `reserve_exact`, `shrink_to`, - and what `collect`, `extend`, `clone`, and `From` allocate, a `collect` in place of a - `Vec`'s `into_iter` included, so `capacity` reads std's and each grows and panics where - std's does. An array's `cap` property is its capacity where that differs from its - length, and an `rt.ByteVec`'s is its buffer's length. A `Vec` taken from a `Bytes` - or a shared `BytesMut` holds what `bytes` gave it, which nothing here counts: reading - its capacity, or keeping it in place, throws until a `shrink_to` at most its length - sets it. On `just ts bench`'s `push/` workloads a push takes 1.2-2x the time JS's own - `push` did, Bun the most, for reading the capacity it checks. 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 diff --git a/ts/fixtures/lang/caller.ts b/ts/fixtures/lang/caller.ts index 3d4eeb18e..366e81c76 100644 --- a/ts/fixtures/lang/caller.ts +++ b/ts/fixtures/lang/caller.ts @@ -787,8 +787,8 @@ const gets = [0, 0x10].flatMap((text) => { /** * `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`; a run of pushes and pops that - * grows and shrinks it; and each way `collects` makes one, of each length it tries. + * least capacity, made by `new` and by `with_capacity`; 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]) => @@ -798,7 +798,7 @@ const capacityCases = [ }), ), ...["capacity::vecs", "capacity::deques", "capacity::heaps"].flatMap((name) => - Array.from({ length: 5 }, (_, kind) => Uint8Array.of(op(name), kind, 0, ...Array.from({ length: 40 }, (_, p) => [p % 3 === 2 ? 2 : 0, p]).flat())), + 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)), ]; diff --git a/ts/fixtures/lang/expected/args.ts b/ts/fixtures/lang/expected/args.ts index e1162486e..aa5376bef 100644 --- a/ts/fixtures/lang/expected/args.ts +++ b/ts/fixtures/lang/expected/args.ts @@ -53,7 +53,7 @@ export function kept(data: rt.ByteSlice, n: rt.u8): rt.ByteSlice[] { if (!(iterStart++ < iterEnd)) { return all; } - rt.vecPush(all, data, 8); + all.push(data); } } diff --git a/ts/fixtures/lang/expected/arrays.ts b/ts/fixtures/lang/expected/arrays.ts index 88c6d6c3f..93a77cdea 100644 --- a/ts/fixtures/lang/expected/arrays.ts +++ b/ts/fixtures/lang/expected/arrays.ts @@ -16,7 +16,7 @@ export function fromFns(data: rt.ByteSlice, out: rt.ByteVec): void { if (_10 === 0) { const seen: rt.usize[] = []; const bytes: Uint8Array = rt.bytesFromFn(4, (i6: rt.usize): rt.u8 => { - rt.vecPush(seen, i6, 4); + seen.push(i6); return rt.u8WrappingMul(op, rt.u8Add(i6 & 0xff, 1)); }); const wide: rt.u64[] = rt.arrayFromFn(3, (i7: rt.usize): rt.u64 => { 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/bounds.ts b/ts/fixtures/lang/expected/bounds.ts index 270b11d26..11be217b4 100644 --- a/ts/fixtures/lang/expected/bounds.ts +++ b/ts/fixtures/lang/expected/bounds.ts @@ -189,9 +189,9 @@ export function bounds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const n: rt.usize = _104[0]; const tag: rt.u8 = _104[1]; if (rt.usizeRem(n, 2) === 0) { - rt.dequePushBack(queue, new bounds_Item.Item(tag), 1); + rt.dequePushBack(queue, new bounds_Item.Item(tag)); } else { - rt.dequePushFront(queue, new bounds_Item.Item(tag), 1); + rt.dequePushFront(queue, new bounds_Item.Item(tag)); } } const _117: [rt.RangeBound, rt.RangeBound] = [bound$usize(s, i), bound$usize(e, j)]; diff --git a/ts/fixtures/lang/expected/boxes.ts b/ts/fixtures/lang/expected/boxes.ts index 3608b9d1b..481c9015d 100644 --- a/ts/fixtures/lang/expected/boxes.ts +++ b/ts/fixtures/lang/expected/boxes.ts @@ -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[] = rt.vecIntoBoxed(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; @@ -251,9 +251,9 @@ export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fromArray2[2] = 7; wides(fromArray2, out); wides(array2, out); - const collected2: rt.u16[] = rt.vecIntoBoxed(rt.iterToArray(rt.iterMap(rt.iterSlice(wide), (_26: rt.u16): rt.u16 => { + const collected2: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(wide), (_26: rt.u16): rt.u16 => { return rt.intRotateLeft(_26, 3, 16, false); - }), undefined, 2, true)); + }), undefined, 2, true); const cloned2: rt.u16[] = collected2.slice(); rt.sliceSort(cloned2, rt.lt); wides(cloned2, out); @@ -266,7 +266,7 @@ export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(collected2, f, rt.u16Debug)]; fmt_put(out, rt.fmtFormat([args4[0]])); const v3: rt.u16[] = fromVec2; - rt.vecPush(v3, 5, 2); + v3.push(5); wides(v3, out); let slot2: rt.u16[] = fromArray2; const _372: rt.u16[] = collected2.slice(); @@ -275,7 +275,7 @@ export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const taken = slot2; slot2 = []; wides(taken, out); - const it: rt.Iter = rt.iterSlice(rt.vecIntoBoxed(wide)); + const it: rt.Iter = rt.iterSlice(wide); rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(option_unwrapOr$1j4op5y(rt.iterToOption(it.nextBack()), 0)).reverse()), undefined, true); rt.byteVecPush(out, it.len() & 0xff); rt.iterExtendBytes(out, rt.iterMap(it, (x4: rt.u16): rt.u8 => { @@ -286,9 +286,9 @@ export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const logged: (a0: rt.u8) => boxes_Logged.Logged = (id: rt.u8): boxes_Logged.Logged => { return new boxes_Logged.Logged(id, rt.arcClone(log)); }; - const boxed2: boxes_Logged.Logged[] = rt.vecIntoBoxed(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_22: rt.u8): boxes_Logged.Logged => { + const boxed2: boxes_Logged.Logged[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_22: rt.u8): boxes_Logged.Logged => { return logged(_22 & 126); - }), undefined, 8, true)); + }), undefined, 8, true); ids(boxed2, out); const cloned3: boxes_Logged.Logged[] = boxed2.map(boxes_Logged.clone$Clone); flush(log.value, out); @@ -296,9 +296,9 @@ export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { flush(log.value, out); const fromRef3: boxes_Logged.Logged[] = rt.sliceRange(cloned3, 0).map(boxes_Logged.clone$Clone); flush(log.value, out); - let collected3: boxes_Logged.Logged[] = rt.vecIntoBoxed(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_23: rt.u8): boxes_Logged.Logged => { + let collected3: boxes_Logged.Logged[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_23: rt.u8): boxes_Logged.Logged => { return logged(_23 | 1); - }), undefined, 8, true)); + }), undefined, 8, true); ids(collected3, out); const _433: boxes_Logged.Logged[] = [logged(16), logged(18)]; rt.dropAll(collected3); @@ -362,12 +362,12 @@ export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const fromArray3: [rt.u8, rt.u16][] = copy$array_tuple2_u8_u16(array3); rt.idx(fromArray3, 0); fromArray3[0][0] = 9; - const quads: Uint8Array[] = rt.vecIntoBoxed(rt.iterToArray(rt.iterMap(rt.byteSliceChunksExact(data2, 2), (c: rt.ByteSlice): Uint8Array => { + const quads: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceChunksExact(data2, 2), (c: rt.ByteSlice): Uint8Array => { rt.idx(c, 0); const _3: rt.u8 = c.data[c.start]; rt.idx(c, 1); return Uint8Array.of(_3, c.data[c.start + 1]); - }), undefined, 2, true)); + }), undefined, 2, true); const quadsV: Uint8Array[] = quads.map(copy$array_u8); const _554: rt.ByteSlice | undefined = rt.optionMap(rt.sliceFirst(quadsV), rt.byteSliceFrom); if (_554 !== undefined) { 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 index db45db914..cea4855fd 100644 --- a/ts/fixtures/lang/expected/capacity.ts +++ b/ts/fixtures/lang/expected/capacity.ts @@ -2,6 +2,7 @@ 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. */ @@ -68,7 +69,7 @@ export function vecs(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL 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 _131!: rt.u8; + 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] => { @@ -80,162 +81,141 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d } 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 _24: rt.ByteSlice | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _27: rt.ByteSlice | rt.Done = iter.next(); + if (_27 === rt.DONE) { break; } - rt.idx(_24, 0); - const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; - const op: rt.u8 = _30[0]; - const arg: rt.u8 = _30[1]; - b3: { - const _39: rt.u8 = rt.u8Rem(op, 25); - if (_39 === 0 || _39 === 1) { - rt.vecPush(v, copy$array_u64(make(arg)), 1280); - break b3; - } - if (_39 === 2) { - rt.vecPop(v); - break b3; - } - if (_39 === 3) { - rt.vecReserve(v, amount(arg, v.length, size), 1280); - break b3; - } - if (_39 === 4) { - rt.vecReserveExact(v, amount(arg, v.length, size), 1280); - break b3; - } - if (_39 === 5) { - rt.vecShrinkTo(v, rt.u8Rem(arg, 40) as rt.usize, 1280); - break b3; - } - if (_39 === 6) { - rt.vecShrinkTo(v, 0, 1280); - break b3; - } - if (_39 === 7) { - rt.vecTruncate(v, rt.u8Rem(arg, 8) as rt.usize); - break b3; + 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); } - if (_39 === 8) { - rt.vecInsert(v, rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.length, 1)), copy$array_u64(make(arg)), 1280); - break b3; + 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); } - if (_39 === 9) { - if (!((v.length === 0))) { - rt.vecRemove(v, rt.usizeRem(arg as rt.usize, v.length)); - break b3; - } - } else { - if (_39 === 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); - break b3; - } - if (_39 === 11) { - rt.iterExtend(v, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 1280, true); - break b3; - } - if (_39 === 12) { - rt.vecExtendFromSlice(v, [make(arg), make(arg)], copy$array_u64, 1280); - break b3; - } - if (_39 === 13) { - rt.vecTruncate(v, 0); - break b3; - } - if (_39 === 14) { - const keep: () => boolean = alternate(); - rt.vecRetain(v, (_25: rt.u64[]): boolean => { - return keep(); - }); - break b3; - } - if (_39 === 15) { - rt.drop(rt.vecDrain(v, { end: rt.min(v.length, rt.u8Rem(arg, 4) as rt.usize) })); - break b3; - } - if (_39 === 16) { - v = v.map(copy$array_u64); - break b3; - } - if (_39 === 17) { - v = rt.vecIntoBoxed(v); - break b3; - } - if (_39 === 18) { - const keep2: () => boolean = alternate(); - v = rt.iterToArrayInPlace(rt.iterFilter(rt.iterSlice(v), (_23: rt.u64[]): boolean => { - return keep2(); - }), 1280, 1280, false, "next"); - break b3; - } - if (_39 === 19) { - const it: rt.Iter = rt.iterSlice(v); - const _128: rt.u8 = rt.u8Rem(arg, 8); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _128; - while ((_131 = iterStart++) < iterEnd) { - if (!(rt.u8Rem(_131, 3) === 2)) { - rt.iterToOption(it.next()); - } else { - rt.iterToOption(it.nextBack()); - } - } - v = rt.iterToArrayInPlace(it, 1280, 1280, true, "next", true); - break b3; - } - if (_39 === 20) { - let taken: rt.u64[][] = rt.replaceIn(v, []); - const _148: rt.u64[] = copy$array_u64(make(arg)); - rt.vecPush(taken, _148, 1280); - put(out, rt.vecCapacity(taken, 1280)); - const _154: rt.u64[][] = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 1280); - const old = taken; - taken = _154; - v = old; - put(out, rt.vecCapacity(taken, 1280)); - break b3; - } - if (_39 === 21) { - if (!((v.length === 0))) { - rt.vecSwapRemove(v, rt.usizeRem(arg as rt.usize, v.length)); - break b3; - } + } 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 { - if (_39 === 22) { - rt.vecDedupBy(v, rt.eqSlice(rt.u64Eq)); - break b3; - } - if (_39 === 23) { - const it2: rt.Iter = rt.iterSlice(v); - const _175: rt.u8 = rt.u8Rem(arg, 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _175; - while (iterStart2++ < iterEnd2) { - rt.iterToOption(it2.next()); - } - v = rt.iterToArrayInPlace(it2.clone({ v: copy$array_u64 }), 1280, 1280, true, "next", true); - put(out, rt.vecCapacity(rt.iterToArrayInPlace(it2, 1280, 1280, true, "next", true), 1280)); - break b3; - } + rt.iterToOption(it.nextBack()); } } - v = rt.vecFromElem(copy$array_u64(make(arg)), rt.u8Rem(arg, 6) as rt.usize, copy$array_u64, 1280); + 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); } - put(out, v.length); - put(out, rt.vecCapacity(v, 1280)); + 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 _131!: 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] => { @@ -247,162 +227,141 @@ export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, } 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 _24: rt.ByteSlice | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _27: rt.ByteSlice | rt.Done = iter.next(); + if (_27 === rt.DONE) { break; } - rt.idx(_24, 0); - const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; - const op: rt.u8 = _30[0]; - const arg: rt.u8 = _30[1]; - b3: { - const _39: rt.u8 = rt.u8Rem(op, 25); - if (_39 === 0 || _39 === 1) { - rt.vecPush(v, copy$tuple2_u64_u8(make(arg)), 16); - break b3; - } - if (_39 === 2) { - rt.vecPop(v); - break b3; - } - if (_39 === 3) { - rt.vecReserve(v, amount(arg, v.length, size), 16); - break b3; - } - if (_39 === 4) { - rt.vecReserveExact(v, amount(arg, v.length, size), 16); - break b3; - } - if (_39 === 5) { - rt.vecShrinkTo(v, rt.u8Rem(arg, 40) as rt.usize, 16); - break b3; - } - if (_39 === 6) { - rt.vecShrinkTo(v, 0, 16); - break b3; - } - if (_39 === 7) { - rt.vecTruncate(v, rt.u8Rem(arg, 8) as rt.usize); - break b3; + 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); } - if (_39 === 8) { - rt.vecInsert(v, rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.length, 1)), copy$tuple2_u64_u8(make(arg)), 16); - break b3; + 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); } - if (_39 === 9) { - if (!((v.length === 0))) { - rt.vecRemove(v, rt.usizeRem(arg as rt.usize, v.length)); - break b3; - } - } else { - if (_39 === 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); - break b3; - } - if (_39 === 11) { - rt.iterExtend(v, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 16, true); - break b3; - } - if (_39 === 12) { - rt.vecExtendFromSlice(v, [make(arg), make(arg)], copy$tuple2_u64_u8, 16); - break b3; - } - if (_39 === 13) { - rt.vecTruncate(v, 0); - break b3; - } - if (_39 === 14) { - const keep: () => boolean = alternate(); - rt.vecRetain(v, (_25: [rt.u64, rt.u8]): boolean => { - return keep(); - }); - break b3; - } - if (_39 === 15) { - rt.drop(rt.vecDrain(v, { end: rt.min(v.length, rt.u8Rem(arg, 4) as rt.usize) })); - break b3; - } - if (_39 === 16) { - v = v.map(copy$tuple2_u64_u8); - break b3; - } - if (_39 === 17) { - v = rt.vecIntoBoxed(v); - break b3; - } - if (_39 === 18) { - const keep2: () => boolean = alternate(); - v = rt.iterToArrayInPlace(rt.iterFilter(rt.iterSlice(v), (_23: [rt.u64, rt.u8]): boolean => { - return keep2(); - }), 16, 16, false, "next"); - break b3; - } - if (_39 === 19) { - const it: rt.Iter<[rt.u64, rt.u8]> = rt.iterSlice(v); - const _128: rt.u8 = rt.u8Rem(arg, 8); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _128; - while ((_131 = iterStart++) < iterEnd) { - if (!(rt.u8Rem(_131, 3) === 2)) { - rt.iterToOption(it.next()); - } else { - rt.iterToOption(it.nextBack()); - } - } - v = rt.iterToArrayInPlace(it, 16, 16, true, "next", true); - break b3; - } - if (_39 === 20) { - let taken: [rt.u64, rt.u8][] = rt.replaceIn(v, []); - const _148: [rt.u64, rt.u8] = copy$tuple2_u64_u8(make(arg)); - rt.vecPush(taken, _148, 16); - put(out, rt.vecCapacity(taken, 16)); - const _154: [rt.u64, rt.u8][] = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 16); - const old = taken; - taken = _154; - v = old; - put(out, rt.vecCapacity(taken, 16)); - break b3; - } - if (_39 === 21) { - if (!((v.length === 0))) { - rt.vecSwapRemove(v, rt.usizeRem(arg as rt.usize, v.length)); - break b3; - } + } 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 { - if (_39 === 22) { - rt.vecDedupBy(v, rt.eqTuple([rt.u64Eq, rt.same])); - break b3; - } - if (_39 === 23) { - const it2: rt.Iter<[rt.u64, rt.u8]> = rt.iterSlice(v); - const _175: rt.u8 = rt.u8Rem(arg, 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _175; - while (iterStart2++ < iterEnd2) { - rt.iterToOption(it2.next()); - } - v = rt.iterToArrayInPlace(it2.clone({ v: copy$tuple2_u64_u8 }), 16, 16, true, "next", true); - put(out, rt.vecCapacity(rt.iterToArrayInPlace(it2, 16, 16, true, "next", true), 16)); - break b3; - } + rt.iterToOption(it.nextBack()); } } - v = rt.vecFromElem(copy$tuple2_u64_u8(make(arg)), rt.u8Rem(arg, 6) as rt.usize, copy$tuple2_u64_u8, 16); + 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); } - put(out, v.length); - put(out, rt.vecCapacity(v, 16)); + 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 _131!: rt.u8; + 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] => { @@ -414,162 +373,141 @@ export function vecSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: n } 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 _24: rt.ByteSlice | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _27: rt.ByteSlice | rt.Done = iter.next(); + if (_27 === rt.DONE) { break; } - rt.idx(_24, 0); - const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; - const op: rt.u8 = _30[0]; - const arg: rt.u8 = _30[1]; - b3: { - const _39: rt.u8 = rt.u8Rem(op, 25); - if (_39 === 0 || _39 === 1) { - rt.vecPush(v, make(arg), 2); - break b3; - } - if (_39 === 2) { - rt.vecPop(v); - break b3; - } - if (_39 === 3) { - rt.vecReserve(v, amount(arg, v.length, size), 2); - break b3; - } - if (_39 === 4) { - rt.vecReserveExact(v, amount(arg, v.length, size), 2); - break b3; - } - if (_39 === 5) { - rt.vecShrinkTo(v, rt.u8Rem(arg, 40) as rt.usize, 2); - break b3; - } - if (_39 === 6) { - rt.vecShrinkTo(v, 0, 2); - break b3; - } - if (_39 === 7) { - rt.vecTruncate(v, rt.u8Rem(arg, 8) as rt.usize); - break b3; + 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); } - if (_39 === 8) { - rt.vecInsert(v, rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.length, 1)), make(arg), 2); - break b3; + 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); } - if (_39 === 9) { - if (!((v.length === 0))) { - rt.vecRemove(v, rt.usizeRem(arg as rt.usize, v.length)); - break b3; - } - } else { - if (_39 === 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); - break b3; - } - if (_39 === 11) { - rt.iterExtend(v, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 2, true); - break b3; - } - if (_39 === 12) { - rt.vecExtendFromSlice(v, [make(arg), make(arg)], undefined, 2); - break b3; - } - if (_39 === 13) { - rt.vecTruncate(v, 0); - break b3; - } - if (_39 === 14) { - const keep: () => boolean = alternate(); - rt.vecRetain(v, (_25: rt.u16): boolean => { - return keep(); - }); - break b3; - } - if (_39 === 15) { - rt.drop(rt.vecDrain(v, { end: rt.min(v.length, rt.u8Rem(arg, 4) as rt.usize) })); - break b3; - } - if (_39 === 16) { - v = v.slice(); - break b3; - } - if (_39 === 17) { - v = rt.vecIntoBoxed(v); - break b3; - } - if (_39 === 18) { - const keep2: () => boolean = alternate(); - v = rt.iterToArrayInPlace(rt.iterFilter(rt.iterSlice(v), (_23: rt.u16): boolean => { - return keep2(); - }), 2, 2, false, "next"); - break b3; - } - if (_39 === 19) { - const it: rt.Iter = rt.iterSlice(v); - const _128: rt.u8 = rt.u8Rem(arg, 8); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _128; - while ((_131 = iterStart++) < iterEnd) { - if (!(rt.u8Rem(_131, 3) === 2)) { - rt.iterToOption(it.next()); - } else { - rt.iterToOption(it.nextBack()); - } - } - v = rt.iterToArrayInPlace(it, 2, 2, true, "next", true); - break b3; - } - if (_39 === 20) { - let taken: rt.u16[] = rt.replaceIn(v, []); - const _148: rt.u16 = make(arg); - rt.vecPush(taken, _148, 2); - put(out, rt.vecCapacity(taken, 2)); - const _154: rt.u16[] = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 2); - const old = taken; - taken = _154; - v = old; - put(out, rt.vecCapacity(taken, 2)); - break b3; - } - if (_39 === 21) { - if (!((v.length === 0))) { - rt.vecSwapRemove(v, rt.usizeRem(arg as rt.usize, v.length)); - break b3; - } + } 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 { - if (_39 === 22) { - rt.vecDedupBy(v, rt.same); - break b3; - } - if (_39 === 23) { - const it2: rt.Iter = rt.iterSlice(v); - const _175: rt.u8 = rt.u8Rem(arg, 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _175; - while (iterStart2++ < iterEnd2) { - rt.iterToOption(it2.next()); - } - v = rt.iterToArrayInPlace(it2.clone(), 2, 2, true, "next", true); - put(out, rt.vecCapacity(rt.iterToArrayInPlace(it2, 2, 2, true, "next", true), 2)); - break b3; - } + rt.iterToOption(it.nextBack()); } } - v = rt.vecFromElem(make(arg), rt.u8Rem(arg, 6) as rt.usize, undefined, 2); + 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); } - put(out, v.length); - put(out, rt.vecCapacity(v, 2)); + 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 _131!: rt.u8; + 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] => { @@ -581,162 +519,137 @@ export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: nu } else { v = new rt.ByteVec(); } - put(out, rt.byteVecCapacity(v)); + 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 _24: rt.ByteSlice | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _27: rt.ByteSlice | rt.Done = iter.next(); + if (_27 === rt.DONE) { break; } - rt.idx(_24, 0); - const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; - const op: rt.u8 = _30[0]; - const arg: rt.u8 = _30[1]; - b3: { - const _39: rt.u8 = rt.u8Rem(op, 25); - if (_39 === 0 || _39 === 1) { - rt.byteVecPush(v, make(arg)); - break b3; - } - if (_39 === 2) { - rt.byteVecPop(v); - break b3; - } - if (_39 === 3) { - rt.byteVecReserve(v, amount(arg, v.length, size)); - break b3; - } - if (_39 === 4) { - rt.byteVecReserveExact(v, amount(arg, v.length, size)); - break b3; - } - if (_39 === 5) { - rt.byteVecShrinkTo(v, rt.u8Rem(arg, 40) as rt.usize); - break b3; - } - if (_39 === 6) { - rt.byteVecShrinkTo(v, 0); - break b3; - } - if (_39 === 7) { - rt.byteVecTruncate(v, rt.u8Rem(arg, 8) as rt.usize); - break b3; + 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); } - if (_39 === 8) { - rt.byteVecInsert(v, rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.length, 1)), make(arg)); - break b3; + 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); } - if (_39 === 9) { - if (!((v.length === 0))) { - rt.byteVecRemove(v, rt.usizeRem(arg as rt.usize, v.length)); - break b3; - } - } else { - if (_39 === 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"); - break b3; - } - if (_39 === 11) { - rt.iterExtendBytes(v, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, true); - break b3; - } - if (_39 === 12) { - rt.byteVecExtendFromSlice(v, rt.byteSliceFrom(Uint8Array.of(make(arg), make(arg)))); - break b3; - } - if (_39 === 13) { - rt.byteVecClear(v); - break b3; - } - if (_39 === 14) { - const keep: () => boolean = alternate(); - rt.byteVecRetain(v, (_25: rt.u8): boolean => { - return keep(); - }); - break b3; - } - if (_39 === 15) { - rt.drop(rt.byteVecDrain(v, { end: rt.min(v.length, rt.u8Rem(arg, 4) as rt.usize) })); - break b3; - } - if (_39 === 16) { - v = rt.byteVecFrom(rt.byteVecView(v)); - break b3; - } - if (_39 === 17) { - v = rt.byteSliceToByteVec(rt.byteVecSlice(v)); - break b3; - } - if (_39 === 18) { - const keep2: () => boolean = alternate(); - v = rt.iterToByteVecInPlace(rt.iterFilter(rt.byteVecIntoIter(v), (_23: rt.u8): boolean => { - return keep2(); - }), 1, false, "next"); - break b3; - } - if (_39 === 19) { - const it: rt.Iter = rt.byteVecIntoIter(v); - const _128: rt.u8 = rt.u8Rem(arg, 8); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _128; - while ((_131 = iterStart++) < iterEnd) { - if (!(rt.u8Rem(_131, 3) === 2)) { - rt.iterToOption(it.next()); - } else { - rt.iterToOption(it.nextBack()); - } - } - v = rt.iterToByteVecInPlace(it, 1, true, "next", true); - break b3; - } - if (_39 === 20) { - let taken: rt.ByteVec = rt.replaceIn(v, new rt.ByteVec()); - const _148: rt.u8 = make(arg); - rt.byteVecPush(taken, _148); - put(out, rt.byteVecCapacity(taken)); - const _154: rt.ByteVec = rt.byteVecWithCapacity(rt.u8Rem(arg, 6) as rt.usize); - const old = taken; - taken = _154; - v = old; - put(out, rt.byteVecCapacity(taken)); - break b3; - } - if (_39 === 21) { - if (!((v.length === 0))) { - rt.byteVecSwapRemove(v, rt.usizeRem(arg as rt.usize, v.length)); - break b3; - } + } 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 { - if (_39 === 22) { - rt.byteVecDedup(v); - break b3; - } - if (_39 === 23) { - const it2: rt.Iter = rt.byteVecIntoIter(v); - const _175: rt.u8 = rt.u8Rem(arg, 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _175; - while (iterStart2++ < iterEnd2) { - rt.iterToOption(it2.next()); - } - v = rt.iterToByteVecInPlace(it2.clone(), 1, true, "next", true); - put(out, rt.byteVecCapacity(rt.iterToByteVecInPlace(it2, 1, true, "next", true))); - break b3; - } + 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); } - put(out, v.length); - put(out, rt.byteVecCapacity(v)); + 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 _131!: rt.u8; + 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] => { @@ -748,165 +661,144 @@ export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: } 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 _24: rt.ByteSlice | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _27: rt.ByteSlice | rt.Done = iter.next(); + if (_27 === rt.DONE) { break; } - rt.idx(_24, 0); - const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; - const op: rt.u8 = _30[0]; - const arg: rt.u8 = _30[1]; - b3: { - const _39: rt.u8 = rt.u8Rem(op, 25); - if (_39 === 0 || _39 === 1) { - const _41: undefined[] = v; - make(arg); - rt.vecPush(_41, undefined, 0); - break b3; - } - if (_39 === 2) { - rt.vecPop(v, rt.None); - break b3; - } - if (_39 === 3) { - rt.vecReserve(v, amount(arg, v.length, size), 0); - break b3; - } - if (_39 === 4) { - rt.vecReserveExact(v, amount(arg, v.length, size), 0); - break b3; - } - if (_39 === 5) { - rt.vecShrinkTo(v, rt.u8Rem(arg, 40) as rt.usize, 0); - break b3; - } - if (_39 === 6) { - rt.vecShrinkTo(v, 0, 0); - break b3; - } - if (_39 === 7) { - rt.vecTruncate(v, rt.u8Rem(arg, 8) as rt.usize); - break b3; + 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); } - if (_39 === 8) { - const _62: undefined[] = v; - const _63: rt.usize = rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.length, 1)); - make(arg); - rt.vecInsert(_62, _63, undefined, 0); - break b3; + 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); } - if (_39 === 9) { - if (!((v.length === 0))) { - rt.vecRemove(v, rt.usizeRem(arg as rt.usize, v.length)); - break b3; - } - } else { - if (_39 === 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); - break b3; - } - if (_39 === 11) { - rt.iterExtend(v, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 0, true); - break b3; - } - if (_39 === 12) { - const _91: undefined[] = v; - make(arg); - make(arg); - rt.vecExtendFromSlice(_91, [undefined, undefined], undefined, 0); - break b3; - } - if (_39 === 13) { - rt.vecTruncate(v, 0); - break b3; - } - if (_39 === 14) { - const keep: () => boolean = alternate(); - rt.vecRetain(v, (_25: undefined): boolean => { - return keep(); - }); - break b3; - } - if (_39 === 15) { - rt.drop(rt.vecDrain(v, { end: rt.min(v.length, rt.u8Rem(arg, 4) as rt.usize) })); - break b3; - } - if (_39 === 16) { - v = v.slice(); - break b3; - } - if (_39 === 17) { - v = rt.vecIntoBoxed(v); - break b3; - } - if (_39 === 18) { - const keep2: () => boolean = alternate(); - v = rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_23: undefined): boolean => { - return keep2(); - }), "next", 0); - break b3; - } - if (_39 === 19) { - const it: rt.Iter = rt.iterSlice(v); - const _128: rt.u8 = rt.u8Rem(arg, 8); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _128; - while ((_131 = iterStart++) < iterEnd) { - if (!(rt.u8Rem(_131, 3) === 2)) { - rt.iterToOption(it.next(), rt.None); - } else { - rt.iterToOption(it.nextBack(), rt.None); - } - } - v = rt.iterToArrayInPlace(it, 0, 0, true, undefined, true); - break b3; - } - if (_39 === 20) { - let taken: undefined[] = rt.replaceIn(v, []); - make(arg); - rt.vecPush(taken, undefined, 0); - put(out, rt.vecCapacity(taken, 0)); - const _154: undefined[] = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 0); - const old = taken; - taken = _154; - v = old; - put(out, rt.vecCapacity(taken, 0)); - break b3; - } - if (_39 === 21) { - if (!((v.length === 0))) { - rt.vecSwapRemove(v, rt.usizeRem(arg as rt.usize, v.length)); - break b3; - } + } 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 { - if (_39 === 22) { - rt.vecDedupBy(v, rt.same); - break b3; - } - if (_39 === 23) { - const it2: rt.Iter = rt.iterSlice(v); - const _175: rt.u8 = rt.u8Rem(arg, 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _175; - while (iterStart2++ < iterEnd2) { - rt.iterToOption(it2.next(), rt.None); - } - v = rt.iterToArrayInPlace(it2.clone(), 0, 0, true, undefined, true); - put(out, rt.vecCapacity(rt.iterToArrayInPlace(it2, 0, 0, true, undefined, true), 0)); - break b3; - } + 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, 0); + v = rt.vecFromElem(undefined, rt.u8Rem(arg, 6) as rt.usize, undefined); + Known.remade(k, false); } - put(out, v.length); - put(out, rt.vecCapacity(v, 0)); + const _267: rt.usize = v.length; + const _269: rt.usize = rt.vecCapacity(v, 0); + Known.put(k, out, _267, _269); } } @@ -950,79 +842,102 @@ export function dequeSteps$array160_u64(dataData: Uint8Array, dataStart: number, } 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 _24: rt.ByteSlice | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _27: rt.ByteSlice | rt.Done = iter.next(); + if (_27 === rt.DONE) { break; } - rt.idx(_24, 0); - const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; - const op: rt.u8 = _30[0]; - const arg: rt.u8 = _30[1]; - const _39: rt.u8 = rt.u8Rem(op, 21); - if (_39 === 0) { - rt.dequePushBack(q, copy$array_u64(make(arg)), 1280); - } else if (_39 === 1) { - rt.dequePushFront(q, copy$array_u64(make(arg)), 1280); - } else if (_39 === 2) { + 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); - } else if (_39 === 3) { - rt.dequeReserve(q, amount(arg, q.n, size), 1280); - } else if (_39 === 4) { - rt.dequeReserveExact(q, amount(arg, q.n, size), 1280); - } else if (_39 === 5) { + 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); - } else if (_39 === 6) { + Known.shrunk(k, q.n, rt.u8Rem(arg, 40) as rt.usize); + } else if (_42 === 6) { rt.dequeShrinkTo(q, 0, 1280); - } else if (_39 === 7) { + Known.shrunk(k, q.n, 0); + k.exact = true; + } else if (_42 === 7) { rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); - } else if (_39 === 8) { - rt.dequeInsert(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), copy$array_u64(make(arg)), 1280); - } else if (_39 === 9) { + 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))); - } else if (_39 === 10) { + 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 (_39 === 11) { + } else if (_42 === 11) { rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 1280, true); - } else if (_39 === 12) { + } else if (_42 === 12) { rt.dequeClear(q); - } else if (_39 === 13) { + Known.loose(k); + } else if (_42 === 13) { const keep: () => boolean = alternate(); - rt.dequeRetain(q, (_25: rt.u64[]): boolean => { + rt.dequeRetain(q, (_28: rt.u64[]): boolean => { return keep(); }); - } else if (_39 === 14) { + Known.loose(k); + } else if (_42 === 14) { rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) }); - } else if (_39 === 15) { - q = rt.dequeClone(q, copy$array_u64); - } else if (_39 === 16) { - q = rt.dequeFromIntoIter(rt.dequeIter(q), 1280) as rt.VecDeque; - } else if (_39 === 17) { - q = rt.dequeFromVec(rt.iterToArray(rt.dequeIter(q), undefined, 1280, true), 1280) as rt.VecDeque; - } else if (_39 === 18) { + 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), (_23: rt.u64[]): boolean => { + q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_26: rt.u64[]): boolean => { return keep2(); - }), "next", 1280), 1280) as rt.VecDeque; - } else if (_39 === 19) { + }), "next", 1280)) as rt.VecDeque; + Known.remade(k, true); + } else if (_42 === 19) { const it: rt.Iter = rt.dequeIter(q); - const _128: rt.u8 = rt.u8Rem(arg, 4); + const _173: rt.u8 = rt.u8Rem(arg, 4); let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _128; + const iterEnd: rt.u8 = _173; while (iterStart++ < iterEnd) { rt.iterToOption(it.next()); } - q = rt.dequeFromIntoIter(it.clone({ v: copy$array_u64 }), 1280) as rt.VecDeque; - put(out, rt.dequeCapacity(rt.dequeFromIntoIter(it, 1280) as rt.VecDeque, 1280)); + 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 { - q = rt.dequeFromVec([copy$array_u64(make(arg)), copy$array_u64(make(arg)), copy$array_u64(make(arg))].map(copy$array_u64), 1280) as rt.VecDeque; + 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); } - put(out, q.n); - put(out, rt.dequeCapacity(q, 1280)); + const _204: rt.usize = q.n; + const _206: rt.usize = rt.dequeCapacity(q, 1280); + Known.put(k, out, _204, _206); } } @@ -1039,79 +954,102 @@ export function dequeSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number } 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 _24: rt.ByteSlice | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _27: rt.ByteSlice | rt.Done = iter.next(); + if (_27 === rt.DONE) { break; } - rt.idx(_24, 0); - const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; - const op: rt.u8 = _30[0]; - const arg: rt.u8 = _30[1]; - const _39: rt.u8 = rt.u8Rem(op, 21); - if (_39 === 0) { - rt.dequePushBack(q, copy$tuple2_u64_u8(make(arg)), 16); - } else if (_39 === 1) { - rt.dequePushFront(q, copy$tuple2_u64_u8(make(arg)), 16); - } else if (_39 === 2) { + 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); - } else if (_39 === 3) { - rt.dequeReserve(q, amount(arg, q.n, size), 16); - } else if (_39 === 4) { - rt.dequeReserveExact(q, amount(arg, q.n, size), 16); - } else if (_39 === 5) { + 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); - } else if (_39 === 6) { + Known.shrunk(k, q.n, rt.u8Rem(arg, 40) as rt.usize); + } else if (_42 === 6) { rt.dequeShrinkTo(q, 0, 16); - } else if (_39 === 7) { + Known.shrunk(k, q.n, 0); + k.exact = true; + } else if (_42 === 7) { rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); - } else if (_39 === 8) { - rt.dequeInsert(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), copy$tuple2_u64_u8(make(arg)), 16); - } else if (_39 === 9) { + 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))); - } else if (_39 === 10) { + 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 (_39 === 11) { + } else if (_42 === 11) { rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 16, true); - } else if (_39 === 12) { + } else if (_42 === 12) { rt.dequeClear(q); - } else if (_39 === 13) { + Known.loose(k); + } else if (_42 === 13) { const keep: () => boolean = alternate(); - rt.dequeRetain(q, (_25: [rt.u64, rt.u8]): boolean => { + rt.dequeRetain(q, (_28: [rt.u64, rt.u8]): boolean => { return keep(); }); - } else if (_39 === 14) { + Known.loose(k); + } else if (_42 === 14) { rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) }); - } else if (_39 === 15) { - q = rt.dequeClone(q, copy$tuple2_u64_u8); - } else if (_39 === 16) { - q = rt.dequeFromIntoIter(rt.dequeIter(q), 16) as rt.VecDeque<[rt.u64, rt.u8]>; - } else if (_39 === 17) { - q = rt.dequeFromVec(rt.iterToArray(rt.dequeIter(q), undefined, 16, true), 16) as rt.VecDeque<[rt.u64, rt.u8]>; - } else if (_39 === 18) { + 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), (_23: [rt.u64, rt.u8]): boolean => { + q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_26: [rt.u64, rt.u8]): boolean => { return keep2(); - }), "next", 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>; - } else if (_39 === 19) { + }), "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 _128: rt.u8 = rt.u8Rem(arg, 4); + const _173: rt.u8 = rt.u8Rem(arg, 4); let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _128; + const iterEnd: rt.u8 = _173; while (iterStart++ < iterEnd) { rt.iterToOption(it.next()); } - q = rt.dequeFromIntoIter(it.clone({ v: copy$tuple2_u64_u8 }), 16) as rt.VecDeque<[rt.u64, rt.u8]>; - put(out, rt.dequeCapacity(rt.dequeFromIntoIter(it, 16) as rt.VecDeque<[rt.u64, rt.u8]>, 16)); + 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 { - q = rt.dequeFromVec([copy$tuple2_u64_u8(make(arg)), copy$tuple2_u64_u8(make(arg)), copy$tuple2_u64_u8(make(arg))].map(copy$tuple2_u64_u8), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + 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); } - put(out, q.n); - put(out, rt.dequeCapacity(q, 16)); + const _204: rt.usize = q.n; + const _206: rt.usize = rt.dequeCapacity(q, 16); + Known.put(k, out, _204, _206); } } @@ -1128,79 +1066,102 @@ export function dequeSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: } 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 _24: rt.ByteSlice | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _27: rt.ByteSlice | rt.Done = iter.next(); + if (_27 === rt.DONE) { break; } - rt.idx(_24, 0); - const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; - const op: rt.u8 = _30[0]; - const arg: rt.u8 = _30[1]; - const _39: rt.u8 = rt.u8Rem(op, 21); - if (_39 === 0) { - rt.dequePushBack(q, make(arg), 2); - } else if (_39 === 1) { - rt.dequePushFront(q, make(arg), 2); - } else if (_39 === 2) { + 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); - } else if (_39 === 3) { - rt.dequeReserve(q, amount(arg, q.n, size), 2); - } else if (_39 === 4) { - rt.dequeReserveExact(q, amount(arg, q.n, size), 2); - } else if (_39 === 5) { + 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); - } else if (_39 === 6) { + Known.shrunk(k, q.n, rt.u8Rem(arg, 40) as rt.usize); + } else if (_42 === 6) { rt.dequeShrinkTo(q, 0, 2); - } else if (_39 === 7) { + Known.shrunk(k, q.n, 0); + k.exact = true; + } else if (_42 === 7) { rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); - } else if (_39 === 8) { - rt.dequeInsert(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), make(arg), 2); - } else if (_39 === 9) { + 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))); - } else if (_39 === 10) { + 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 (_39 === 11) { + } else if (_42 === 11) { rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 2, true); - } else if (_39 === 12) { + } else if (_42 === 12) { rt.dequeClear(q); - } else if (_39 === 13) { + Known.loose(k); + } else if (_42 === 13) { const keep: () => boolean = alternate(); - rt.dequeRetain(q, (_25: rt.u16): boolean => { + rt.dequeRetain(q, (_28: rt.u16): boolean => { return keep(); }); - } else if (_39 === 14) { + Known.loose(k); + } else if (_42 === 14) { rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) }); - } else if (_39 === 15) { - q = rt.dequeClone(q, undefined); - } else if (_39 === 16) { - q = rt.dequeFromIntoIter(rt.dequeIter(q), 2) as rt.VecDeque; - } else if (_39 === 17) { - q = rt.dequeFromVec(rt.iterToArray(rt.dequeIter(q), undefined, 2, true), 2) as rt.VecDeque; - } else if (_39 === 18) { + 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), (_23: rt.u16): boolean => { + q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_26: rt.u16): boolean => { return keep2(); - }), "next", 2), 2) as rt.VecDeque; - } else if (_39 === 19) { + }), "next", 2)) as rt.VecDeque; + Known.remade(k, true); + } else if (_42 === 19) { const it: rt.Iter = rt.dequeIter(q); - const _128: rt.u8 = rt.u8Rem(arg, 4); + const _173: rt.u8 = rt.u8Rem(arg, 4); let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _128; + const iterEnd: rt.u8 = _173; while (iterStart++ < iterEnd) { rt.iterToOption(it.next()); } - q = rt.dequeFromIntoIter(it.clone(), 2) as rt.VecDeque; - put(out, rt.dequeCapacity(rt.dequeFromIntoIter(it, 2) as rt.VecDeque, 2)); + 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 { - q = rt.dequeFromVec([make(arg), make(arg), make(arg)], 2) as rt.VecDeque; + 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); } - put(out, q.n); - put(out, rt.dequeCapacity(q, 2)); + const _204: rt.usize = q.n; + const _206: rt.usize = rt.dequeCapacity(q, 2); + Known.put(k, out, _204, _206); } } @@ -1217,79 +1178,102 @@ export function dequeSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: } 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 _24: rt.ByteSlice | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _27: rt.ByteSlice | rt.Done = iter.next(); + if (_27 === rt.DONE) { break; } - rt.idx(_24, 0); - const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; - const op: rt.u8 = _30[0]; - const arg: rt.u8 = _30[1]; - const _39: rt.u8 = rt.u8Rem(op, 21); - if (_39 === 0) { - rt.dequePushBack(q, make(arg), 1); - } else if (_39 === 1) { - rt.dequePushFront(q, make(arg), 1); - } else if (_39 === 2) { + 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); - } else if (_39 === 3) { - rt.dequeReserve(q, amount(arg, q.n, size), 1); - } else if (_39 === 4) { - rt.dequeReserveExact(q, amount(arg, q.n, size), 1); - } else if (_39 === 5) { + 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); - } else if (_39 === 6) { + Known.shrunk(k, q.n, rt.u8Rem(arg, 40) as rt.usize); + } else if (_42 === 6) { rt.dequeShrinkTo(q, 0, 1); - } else if (_39 === 7) { + Known.shrunk(k, q.n, 0); + k.exact = true; + } else if (_42 === 7) { rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); - } else if (_39 === 8) { - rt.dequeInsert(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), make(arg), 1); - } else if (_39 === 9) { + 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))); - } else if (_39 === 10) { + 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 (_39 === 11) { + } else if (_42 === 11) { rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 1, true); - } else if (_39 === 12) { + } else if (_42 === 12) { rt.dequeClear(q); - } else if (_39 === 13) { + Known.loose(k); + } else if (_42 === 13) { const keep: () => boolean = alternate(); - rt.dequeRetain(q, (_25: rt.u8): boolean => { + rt.dequeRetain(q, (_28: rt.u8): boolean => { return keep(); }); - } else if (_39 === 14) { + Known.loose(k); + } else if (_42 === 14) { rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) }); - } else if (_39 === 15) { - q = rt.dequeClone(q, undefined); - } else if (_39 === 16) { - q = rt.dequeFromIntoIter(rt.dequeIter(q), 1) as rt.VecDeque; - } else if (_39 === 17) { - q = rt.dequeFromVec(rt.byteVecToVec(rt.iterToByteVec(rt.dequeIter(q), undefined, true)), 1) as rt.VecDeque; - } else if (_39 === 18) { + 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), (_23: rt.u8): boolean => { + q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_26: rt.u8): boolean => { return keep2(); - }), "next", 1), 1) as rt.VecDeque; - } else if (_39 === 19) { + }), "next", 1)) as rt.VecDeque; + Known.remade(k, true); + } else if (_42 === 19) { const it: rt.Iter = rt.dequeIter(q); - const _128: rt.u8 = rt.u8Rem(arg, 4); + const _173: rt.u8 = rt.u8Rem(arg, 4); let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _128; + const iterEnd: rt.u8 = _173; while (iterStart++ < iterEnd) { rt.iterToOption(it.next()); } - q = rt.dequeFromIntoIter(it.clone(), 1) as rt.VecDeque; - put(out, rt.dequeCapacity(rt.dequeFromIntoIter(it, 1) as rt.VecDeque, 1)); + 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 { - q = rt.dequeFromVec(Array.from(Uint8Array.of(make(arg), make(arg), make(arg))), 1) as rt.VecDeque; + 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); } - put(out, q.n); - put(out, rt.dequeCapacity(q, 1)); + const _204: rt.usize = q.n; + const _206: rt.usize = rt.dequeCapacity(q, 1); + Known.put(k, out, _204, _206); } } @@ -1306,89 +1290,111 @@ export function dequeSteps$unit(dataData: Uint8Array, dataStart: number, dataLen } 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 _24: rt.ByteSlice | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _27: rt.ByteSlice | rt.Done = iter.next(); + if (_27 === rt.DONE) { break; } - rt.idx(_24, 0); - const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; - const op: rt.u8 = _30[0]; - const arg: rt.u8 = _30[1]; - const _39: rt.u8 = rt.u8Rem(op, 21); - if (_39 === 0) { - const _41: rt.VecDeque = q; + 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(_41, undefined, 0); - } else if (_39 === 1) { - const _43: rt.VecDeque = q; + rt.dequePushBack(_44, undefined); + } else if (_42 === 1) { + const _46: rt.VecDeque = q; make(arg); - rt.dequePushFront(_43, undefined, 0); - } else if (_39 === 2) { + rt.dequePushFront(_46, undefined); + } else if (_42 === 2) { rt.dequePopFront(q, rt.None); - } else if (_39 === 3) { - rt.dequeReserve(q, amount(arg, q.n, size), 0); - } else if (_39 === 4) { - rt.dequeReserveExact(q, amount(arg, q.n, size), 0); - } else if (_39 === 5) { + 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); - } else if (_39 === 6) { + Known.shrunk(k, q.n, rt.u8Rem(arg, 40) as rt.usize); + } else if (_42 === 6) { rt.dequeShrinkTo(q, 0, 0); - } else if (_39 === 7) { + Known.shrunk(k, q.n, 0); + k.exact = true; + } else if (_42 === 7) { rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); - } else if (_39 === 8) { - const _64: rt.VecDeque = q; - const _65: rt.usize = rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)); + 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(_64, _65, undefined, 0); - } else if (_39 === 9) { + 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); - } else if (_39 === 10) { + 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 (_39 === 11) { + } else if (_42 === 11) { rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 0, true); - } else if (_39 === 12) { + } else if (_42 === 12) { rt.dequeClear(q); - } else if (_39 === 13) { + Known.loose(k); + } else if (_42 === 13) { const keep: () => boolean = alternate(); - rt.dequeRetain(q, (_25: undefined): boolean => { + rt.dequeRetain(q, (_28: undefined): boolean => { return keep(); }); - } else if (_39 === 14) { + Known.loose(k); + } else if (_42 === 14) { rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) }); - } else if (_39 === 15) { - q = rt.dequeClone(q, undefined); - } else if (_39 === 16) { - q = rt.dequeFromIntoIter(rt.dequeIter(q), 0) as rt.VecDeque; - } else if (_39 === 17) { - q = rt.dequeFromVec(rt.iterToArray(rt.dequeIter(q), undefined, 0, true), 0) as rt.VecDeque; - } else if (_39 === 18) { + 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), (_23: undefined): boolean => { + q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_26: undefined): boolean => { return keep2(); - }), "next", 0), 0) as rt.VecDeque; - } else if (_39 === 19) { + }), "next", 0)) as rt.VecDeque; + Known.remade(k, true); + } else if (_42 === 19) { const it: rt.Iter = rt.dequeIter(q); - const _128: rt.u8 = rt.u8Rem(arg, 4); + const _173: rt.u8 = rt.u8Rem(arg, 4); let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _128; + const iterEnd: rt.u8 = _173; while (iterStart++ < iterEnd) { rt.iterToOption(it.next(), rt.None); } - q = rt.dequeFromIntoIter(it.clone(), 0) as rt.VecDeque; - put(out, rt.dequeCapacity(rt.dequeFromIntoIter(it, 0) as rt.VecDeque, 0)); + 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.dequeFromVec([undefined, undefined, undefined], 0) as rt.VecDeque; + q = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice([undefined, undefined, undefined]), undefined, 0, true); + Known.remade(k, false); } - put(out, q.n); - put(out, rt.dequeCapacity(q, 0)); + const _204: rt.usize = q.n; + const _206: rt.usize = rt.dequeCapacity(q, 0); + Known.put(k, out, _204, _206); } } @@ -1432,64 +1438,78 @@ export function heapSteps$array160_u64(dataData: Uint8Array, dataStart: number, } 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 _25: rt.ByteSlice | rt.Done = iter.next(); - if (_25 === rt.DONE) { + const _28: rt.ByteSlice | rt.Done = iter.next(); + if (_28 === rt.DONE) { break; } - rt.idx(_25, 0); - const _31: [rt.u8, rt.u8] = [_25.data[_25.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_25, 1), 0)]; - const op: rt.u8 = _31[0]; - const arg: rt.u8 = _31[1]; - const _40: rt.u8 = rt.u8Rem(op, 13); - if (_40 === 0 || _40 === 1) { - rt.heapPush(h, copy$array_u64(make(arg)), rt.cmpLe(rt.cmpSlice(rt.cmp)), 1280); - } else if (_40 === 2) { + 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))); - } else if (_40 === 3) { - const _46: rt.BinaryHeap = h; - const _47: rt.usize = amount(arg, h.d.length, size); - rt.vecReserve(_46.d, _47, 1280); - } else if (_40 === 4) { - const _50: rt.BinaryHeap = h; - const _51: rt.usize = amount(arg, h.d.length, size); - rt.vecReserveExact(_50.d, _51, 1280); - } else if (_40 === 5) { + 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); - } else if (_40 === 6) { + Known.shrunk(k, h.d.length, rt.u8Rem(arg, 40) as rt.usize); + } else if (_43 === 6) { rt.vecShrinkTo(h.d, 0, 1280); - } else if (_40 === 7) { + Known.shrunk(k, h.d.length, 0); + k.exact = true; + } else if (_43 === 7) { rt.heapClear(h); - } else if (_40 === 8) { + 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 (_40 === 9) { - const _68: rt.u64[] = copy$array_u64(make(arg)); - rt.heapPush(other, _68, rt.cmpLe(rt.cmpSlice(rt.cmp)), 1280); - rt.heapAppend(h, other, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp)), 1280); - put(out, rt.vecCapacity(other.d, 1280)); - } else if (_40 === 10) { + } 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)); - } else if (_40 === 11) { - const _77: 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 (_77 !== undefined) { - const top: rt.PeekMut = _77; - const _81: rt.u64[] = copy$array_u64(make(arg)); + 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, _81); + 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))); } - put(out, h.d.length); - put(out, rt.vecCapacity(h.d, 1280)); + const _127: rt.usize = h.d.length; + const _129: rt.usize = rt.vecCapacity(h.d, 1280); + Known.put(k, out, _127, _129); } - put(out, rt.vecCapacity(rt.heapClone(h, copy$array_u64).d, 1280)); - put(out, rt.vecCapacity(rt.heapIntoSortedVec(h, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))), 1280)); + 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 { @@ -1505,64 +1525,78 @@ export function heapSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, } 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 _25: rt.ByteSlice | rt.Done = iter.next(); - if (_25 === rt.DONE) { + const _28: rt.ByteSlice | rt.Done = iter.next(); + if (_28 === rt.DONE) { break; } - rt.idx(_25, 0); - const _31: [rt.u8, rt.u8] = [_25.data[_25.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_25, 1), 0)]; - const op: rt.u8 = _31[0]; - const arg: rt.u8 = _31[1]; - const _40: rt.u8 = rt.u8Rem(op, 13); - if (_40 === 0 || _40 === 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])), 16); - } else if (_40 === 2) { + 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]))); - } else if (_40 === 3) { - const _46: rt.BinaryHeap<[rt.u64, rt.u8]> = h; - const _47: rt.usize = amount(arg, h.d.length, size); - rt.vecReserve(_46.d, _47, 16); - } else if (_40 === 4) { - const _50: rt.BinaryHeap<[rt.u64, rt.u8]> = h; - const _51: rt.usize = amount(arg, h.d.length, size); - rt.vecReserveExact(_50.d, _51, 16); - } else if (_40 === 5) { + 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); - } else if (_40 === 6) { + Known.shrunk(k, h.d.length, rt.u8Rem(arg, 40) as rt.usize); + } else if (_43 === 6) { rt.vecShrinkTo(h.d, 0, 16); - } else if (_40 === 7) { + Known.shrunk(k, h.d.length, 0); + k.exact = true; + } else if (_43 === 7) { rt.heapClear(h); - } else if (_40 === 8) { + 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 (_40 === 9) { - const _68: [rt.u64, rt.u8] = copy$tuple2_u64_u8(make(arg)); - rt.heapPush(other, _68, rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), 16); - 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])), 16); - put(out, rt.vecCapacity(other.d, 16)); - } else if (_40 === 10) { + } 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)); - } else if (_40 === 11) { - const _77: 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 (_77 !== undefined) { - const top: rt.PeekMut<[rt.u64, rt.u8]> = _77; - const _81: [rt.u64, rt.u8] = copy$tuple2_u64_u8(make(arg)); + 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, _81); + 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]))); } - put(out, h.d.length); - put(out, rt.vecCapacity(h.d, 16)); + const _127: rt.usize = h.d.length; + const _129: rt.usize = rt.vecCapacity(h.d, 16); + Known.put(k, out, _127, _129); } - put(out, rt.vecCapacity(rt.heapClone(h, copy$tuple2_u64_u8).d, 16)); - put(out, rt.vecCapacity(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]))), 16)); + 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 { @@ -1578,64 +1612,78 @@ export function heapSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: } 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 _25: rt.ByteSlice | rt.Done = iter.next(); - if (_25 === rt.DONE) { + const _28: rt.ByteSlice | rt.Done = iter.next(); + if (_28 === rt.DONE) { break; } - rt.idx(_25, 0); - const _31: [rt.u8, rt.u8] = [_25.data[_25.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_25, 1), 0)]; - const op: rt.u8 = _31[0]; - const arg: rt.u8 = _31[1]; - const _40: rt.u8 = rt.u8Rem(op, 13); - if (_40 === 0 || _40 === 1) { - rt.heapPush(h, make(arg), rt.le, 2); - } else if (_40 === 2) { + 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); - } else if (_40 === 3) { - const _46: rt.BinaryHeap = h; - const _47: rt.usize = amount(arg, h.d.length, size); - rt.vecReserve(_46.d, _47, 2); - } else if (_40 === 4) { - const _50: rt.BinaryHeap = h; - const _51: rt.usize = amount(arg, h.d.length, size); - rt.vecReserveExact(_50.d, _51, 2); - } else if (_40 === 5) { + 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); - } else if (_40 === 6) { + Known.shrunk(k, h.d.length, rt.u8Rem(arg, 40) as rt.usize); + } else if (_43 === 6) { rt.vecShrinkTo(h.d, 0, 2); - } else if (_40 === 7) { + Known.shrunk(k, h.d.length, 0); + k.exact = true; + } else if (_43 === 7) { rt.heapClear(h); - } else if (_40 === 8) { + 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 (_40 === 9) { - const _68: rt.u16 = make(arg); - rt.heapPush(other, _68, rt.le, 2); - rt.heapAppend(h, other, rt.le, rt.ge, rt.lt, 2); - put(out, rt.vecCapacity(other.d, 2)); - } else if (_40 === 10) { + } 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)); - } else if (_40 === 11) { - const _77: rt.PeekMut | undefined = rt.heapPeekMut(h, rt.le, rt.ge, rt.lt); - if (_77 !== undefined) { - const top: rt.PeekMut = _77; - const _81: rt.u16 = make(arg); + 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 = _81; + top.v = _115; } + Known.remade(k, false); } else { h = rt.heapFrom(h.d, rt.le, rt.ge, rt.lt); } - put(out, h.d.length); - put(out, rt.vecCapacity(h.d, 2)); + const _127: rt.usize = h.d.length; + const _129: rt.usize = rt.vecCapacity(h.d, 2); + Known.put(k, out, _127, _129); } - put(out, rt.vecCapacity(rt.heapClone(h).d, 2)); - put(out, rt.vecCapacity(rt.heapIntoSortedVec(h, rt.le, rt.ge, rt.lt), 2)); + 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 { @@ -1651,64 +1699,76 @@ export function heapSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: n } 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 _25: rt.ByteSlice | rt.Done = iter.next(); - if (_25 === rt.DONE) { + const _28: rt.ByteSlice | rt.Done = iter.next(); + if (_28 === rt.DONE) { break; } - rt.idx(_25, 0); - const _31: [rt.u8, rt.u8] = [_25.data[_25.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_25, 1), 0)]; - const op: rt.u8 = _31[0]; - const arg: rt.u8 = _31[1]; - const _40: rt.u8 = rt.u8Rem(op, 13); - if (_40 === 0 || _40 === 1) { - rt.heapPush(h, make(arg), rt.le, 1); - } else if (_40 === 2) { + 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); - } else if (_40 === 3) { - const _46: rt.BinaryHeap = h; - const _47: rt.usize = amount(arg, h.d.length, size); - rt.vecReserve(_46.d, _47, 1); - } else if (_40 === 4) { - const _50: rt.BinaryHeap = h; - const _51: rt.usize = amount(arg, h.d.length, size); - rt.vecReserveExact(_50.d, _51, 1); - } else if (_40 === 5) { + 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); - } else if (_40 === 6) { + Known.shrunk(k, h.d.length, rt.u8Rem(arg, 40) as rt.usize); + } else if (_43 === 6) { rt.vecShrinkTo(h.d, 0, 1); - } else if (_40 === 7) { + Known.shrunk(k, h.d.length, 0); + k.exact = true; + } else if (_43 === 7) { rt.heapClear(h); - } else if (_40 === 8) { + 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 (_40 === 9) { - const _68: rt.u8 = make(arg); - rt.heapPush(other, _68, rt.le, 1); - rt.heapAppend(h, other, rt.le, rt.ge, rt.lt, 1); - put(out, rt.vecCapacity(other.d, 1)); - } else if (_40 === 10) { + } 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)); - } else if (_40 === 11) { - const _77: rt.PeekMut | undefined = rt.heapPeekMut(h, rt.le, rt.ge, rt.lt); - if (_77 !== undefined) { - const top: rt.PeekMut = _77; - const _81: rt.u8 = make(arg); + 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 = _81; + top.v = _115; } + Known.remade(k, false); } else { - h = rt.heapFrom(rt.byteVecToVec(rt.byteVecFromVec(h.d)), rt.le, rt.ge, rt.lt); + h = rt.heapFrom(rt.byteVecToVec(rt.byteVecFrom(Uint8Array.from(h.d))), rt.le, rt.ge, rt.lt); } - put(out, h.d.length); - put(out, rt.vecCapacity(h.d, 1)); + const _127: rt.usize = h.d.length; + const _129: rt.usize = rt.vecCapacity(h.d, 1); + Known.put(k, out, _127, _129); } - put(out, rt.byteVecCapacity(rt.byteVecFromVec(rt.heapClone(h).d))); - put(out, rt.byteVecCapacity(rt.byteVecFromVec(rt.heapIntoSortedVec(h, rt.le, rt.ge, rt.lt)))); + const cloned: rt.ByteVec = rt.byteVecFrom(Uint8Array.from(rt.heapClone(h, undefined, 1).d)); + Known.put(Known.new(0), out, cloned.length, cloned.data.length); + const sorted: rt.ByteVec = rt.byteVecFrom(Uint8Array.from(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 { @@ -1724,66 +1784,80 @@ export function heapSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: } 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 _25: rt.ByteSlice | rt.Done = iter.next(); - if (_25 === rt.DONE) { + const _28: rt.ByteSlice | rt.Done = iter.next(); + if (_28 === rt.DONE) { break; } - rt.idx(_25, 0); - const _31: [rt.u8, rt.u8] = [_25.data[_25.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_25, 1), 0)]; - const op: rt.u8 = _31[0]; - const arg: rt.u8 = _31[1]; - const _40: rt.u8 = rt.u8Rem(op, 13); - if (_40 === 0 || _40 === 1) { - const _42: rt.BinaryHeap = h; + 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(_42, undefined, rt.cmpLe(rt.cmpNothing), 0); - } else if (_40 === 2) { + rt.heapPush(_45, undefined, rt.cmpLe(rt.cmpNothing)); + } else if (_43 === 2) { rt.heapPop(h, rt.cmpLe(rt.cmpNothing), rt.None); - } else if (_40 === 3) { - const _46: rt.BinaryHeap = h; - const _47: rt.usize = amount(arg, h.d.length, size); - rt.vecReserve(_46.d, _47, 0); - } else if (_40 === 4) { - const _50: rt.BinaryHeap = h; - const _51: rt.usize = amount(arg, h.d.length, size); - rt.vecReserveExact(_50.d, _51, 0); - } else if (_40 === 5) { + 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); - } else if (_40 === 6) { + Known.shrunk(k, h.d.length, rt.u8Rem(arg, 40) as rt.usize); + } else if (_43 === 6) { rt.vecShrinkTo(h.d, 0, 0); - } else if (_40 === 7) { + Known.shrunk(k, h.d.length, 0); + k.exact = true; + } else if (_43 === 7) { rt.heapClear(h); - } else if (_40 === 8) { + 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 (_40 === 9) { + } else if (_43 === 9) { make(arg); - rt.heapPush(other, undefined, rt.cmpLe(rt.cmpNothing), 0); - rt.heapAppend(h, other, rt.cmpLe(rt.cmpNothing), rt.cmpGe(rt.cmpNothing), rt.cmpLt(rt.cmpNothing), 0); - put(out, rt.vecCapacity(other.d, 0)); - } else if (_40 === 10) { + 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)); - } else if (_40 === 11) { - const _77: rt.PeekMut | undefined = rt.heapPeekMut(h, rt.cmpLe(rt.cmpNothing), rt.cmpGe(rt.cmpNothing), rt.cmpLt(rt.cmpNothing)); - if (_77 !== undefined) { - const top: rt.PeekMut = _77; + 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)); } - put(out, h.d.length); - put(out, rt.vecCapacity(h.d, 0)); + const _127: rt.usize = h.d.length; + const _129: rt.usize = rt.vecCapacity(h.d, 0); + Known.put(k, out, _127, _129); } - put(out, rt.vecCapacity(rt.heapClone(h).d, 0)); - put(out, rt.vecCapacity(rt.heapIntoSortedVec(h, rt.cmpLe(rt.cmpNothing), rt.cmpGe(rt.cmpNothing), rt.cmpLt(rt.cmpNothing)), 0)); + 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); } /** @@ -1800,62 +1874,90 @@ export function collects(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void return [i, i] as [rt.u32, rt.u32]; }); rt.iterExtend(pairs2, _15, undefined, 8, true); - const _18: rt.u8 = rt.u8Rem(kind, 8); - if (_18 === 0) { - put(out, rt.vecCapacity(rt.iterToArrayInPlace(rt.iterMap(rt.iterSlice(pairs2), (_27: [rt.u32, rt.u32]): rt.u32 => { + 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]; - }), 8, 4, false, "next", true), 4)); - } else if (_18 === 1) { + }), "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 _32: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(n, data.length)); - rt.byteVecExtendFromSlice(bytes, _32); - put(out, rt.byteVecCapacity(rt.iterToByteVecInPlace(rt.iterFilter(rt.byteVecIntoIter(rt.byteVecFrom(rt.byteVecView(bytes))), (b5: rt.u8): boolean => { + 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; - }), 1, false, "next"))); - put(out, rt.vecCapacity(rt.iterToArray(rt.iterMap(rt.byteVecIntoIter(bytes), (a0: rt.u8): rt.u16 => { + }), "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), 2)); - } else if (_18 === 2) { - const _54: rt.Iter<[rt.u32, rt.u32]> = rt.iterCopied(rt.iterFilter(rt.iterSlice(pairs2), (_24: [rt.u32, rt.u32]): boolean => { - return rt.u32Rem(_24[0], 2) === 0; + }), 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 _53: [rt.u32[], rt.VecDeque] = rt.tupleExtend([[], rt.dequeNew() as rt.VecDeque] as [rt.u32[], rt.VecDeque], _54, [rt.vecPart(4), rt.dequePart(4)]); - const a: rt.u32[] = _53[0]; - const b: rt.VecDeque = _53[1]; - put(out, rt.vecCapacity(a, 4)); - put(out, rt.dequeCapacity(b, 4)); - const _68: rt.Iter<[rt.u8, rt.u32]> = rt.iterMap(rt.iterSlice(pairs2), (_26: [rt.u32, rt.u32]): [rt.u8, rt.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 _67: [rt.ByteVec, rt.BinaryHeap] = rt.tupleExtend([new rt.ByteVec(), rt.heapNew() as rt.BinaryHeap] as [rt.ByteVec, rt.BinaryHeap], _68, [rt.byteVecPart(), rt.heapPart(rt.le, 4)]); - const c: rt.ByteVec = _67[0]; - const d: rt.BinaryHeap = _67[1]; - put(out, rt.byteVecCapacity(c)); - put(out, rt.vecCapacity(d.d, 4)); - } else if (_18 === 3) { - put(out, rt.vecCapacity(rt.vecFromElem(0, n, undefined, 2), 2)); - put(out, rt.vecCapacity(rt.vecFromElem(undefined, n, undefined, 0), 0)); - } else if (_18 === 4) { + 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 (_18 === 5) { + } 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 (_18 === 6) { + } else if (_20 === 6) { const bytes2: rt.ByteVec = rt.byteVecWithCapacity(rt.usizeAdd(n, 5)); - const _103: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(n, data.length)); - rt.byteVecExtendFromSlice(bytes2, _103); - put(out, rt.dequeCapacity(rt.dequeFromVec(rt.byteVecToVec(rt.byteVecFrom(rt.byteVecView(bytes2))), 1) as rt.VecDeque, 1)); + 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); - put(out, rt.vecCapacity(heap.d, 1)); - put(out, rt.byteVecCapacity(rt.byteVecFromVec(heap.d))); + 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.byteVecFrom(Uint8Array.from(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 _127: rt.Iter = rt.iterFilter(new rt.Range(0, n & 0xff), (b3: rt.u8): boolean => { + 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, _127, "next"); - put(out, rt.byteVecCapacity(grown)); + rt.iterExtendBytes(grown, _171, "next"); + Known.put(exact, out, grown.length, grown.data.length); rt.byteVecShrinkTo(grown, rt.usizeDiv(n, 2)); - put(out, rt.byteVecCapacity(grown)); + Known.put(exact, out, grown.length, grown.data.length); } } diff --git a/ts/fixtures/lang/expected/chars.ts b/ts/fixtures/lang/expected/chars.ts index 20a3b792e..98f915966 100644 --- a/ts/fixtures/lang/expected/chars.ts +++ b/ts/fixtures/lang/expected/chars.ts @@ -6,14 +6,14 @@ 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))) { const buf: Uint8Array = rt.bytes(4); const n: rt.usize = rt.min(rest.length, 4); rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(rest, 0, n)); - rt.vecPush(all, rt.u32FromBeBytes(buf), 4); + all.push(rt.u32FromBeBytes(buf)); rest = rt.byteSliceRange(rest, n); } else { return all; @@ -92,9 +92,9 @@ export function chars(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(((c2 as rt.u32) & 0xff) as rt.u16))); } } else if (_4 === 2) { - const cs: rt.char[] = rt.iterToArrayInPlace(rt.iterFilterMap(rt.iterSlice(scalars(data)), (a0: rt.u32): rt.char | undefined => { + const cs: rt.char[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(scalars(data)), (a0: rt.u32): rt.char | undefined => { return rt.charFromU32(a0); - }), 4, 4, false, "next"); + }), "next", 4); const sorted: rt.BTreeSet = rt.btreeNew(rt.cmp) as rt.BTreeSet; const seen: rt.HashSet = rt.hashNew() as rt.HashSet; const iter3: rt.Iter<[rt.usize, rt.char]> = rt.iterEnumerate(rt.iterSlice(cs)); diff --git a/ts/fixtures/lang/expected/clones.ts b/ts/fixtures/lang/expected/clones.ts index 94a84ac01..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); @@ -6614,7 +6614,7 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }, plan, (x68: rt.u8): rt.u8 => { return x68; }, out); - turns$vec_IntoIter_u8_clones_iters_closure18_clones_iters_closure19(rt.byteVecIntoIter(rt.byteSliceToByteVec(data)), (it76: rt.Iter): rt.u8 | undefined => { + turns$vec_IntoIter_u8_clones_iters_closure18_clones_iters_closure19(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(data))), (it76: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it76.nextBack()); }, plan, (x69: rt.u8): rt.u8 => { return x69; @@ -6861,7 +6861,7 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }, out); turns$iter_Flatten_iter_Map_slice_Chunks_u8_clones_iters_closure89_clones_iters_closure90_clones_iters_closure91(rt.iterFlatten(rt.iterMap(rt.byteSliceChunks(data, n), (c3: rt.ByteSlice): rt.ByteVec => { return rt.byteSliceToByteVec(c3); - }), (value: rt.ByteVec) => rt.byteVecIntoIter(value)), (it43: rt.Iter): rt.u8 | undefined => { + }), (value: rt.ByteVec) => rt.iterSlice(rt.byteVecView(value))), (it43: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it43.nextBack()); }, plan, (x47: rt.u8): rt.u8 => { return x47; @@ -7005,7 +7005,7 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(zip3.clone(), zip3), (x29: rt.u8): rt.u8 => { return x29 ^ 64; }), undefined, true); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.refCellReplace(log, new rt.ByteVec())), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.refCellReplace(log, new rt.ByteVec()))), undefined, true); } else if (_9 === 8) { it = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(data))); let iterStart5: rt.usize = 0; @@ -7148,9 +7148,9 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; for (const b6 of rt.byteSliceView(data)) { if (rt.u8Rem(b6, 2) === 0) { - rt.dequePushFront(q, b6, 1); + rt.dequePushFront(q, b6); } else { - rt.dequePushBack(q, b6, 1); + rt.dequePushBack(q, b6); } } turns$collections_vec_deque_Iter_u8_clones_iters_closure138_clones_iters_closure0(rt.dequeIter(q), (it7: rt.Iter): rt.u8 | undefined => { @@ -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; @@ -7252,9 +7252,9 @@ export function unordered$iter_Copied_collections_hash_map_Keys_u8_u8(it: rt.Ite const _16: [rt.ByteVec, rt.ByteVec] = [_17, rt.iterToByteVec(other, "next")]; const rest: rt.ByteVec = _17; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); - rt.iterExtendBytes(all, rt.byteVecIntoIter(rest), undefined, true); + rt.iterExtendBytes(all, rt.iterSlice(rt.byteVecView(rest)), undefined, true); rt.byteSliceView(rt.byteVecSlice(all)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(all), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(all)), undefined, true); } /** @@ -7270,9 +7270,9 @@ export function unordered$iter_Copied_collections_hash_map_Values_u8_u8(it: rt.I const _16: [rt.ByteVec, rt.ByteVec] = [_17, rt.iterToByteVec(other, "next")]; const rest: rt.ByteVec = _17; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); - rt.iterExtendBytes(all, rt.byteVecIntoIter(rest), undefined, true); + rt.iterExtendBytes(all, rt.iterSlice(rt.byteVecView(rest)), undefined, true); rt.byteSliceView(rt.byteVecSlice(all)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(all), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(all)), undefined, true); } /** @@ -7288,9 +7288,9 @@ export function unordered$iter_Copied_collections_hash_set_Difference_u8_hash_Ra const _16: [rt.ByteVec, rt.ByteVec] = [_17, rt.iterToByteVec(other, "next")]; const rest: rt.ByteVec = _17; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); - rt.iterExtendBytes(all, rt.byteVecIntoIter(rest), undefined, true); + rt.iterExtendBytes(all, rt.iterSlice(rt.byteVecView(rest)), undefined, true); rt.byteSliceView(rt.byteVecSlice(all)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(all), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(all)), undefined, true); } /** @@ -7306,9 +7306,9 @@ export function unordered$iter_Copied_collections_hash_set_Intersection_u8_hash_ const _16: [rt.ByteVec, rt.ByteVec] = [_17, rt.iterToByteVec(other, "next")]; const rest: rt.ByteVec = _17; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); - rt.iterExtendBytes(all, rt.byteVecIntoIter(rest), undefined, true); + rt.iterExtendBytes(all, rt.iterSlice(rt.byteVecView(rest)), undefined, true); rt.byteSliceView(rt.byteVecSlice(all)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(all), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(all)), undefined, true); } /** @@ -7324,9 +7324,9 @@ export function unordered$iter_Copied_collections_hash_set_Iter_u8(it: rt.Iter { return logged(_22 & 112); - }), undefined, 8, true), 8) as rt.VecDeque, 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); @@ -7455,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 21d26e426..d7eb7e3a4 100644 --- a/ts/fixtures/lang/expected/collections.ts +++ b/ts/fixtures/lang/expected/collections.ts @@ -922,7 +922,7 @@ export function btreeMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi /** Pushes an item, and gives back the deque. */ export function touch(q: rt.VecDeque): rt.VecDeque { - rt.dequePushBack(q, 66, 1); + rt.dequePushBack(q, 66); return q; } @@ -938,16 +938,16 @@ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_12 === 1) { rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.dequePopBack(q), 237)); } else if (_12 === 2) { - rt.dequePushFront(q, b, 1); + rt.dequePushFront(q, b); } else if (_12 === 3) { rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.dequeEnd(q), 236)); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.dequeEnd(q, true), 235)); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.dequeGet(q, rt.usizeRem(b as rt.usize, 5)), 234)); } else { - rt.dequePushBack(q, b, 1); + rt.dequePushBack(q, b); } const _42: [rt.u8, rt.u8] = [b, q.n & 0xff]; - rt.dequePushBack(pairs, _42, 2); + rt.dequePushBack(pairs, _42); if (pairs.n > 3) { rt.dequePopFront(pairs); } @@ -980,8 +980,8 @@ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, q.n === 0 ? 1 : 0); const tallies: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): collections_Tally.Tally => { return { n: _25 as rt.u16 }; - }), undefined, 2, true), 2) as rt.VecDeque; - 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; @@ -1019,14 +1019,14 @@ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { }), undefined, true); const _162: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); rt.dequeExtend(q, _162, undefined, 1, true); - rt.dequeInsert(q, rt.usizeDiv(q.n, 2), 66, 1); + rt.dequeInsert(q, rt.usizeDiv(q.n, 2), 66); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.dequeRemove(q, 1), 233)); rt.dequeTruncate(q, 5); rt.byteVecPush(out, rt.dequeContains(q, 66, rt.same) ? 1 : 0); rt.iterExtendBytes(out, rt.iterRev(rt.dequeIter(q)), undefined, true); const a: rt.usize = rt.usizeRem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0) as rt.usize, 8); const b2: rt.usize = rt.usizeRem(option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0) as rt.usize, 8); - const q2: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterSlice(rt.byteSliceView(data)), undefined, 1, true), 1) as rt.VecDeque; + 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"); @@ -1058,7 +1058,7 @@ export function vecs(data: rt.ByteSlice, out: rt.ByteVec): void { const bytes: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(a, b, 66)); rt.byteVecExtendFromSlice(out, rt.byteVecSlice(bytes)); const pairs: [rt.u8, rt.u16][] = copy$array_tuple2_u8_u16([[a, b as rt.u16] as [rt.u8, rt.u16]]).map(copy$tuple2_u8_u16); - rt.vecPush(pairs, [b, a as rt.u16] as [rt.u8, rt.u16], 4); + pairs.push([b, a as rt.u16] as [rt.u8, rt.u16]); const at = rt.idx(pairs, 0); pairs[at][0] = pairs[at][0] ^ 255; for (const _39 of pairs) { @@ -1069,25 +1069,25 @@ export function vecs(data: rt.ByteSlice, out: rt.ByteVec): void { const one: Cloned.Cloned[] = [{ depth: a, name: name }]; rt.byteVecPush(out, one[rt.idx(one, 0)].depth); rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.byteVecOf(b, n))); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.vecFromElem(rt.u16Mul(a as rt.u16, 257), n, undefined, 2)), (w: rt.u16): rt.u8 => { + rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.vecFromElem(rt.u16Mul(a as rt.u16, 257), n, undefined)), (w: rt.u16): rt.u8 => { return rt.u16Shr(w, 4) & 0xff; }), undefined, true); - const tuples: [rt.u8, rt.u8][] = rt.vecFromElem([a, b] as [rt.u8, rt.u8], n, copy$tuple2_u8_u8, 2); + const tuples: [rt.u8, rt.u8][] = rt.vecFromElem([a, b] as [rt.u8, rt.u8], n, copy$tuple2_u8_u8); if (n > 0) { tuples[rt.idx(tuples, 0)][0] = 238; } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(tuples), (t: [rt.u8, rt.u8]): rt.u8 => { return t[0] ^ t[1]; }), undefined, true); - rt.byteVecPush(out, rt.vecFromElem(name, n, undefined, 12).length & 0xff); - const cloned: Cloned.Cloned[] = rt.vecFromElem({ depth: 0, name }, n, Cloned.clone$Clone, 16); + rt.byteVecPush(out, rt.vecFromElem(name, n, undefined).length & 0xff); + const cloned: Cloned.Cloned[] = rt.vecFromElem({ depth: 0, name }, n, Cloned.clone$Clone); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(cloned), (c: Cloned.Cloned): rt.u8 => { return c.depth; }), undefined, true); rt.byteVecPush(out, rt.iterAll(rt.iterSlice(cloned), (c2: Cloned.Cloned): boolean => { return rt.stringLen(c2.name) === data.length; }) ? 1 : 0); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.vecFromElem({ _0: b }, n, Bumped.clone$Clone, 1)), (o: Bumped.Bumped): rt.u8 => { + rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.vecFromElem({ _0: b }, n, Bumped.clone$Clone)), (o: Bumped.Bumped): rt.u8 => { return o._0; }), undefined, true); const pair: [rt.u8, rt.u8] = [a, b]; @@ -1095,10 +1095,10 @@ export function vecs(data: rt.ByteSlice, out: rt.ByteVec): void { const listed: [rt.u8, rt.u8][] = copy$array_tuple2_u8_u8([pair, pair]).map(copy$tuple2_u8_u8); const at4 = rt.idx(listed, 0); listed[at4][0] = listed[at4][0] ^ 255; - const repeated: [rt.u8, rt.u8][] = rt.vecFromElem(copy$tuple2_u8_u8(pair), n, copy$tuple2_u8_u8, 2); - const again: [rt.u8, rt.u8][] = rt.vecFromElem(copy$tuple2_u8_u8(pair), n, copy$tuple2_u8_u8, 2); - const bumps: Bumped.Bumped[] = rt.vecFromElem(copy$iters_Bumped(held), n, Bumped.clone$Clone, 1); - const kept: Bumped.Bumped[] = rt.vecFromElem(copy$iters_Bumped(held), n, Bumped.clone$Clone, 1); + const repeated: [rt.u8, rt.u8][] = rt.vecFromElem(copy$tuple2_u8_u8(pair), n, copy$tuple2_u8_u8); + const again: [rt.u8, rt.u8][] = rt.vecFromElem(copy$tuple2_u8_u8(pair), n, copy$tuple2_u8_u8); + const bumps: Bumped.Bumped[] = rt.vecFromElem(copy$iters_Bumped(held), n, Bumped.clone$Clone); + const kept: Bumped.Bumped[] = rt.vecFromElem(copy$iters_Bumped(held), n, Bumped.clone$Clone); if (n > 0) { const at5 = rt.idx(repeated, rt.usizeSub(n, 1)); repeated[at5][1] = repeated[at5][1] ^ 255; @@ -1123,7 +1123,7 @@ export function vecs(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, _183.length & 0xff); rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_183)); } - const wrapped: Wrap.Wrap[] = rt.vecFromElem(new Wrap.Wrap(a, b), n, copy$generics_Wrap_u8, 2); + const wrapped: Wrap.Wrap[] = rt.vecFromElem(new Wrap.Wrap(a, b), n, copy$generics_Wrap_u8); if (n > 0) { const _195: Wrap.Wrap[] = wrapped; const _197: rt.usize = rt.usizeSub(n, 1); @@ -1140,7 +1140,7 @@ export function vecs(data: rt.ByteSlice, out: rt.ByteVec): void { /** Stores `p` by value in `v`. */ export function keep(v: [rt.u8, rt.u8][], p: [rt.u8, rt.u8]): void { - rt.vecPush(v, copy$tuple2_u8_u8(p), 2); + v.push(copy$tuple2_u8_u8(p)); } /** Gives back what it was given. */ @@ -1170,11 +1170,11 @@ export function stores(data: rt.ByteSlice, out: rt.ByteVec): void { const changed: [rt.u8, rt.u8] = [b, a]; changed[0] = changed[0] ^ 16; const v: [rt.u8, rt.u8][] = []; - rt.vecPush(v, copy$tuple2_u8_u8(pair), 2); - rt.vecPush(v, copy$tuple2_u8_u8(pair), 2); + v.push(copy$tuple2_u8_u8(pair)); + v.push(copy$tuple2_u8_u8(pair)); const at = rt.idx(v, 0); v[at][0] = v[at][0] ^ 1; - rt.vecPush(v, copy$tuple2_u8_u8(changed), 2); + v.push(copy$tuple2_u8_u8(changed)); changed[1] = changed[1] ^ 32; const at2 = rt.idx(v, 2); v[at2][0] = v[at2][0] ^ 4; @@ -1182,7 +1182,7 @@ export function stores(data: rt.ByteSlice, out: rt.ByteVec): void { const at3 = rt.idx(v, 3); v[at3][1] = v[at3][1] ^ 8; const _30: [rt.u8, rt.u8] = copy$tuple2_u8_u8(same(pair)); - rt.vecPush(v, _30, 2); + v.push(_30); const at4 = rt.idx(v, 4); v[at4][0] = v[at4][0] ^ 64; const _36: [rt.u8, rt.u8] = copy$tuple2_u8_u8(changed); @@ -1203,9 +1203,9 @@ export function stores(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(changed[0], changed[1], old[0], old[1]))); const tally: collections_Tally.Tally = { n: a as rt.u16 }; const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; - rt.dequePushBack(q, copy$collections_Tally(tally), 2); - rt.dequePushFront(q, copy$collections_Tally(tally), 2); - rt.dequeInsert(q, 1, copy$collections_Tally(tally), 2); + rt.dequePushBack(q, copy$collections_Tally(tally)); + rt.dequePushFront(q, copy$collections_Tally(tally)); + rt.dequeInsert(q, 1, copy$collections_Tally(tally)); const _68: collections_Tally.Tally | undefined = rt.dequeEnd(q); if (_68 !== undefined) { _68.n = _68.n ^ 1; @@ -1245,7 +1245,7 @@ export function stores(data: rt.ByteSlice, out: rt.ByteVec): void { const boxed: [rt.u8, rt.u8] = copy$tuple2_u8_u8(pair); boxed[0] = boxed[0] ^ 1; const holders: Holder.Holder[] = [{ pair: copy$tuple2_u8_u8(pair) }]; - rt.vecPush(holders, { pair: copy$tuple2_u8_u8(pair) }, 2); + holders.push({ pair: copy$tuple2_u8_u8(pair) }); const at9 = rt.idx(holders, 1); holders[at9].pair[1] = holders[at9].pair[1] ^ 2; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(boxed[0], boxed[1], holders[rt.idx(holders, 0)].pair[1], holders[rt.idx(holders, 1)].pair[1]))); @@ -1253,7 +1253,7 @@ export function stores(data: rt.ByteSlice, out: rt.ByteVec): void { const held: Holder.Holder = hold(pair); held.pair[1] = held.pair[1] ^ 4; const _142: Holder.Holder = hold(pair); - rt.vecPush(holders, _142, 2); + holders.push(_142); const at12 = rt.idx(holders, 2); holders[at12].pair[0] = holders[at12].pair[0] ^ 8; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(held.pair[1], holders[rt.idx(holders, 2)].pair[0]))); @@ -3566,7 +3566,7 @@ export function rights(kind: rt.u8, data: rt.ByteSlice): Right.Right[] { return { _0: rt.u16Add(_2[1] as rt.u16, step(_2[0])) }; }), undefined, 2, true); if ((kind & 64) !== 0) { - rt.vecPop(rights); + rights.pop(); return rights; } return rights; @@ -3703,11 +3703,11 @@ export function unlikeEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi break; } const _232: Left.Left = { _0: _226 as rt.u16, _1: log }; - rt.dequePushFront(q, _232, 8); + rt.dequePushFront(q, _232); } for (const _239 of rt.byteSliceView(rt.byteSliceRange(data, half))) { const _245: Left.Left = { _0: _239 as rt.u16, _1: log }; - rt.dequePushBack(q, _245, 8); + rt.dequePushBack(q, _245); } const _252: Right.Right[] = rights_; putEq(rt.eqSeq((a26: Left.Left, b24: Right.Right): boolean => { @@ -3743,7 +3743,7 @@ export function unlikeEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi if (_305 === rt.DONE) { break; } - rt.dequePushFront(bytes, _305, 1); + rt.dequePushFront(bytes, _305); } const _313: rt.ByteSlice = rt.byteSliceRange(data, half); rt.dequeExtend(bytes, rt.iterSlice(rt.byteSliceView(_313)), undefined, 1, true); @@ -3756,7 +3756,7 @@ export function unlikeEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi putEq(rt.eqSeq(rt.same)(bytes, _334), log, out); const wide: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.dequeIter(bytes), (_28: rt.u8): rt.u16 => { return _28 as rt.u16; - }), undefined, 2, true), 2) as rt.VecDeque; + }), 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) { @@ -3764,10 +3764,10 @@ export function unlikeEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi if (_351 === rt.DONE) { break; } - rt.dequePushFront(wrapped, _351 as rt.u16, 2); + 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()])); @@ -3791,7 +3791,7 @@ export function unlikeEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi })(a035, a135); }) !== undefined, log, out); rt.byteVecPush(out, rt.iterCount(it) & 0xff); - const it2: rt.Peekable> = rt.iterPeekable(rt.iterSlice([rt.dequeClone(bytes, undefined), 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); @@ -3816,7 +3816,7 @@ export function wrapped$collections_Picky(v: collections_Picky.Picky[]): rt.VecD break; } const _18: collections_Picky.Picky = collections_Picky.clone$Clone(_12); - rt.dequePushFront(q, _18, 8); + rt.dequePushFront(q, _18); } const _21: rt.Iter = rt.iterMap(rt.iterSlice(rt.sliceRange(v, half)), collections_Picky.clone$Clone); rt.dequeExtend(q, _21, undefined, 8, true); @@ -3941,7 +3941,7 @@ export function ownNes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return { _0: rt.u16Add(_22[1] as rt.u16, step(_22[0])), _1: log }; }), undefined, 8, true); if ((kind & 64) !== 0) { - rt.vecPop(b); + b.pop(); } const one: (a0: collections_Picky.Picky[], a1: rt.usize) => collections_Picky.Picky = (v2: collections_Picky.Picky[], i4: rt.usize): collections_Picky.Picky => { return { _0: _34(v2, i4), _1: log }; @@ -3984,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); @@ -4108,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); @@ -4152,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 => { @@ -4385,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); @@ -4736,8 +4736,10 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_147, _152, !rt.eqSlice(ByRef.eq$cmp_PartialEq_ref)(_161, _164)], (a022: boolean): rt.u8 => { return a022 ? 1 : 0; })), undefined, true); - const _170: rt.VecDeque = rt.dequeFromVec([a, b], 4) as rt.VecDeque; - const _173: rt.VecDeque = rt.dequeFromVec([b, a], 4) as rt.VecDeque; + const _171: ByRef.ByRef[] = [a, b]; + const _170: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_171), undefined, 4, true); + const _174: ByRef.ByRef[] = [b, a]; + const _173: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_174), undefined, 4, true); rt.byteVecPush(out, rt.eqSeq(ByRef.eq$cmp_PartialEq_ref)(_170, _173) ? 1 : 0); const _180: ByRef.ByRef = a; const _182: ByRef.ByRef = b; @@ -4858,8 +4860,10 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_458, _463, !rt.eqSlice(ByRef.eq$cmp_PartialEq_ref)(_472, _475)], (a067: boolean): rt.u8 => { return a067 ? 1 : 0; })), undefined, true); - const _481: rt.VecDeque = rt.dequeFromVec([a2, b2], 4) as rt.VecDeque; - const _484: rt.VecDeque = rt.dequeFromVec([b2, a2], 4) as rt.VecDeque; + const _482: ByRef.ByRef[] = [a2, b2]; + const _481: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_482), undefined, 4, true); + const _485: ByRef.ByRef[] = [b2, a2]; + const _484: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_485), undefined, 4, true); rt.byteVecPush(out, rt.eqSeq(ByRef.eq$cmp_PartialEq_ref)(_481, _484) ? 1 : 0); const _491: ByRef.ByRef = a2; const _493: ByRef.ByRef = b2; @@ -4980,8 +4984,10 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_761, _766, !rt.eqSlice(ByVal.eq$cmp_PartialEq)(_775, _778)], (a0112: boolean): rt.u8 => { return a0112 ? 1 : 0; })), undefined, true); - const _784: rt.VecDeque = rt.dequeFromVec([a3, b3], 4) as rt.VecDeque; - const _787: rt.VecDeque = rt.dequeFromVec([b3, a3], 4) as rt.VecDeque; + const _785: ByVal.ByVal[] = [a3, b3]; + const _784: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_785), undefined, 4, true); + const _788: ByVal.ByVal[] = [b3, a3]; + const _787: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_788), undefined, 4, true); rt.byteVecPush(out, rt.eqSeq(ByVal.eq$cmp_PartialEq)(_784, _787) ? 1 : 0); const _794: ByVal.ByVal = a3; const _796: ByVal.ByVal = b3; @@ -5102,8 +5108,10 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_1068, _1073, !rt.eqSlice(ByVal.eq$cmp_PartialEq)(_1082, _1085)], (a0157: boolean): rt.u8 => { return a0157 ? 1 : 0; })), undefined, true); - const _1091: rt.VecDeque = rt.dequeFromVec([a4, b4], 4) as rt.VecDeque; - const _1094: rt.VecDeque = rt.dequeFromVec([b4, a4], 4) as rt.VecDeque; + const _1092: ByVal.ByVal[] = [a4, b4]; + const _1091: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_1092), undefined, 4, true); + const _1095: ByVal.ByVal[] = [b4, a4]; + const _1094: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_1095), undefined, 4, true); rt.byteVecPush(out, rt.eqSeq(ByVal.eq$cmp_PartialEq)(_1091, _1094) ? 1 : 0); const _1101: ByVal.ByVal = a4; const _1103: ByVal.ByVal = b4; @@ -5227,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; @@ -5273,10 +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); - rt.byteVecPush(out, rt.dequeContains(rt.dequeFromVec(xs.slice(), 4) as rt.VecDeque, xs[rt.idx(xs, rt.usizeDiv(xs.length, 2))], ByRef.eq$cmp_PartialEq_ref) ? 1 : 0); + rt.byteVecPush(out, rt.dequeContains(rt.dequeFromVec(rt.vecExact(xs.slice(), 4)) 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; @@ -5322,10 +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); - rt.byteVecPush(out, rt.dequeContains(rt.dequeFromVec(xs2.slice(), 4) as rt.VecDeque, xs2[rt.idx(xs2, rt.usizeDiv(xs2.length, 2))], ByVal.eq$cmp_PartialEq) ? 1 : 0); + rt.byteVecPush(out, rt.dequeContains(rt.dequeFromVec(rt.vecExact(xs2.slice(), 4)) 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; @@ -5371,7 +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); - rt.byteVecPush(out, rt.dequeContains(rt.dequeFromVec(xs3.slice(), 4) as rt.VecDeque, xs3[rt.idx(xs3, rt.usizeDiv(xs3.length, 2))], Mixed.eq$cmp_PartialEq) ? 1 : 0); + rt.byteVecPush(out, rt.dequeContains(rt.dequeFromVec(rt.vecExact(xs3.slice(), 4)) 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/counts.ts b/ts/fixtures/lang/expected/counts.ts index b7faa362a..d9a46b6d8 100644 --- a/ts/fixtures/lang/expected/counts.ts +++ b/ts/fixtures/lang/expected/counts.ts @@ -38,13 +38,13 @@ export function arcs(data: rt.ByteSlice, out: rt.ByteVec): void { const _19: rt.u8 = rt.u8Rem(op, 12); if (_19 === 0) { const _22: rt.Arc = new rt.Arc(new counts_Noisy.Noisy(op, rt.arcClone(log))); - rt.vecPush(strong, _22, 4); + strong.push(_22); continue; } if (_19 === 1) { if (!((strong.length === 0))) { const again: rt.Arc = rt.arcClone(strong[rt.idx(strong, rt.usizeRem(pick, strong.length))]); - rt.vecPush(strong, again, 4); + strong.push(again); continue; } } else if (_19 === 2) { @@ -68,13 +68,13 @@ export function arcs(data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_19 === 3) { if (!((strong.length === 0))) { const _62: rt.Weak = new rt.Weak(strong[rt.idx(strong, rt.usizeRem(pick, strong.length))]); - rt.vecPush(weak, _62, 4); + weak.push(_62); continue; } } else if (_19 === 4) { if (!((weak.length === 0))) { const again2: rt.Weak = rt.weakClone(weak[rt.idx(weak, rt.usizeRem(pick, weak.length))]); - rt.vecPush(weak, again2, 4); + weak.push(again2); continue; } } else if (_19 === 5) { @@ -91,13 +91,13 @@ export function arcs(data: rt.ByteSlice, out: rt.ByteVec): void { } const up: rt.Arc = _90; rt.byteVecPush(out, up.value.id); - rt.vecPush(strong, up, 4); + strong.push(up); continue; } } else { if (_19 === 7) { const _106: rt.Weak = new rt.Weak(); - rt.vecPush(weak, _106, 4); + weak.push(_106); continue; } if (_19 === 8) { @@ -274,7 +274,7 @@ export function clonedArcs(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, handles[at].strong & 0xff); if (keep) { _191 = false; - rt.vecPush(lists, all, 12); + lists.push(all); } if (_191) { rt.dropAll(all); @@ -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; })); @@ -331,7 +331,7 @@ export function clonedArcs(data: rt.ByteSlice, out: rt.ByteVec): void { break b2; } } - rt.dropAll(rt.vecPop(lists)); + rt.dropAll(lists.pop()); } } rt.byteVecPush(out, handles[rt.idx(handles, rt.usizeRem(pick, handles.length))].strong & 0xff); @@ -413,10 +413,10 @@ export function cyclicArcs(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, node.weak & 0xff); const _69: rt.u8 = op >> 6; if (_69 === 0) { - rt.vecPush(kept, node, 4); + kept.push(node); } else if (_69 === 1) { const _76: rt.Weak = new rt.Weak(node); - rt.vecPush(outside, _76, 4); + outside.push(_76); node[Symbol.dispose](); } else { node[Symbol.dispose](); @@ -465,13 +465,13 @@ export function uniqueArcs(data: rt.ByteSlice, out: rt.ByteVec): void { const _24: rt.u8 = rt.u8Rem(op, 7); if (_24 === 0) { const _27: rt.Arc = new rt.Arc(op); - rt.vecPush(strong, _27, 4); + strong.push(_27); } else if (_24 === 1) { const again: rt.Arc = rt.arcClone(strong[rt.idx(strong, pick)]); - rt.vecPush(strong, again, 4); + strong.push(again); } else if (_24 === 2) { const _34: rt.Weak = new rt.Weak(strong[rt.idx(strong, pick)]); - rt.vecPush(weak, _34, 4); + weak.push(_34); } else if (_24 === 3) { if (strong.length > 1) { if ((op & 128) === 0) { @@ -631,7 +631,7 @@ export function clonedRcs(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, handles[at].strong & 0xff); if (keep) { _191 = false; - rt.vecPush(lists, all, 12); + lists.push(all); } if (_191) { rt.dropAll(all); @@ -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; })); @@ -688,7 +688,7 @@ export function clonedRcs(data: rt.ByteSlice, out: rt.ByteVec): void { break b2; } } - rt.dropAll(rt.vecPop(lists)); + rt.dropAll(lists.pop()); } } rt.byteVecPush(out, handles[rt.idx(handles, rt.usizeRem(pick, handles.length))].strong & 0xff); @@ -770,10 +770,10 @@ export function cyclicRcs(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, node.weak & 0xff); const _69: rt.u8 = op >> 6; if (_69 === 0) { - rt.vecPush(kept, node, 4); + kept.push(node); } else if (_69 === 1) { const _76: rt.Weak = new rt.Weak(node); - rt.vecPush(outside, _76, 4); + outside.push(_76); node[Symbol.dispose](); } else { node[Symbol.dispose](); @@ -806,13 +806,13 @@ export function rcs(data: rt.ByteSlice, out: rt.ByteVec): void { const _19: rt.u8 = rt.u8Rem(op, 12); if (_19 === 0) { const _22: rt.Arc = new rt.Arc(new counts_Noisy.Noisy(op, rt.arcClone(log))); - rt.vecPush(strong, _22, 4); + strong.push(_22); continue; } if (_19 === 1) { if (!((strong.length === 0))) { const again: rt.Arc = rt.arcClone(strong[rt.idx(strong, rt.usizeRem(pick, strong.length))]); - rt.vecPush(strong, again, 4); + strong.push(again); continue; } } else if (_19 === 2) { @@ -836,13 +836,13 @@ export function rcs(data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_19 === 3) { if (!((strong.length === 0))) { const _62: rt.Weak = new rt.Weak(strong[rt.idx(strong, rt.usizeRem(pick, strong.length))]); - rt.vecPush(weak, _62, 4); + weak.push(_62); continue; } } else if (_19 === 4) { if (!((weak.length === 0))) { const again2: rt.Weak = rt.weakClone(weak[rt.idx(weak, rt.usizeRem(pick, weak.length))]); - rt.vecPush(weak, again2, 4); + weak.push(again2); continue; } } else if (_19 === 5) { @@ -859,13 +859,13 @@ export function rcs(data: rt.ByteSlice, out: rt.ByteVec): void { } const up: rt.Arc = _90; rt.byteVecPush(out, up.value.id); - rt.vecPush(strong, up, 4); + strong.push(up); continue; } } else { if (_19 === 7) { const _106: rt.Weak = new rt.Weak(); - rt.vecPush(weak, _106, 4); + weak.push(_106); continue; } if (_19 === 8) { @@ -1000,13 +1000,13 @@ export function uniqueRcs(data: rt.ByteSlice, out: rt.ByteVec): void { const _24: rt.u8 = rt.u8Rem(op, 7); if (_24 === 0) { const _27: rt.Arc = new rt.Arc(op); - rt.vecPush(strong, _27, 4); + strong.push(_27); } else if (_24 === 1) { const again: rt.Arc = rt.arcClone(strong[rt.idx(strong, pick)]); - rt.vecPush(strong, again, 4); + strong.push(again); } else if (_24 === 2) { const _34: rt.Weak = new rt.Weak(strong[rt.idx(strong, pick)]); - rt.vecPush(weak, _34, 4); + weak.push(_34); } else if (_24 === 3) { if (strong.length > 1) { if ((op & 128) === 0) { diff --git a/ts/fixtures/lang/expected/cows.ts b/ts/fixtures/lang/expected/cows.ts index eeb45d30d..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) { @@ -239,7 +239,7 @@ export function slices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let c2: rt.Cow = cowOf(v, owned); const owned4 = rt.cowIntoOwned(c2); c2 = owned4; - rt.vecPush(owned4, 7, 2); + owned4.push(7); const owned5 = rt.cowIntoOwned(c2); c2 = owned5; const m: rt.u16[] = owned5; @@ -247,7 +247,7 @@ export function slices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (_119 !== undefined) { _119.v = _119.v ^ 65535; } - rt.vecPush(m, 9, 2); + m.push(9); putWords(out, rt.cowSlice(c2)); putWords(out, v); const cs: rt.Cow[] = [cowOf(half, owned), cowOf(v, !owned)]; @@ -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)); @@ -314,7 +314,7 @@ export function slices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { putWords(out, c3 as rt.u16[]); } if (!(c3 instanceof rt.Borrowed)) { - rt.vecPush(c3 as rt.u16[], 5, 2); + (c3 as rt.u16[]).push(5); } putWords(out, rt.cowSlice(c3)); const kept: rt.Cow = rt.cowClone(c3); @@ -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); @@ -424,12 +424,12 @@ export function slices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _506: rt.Place> = rt.place(() => c4, (value2) => c4 = value2); const owned2 = rt.cowIntoOwned(_506.v, cows_Tally.clone$Clone); _506.v = owned2; - rt.drop(rt.vecPop(owned2)); + rt.drop(owned2.pop()); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.cellReplace(log, 0)))); const _515: rt.Place> = rt.place(() => c4, (value3) => c4 = value3); const owned3 = rt.cowIntoOwned(_515.v, cows_Tally.clone$Clone); _515.v = owned3; - rt.vecPush(owned3, new cows_Tally.Tally(9, log), 8); + owned3.push(new cows_Tally.Tally(9, log)); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.cellReplace(log, 0)))); const _524: rt.Place> = rt.place(() => c4, (value4) => c4 = value4); if (!(_524.v instanceof rt.Borrowed)) { diff --git a/ts/fixtures/lang/expected/cycles.ts b/ts/fixtures/lang/expected/cycles.ts index b87c7ad48..3f2e05d0d 100644 --- a/ts/fixtures/lang/expected/cycles.ts +++ b/ts/fixtures/lang/expected/cycles.ts @@ -975,7 +975,7 @@ export function cycles(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return _22[0] ^ _22[1]; }), "next"); rt.iterExtendBytes(out, rt.iterTake(rt.iterStepBy(rt.iterSkip(rt.iterCycle(new rt.RangeInclusive(1, 3, rt.u8Step)), n), 2), m), "next"); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterTake(rt.iterCycle(rt.iterSlice(rt.byteSliceView(data))), m), "next")), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterTake(rt.iterCycle(rt.iterSlice(rt.byteSliceView(data))), m), "next"))), undefined, true); rt.byteVecPush(out, rt.iterAny(rt.iterTake(rt.iterCycle(rt.iterSlice(rt.byteSliceView(data))), m), (_23: rt.u8): boolean => { return _23 === 7; }) ? 1 : 0); diff --git a/ts/fixtures/lang/expected/dyns.ts b/ts/fixtures/lang/expected/dyns.ts index 8e0d7bb96..8d043d1ba 100644 --- a/ts/fixtures/lang/expected/dyns.ts +++ b/ts/fixtures/lang/expected/dyns.ts @@ -117,7 +117,7 @@ export function dyns(dataData: Uint8Array, dataStart: number, dataLen: number, o const i: rt.usize = _94[0]; const x: rt.u8 = _94[1]; const _101: dyns_Named.Named = make(rt.u8WrappingAdd(x, i & 0xff), x); - rt.vecPush(shapes, _101, 8); + shapes.push(_101); } const _106: rt.usize = shapes.length; let iterStart: rt.usize = 0; @@ -469,7 +469,7 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o } else { _237 = new Any.of$dyns_Square({ side: i & 0xffff }); } - rt.vecPush(boxes, _237, 8); + boxes.push(_237); } const kept: Any.Any[] = []; const iter5: rt.Iter<[rt.usize, Any.Any]> = rt.iterEnumerate(rt.iterSlice(boxes, rt.drop)); @@ -500,7 +500,7 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o rt.drop(other3); } } else { - rt.vecPush(kept, _261.error, 8); + kept.push(_261.error); } } rt.drop(iter5); @@ -610,7 +610,7 @@ export function fns(data: rt.ByteSlice, out: rt.ByteVec): void { const _94: (a0: rt.u8) => rt.u8 = (x3: rt.u8): rt.u8 => { return rt.u8WrappingAdd(twice(halve, x3), captured); }; - rt.vecPush(fs, _94, 8); + fs.push(_94); rt.sliceSwap(fs, 0, rt.usizeRem(b as rt.usize, fs.length)); let captured2: rt.u8 = 0; const hook: Hook.Hook = new Hook.Hook((x4: rt.u8): rt.u32 => { @@ -645,7 +645,7 @@ export function fns(data: rt.ByteSlice, out: rt.ByteVec): void { }))(b); const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(part6), f, rt.u8Debug)]; fmt_put(out, rt.fmtFormat([args12[0], " "])); - const part7 = rt.once(rt.optionUnwrap(rt.vecPop(fs)))(a); + const part7 = rt.once(rt.optionUnwrap(fs.pop()))(a); const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(part7, f)]; fmt_put(out, rt.fmtFormat([args14[0], " "])); const captured4 = b; diff --git a/ts/fixtures/lang/expected/edits.ts b/ts/fixtures/lang/expected/edits.ts index d053a56cd..090c62c6a 100644 --- a/ts/fixtures/lang/expected/edits.ts +++ b/ts/fixtures/lang/expected/edits.ts @@ -47,11 +47,11 @@ 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; - rt.vecPush(seen, x4, 2); + seen.push(x4); return rt.u16Rem(x4, 4) !== 0; }); putU16s(out, seen); @@ -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; @@ -132,8 +132,8 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }), undefined, 16, true); const seen2: rt.u16[] = []; rt.vecDedupBy(tested, (a3: edits_Named.Named, b10: edits_Named.Named): boolean => { - rt.vecPush(seen2, a3.id, 2); - rt.vecPush(seen2, b10.id, 2); + seen2.push(a3.id); + seen2.push(b10.id); return a3.name === b10.name; }); putU16s(out, seen2); @@ -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 + "!"; @@ -250,7 +250,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, !rt.eqSlice(edits_Named.eq$cmp_PartialEq)(changed, named2) ? 1 : 0); rt.byteVecPush(out, rt.cmpSlice(edits_Named.partialCmp$cmp_PartialOrd)(changed, named2) === -1 ? 1 : 0); const _435: edits_Named.Named[] = rt.sliceRange(named2, 0, rt.usizeDiv(named2.length, 2)); - rt.vecExtendFromSlice(changed, _435, edits_Named.clone$Clone, 16); + rt.vecExtendFromSlice(changed, _435, edits_Named.clone$Clone); rt.byteVecPush(out, changed.length & 0xff); const nested: rt.u16[][] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): rt.u16[] => { const b5: rt.u8 = _29; @@ -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,8 +271,8 @@ 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(); - rt.vecExtendFromSlice(grown, words, undefined, 2); + const grown: rt.u16[] = rt.vecExact(words.slice(), 2); + rt.vecExtendFromSlice(grown, words); putU16s(out, grown); } else if (_8 === 5) { let tally: edits_Tally.Tally = { n: at(0), names: [text(data)] }; @@ -282,7 +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)]); - let queue: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterSlice(words), undefined, 2, true), 2) as rt.VecDeque; + 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; @@ -315,12 +315,12 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }), undefined, 16, true); const _615: rt.usize = rt.usizeRem(at(0) as rt.usize, 8); const _621: edits_Named.Named = _604(511); - rt.vecInsert(v7, _615, _621, 16); + rt.vecInsert(v7, _615, _621); putU16s(out, _605(v7)); 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)); @@ -339,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[] = []; @@ -463,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; @@ -498,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 e251d9e12..10150aca7 100644 --- a/ts/fixtures/lang/expected/errors.ts +++ b/ts/fixtures/lang/expected/errors.ts @@ -436,10 +436,10 @@ 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(); - rt.vecPush(all, input, 8); - 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(); - rt.vecPush(bytes, data, 8); + 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.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) { pairs$Result_bool_str_ParseBoolError(parsed$bool(all), out); diff --git a/ts/fixtures/lang/expected/fmt.ts b/ts/fixtures/lang/expected/fmt.ts index 346368b3e..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)); @@ -736,10 +736,10 @@ export function collections(data: rt.ByteSlice, out: rt.ByteVec): void { const _12: rt.u8 = rt.u8Rem(b, 4); if (_12 === 0) { const _15: rt.u8 | undefined = thenSome$0d5am30(rt.u8Rem(b, 3) !== 0, b); - rt.dequePushBack(q, _15, 2); + rt.dequePushBack(q, _15); } else if (_12 === 1) { const _20: rt.u8 | undefined = thenSome$0d5am30(rt.u8Rem(b, 3) !== 0, b); - rt.dequePushFront(q, _20, 2); + rt.dequePushFront(q, _20); } else if (_12 === 2) { rt.dequePopBack(q, rt.None); } else { @@ -751,9 +751,9 @@ export function collections(data: rt.ByteSlice, out: rt.ByteVec): void { 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, 4); + rt.dequePushFront(wrapped, _48); const _57: Hex.Hex = { _0: at(1) as rt.u32 }; - rt.dequePushFront(wrapped, _57, 4); + rt.dequePushFront(wrapped, _57); rt.dequePopBack(wrapped); const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.dequeIter(wrapped), f, (value: Hex.Hex, f: rt.Formatter) => Hex.fmt$fmt_Debug(value, f))]; const mid: string = rt.fmtFormat([args4[0]]); @@ -761,10 +761,13 @@ 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 units: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(new rt.Range(0, rt.u8Rem(at(2), 3)), (_2: rt.u8): undefined => {}), undefined, 0, true), 0) as rt.VecDeque; + const 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 part = rt.dequeFromVec([rt.dequeNew() as rt.VecDeque, rt.dequeFromVec([{ _0: at(3), _1: -1 }, { _0: 2, _1: 3 }], 16) as rt.VecDeque], 16) as rt.VecDeque>; + const _114: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const _116: fmt_Pair.Pair[] = [{ _0: at(3), _1: -1 }, { _0: 2, _1: 3 }]; + const _113: rt.VecDeque[] = [_114, rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_116), undefined, 16, true)]; + const part = rt.dequeExtend(rt.dequeNew() as rt.VecDeque>, rt.iterSlice(_113), undefined, 16, true); const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.dequeIter(part), f, (value: rt.VecDeque, f: rt.Formatter) => rt.fmtList(rt.dequeIter(value), f, (value: fmt_Pair.Pair, f: rt.Formatter) => fmt_Pair.fmt$fmt_Debug(value, f)))]; put(out, rt.fmtFormat([args10[0], "|", rt.fmtSpec({ alternate: true }, args10[0])])); const _135: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): rt.u8 | undefined => { @@ -784,7 +787,7 @@ export function collections(data: rt.ByteSlice, out: rt.ByteVec): void { const b2: rt.u8 = _154; rt.dequePushFront(rt.entryOrInsertWith(rt.entry(map, rt.u8Rem(b2, 4)), (): rt.VecDeque => { return rt.dequeNew() as rt.VecDeque; - }), { _0: b2, _1: rt.i64Neg(b2 as rt.i64) }, 16); + }), { _0: b2, _1: rt.i64Neg(b2 as rt.i64) }); } const _176: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; const _178: rt.BTreeSet = rt.btreeNew(rt.cmp) as rt.BTreeSet; @@ -1008,7 +1011,7 @@ export function iters(data: rt.ByteSlice, out: rt.ByteVec): void { }), undefined, 16, true)), front, back); const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part3, f, (value: fmt_Pair.Pair, f: rt.Formatter) => fmt_Pair.fmt$fmt_Debug(value, f), ["IntoIter"])]; put(out, rt.fmtFormat([args6[0], "|", rt.fmtSpec({ alternate: true }, args6[0])])); - const part4 = ends$iters_vec_IntoIter_u8(rt.byteVecIntoIter(rt.byteSliceToByteVec(data)), front, back); + const part4 = ends$iters_vec_IntoIter_u8(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(data))), front, back); const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part4, f, rt.u8Debug, ["IntoIter"])]; put(out, rt.fmtFormat([rt.fmtSpec({ debugHex: "x" }, args8[0])])); const it4: rt.Iter = ends$iters_vec_Drain_fmt_Hex(rt.vecDrain(rt.iterToArray(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 5), (_23: rt.u8): Hex.Hex => { @@ -1037,24 +1040,24 @@ export function iters(data: rt.ByteSlice, out: rt.ByteVec): void { put(out, rt.fmtFormat([args16[0]])); const _165: Array = []; const _174: rt.Iter = rt.iterSlice(_165); - const _176: rt.Iter = rt.byteVecIntoIter(new rt.ByteVec()); + const _176: rt.Iter = rt.iterSlice(rt.byteVecView(new rt.ByteVec())); const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(_174, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), ["Iter"]), (f: rt.Formatter) => rt.fmtIter(_176, f, rt.u8Debug, ["IntoIter"])]; put(out, rt.fmtFormat([args18[0], "|", rt.fmtSpec({ alternate: true }, args18[1])])); const heap: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterSlice(rt.byteSliceView(data)), undefined, 1, true), rt.le, rt.ge, rt.lt); 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 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); - }), undefined, 2, true), 2) as rt.VecDeque), 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.ts b/ts/fixtures/lang/expected/generics.ts index 38d78e7c6..c02590bbb 100644 --- a/ts/fixtures/lang/expected/generics.ts +++ b/ts/fixtures/lang/expected/generics.ts @@ -61,7 +61,7 @@ export function methods(data: rt.ByteSlice, out: rt.ByteVec): void { const _168: rt.u16[] = []; const list: Wrap.Wrap = new Wrap.Wrap(_168, 1); const _171: rt.u16 = at(10) as rt.u16; - rt.vecPush(list.value, _171, 2); + list.value.push(_171); Wrap.bump$Vec_u16(list); const none: Wrap.Wrap = new Wrap.Wrap(undefined, 0); const some: Wrap.Wrap = Wrap.new$Option_u8(rt.byteSliceGet(data, 11)); @@ -69,7 +69,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]])); diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 6bfb89df2..591c73873 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 => { @@ -258,7 +259,13 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) borrows_maps(data90, out91); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locks::mapped", (_2191: rt.u8, data91: rt.ByteSlice, out92: rt.ByteVec): undefined => { mapped(data91, out92); - }] 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 7f87fd350..49b695820 100644 --- a/ts/fixtures/lang/expected/hints.ts +++ b/ts/fixtures/lang/expected/hints.ts @@ -1961,7 +1961,7 @@ export function hints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (_312 === 0) { walk$slice_Iter_u8(rt.iterSlice(rt.byteSliceView(bytes)), steps, out); } else if (_312 === 1) { - walk$vec_IntoIter_u8(rt.byteVecIntoIter(rt.byteSliceToByteVec(bytes)), steps, out); + walk$vec_IntoIter_u8(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(bytes))), steps, out); } else if (_312 === 2) { walk$array_IntoIter_u8_3(rt.iterSlice(Uint8Array.of(at(3), at(4), at(5))), steps, out); } else if (_312 === 3) { @@ -2081,7 +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 deque: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterSlice(rt.byteSliceView(bytes)), undefined, 1, true), 1) as rt.VecDeque; + 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); @@ -2619,19 +2619,19 @@ export function fill$array275_u32_iter_Filter_iter_Map_ops_RangeInclusive_u32_hi rt.iterExtend(v, items, "next", 1100); len = v.length; } else if (coll === 2) { - const v2: rt.u32[][] = rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32, 1100); + const v2: rt.u32[][] = rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32); rt.iterExtend(v2, items, "next", 1100); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100), 1100) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100)) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32, 1100), 1100) as rt.VecDeque; + 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) { len = rt.heapFrom(rt.iterToArray(items, "next", 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32, 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); rt.heapExtend(h, items, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp)), "next", 1100); len = h.d.length; } else if (coll === 7) { @@ -2689,19 +2689,19 @@ export function fill$array275_u32_iter_Map_iter_Flatten_array_IntoIter_ops_Range rt.iterExtend(v, items, "next", 1100); len = v.length; } else if (coll === 2) { - const v2: rt.u32[][] = rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32, 1100); + const v2: rt.u32[][] = rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32); rt.iterExtend(v2, items, "next", 1100); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100), 1100) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100)) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32, 1100), 1100) as rt.VecDeque; + 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) { len = rt.heapFrom(rt.iterToArray(items, "next", 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32, 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); rt.heapExtend(h, items, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp)), "next", 1100); len = h.d.length; } else if (coll === 7) { @@ -2759,19 +2759,19 @@ export function fill$array275_u32_iter_Map_iter_Flatten_array_IntoIter_ops_Range rt.iterExtend(v, items, "next", 1100); len = v.length; } else if (coll === 2) { - const v2: rt.u32[][] = rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32, 1100); + const v2: rt.u32[][] = rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32); rt.iterExtend(v2, items, "next", 1100); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100), 1100) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100)) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32, 1100), 1100) as rt.VecDeque; + 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) { len = rt.heapFrom(rt.iterToArray(items, "next", 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32, 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); rt.heapExtend(h, items, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp)), "next", 1100); len = h.d.length; } else if (coll === 7) { @@ -2829,19 +2829,19 @@ export function fill$array275_u32_iter_Map_ops_RangeInclusive_u32_hints_typed_cl rt.iterExtend(v, items, undefined, 1100, true); len = v.length; } else if (coll === 2) { - const v2: rt.u32[][] = rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32, 1100); + const v2: rt.u32[][] = rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32); rt.iterExtend(v2, items, undefined, 1100, true); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 1100, true), 1100) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 1100, true)) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32, 1100), 1100) as rt.VecDeque; + 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) { len = rt.heapFrom(rt.iterToArray(items, undefined, 1100, true), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32, 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); rt.heapExtend(h, items, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp)), undefined, 1100, true); len = h.d.length; } else if (coll === 7) { @@ -2899,19 +2899,19 @@ export function fill$array275_u32_iter_Skip_iter_Map_ops_RangeInclusive_u32_hint rt.iterExtend(v, items, "next", 1100); len = v.length; } else if (coll === 2) { - const v2: rt.u32[][] = rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32, 1100); + const v2: rt.u32[][] = rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32); rt.iterExtend(v2, items, "next", 1100); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100), 1100) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100)) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32, 1100), 1100) as rt.VecDeque; + 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) { len = rt.heapFrom(rt.iterToArray(items, "next", 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32, 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); rt.heapExtend(h, items, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp)), "next", 1100); len = h.d.length; } else if (coll === 7) { @@ -2968,19 +2968,19 @@ export function fill$hints_Unit_iter_Filter_iter_Map_ops_RangeInclusive_u32_hint rt.iterExtend(v, items, "next", 0); len = v.length; } else if (coll === 2) { - const v2: hints_Unit.Unit[] = rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone, 0); + const v2: hints_Unit.Unit[] = rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone); rt.iterExtend(v2, items, "next", 0); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0), 0) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0)) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone, 0), 0) as rt.VecDeque; + 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) { len = rt.heapFrom(rt.iterToArray(items, "next", 0), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone, 0), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)); rt.heapExtend(h, items, rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd), "next", 0); len = h.d.length; } else if (coll === 7) { @@ -3037,19 +3037,19 @@ export function fill$hints_Unit_iter_Map_iter_Flatten_array_IntoIter_ops_RangeIn rt.iterExtend(v, items, "next", 0); len = v.length; } else if (coll === 2) { - const v2: hints_Unit.Unit[] = rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone, 0); + const v2: hints_Unit.Unit[] = rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone); rt.iterExtend(v2, items, "next", 0); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0), 0) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0)) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone, 0), 0) as rt.VecDeque; + 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) { len = rt.heapFrom(rt.iterToArray(items, "next", 0), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone, 0), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)); rt.heapExtend(h, items, rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd), "next", 0); len = h.d.length; } else if (coll === 7) { @@ -3106,19 +3106,19 @@ export function fill$hints_Unit_iter_Map_iter_Flatten_array_IntoIter_ops_RangeIn rt.iterExtend(v, items, "next", 0); len = v.length; } else if (coll === 2) { - const v2: hints_Unit.Unit[] = rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone, 0); + const v2: hints_Unit.Unit[] = rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone); rt.iterExtend(v2, items, "next", 0); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0), 0) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0)) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone, 0), 0) as rt.VecDeque; + 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) { len = rt.heapFrom(rt.iterToArray(items, "next", 0), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone, 0), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)); rt.heapExtend(h, items, rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd), "next", 0); len = h.d.length; } else if (coll === 7) { @@ -3175,19 +3175,19 @@ export function fill$hints_Unit_iter_Map_ops_RangeInclusive_u32_hints_typed_clos rt.iterExtend(v, items, undefined, 0, true); len = v.length; } else if (coll === 2) { - const v2: hints_Unit.Unit[] = rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone, 0); + const v2: hints_Unit.Unit[] = rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone); rt.iterExtend(v2, items, undefined, 0, true); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 0, true), 0) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 0, true)) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone, 0), 0) as rt.VecDeque; + 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) { len = rt.heapFrom(rt.iterToArray(items, undefined, 0, true), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone, 0), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)); rt.heapExtend(h, items, rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd), undefined, 0, true); len = h.d.length; } else if (coll === 7) { @@ -3244,19 +3244,19 @@ export function fill$hints_Unit_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_ rt.iterExtend(v, items, "next", 0); len = v.length; } else if (coll === 2) { - const v2: hints_Unit.Unit[] = rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone, 0); + const v2: hints_Unit.Unit[] = rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone); rt.iterExtend(v2, items, "next", 0); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0), 0) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0)) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone, 0), 0) as rt.VecDeque; + 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) { len = rt.heapFrom(rt.iterToArray(items, "next", 0), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone, 0), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)); rt.heapExtend(h, items, rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd), "next", 0); len = h.d.length; } else if (coll === 7) { @@ -3314,19 +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(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8, 16); + 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.dequeFromVec(rt.iterToArray(items, "next", 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16)) as rt.VecDeque<[rt.u64, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8, 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + 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(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8, 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]))); + 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) { @@ -3384,19 +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(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8, 16); + 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.dequeFromVec(rt.iterToArray(items, "next", 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16)) as rt.VecDeque<[rt.u64, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8, 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + 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(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8, 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]))); + 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) { @@ -3454,19 +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(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8, 16); + 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.dequeFromVec(rt.iterToArray(items, "next", 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16)) as rt.VecDeque<[rt.u64, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8, 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + 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(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8, 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]))); + 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) { @@ -3524,19 +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(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8, 16); + 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.dequeFromVec(rt.iterToArray(items, undefined, 16, true), 16) as rt.VecDeque<[rt.u64, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 16, true)) as rt.VecDeque<[rt.u64, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8, 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + 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(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8, 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]))); + 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) { @@ -3594,19 +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(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8, 16); + 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.dequeFromVec(rt.iterToArray(items, "next", 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16)) as rt.VecDeque<[rt.u64, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8, 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + 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(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8, 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]))); + 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) { @@ -3663,19 +3663,19 @@ export function fill$tuple3_u8_u8_u8_iter_Filter_iter_Map_ops_RangeInclusive_u32 rt.iterExtend(v, items, "next", 3); len = v.length; } else if (coll === 2) { - const v2: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined, 3); + const v2: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined); rt.iterExtend(v2, items, "next", 3); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined, 3), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; + 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) { len = rt.heapFrom(rt.iterToArray(items, "next", 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined, 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))); + const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))); rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), "next", 3); len = h.d.length; } else if (coll === 7) { @@ -3732,19 +3732,19 @@ export function fill$tuple3_u8_u8_u8_iter_Map_iter_Flatten_array_IntoIter_ops_Ra rt.iterExtend(v, items, "next", 3); len = v.length; } else if (coll === 2) { - const v2: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined, 3); + const v2: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined); rt.iterExtend(v2, items, "next", 3); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined, 3), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; + 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) { len = rt.heapFrom(rt.iterToArray(items, "next", 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined, 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))); + const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))); rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), "next", 3); len = h.d.length; } else if (coll === 7) { @@ -3801,19 +3801,19 @@ export function fill$tuple3_u8_u8_u8_iter_Map_iter_Flatten_array_IntoIter_ops_Ra rt.iterExtend(v, items, "next", 3); len = v.length; } else if (coll === 2) { - const v2: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined, 3); + const v2: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined); rt.iterExtend(v2, items, "next", 3); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined, 3), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; + 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) { len = rt.heapFrom(rt.iterToArray(items, "next", 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined, 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))); + const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))); rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), "next", 3); len = h.d.length; } else if (coll === 7) { @@ -3870,19 +3870,19 @@ export function fill$tuple3_u8_u8_u8_iter_Map_ops_RangeInclusive_u32_hints_typed rt.iterExtend(v, items, undefined, 3, true); len = v.length; } else if (coll === 2) { - const v2: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined, 3); + const v2: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined); rt.iterExtend(v2, items, undefined, 3, true); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 3, true), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).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 q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined, 3), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; + 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) { len = rt.heapFrom(rt.iterToArray(items, undefined, 3, true), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined, 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))); + const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))); rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), undefined, 3, true); len = h.d.length; } else if (coll === 7) { @@ -3939,19 +3939,19 @@ export function fill$tuple3_u8_u8_u8_iter_Skip_iter_Map_ops_RangeInclusive_u32_h rt.iterExtend(v, items, "next", 3); len = v.length; } else if (coll === 2) { - const v2: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined, 3); + const v2: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined); rt.iterExtend(v2, items, "next", 3); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined, 3), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; + 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) { len = rt.heapFrom(rt.iterToArray(items, "next", 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined, 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))); + const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))); rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), "next", 3); len = h.d.length; } else if (coll === 7) { @@ -4008,19 +4008,19 @@ export function fill$u32_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed rt.iterExtend(v, items, "next", 4); len = v.length; } else if (coll === 2) { - const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined, 4); + const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined); rt.iterExtend(v2, items, "next", 4); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4), 4) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4)) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined, 4), 4) as rt.VecDeque; + 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) { len = rt.heapFrom(rt.iterToArray(items, "next", 4), rt.le, rt.ge, rt.lt).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined, 4), rt.le, rt.ge, rt.lt); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.le, rt.ge, rt.lt); rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 4); len = h.d.length; } else if (coll === 7) { @@ -4077,19 +4077,19 @@ export function fill$u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive rt.iterExtend(v, items, "next", 4); len = v.length; } else if (coll === 2) { - const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined, 4); + const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined); rt.iterExtend(v2, items, "next", 4); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4), 4) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4)) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined, 4), 4) as rt.VecDeque; + 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) { len = rt.heapFrom(rt.iterToArray(items, "next", 4), rt.le, rt.ge, rt.lt).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined, 4), rt.le, rt.ge, rt.lt); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.le, rt.ge, rt.lt); rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 4); len = h.d.length; } else if (coll === 7) { @@ -4146,19 +4146,19 @@ export function fill$u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive rt.iterExtend(v, items, "next", 4); len = v.length; } else if (coll === 2) { - const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined, 4); + const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined); rt.iterExtend(v2, items, "next", 4); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4), 4) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4)) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined, 4), 4) as rt.VecDeque; + 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) { len = rt.heapFrom(rt.iterToArray(items, "next", 4), rt.le, rt.ge, rt.lt).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined, 4), rt.le, rt.ge, rt.lt); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.le, rt.ge, rt.lt); rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 4); len = h.d.length; } else if (coll === 7) { @@ -4215,19 +4215,19 @@ export function fill$u32_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u3 rt.iterExtend(v, items, undefined, 4, true); len = v.length; } else if (coll === 2) { - const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined, 4); + const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined); rt.iterExtend(v2, items, undefined, 4, true); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 4, true), 4) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 4, true)) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined, 4), 4) as rt.VecDeque; + 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) { len = rt.heapFrom(rt.iterToArray(items, undefined, 4, true), rt.le, rt.ge, rt.lt).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined, 4), rt.le, rt.ge, rt.lt); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.le, rt.ge, rt.lt); rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, undefined, 4, true); len = h.d.length; } else if (coll === 7) { @@ -4284,19 +4284,19 @@ export function fill$u32_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_c rt.iterExtend(v, items, "next", 4); len = v.length; } else if (coll === 2) { - const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined, 4); + const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined); rt.iterExtend(v2, items, "next", 4); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4), 4) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4)) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined, 4), 4) as rt.VecDeque; + 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) { len = rt.heapFrom(rt.iterToArray(items, "next", 4), rt.le, rt.ge, rt.lt).d.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined, 4), rt.le, rt.ge, rt.lt); + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.le, rt.ge, rt.lt); rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 4); len = h.d.length; } else if (coll === 7) { @@ -4357,9 +4357,9 @@ export function fill$u8_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_ rt.iterExtendBytes(v2, items, "next"); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1), 1) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1)) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2)), 1) as rt.VecDeque; + 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) { @@ -4426,9 +4426,9 @@ export function fill$u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_ rt.iterExtendBytes(v2, items, "next"); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1), 1) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1)) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2)), 1) as rt.VecDeque; + 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) { @@ -4495,9 +4495,9 @@ export function fill$u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_ rt.iterExtendBytes(v2, items, "next"); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1), 1) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1)) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2)), 1) as rt.VecDeque; + 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) { @@ -4564,9 +4564,9 @@ export function fill$u8_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u8_ rt.iterExtendBytes(v2, items, undefined, true); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 1, true), 1) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 1, true)) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2)), 1) as rt.VecDeque; + 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) { @@ -4633,9 +4633,9 @@ export function fill$u8_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_cl rt.iterExtendBytes(v2, items, "next"); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1), 1) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1)) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2)), 1) as rt.VecDeque; + 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) { diff --git a/ts/fixtures/lang/expected/holds.ts b/ts/fixtures/lang/expected/holds.ts index ec59aaae9..234798d63 100644 --- a/ts/fixtures/lang/expected/holds.ts +++ b/ts/fixtures/lang/expected/holds.ts @@ -112,7 +112,7 @@ export function indexed(data: rt.ByteSlice, out: rt.ByteVec): void { rt.idx(data, _9); i = rt.usizeAdd(i, 1); rt.byteVecPush(out, data.data[data.start + _9]); - rt.vecPush(kept, data.data[data.start + _9], 4); + kept.push(data.data[data.start + _9]); } rt.iterExtendBytes(out, rt.iterSlice(kept), undefined, true); const v: rt.ByteVec = rt.byteSliceToByteVec(data); @@ -123,7 +123,7 @@ export function indexed(data: rt.ByteSlice, out: rt.ByteVec): void { const _31: rt.u8 = rt.u8WrappingAdd(v.data[at], i2 & 0xff); v.data[at] = _31; } - rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); } /** @@ -145,7 +145,7 @@ export function reborrows(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVe const s2: rt.u8 = r2; r2 = _25; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(s2, r2)), undefined, true); - rt.vecPush(kept, s2, 4); + kept.push(s2); } rt.iterExtendBytes(out, rt.iterSlice(kept), undefined, true); } @@ -160,7 +160,7 @@ export function copies(a: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { for (const _9 of rt.byteSliceView(data)) { const s: rt.u8 = r; r = _9; - rt.vecPush(kept, s, 4); + kept.push(s); } rt.iterExtendBytes(out, rt.iterSlice(kept), undefined, true); const range: rt.Range = new rt.Range(0, data.length); @@ -198,9 +198,9 @@ export function closures(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec const v: rt.ByteVec = rt.byteSliceToByteVec(data); const fs: Array<() => rt.u8> = []; for (const _17 of rt.byteSliceView(data)) { - rt.vecPush(fs, (): rt.u8 => { + fs.push((): rt.u8 => { return _17; - }, 8); + }); } const _28: rt.usize = v.length; let iterStart: rt.usize = 0; @@ -210,7 +210,7 @@ export function closures(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec const _39: () => rt.u8 = (): rt.u8 => { return rt.u8WrappingAdd(v.data[at], 1); }; - rt.vecPush(fs, _39, 8); + fs.push(_39); } const _43: rt.usize = rt.byteSliceFrom(arr).length; let rangeStart: rt.usize = 0; @@ -220,9 +220,9 @@ export function closures(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec if (!(i2 < 8)) { rt.panic("index out of bounds: the len is " + 8 + " but the index is " + i2); } - rt.vecPush(fs, (): rt.u8 => { + fs.push((): rt.u8 => { return arr[i2]; - }, 8); + }); } const iter3: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); while (true) { @@ -234,7 +234,7 @@ export function closures(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec const _68: () => rt.u8 = (): rt.u8 => { return rt.u8WrappingAdd(_61[1], captured & 0xff); }; - rt.vecPush(fs, _68, 8); + fs.push(_68); } const itS: Row.Row[] = rows; let itI: number = 0; @@ -242,9 +242,9 @@ export function closures(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec const _74: Row.Row | rt.Done = itI < itS.length ? itS[itI++] : rt.DONE; if (_74 !== rt.DONE) { const cells: rt.ByteSlice = rt.byteSliceFrom(_74.cells); - rt.vecPush(fs, (): rt.u8 => { + fs.push((): rt.u8 => { return cells.data[cells.start + 1]; - }, 8); + }); } else { break; } @@ -259,9 +259,9 @@ export function closures(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _96); } const captured2 = n; - rt.vecPush(fs, (): rt.u8 => { + fs.push((): rt.u8 => { return rows[_96].cells[0] ^ captured2; - }, 8); + }); } for (const _111 of fs) { rt.byteVecPush(out, _111()); diff --git a/ts/fixtures/lang/expected/ints.ts b/ts/fixtures/lang/expected/ints.ts index 9cc383c5f..49b37a30a 100644 --- a/ts/fixtures/lang/expected/ints.ts +++ b/ts/fixtures/lang/expected/ints.ts @@ -2869,7 +2869,7 @@ export function edges(max: rt.u128, min: rt.u128, bits: rt.usize, radix: rt.u32) if (_193 === rt.DONE) { break; } - rt.vecPush(all, _193, 12); + all.push(_193); } const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCharDisplay(stray, f)]; const _203: string = rt.fmtFormat(["1", args22[0]]); diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index 215f20f4d..d21d32c91 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -169,10 +169,10 @@ export function chunksByZero$iters_ChunksByZero_slice_u8(self: rt.ByteSlice): rt } else { const taken = word; word = new rt.ByteVec(); - rt.vecPush(words, taken, 12); + words.push(taken); } } - rt.vecPush(words, word, 12); + words.push(word); return words; } @@ -340,12 +340,12 @@ export function reducers(data: rt.ByteSlice, out: rt.ByteVec): void { }), 204, (v: rt.ByteVec): rt.u8 => { return v.length & 0xff; })); - rt.iterExtendBytes(out, rt.byteVecIntoIter(option_unwrapOrDefault$0wx44sw(rt.iterReduce(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_23: rt.u8): rt.ByteVec => { + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(option_unwrapOrDefault$0wx44sw(rt.iterReduce(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_23: rt.u8): rt.ByteVec => { return rt.byteVecFrom(Uint8Array.of(_23)); }), (a4: rt.ByteVec, b7: rt.ByteVec): rt.ByteVec => { - rt.iterExtendBytes(a4, rt.byteVecIntoIter(b7), undefined, true); + rt.iterExtendBytes(a4, rt.iterSlice(rt.byteVecView(b7)), undefined, true); return a4; - }))), undefined, true); + })))), undefined, true); const it: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(data))); const _38: rt.Place | undefined = rt.peekablePeekMut(it, true); if (_38 !== undefined) { @@ -367,7 +367,7 @@ export function reducers(data: rt.ByteSlice, out: rt.ByteVec): void { if (_73 !== undefined) { rt.byteVecPush(_73, 153); } - rt.iterExtendBytes(out, rt.byteVecIntoIter(option_unwrapOrDefault$0wx44sw(rt.iterToOption(words.next()))), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(option_unwrapOrDefault$0wx44sw(rt.iterToOption(words.next())))), undefined, true); const _87: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(first)); rt.byteVecPush(out, option_mapOr$1a3irjf(rt.peekableNextIfEq(words, _87, rt.eqBytes), 136, (w: rt.ByteVec): rt.u8 => { return w.data[rt.idx(w, 0)]; @@ -380,8 +380,8 @@ export function reducers(data: rt.ByteSlice, out: rt.ByteVec): void { if (_94 !== undefined) { _94.v = 119; } - rt.iterExtendBytes(out, rt.byteVecIntoIter(bytes), undefined, true); - rt.iterExtendBytes(out, rt.byteVecIntoIter(log), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(log)), undefined, true); } export function eq$cmp_PartialEq_iters_Quarter_u8(self: rt.u8, other: Quarter.Quarter): boolean { @@ -422,14 +422,14 @@ export function peekedOthers(data: rt.ByteSlice, out: rt.ByteVec): void { }); }; const _159: (a0: rt.u8) => rt.u16[] = (b2: rt.u8): rt.u16[] => { - return rt.vecFromElem((((rt.u8Rem(b2, 2) as rt.u16)) << 9) & 0xffff, rt.u8Rem(b2, 3) as rt.usize, undefined, 2); + return rt.vecFromElem((((rt.u8Rem(b2, 2) as rt.u16)) << 9) & 0xffff, rt.u8Rem(b2, 3) as rt.usize, undefined); }; const words: string[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): string => { return _3(_2); }), 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)); @@ -567,7 +567,7 @@ export function peekedOthers(data: rt.ByteSlice, out: rt.ByteVec): void { }), 170, (b9: rt.Place): rt.u8 => { return b9.v; })); - rt.iterExtendBytes(out, rt.byteVecIntoIter(bytes), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); const it11: rt.Peekable = rt.iterPeekable(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): Quarter.Quarter => { return { _0: _210, _1: calls }; })); @@ -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); @@ -1990,9 +1990,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2299[0] as rt.u32, _2299[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_41 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z, (_2298: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z, (_2298: [rt.u8, rt.u8]): rt.u8 => { return _2298[0] ^ _2298[1]; - }), undefined, true)), undefined, true); + }), undefined, true))), undefined, true); } else if (_41 === 5) { rt.byteVecPush(out, rt.iterFold(z, 0, (acc7: rt.u8, p20: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc7, 3) ^ _40(p20); @@ -2179,9 +2179,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2268[0] as rt.u32, _2268[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_202 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z3, (_2267: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z3, (_2267: [rt.u8, rt.u8]): rt.u8 => { return _2267[0] ^ _2267[1]; - }), undefined, true)), undefined, true); + }), undefined, true))), undefined, true); } else if (_202 === 5) { rt.byteVecPush(out, rt.iterFold(z3, 0, (acc6: rt.u8, p18: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc6, 3) ^ _201(p18); @@ -2366,9 +2366,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2237[0] as rt.u32, _2237[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_381 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z5, (_2236: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z5, (_2236: [rt.u8, rt.u8]): rt.u8 => { return _2236[0] ^ _2236[1]; - }), undefined, true)), undefined, true); + }), undefined, true))), undefined, true); } else if (_381 === 5) { rt.byteVecPush(out, rt.iterFold(z5, 0, (acc5: rt.u8, p16: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc5, 3) ^ _380(p16); @@ -2526,12 +2526,12 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_28 === 2) { if (!other) { if ((kind & 16) === 0) { - const z7: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x138: rt.u8): rt.u8 => { + const z7: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x138: rt.u8): rt.u8 => { const _6178: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6178.value, x138 ^ 7); rt.refMutRelease(_6178); return x138; - }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x139: rt.u8): rt.u8 => { + }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x139: rt.u8): rt.u8 => { const _6179: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6179.value, x139 ^ 8); rt.refMutRelease(_6179); @@ -2553,9 +2553,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2206[0] as rt.u32, _2206[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_574 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVecInPlace(rt.iterMap(z7, (_2205: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z7, (_2205: [rt.u8, rt.u8]): rt.u8 => { return _2205[0] ^ _2205[1]; - }), 1, false, undefined, true)), undefined, true); + }), undefined, true))), undefined, true); } else if (_574 === 5) { rt.byteVecPush(out, rt.iterFold(z7, 0, (acc4: rt.u8, p14: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc4, 3) ^ _573(p14); @@ -2588,12 +2588,12 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else { const _612: rt.usize = rt.usizeRem(data.length, 8); if (_612 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x135: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x135: rt.u8): rt.u8 => { const _6176: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6176.value, x135 ^ 7); rt.refMutRelease(_6176); return x135; - }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x136: rt.u8): rt.u8 => { + }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x136: rt.u8): rt.u8 => { const _6177: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6177.value, x136 ^ 8); rt.refMutRelease(_6177); @@ -2602,12 +2602,12 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u8Rem(_2198[0], 2) === 0; })) & 0xff); } else if (_612 === 1) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilterMap(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x132: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterFilterMap(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x132: rt.u8): rt.u8 => { const _6174: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6174.value, x132 ^ 7); rt.refMutRelease(_6174); return x132; - }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x133: rt.u8): rt.u8 => { + }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x133: rt.u8): rt.u8 => { const _6175: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6175.value, x133 ^ 8); rt.refMutRelease(_6175); @@ -2616,12 +2616,12 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u8CheckedSub(_2197[0], _2197[1]); })) & 0xff); } else if (_612 === 2) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkipWhile(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x129: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterSkipWhile(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x129: rt.u8): rt.u8 => { const _6172: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6172.value, x129 ^ 7); rt.refMutRelease(_6172); return x129; - }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x130: rt.u8): rt.u8 => { + }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x130: rt.u8): rt.u8 => { const _6173: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6173.value, x130 ^ 8); rt.refMutRelease(_6173); @@ -2630,12 +2630,12 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return _2196[0] < 128; })) & 0xff); } else if (_612 === 3) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(rt.iterMap(rt.iterEnumerate(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x127: rt.u8): rt.u8 => { + rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(rt.iterMap(rt.iterEnumerate(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x127: rt.u8): rt.u8 => { const _6170: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6170.value, x127 ^ 7); rt.refMutRelease(_6170); return x127; - }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x128: rt.u8): rt.u8 => { + }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x128: rt.u8): rt.u8 => { const _6171: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6171.value, x128 ^ 8); rt.refMutRelease(_6171); @@ -2644,48 +2644,48 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return _2195[0] & 0xff; })), 238)); } else if (_612 === 4) { - rt.byteVecPush(out, rt.iterCount(rt.iterChain(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x125: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterChain(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x125: rt.u8): rt.u8 => { const _6168: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6168.value, x125 ^ 7); rt.refMutRelease(_6168); return x125; - }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x126: rt.u8): rt.u8 => { + }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x126: rt.u8): rt.u8 => { const _6169: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6169.value, x126 ^ 8); rt.refMutRelease(_6169); return x126; }), "len"), rt.iterSlice([[1, 2] as [rt.u8, rt.u8]]))) & 0xff); } else if (_612 === 5) { - rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x123: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x123: rt.u8): rt.u8 => { const _6166: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6166.value, x123 ^ 7); rt.refMutRelease(_6166); return x123; - }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x124: rt.u8): rt.u8 => { + }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x124: rt.u8): rt.u8 => { const _6167: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6167.value, x124 ^ 8); rt.refMutRelease(_6167); return x124; }), "len"), n)) & 0xff); } else if (_612 === 6) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x121: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x121: rt.u8): rt.u8 => { const _6164: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6164.value, x121 ^ 7); rt.refMutRelease(_6164); return x121; - }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x122: rt.u8): rt.u8 => { + }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x122: rt.u8): rt.u8 => { const _6165: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6165.value, x122 ^ 8); rt.refMutRelease(_6165); return x122; }), "len"), n)) & 0xff); } else { - const p4: rt.Peekable<[rt.u8, rt.u8]> = rt.iterPeekable(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x119: rt.u8): rt.u8 => { + const p4: rt.Peekable<[rt.u8, rt.u8]> = rt.iterPeekable(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x119: rt.u8): rt.u8 => { const _6162: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6162.value, x119 ^ 7); rt.refMutRelease(_6162); return x119; - }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x120: rt.u8): rt.u8 => { + }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x120: rt.u8): rt.u8 => { const _6163: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6163.value, x120 ^ 8); rt.refMutRelease(_6163); @@ -2695,7 +2695,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } } else if ((kind & 16) === 0) { - const z9: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x107: rt.u8): rt.u8 => { + const z9: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x107: rt.u8): rt.u8 => { const _6158: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6158.value, x107 ^ 9); rt.refMutRelease(_6158); @@ -2723,9 +2723,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2193[0] as rt.u32, _2193[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_751 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVecInPlace(rt.iterMap(z9, (_2192: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z9, (_2192: [rt.u8, rt.u8]): rt.u8 => { return _2192[0] ^ _2192[1]; - }), 1, false, undefined, true)), undefined, true); + }), undefined, true))), undefined, true); } else if (_751 === 5) { rt.byteVecPush(out, rt.iterFold(z9, 0, (acc3: rt.u8, p12: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc3, 3) ^ _750(p12); @@ -2758,7 +2758,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else { const _789: rt.usize = rt.usizeRem(data.length, 8); if (_789 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x104: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x104: rt.u8): rt.u8 => { const _6156: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6156.value, x104 ^ 9); rt.refMutRelease(_6156); @@ -2773,7 +2773,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u8Rem(_2184[0], 2) === 0; })) & 0xff); } else if (_789 === 1) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilterMap(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x101: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterFilterMap(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x101: rt.u8): rt.u8 => { const _6154: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6154.value, x101 ^ 9); rt.refMutRelease(_6154); @@ -2788,7 +2788,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u8CheckedSub(_2182[0], _2182[1]); })) & 0xff); } else if (_789 === 2) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkipWhile(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x98: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterSkipWhile(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x98: rt.u8): rt.u8 => { const _6152: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6152.value, x98 ^ 9); rt.refMutRelease(_6152); @@ -2803,7 +2803,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return _2180[0] < 128; })) & 0xff); } else if (_789 === 3) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(rt.iterMap(rt.iterEnumerate(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x96: rt.u8): rt.u8 => { + rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(rt.iterMap(rt.iterEnumerate(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x96: rt.u8): rt.u8 => { const _6150: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6150.value, x96 ^ 9); rt.refMutRelease(_6150); @@ -2818,7 +2818,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return _2178[0] & 0xff; })), 238)); } else if (_789 === 4) { - rt.byteVecPush(out, rt.iterCount(rt.iterChain(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x94: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterChain(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x94: rt.u8): rt.u8 => { const _6148: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6148.value, x94 ^ 9); rt.refMutRelease(_6148); @@ -2831,7 +2831,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return x95; }), "len"), rt.iterSlice([[1, 2] as [rt.u8, rt.u8]]))) & 0xff); } else if (_789 === 5) { - rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x92: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x92: rt.u8): rt.u8 => { const _6146: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6146.value, x92 ^ 9); rt.refMutRelease(_6146); @@ -2844,7 +2844,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return x93; }), "len"), n)) & 0xff); } else if (_789 === 6) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x90: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x90: rt.u8): rt.u8 => { const _6144: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6144.value, x90 ^ 9); rt.refMutRelease(_6144); @@ -2857,7 +2857,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return x91; }), "len"), n)) & 0xff); } else { - const p5: rt.Peekable<[rt.u8, rt.u8]> = rt.iterPeekable(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x88: rt.u8): rt.u8 => { + const p5: rt.Peekable<[rt.u8, rt.u8]> = rt.iterPeekable(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x88: rt.u8): rt.u8 => { const _6142: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6142.value, x88 ^ 9); rt.refMutRelease(_6142); @@ -2905,9 +2905,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2171[0] as rt.u32, _2171[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_927 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z11, (_2170: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z11, (_2170: [rt.u8, rt.u8]): rt.u8 => { return _2170[0] ^ _2170[1]; - }), "next")), undefined, true); + }), "next"))), undefined, true); } else if (_927 === 5) { rt.byteVecPush(out, rt.iterFold(z11, 0, (acc2: rt.u8, p10: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc2, 3) ^ _926(p10); @@ -3116,9 +3116,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2131[0] as rt.u32, _2131[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_1102 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z13, (_2130: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z13, (_2130: [rt.u8, rt.u8]): rt.u8 => { return _2130[0] ^ _2130[1]; - }), undefined, true)), undefined, true); + }), undefined, true))), undefined, true); } else if (_1102 === 5) { rt.byteVecPush(out, rt.iterFold(z13, 0, (acc: rt.u8, p8: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc, 3) ^ _1101(p8); @@ -4610,7 +4610,7 @@ export function adapted(a: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const v: rt.ByteVec = new rt.ByteVec(); const _22: rt.Iter = rt.iterTake(new rt.RangeFrom(lo, rt.u8Step), 3); rt.iterExtendBytes(v, _22, undefined, true); - rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); rt.iterExtendBytes(out, rt.iterTake(rt.iterFlatten(rt.iterSlice([new rt.RangeFrom(lo, rt.u8Step), new rt.RangeFrom(rt.u8Div(b, 2), rt.u8Step)])), 5), "next"); rt.iterExtendBytes(out, rt.iterTake(rt.iterFlatMap(it(), (x: rt.u8): rt.RangeFrom => { return new rt.RangeFrom(rt.u8Div(x, 4), rt.u8Step); @@ -4625,7 +4625,7 @@ export function adapted(a: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterMap(rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _54, true, undefined, undefined, undefined, 8, true)), (_24: [rt.u8, rt.usize]): rt.u8 => { return _24[0] ^ (_24[1] & 0xff); }), undefined, true); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterTake(rt.iterStepBy(new rt.RangeFrom(lo, rt.u8Step), 3), 4), "next")), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterTake(rt.iterStepBy(new rt.RangeFrom(lo, rt.u8Step), 3), 4), "next"))), undefined, true); rt.iterExtendBytes(out, rt.strBytes(rt.stringExtendChars("", rt.iterTake(new rt.RangeFrom(97, rt.charStep), rt.usizeRem(n, 6)))), undefined, true); const _77: [rt.usize, rt.usize | undefined] = rt.iterZip(it(), new rt.RangeFrom(lo, rt.u8Step), "len").sizeHint(); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_77[0] & 0xff, option_mapOr$02k4ito(_77[1], 238, (h: rt.usize): rt.u8 => { @@ -4691,7 +4691,7 @@ export function overflowed(a: rt.u8, _dataData: Uint8Array, _dataStart: number, return c & 0xff; })); } else { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(new rt.RangeFrom(top, rt.u8Step), undefined, true)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(new rt.RangeFrom(top, rt.u8Step), undefined, true))), undefined, true); } } diff --git a/ts/fixtures/lang/expected/joins.ts b/ts/fixtures/lang/expected/joins.ts index 5576b06a5..3c10edf32 100644 --- a/ts/fixtures/lang/expected/joins.ts +++ b/ts/fixtures/lang/expected/joins.ts @@ -125,9 +125,9 @@ 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 rt.vecIntoBoxed(a016); + return a016; }), undefined, 8, true); wides(rt.slicesJoin(boxed2, 2), out); wides(rt.slicesJoin(boxed2, 2, [sep2]), out); @@ -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); @@ -235,10 +235,10 @@ export function joins(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.strsJoin(texts, "--")); } else { const big: rt.ByteVec = rt.byteVecOf(1, 1 << 16); - const wide4: rt.u16[] = rt.vecFromElem(1, 1 << 16, undefined, 2); + const wide4: rt.u16[] = rt.vecFromElem(1, 1 << 16, undefined); const text_: string = text(rt.byteVecSlice(big)); const refs: (a0: rt.usize) => rt.ByteSlice[] = (n: rt.usize): rt.ByteSlice[] => { - return rt.vecFromElem(rt.byteSliceRange(rt.byteVecSlice(big), 0), n, undefined, 8); + return rt.vecFromElem(rt.byteSliceRange(rt.byteVecSlice(big), 0), n, undefined); }; const _512: rt.u8 = rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0), 7); if (_512 === 0) { @@ -248,17 +248,17 @@ export function joins(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_512 === 2) { bytes(rt.byteSlicesJoin(refs(rt.usizeAdd(1 << 14, 1)), rt.byteSliceRange(rt.byteVecSlice(big), 0)), out); } else if (_512 === 3) { - wides(rt.slicesJoin(rt.vecFromElem(rt.sliceRange(wide4, 0), rt.usizeAdd(1 << 14, 1), undefined, 8), 2), out); + wides(rt.slicesJoin(rt.vecFromElem(rt.sliceRange(wide4, 0), rt.usizeAdd(1 << 14, 1), undefined), 2), out); } else if (_512 === 4) { - fmt_put(out, rt.strsJoin(rt.vecFromElem(text_, rt.usizeAdd(1 << 15, 1), undefined, 8), "")); + fmt_put(out, rt.strsJoin(rt.vecFromElem(text_, rt.usizeAdd(1 << 15, 1), undefined), "")); } else if (_512 === 5) { - fmt_put(out, rt.strsJoin(rt.vecFromElem(text_, rt.usizeAdd(1 << 16, 1), undefined, 8), "")); + fmt_put(out, rt.strsJoin(rt.vecFromElem(text_, rt.usizeAdd(1 << 16, 1), undefined), "")); } else { const sep5: Sentinel.Sentinel[] = rt.iterToArray(rt.iterMap(new rt.Range(0, 1 << 16), (i: rt.i32): Sentinel.Sentinel => { return { _0: (i & 0xff) ^ 90 }; }), undefined, 1, true); const _597: Sentinel.Sentinel[] = []; - rt.slicesJoin(rt.vecFromElem(_597, rt.usizeAdd(1 << 16, 1), undefined, 8), 1, rt.sliceRange(sep5, 0), undefined, Sentinel.clone$Clone); + rt.slicesJoin(rt.vecFromElem(_597, rt.usizeAdd(1 << 16, 1), undefined), 1, rt.sliceRange(sep5, 0), undefined, Sentinel.clone$Clone); } } } diff --git a/ts/fixtures/lang/expected/keys.ts b/ts/fixtures/lang/expected/keys.ts index b609adb3d..acc506612 100644 --- a/ts/fixtures/lang/expected/keys.ts +++ b/ts/fixtures/lang/expected/keys.ts @@ -1126,7 +1126,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void if (_120 === rt.DONE) { break; } - rt.vecPush(entries, [rt.byteSliceToArray(_120[0]), _120[1]] as [Uint8Array, rt.u8], 3); + entries.push([rt.byteSliceToArray(_120[0]), _120[1]] as [Uint8Array, rt.u8]); } rt.sliceSort(entries, rt.cmpLt(rt.cmpTuple<[Uint8Array, rt.u8], rt.Ordering | undefined>([rt.cmpBytes, rt.cmp]))); for (const _136 of entries) { @@ -1447,8 +1447,8 @@ export function lentValues(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo rt.hashInsert(map, rt.u8Rem(_11.data[_11.start], 8), copy$array_u8(value)); rt.idx(_11, 1); rt.btreeInsert(tree, rt.u8Rem(_11.data[_11.start + 1], 8), copy$array_u8(value)); - rt.dequePushBack(deque, copy$array_u8(value), 2); - rt.heapPush(heap, copy$array_u8(value), rt.cmpLe(rt.cmpBytes), 2); + rt.dequePushBack(deque, copy$array_u8(value)); + rt.heapPush(heap, copy$array_u8(value), rt.cmpLe(rt.cmpBytes)); } const at: rt.u8 = rt.u8Rem(kind, 8); rt.iterExtendBytes(out, rt.iterSlice(option_mapOr$0z7fb2w(rt.optionMap(rt.hashGet(map, at), rt.byteSliceFrom), rt.bytes(2).fill(221), (v2: rt.ByteSlice): Uint8Array => { @@ -1797,7 +1797,7 @@ export function keyed$Option_u8_2_keys_arrays_closure5(data: rt.ByteSlice, make: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -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); @@ -2053,7 +2053,7 @@ export function keyed$bool_2_keys_arrays_closure4(data: rt.ByteSlice, make: (a0: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -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); @@ -2308,7 +2308,7 @@ export function keyed$char_2_keys_arrays_closure3(data: rt.ByteSlice, make: (a0: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -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); @@ -2564,7 +2564,7 @@ export function keyed$i32_2_keys_arrays_closure2(data: rt.ByteSlice, make: (a0: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -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); @@ -2819,7 +2819,7 @@ export function keyed$keys_Hop_2_keys_arrays_closure6(data: rt.ByteSlice, make: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -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); @@ -3075,7 +3075,7 @@ export function keyed$u16_2_keys_arrays_closure0(data: rt.ByteSlice, make: (a0: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -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); @@ -3331,7 +3331,7 @@ export function keyed$u32_0_keys_arrays_closure7(data: rt.ByteSlice, make: (a0: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -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); @@ -3587,7 +3587,7 @@ export function keyed$u32_275_keys_arrays_closure8(data: rt.ByteSlice, make: (a0 rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -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); @@ -3843,7 +3843,7 @@ export function keyed$u64_2_keys_arrays_closure1(data: rt.ByteSlice, make: (a0: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -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)) { @@ -4176,7 +4176,7 @@ export function taken$0_keys_byte_refs_closure1(data: rt.ByteSlice, make: (a0: r const _332: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_332.value, counted2); rt.refMutRelease(_332); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.refCellReplace(log, new rt.ByteVec())), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.refCellReplace(log, new rt.ByteVec()))), undefined, true); const lent: [rt.ByteSlice, rt.ByteSlice][] = rt.iterToArray(rt.iterMap(rt.iterLend(rt.hashIter(map), (held20): [rt.ByteSlice, rt.ByteSlice] => { return [rt.byteSliceFrom(held20[0]), rt.byteSliceFrom(held20[1])]; }), (_23: [rt.ByteSlice, rt.ByteSlice]): [rt.ByteSlice, rt.ByteSlice] => { @@ -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)) { @@ -4477,7 +4477,7 @@ export function taken$2_keys_byte_refs_closure0(data: rt.ByteSlice, make: (a0: r const _332: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_332.value, counted2); rt.refMutRelease(_332); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.refCellReplace(log, new rt.ByteVec())), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.refCellReplace(log, new rt.ByteVec()))), undefined, true); const lent: [rt.ByteSlice, rt.ByteSlice][] = rt.iterToArray(rt.iterMap(rt.iterLend(rt.hashIter(map), (held20): [rt.ByteSlice, rt.ByteSlice] => { return [rt.byteSliceFrom(held20[0]), rt.byteSliceFrom(held20[1])]; }), (_23: [rt.ByteSlice, rt.ByteSlice]): [rt.ByteSlice, rt.ByteSlice] => { diff --git a/ts/fixtures/lang/expected/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/lists.ts b/ts/fixtures/lang/expected/lists.ts index 33a583b7e..c553e8c4b 100644 --- a/ts/fixtures/lang/expected/lists.ts +++ b/ts/fixtures/lang/expected/lists.ts @@ -115,10 +115,10 @@ export function lists(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (_13 === 11) { l = rt.replaceIn(m, l); } else { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.listExtractIfMut(l, (x5: rt.Place): boolean => { + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.listExtractIfMut(l, (x5: rt.Place): boolean => { x5.v = rt.u8WrappingAdd(x5.v, 1); return rt.u8Rem(x5.v, 3) === 0; - }), "next")), undefined, true); + }), "next"))), undefined, true); } } } @@ -193,7 +193,7 @@ export function edges(data: rt.ByteSlice, out: rt.ByteVec): void { const _64: rt.LinkedList = rt.listClone(whole, undefined); rt.listAppend(from, _64); const _68: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(7, 8)); - rt.listExtend(from, rt.byteVecIntoIter(_68)); + rt.listExtend(from, rt.iterSlice(rt.byteVecView(_68))); items(from, out); const _75: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): [rt.u8, rt.u8] => { const b: rt.u8 = _2; diff --git a/ts/fixtures/lang/expected/locals.ts b/ts/fixtures/lang/expected/locals.ts index 93a7811eb..3ce07f5df 100644 --- a/ts/fixtures/lang/expected/locals.ts +++ b/ts/fixtures/lang/expected/locals.ts @@ -61,9 +61,9 @@ export function locals(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, ((a0: rt.Cell): rt.u32 => { return a0.v; })(COUNT.get()) & 0xff); - rt.iterExtendBytes(out, rt.byteVecIntoIter(withBorrow$1k8k9m1(LOG, (log2: rt.ByteVec): rt.ByteVec => { + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(withBorrow$1k8k9m1(LOG, (log2: rt.ByteVec): rt.ByteVec => { return rt.byteVecFrom(rt.byteVecView(log2)); - })), undefined, true); + }))), undefined, true); rt.byteVecPush(out, ((p: locals_Polling.Polling): rt.u8 => { return option_mapOr$0ucbp7g(copy$Option_tuple2_u64_u64(p.current.v), 253, (_2: [rt.u64, rt.u64]): rt.u8 => { return rt.u64Low(_2[0]) & 0xff; @@ -165,9 +165,9 @@ export function locals(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, withBorrow$0r4ucls(LOG, (log4: rt.ByteVec): rt.u8 => { return log4.length & 0xff; })); - rt.iterExtendBytes(out, rt.byteVecIntoIter(replace$1xk72wn(LOG, rt.byteVecFrom(Uint8Array.of(op)))), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(replace$1xk72wn(LOG, rt.byteVecFrom(Uint8Array.of(op))))), undefined, true); rt.localKeyRefCellSet(LOG, rt.byteVecFrom(Uint8Array.of(op, op))); - rt.iterExtendBytes(out, rt.byteVecIntoIter(local_take$122f15k(LOG)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(local_take$122f15k(LOG))), undefined, true); rt.localKeyRefCellSet(LOG, rt.byteVecFrom(Uint8Array.of(1, 2, 3))); const _141: rt.LocalKey> = HELD; const _144: rt.Arc> = rt.arcClone(log); diff --git a/ts/fixtures/lang/expected/nested.ts b/ts/fixtures/lang/expected/nested.ts index 42767b99e..ff178e363 100644 --- a/ts/fixtures/lang/expected/nested.ts +++ b/ts/fixtures/lang/expected/nested.ts @@ -441,7 +441,7 @@ export function closures(data: rt.ByteSlice, out: rt.ByteVec): void { }, undefined, rt.None), "next", 2)), (_222: rt.u8 | undefined): rt.u8 => { return code(_222); }), undefined, true); - rt.iterExtendBytes(out, rt.byteVecIntoIter(seen), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(seen)), undefined, true); let steps: rt.u8 = 0; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.iterCount(rt.iterSuccessors(undefined, (_223: undefined): undefined | rt.None => { steps = rt.u8Add(steps, 1); @@ -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 => { @@ -536,7 +536,7 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.vecPop(v, rt.None)), code(rt.vecPopIfMut(v, (_213: rt.Place): boolean => { return true; }, undefined, rt.None)))), undefined, true); - const units: undefined[] = rt.vecFromElem(undefined, data.length, undefined, 0); + const units: undefined[] = rt.vecFromElem(undefined, data.length, undefined); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.sliceFirst(units, rt.None) !== rt.None ? 1 : 0, rt.sliceLast(units, rt.None) !== rt.None ? 1 : 0, rt.sliceGet(units, at, rt.None) !== rt.None ? 1 : 0)), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.sliceFirstMut(units) !== undefined ? 1 : 0, rt.sliceLastMut(units) !== undefined ? 1 : 0, rt.sliceGetMut(units, at) !== undefined ? 1 : 0)), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.vecPopIfMut(units, (_217: rt.Place): boolean => { @@ -557,9 +557,9 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { const i: rt.usize = _167[0]; const o2: rt.u8 | undefined = _167[1]; if (rt.usizeRem(i, 2) === 0) { - rt.dequePushBack(q, o2, 2); + rt.dequePushBack(q, o2); } else { - rt.dequePushFront(q, o2, 2); + rt.dequePushFront(q, o2); } } rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.dequeEnd(q, false, rt.None)), code(rt.dequeEnd(q, true, rt.None)), code(rt.dequeGet(q, at, rt.None)))), undefined, true); @@ -593,7 +593,7 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { } } rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.dequePopFront(q, rt.None)), code(rt.dequePopBack(q, rt.None)), code(rt.dequeEnd(q, false, rt.None)), code(rt.dequeRemove(q, 0, rt.None)), code(rt.dequeSwapRemove(q, 0, true, rt.None)), code(rt.dequeSwapRemove(q, 0, false, rt.None)))), undefined, true); - const unitQ: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(undefined, rt.usizeMul(data.length, 2), undefined, 0), 0) as rt.VecDeque; + 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))); @@ -746,7 +746,7 @@ export function madeAll$nested_Unit(m: nested_Unit.Unit, data: rt.ByteSlice): un export function units(data: rt.ByteSlice, out: rt.ByteVec): void { let f!: (a0: rt.u8) => undefined; const units: undefined[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): undefined => {}), undefined, 0, true); - const q: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), (_22: rt.u8): undefined => {}), undefined, 0, true), 0) as rt.VecDeque; + const q: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), (_22: rt.u8): undefined => {}), undefined, 0, true)) 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: { @@ -761,7 +761,7 @@ export function units(data: rt.ByteSlice, out: rt.ByteVec): void { const byPointer: undefined[] = pointed(data, f); const generic: undefined[] = each$unit_nested_units_closure3(data, (_25: rt.u8): undefined => {}); const byName: undefined[] = each$unit_nested_ignore(data, ignore as (a0: rt.u8) => undefined); - rt.iterExtendBytes(out, rt.byteVecIntoIter(each$u8_nested_half(data, half)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(each$u8_nested_half(data, half))), undefined, true); const methods: undefined[] = madeAll$nested_Unit({}, data); const dynamic: undefined[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), rt.lent(ignore as (a0: rt.u8) => undefined)), undefined, 0, true); const iter: rt.Iter = rt.iterSlice([units, named, byPointer, generic, byName, methods, dynamic]); diff --git a/ts/fixtures/lang/expected/objects.ts b/ts/fixtures/lang/expected/objects.ts index 8bf7cb270..ab7b20790 100644 --- a/ts/fixtures/lang/expected/objects.ts +++ b/ts/fixtures/lang/expected/objects.ts @@ -134,7 +134,7 @@ export function swapWindows(a: objects_Window.Window, b: objects_Window.Window): export function swapIn(v: rt.Arc[], with_: rt.Arc): rt.Arc[] { const mine: rt.Arc[] = [rt.arcClone(with_)]; const swapped = rt.replaceIn(v, mine); - rt.vecPush(v, rt.arcClone(with_), 4); + v.push(rt.arcClone(with_)); return swapped; } @@ -187,7 +187,7 @@ export function refill(v: rt.Arc[], bytes: rt.ByteVec, with_: rt.Arc, map: rt.HashMap, n: rt.u8): rt.usize { - const old: rt.VecDeque = rt.replaceIn(q, rt.dequeFromVec(rt.iterToArray(new rt.Range(0, rt.u8Rem(n, 5)), undefined, 1, true), 1) as rt.VecDeque); + const old: rt.VecDeque = rt.replaceIn(q, rt.dequeFromVec(rt.iterToArray(new rt.Range(0, rt.u8Rem(n, 5)), undefined, 1, true)) as rt.VecDeque); Object.assign(map, rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice([[n, n] as [rt.u8, rt.u8]]), undefined, undefined, undefined, 469762048)); return old.n; } @@ -442,7 +442,8 @@ export function objects(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteVecSlice(bytes)); counts(out, [one, two], w.held); counts(out, [one, two], other); - const q: rt.VecDeque = rt.dequeFromVec(Array.from(Uint8Array.of(by)), 1) as rt.VecDeque; + const _515: Uint8Array = Uint8Array.of(by); + const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_515), undefined, 1, true); const map: rt.HashMap = rt.hashNew() as rt.HashMap; for (const _519 of rt.byteSliceView(data)) { rt.byteVecPush(out, requeue(q, map, _519) & 0xff); diff --git a/ts/fixtures/lang/expected/orders.ts b/ts/fixtures/lang/expected/orders.ts index c13233ff8..3962bc1b6 100644 --- a/ts/fixtures/lang/expected/orders.ts +++ b/ts/fixtures/lang/expected/orders.ts @@ -255,7 +255,7 @@ export function heaps(data: rt.ByteSlice, out: rt.ByteVec): void { const _17: rt.u8 = rt.u8Rem(op, 12); if (0 <= _17) { if (_17 <= 2) { - rt.heapPush(heap, item(i, v), orders_Item.le$cmp_PartialOrd, 2); + rt.heapPush(heap, item(i, v), orders_Item.le$cmp_PartialOrd); break b2; } } @@ -310,9 +310,9 @@ export function heaps(data: rt.ByteSlice, out: rt.ByteVec): void { } } else if (_17 === 6) { const _57: orders_Item.Item = item(i, v); - rt.heapPush(other, _57, orders_Item.le$cmp_PartialOrd, 2); + rt.heapPush(other, _57, orders_Item.le$cmp_PartialOrd); } else if (_17 === 7) { - rt.heapAppend(heap, other, orders_Item.le$cmp_PartialOrd, orders_Item.ge$cmp_PartialOrd, orders_Item.lt$cmp_PartialOrd, 2); + rt.heapAppend(heap, other, orders_Item.le$cmp_PartialOrd, orders_Item.ge$cmp_PartialOrd, orders_Item.lt$cmp_PartialOrd); } else if (_17 === 8) { rt.heapRetain(heap, (x4: orders_Item.Item): boolean => { return x4.key !== rt.u8Rem(v, 8); @@ -380,12 +380,12 @@ export function heaps(data: rt.ByteSlice, out: rt.ByteVec): void { */ export function values(data: rt.ByteSlice, out: rt.ByteVec): void { const bytes: rt.BinaryHeap = rt.heapFrom(rt.byteVecToVec(rt.byteSliceToByteVec(data)), rt.le, rt.ge, rt.lt); - rt.heapPush(bytes, data.length & 0xff, rt.le, 1); + 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.byteVecIntoIter(rt.byteVecFromVec(rt.heapIntoSortedVec(rt.heapClone(bytes), rt.le, rt.ge, rt.lt))), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFrom(Uint8Array.from(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.byteVecIntoIter(rt.byteVecFromVec(bytes.d)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFrom(Uint8Array.from(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)); @@ -568,7 +568,7 @@ export function bytes(data: rt.ByteSlice, out: rt.ByteVec): void { } if (_228.length >= 2) { rt.idx(_228, 0); - rt.vecPush(refs, [new rt.ByteSlice(_228.data, _228.start, 2), rt.u8Div(_228.data[_228.start], 64)] as [rt.ByteSlice, rt.u8], 8); + refs.push([new rt.ByteSlice(_228.data, _228.start, 2), rt.u8Div(_228.data[_228.start], 64)] as [rt.ByteSlice, rt.u8]); } } rt.sliceSort(refs, rt.cmpLt(rt.cmpTuple<[rt.ByteSlice, rt.u8], rt.Ordering | undefined>([rt.cmpBytes, rt.cmp]))); @@ -751,7 +751,7 @@ export function deque$orders_Part_orders_held_closure3(sData: Uint8Array, sStart const _17: rt.usize = at; const d: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rt.usize, rt.u8]): Part.Part => { return f(rt.usizeAdd(_2[0], _17), _2[1]); - }), undefined, 2, true), 2) as rt.VecDeque; + }), 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(); @@ -759,7 +759,7 @@ export function deque$orders_Part_orders_held_closure3(sData: Uint8Array, sStart return d; } const _30: Part.Part = f(_23[0], _23[1]); - rt.dequePushFront(d, _30, 2); + rt.dequePushFront(d, _30); } } @@ -781,7 +781,7 @@ export function deque$orders_Part_orders_part(sData: Uint8Array, sStart: number, const _17: rt.usize = at; const d: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rt.usize, rt.u8]): Part.Part => { return part(rt.usizeAdd(_2[0], _17), _2[1]); - }), undefined, 2, true), 2) as rt.VecDeque; + }), 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(); @@ -789,7 +789,7 @@ export function deque$orders_Part_orders_part(sData: Uint8Array, sStart: number, return d; } const _30: Part.Part = part(_23[0], _23[1]); - rt.dequePushFront(d, _30, 2); + rt.dequePushFront(d, _30); } } @@ -811,7 +811,7 @@ export function deque$u8_orders_held_closure11(sData: Uint8Array, sStart: number const _17: rt.usize = at; const d: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rt.usize, rt.u8]): rt.u8 => { return f(rt.usizeAdd(_2[0], _17), _2[1]); - }), undefined, 1, true), 1) as rt.VecDeque; + }), 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(); @@ -819,7 +819,7 @@ export function deque$u8_orders_held_closure11(sData: Uint8Array, sStart: number return d; } const _30: rt.u8 = f(_23[0], _23[1]); - rt.dequePushFront(d, _30, 1); + rt.dequePushFront(d, _30); } } @@ -841,7 +841,7 @@ export function deque$u8_orders_held_closure8(sData: Uint8Array, sStart: number, const _17: rt.usize = at; const d: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rt.usize, rt.u8]): rt.u8 => { return f(rt.usizeAdd(_2[0], _17), _2[1]); - }), undefined, 1, true), 1) as rt.VecDeque; + }), 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(); @@ -849,7 +849,7 @@ export function deque$u8_orders_held_closure8(sData: Uint8Array, sStart: number, return d; } const _30: rt.u8 = f(_23[0], _23[1]); - rt.dequePushFront(d, _30, 1); + rt.dequePushFront(d, _30); } } @@ -892,7 +892,7 @@ export function held(data: rt.ByteSlice, out: rt.ByteVec): void { return p2.key as rt.f64; } return NaN; - }), undefined, 8, true), 8) as rt.VecDeque; + }), undefined, 8, true)) as rt.VecDeque; }; const iter: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.byteSliceWindows(data, 2)); while (true) { @@ -1173,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); @@ -1237,7 +1237,7 @@ export function btrees(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecClear(a034); }); } - const apart: Apart.Apart[] = rt.vecFromElem({}, short.length, undefined, 0); + const apart: Apart.Apart[] = rt.vecFromElem({}, short.length, undefined); const _183: rt.Iter = rt.iterSlice(apart); const set2: rt.BTreeSet = rt.btreeCollectKeys(rt.btreeNew(Apart.cmp$cmp_Ord) as rt.BTreeSet, rt.iterToArray(_183, undefined, 0, true), undefined, Apart.eq$cmp_PartialEq); const _188: rt.Iter<[Apart.Apart, undefined]> = rt.iterMap(rt.iterSlice(apart), (_211: Apart.Apart): [Apart.Apart, undefined] => { diff --git a/ts/fixtures/lang/expected/pointers.ts b/ts/fixtures/lang/expected/pointers.ts index f328c30ca..f4c456db1 100644 --- a/ts/fixtures/lang/expected/pointers.ts +++ b/ts/fixtures/lang/expected/pointers.ts @@ -665,7 +665,7 @@ export function lapsed(data: rt.ByteSlice, out: rt.ByteVec): void { const _33: Log.Log = { bytes: rt.byteVecFrom(Uint8Array.of(n, ~n & 0xff)) }; const old3 = log; log = _33; - rt.iterExtendBytes(out, rt.byteVecIntoIter(old3.bytes), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(old3.bytes)), undefined, true); const old2: Duo.Duo = rt.replaceIn(pair, { _0: n, _1: n ^ 15 }); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(old2._0, old2._1)), undefined, true); } else if (_24 === 2) { @@ -695,7 +695,7 @@ export function lapsed(data: rt.ByteSlice, out: rt.ByteVec): void { } } rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(pair._0, pair._1)), undefined, true); - rt.iterExtendBytes(out, rt.byteVecIntoIter(log.bytes), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(log.bytes)), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(window), undefined, true); } @@ -797,11 +797,11 @@ export function segments(data: rt.ByteSlice, out: rt.ByteVec): void { if (!(rt.usizeRem(len, 8) === 0)) { if (rt.usizeRem(len, 4) === 0) { const _27: Segment.Segment = Segment.iterated(); - rt.vecPush(log, _27, 8); + log.push(_27); } } else { const _20: Segment.Segment = Segment.new(); - rt.vecPush(log, _20, 8); + log.push(_20); } const at5 = rt.idx(log, rt.usizeDiv(len, 4)); Lent.withMut$mem_MaybeUninit_tuple2_u8_u8_mut_tuple2_u8_u8_pointers_segments_closure0(Segment.slot(log[at5], log[at5].filled), (p3: [rt.u8, rt.u8]): [rt.u8, rt.u8] => { @@ -1089,7 +1089,7 @@ export function readBefore(n: rt.u8): Uint8Array { } export function keep(d: Duo.Duo, kept: Duo.Duo[]): void { - rt.vecPush(kept, d, 4); + kept.push(d); } export function perIteration(n: rt.u8, out: rt.ByteVec): void { diff --git a/ts/fixtures/lang/expected/refs.ts b/ts/fixtures/lang/expected/refs.ts index 75a91a741..71e1a2200 100644 --- a/ts/fixtures/lang/expected/refs.ts +++ b/ts/fixtures/lang/expected/refs.ts @@ -466,7 +466,7 @@ export function lent(data: rt.ByteSlice, out: rt.ByteVec): void { break; } _126[1].v = _126[0] as rt.u32; - rt.vecPush(held, rt.place(() => _126[1].v as rt.u32, (value13) => (_126[1].v as rt.u32) = value13), 4); + held.push(rt.place(() => _126[1].v as rt.u32, (value13) => (_126[1].v as rt.u32) = value13)); } const iter4: rt.Iter> = rt.iterSlice(held); while (true) { @@ -570,11 +570,11 @@ export function taken(data: rt.ByteSlice, out: rt.ByteVec): void { const _34: rt.u32[] = []; const old2 = wide; wide = _34; - wide = rt.iterToArrayInPlace(rt.iterMap(rt.iterFilter(rt.iterSlice(old2), (_25: rt.u32): boolean => { + wide = rt.iterToArray(rt.iterMap(rt.iterFilter(rt.iterSlice(old2), (_25: rt.u32): boolean => { return _25 > ((b4 as rt.u32)); }), (x3: rt.u32): rt.u32 => { return rt.u32Div(x3, 2); - }), 4, 4, false, "next"); + }), "next", 4); })(); return held.length === 0; }) as rt.u32))); @@ -591,7 +591,7 @@ export function taken(data: rt.ByteSlice, out: rt.ByteVec): void { const swapped: rt.ByteVec = new rt.ByteVec(); for (const _39 of rt.byteSliceView(data)) { const _45: rt.ByteVec = swap(_39); - rt.iterExtendBytes(swapped, rt.byteVecIntoIter(_45), undefined, true); + rt.iterExtendBytes(swapped, rt.iterSlice(rt.byteVecView(_45)), undefined, true); } const list: (a0: rt.u8) => undefined = (b6: rt.u8): undefined => { const taken2 = pair[1].listed; @@ -604,7 +604,7 @@ export function taken(data: rt.ByteSlice, out: rt.ByteVec): void { }); for (const _57 of rt.byteSliceView(data)) { const _63: rt.ByteVec = option_unwrapOrDefault$0wx44sw(restock(pair[1], _57)); - rt.iterExtendBytes(swapped, rt.byteVecIntoIter(_63), undefined, true); + rt.iterExtendBytes(swapped, rt.iterSlice(rt.byteVecView(_63)), undefined, true); } const taken3 = pair[1].stale; pair[1].stale = new rt.ByteVec(); @@ -763,9 +763,9 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { return 0; }); _214.v = rt.u32Add(_214.v, _213); - rt.dequePushBack(queue, b2 as rt.u32, 4); + rt.dequePushBack(queue, b2 as rt.u32); if (rt.u8Rem(b2, 3) === 0) { - rt.dequePushFront(queue, rt.u32Add(b2 as rt.u32, 1), 4); + rt.dequePushFront(queue, rt.u32Add(b2 as rt.u32, 1)); } } const iter12: rt.Iter<[rt.u8, rt.u8]> = rt.hashValues(hash); diff --git a/ts/fixtures/lang/expected/shapes.ts b/ts/fixtures/lang/expected/shapes.ts index 7d5547f17..9961e054c 100644 --- a/ts/fixtures/lang/expected/shapes.ts +++ b/ts/fixtures/lang/expected/shapes.ts @@ -372,13 +372,13 @@ 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[] = []; - rt.vecPush(lenses, copy$shapes_Lens(lens), 8); + lenses.push(copy$shapes_Lens(lens)); const _114: rt.Iter = rt.iterSlice([lens]); rt.iterExtend(lenses, rt.iterMap(_114, copy$shapes_Lens), undefined, 8, true); const iter4: rt.Iter = rt.iterCopied(rt.iterSlice(lenses), copy$shapes_Lens); @@ -417,7 +417,7 @@ export function shares(data: rt.ByteSlice, out: rt.ByteVec): void { }); rt.byteVecPush(out, writeAt(rt.byteSliceFrom(bytes), at, a)); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(bytes)); - const points: Point.Point[] = rt.vecFromElem(copy$shapes_Point(Point.new(a as rt.i32, 0)), 2, copy$shapes_Point, 8); + const points: Point.Point[] = rt.vecFromElem(copy$shapes_Point(Point.new(a as rt.i32, 0)), 2, copy$shapes_Point); movedAt(points, at); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(points[rt.idx(points, 0)].x & 0xff, points[rt.idx(points, 1)].x & 0xff, points[rt.idx(points, 1)].y & 0xff))); arc[Symbol.dispose](); @@ -2228,7 +2228,7 @@ export function closures(data: rt.ByteSlice, out: rt.ByteVec): void { const parsed: Array = []; for (const _53 of rt.byteSliceView(data)) { const _59: shapes_Dir.Dir | undefined = dir(_53); - rt.vecPush(parsed, _59, 1); + parsed.push(_59); } const tags: rt.ByteVec = new rt.ByteVec(); for (const _64 of parsed) { diff --git a/ts/fixtures/lang/expected/slices.ts b/ts/fixtures/lang/expected/slices.ts index 9e3d7659b..c1505a94d 100644 --- a/ts/fixtures/lang/expected/slices.ts +++ b/ts/fixtures/lang/expected/slices.ts @@ -1208,7 +1208,7 @@ export function drains(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return x8.tag; }), undefined, true); rt.dropAll(taken); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.byteVecDrain(bytes, { end: b }), "fold", true)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.byteVecDrain(bytes, { end: b }), "fold", true))), undefined, true); rt.drop(rt.vecDrain(words, { end: b })); } else if (_31 === 3) { const drain4: rt.Iter = rt.vecDrain(items, new rt.RangeFrom(a, rt.usizeStep), rt.drop); @@ -1263,7 +1263,7 @@ export function drains(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const other: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(238)); const _195: rt.Iter = rt.iterRev(rt.byteVecDrain(bytes, new rt.Range(a, b))); rt.iterExtendBytes(other, _195, "fold", true); - rt.iterExtendBytes(out, rt.byteVecIntoIter(other), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(other)), undefined, true); rt.dropAll(kept); } flush(out); @@ -1275,7 +1275,7 @@ export function drains(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(words), (_26: rt.u32): rt.u8 => { return _26 & 0xff; }), undefined, true); - rt.vecPush(items, new slices_Item.Item(255), 1); + items.push(new slices_Item.Item(255)); rt.dropAll(items); flush(out); } @@ -1934,7 +1934,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }); rt.sliceCopyFromSlice(more, rt.sliceRange(array, 0, 3)); rt.sliceCopyFromSlice(rt.sliceRangeMut(array, 2), more); - const source: slices_Pair.Pair[] = rt.vecFromElem({ a: 4, b: 5 }, c, copy$slices_Pair, 4); + const source: slices_Pair.Pair[] = rt.vecFromElem({ a: 4, b: 5 }, c, copy$slices_Pair); rt.sliceCopyFromSlice(rt.sliceRangeMut(pairs, 0, b), source, copy$slices_Pair); } else if (_60 === 6) { const source2: slices_Noisy.Noisy[] = rt.iterToArray(rt.iterMap(new rt.Range(0, c), (tag3: rt.usize): slices_Noisy.Noisy => { diff --git a/ts/fixtures/lang/expected/strs.ts b/ts/fixtures/lang/expected/strs.ts index eb95c90bc..f9aa54a2d 100644 --- a/ts/fixtures/lang/expected/strs.ts +++ b/ts/fixtures/lang/expected/strs.ts @@ -129,7 +129,7 @@ export function strs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (_13 === 2) { const seen: rt.char[] = []; const parts2: rt.Iter = rt.strSplit(s, (c9: rt.char): boolean => { - rt.vecPush(seen, c9, 4); + seen.push(c9); if (!(c9 === sep)) { return rt.isAsciiDigit(c9); } @@ -160,12 +160,12 @@ export function strs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_13 === 4) { const seen2: rt.char[] = []; fmt_put(out, rt.strTrimStartMatches(s, (c5: rt.char): boolean => { - rt.vecPush(seen2, c5, 4); + seen2.push(c5); return c5 === sep; })); putSeen(out, seen2); fmt_put(out, rt.strTrimEndMatches(s, (c6: rt.char): boolean => { - rt.vecPush(seen2, c6, 4); + seen2.push(c6); return c6 !== sep; })); putSeen(out, seen2); @@ -174,7 +174,7 @@ export function strs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }) ? 1 : 0); fmt_put(out, rt.strTrimStartMatches(s, digit)); putOffset(out, rt.strRfind(s, (c8: rt.char): boolean => { - rt.vecPush(seen2, c8, 4); + seen2.push(c8); return c8 === sep; })); putSeen(out, seen2); @@ -411,7 +411,7 @@ export function unescape(path: string): string[] { if (ch === 47) { const taken = part; part = ""; - rt.vecPush(parts, taken, 12); + parts.push(taken); } else if (ch === 92) { const _14: rt.char | rt.Done = chars.next(); if (_14 === rt.DONE) { @@ -430,7 +430,7 @@ export function unescape(path: string): string[] { break; } } - rt.vecPush(parts, part, 12); + parts.push(part); return parts; } return []; @@ -556,7 +556,7 @@ export function edit(s: rt.Place, op: rt.u8, a: rt.u8, b: rt.u8, out: rt if (!(rt.u8Rem(b, 2) === 1)) { const seen: rt.char[] = []; s.v = rt.stringRetain(s.v, (c: rt.char): boolean => { - rt.vecPush(seen, c, 4); + seen.push(c); return rt.u32Rem(c as rt.u32, 3) !== rt.u8Rem(a, 3) as rt.u32; }); putSeen(out, seen); @@ -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 3a53d1215..1c1813c14 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.byteVecIntoIter(rt.byteVecFromVec(rt.tupleExtendOne([rt.heapNew() as rt.BinaryHeap] as [rt.BinaryHeap], _22, (c3, items3) => rt.heapExtend(c3, items3, rt.le, rt.ge, rt.lt, undefined, 1, true))[0].d)), undefined, true); + 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); const _28: rt.Iter<[rt.u8]> = rt.iterMap(rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): boolean => { return (_210 & 1) === 0; }), (_211: rt.u8): [rt.u8] => { @@ -103,7 +103,7 @@ export function ones(data: rt.ByteSlice, out: rt.ByteVec): void { return [c7.data[c7.start]] as [rt.u8]; }); rt.tupleExtendOne(t, _48, (c8, items7) => rt.iterExtendBytes(c8, items7, undefined, true)); - rt.iterExtendBytes(out, rt.byteVecIntoIter(t[0]), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(t[0])), undefined, true); const t2: [string] = ["ab"]; const _56: rt.Iter<[string]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_214: rt.u8): [string] => { const _84: rt.usize = rt.u8Rem(_214, 3) as rt.usize; @@ -121,8 +121,8 @@ export function ones(data: rt.ByteSlice, out: rt.ByteVec): void { const _64: [[rt.ByteVec, rt.BinaryHeap]] = rt.tupleExtendOne([[new rt.ByteVec(), rt.heapNew() as rt.BinaryHeap]] as [[rt.ByteVec, rt.BinaryHeap]], _65, (c10, items9) => rt.tupleExtend(c10, items9, [rt.byteVecPart(), rt.heapPart(rt.le, 1)])); const v2: rt.ByteVec = _64[0][0]; const heap2: rt.BinaryHeap = _64[0][1]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v2), undefined, true); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(heap2.d)), undefined, true); + 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.tupleExtendOne([undefined] as [undefined], rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_216: rt.u8): [undefined] => { return [undefined] as [undefined]; }), (_c11, items10) => rt.iterFold(items10, undefined, () => undefined)); @@ -142,7 +142,7 @@ export function pairs(data: rt.ByteSlice, out: rt.ByteVec): void { const _5: [rt.ByteVec, string] = rt.tupleExtend([new rt.ByteVec(), ""] as [rt.ByteVec, string], _6, [rt.byteVecPart(), rt.STRING_CHARS_PART]); const v: rt.ByteVec = _5[0]; const s: string = _5[1]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); const _16: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): [rt.u8, rt.u8] => { const b2: rt.u8 = _25; @@ -151,7 +151,7 @@ export function pairs(data: rt.ByteSlice, out: rt.ByteVec): void { const _15: [rt.ByteVec, rt.BTreeSet] = rt.tupleExtend([new rt.ByteVec(), rt.btreeNew(rt.cmp) as rt.BTreeSet] as [rt.ByteVec, rt.BTreeSet], _16, [rt.byteVecPart(), rt.btreeKeysPart()]); const v2: rt.ByteVec = _15[0]; const tree: rt.BTreeSet = _15[1]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v2), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v2)), undefined, true); rt.iterExtendBytes(out, rt.btreeKeys(tree), undefined, true); const _23: rt.Iter<[rt.u8, rt.u16]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_27: rt.u8): [rt.u8, rt.u16] => { const b3: rt.u8 = _27; @@ -160,14 +160,14 @@ export function pairs(data: rt.ByteSlice, out: rt.ByteVec): void { const _22: [rt.BinaryHeap, rt.VecDeque] = rt.tupleExtend([rt.heapNew() as rt.BinaryHeap, rt.dequeNew() 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.byteVecIntoIter(rt.byteVecFromVec(heap.d)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFrom(Uint8Array.from(heap.d)))), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.dequeIter(q), (n: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n).reverse(); }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); const _33: rt.Iter<[undefined, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): [undefined, rt.u8] => { return [undefined, _210] as [undefined, rt.u8]; }); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.tupleExtend([undefined, new rt.ByteVec()] as [undefined, rt.ByteVec], _33, [rt.UNIT_PART, rt.byteVecPart()])[1]), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.tupleExtend([undefined, new rt.ByteVec()] as [undefined, rt.ByteVec], _33, [rt.UNIT_PART, rt.byteVecPart()])[1])), undefined, true); const _39: rt.Iter<[rt.u16, rt.u8]> = rt.iterMap(rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (_211: rt.u8): boolean => { return _211 > 64; }), (_212: rt.u8): [rt.u16, rt.u8] => { @@ -193,7 +193,7 @@ export function triples(data: rt.ByteSlice, out: rt.ByteVec): void { const v: rt.ByteVec = _6[0]; const q: rt.VecDeque = _6[1]; const s: string = _6[2]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.dequeIter(q), (n: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n).reverse(); }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); @@ -210,7 +210,7 @@ export function triples(data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeIter(tree), (_25: [rt.u8, rt.u16]): Uint8Array => { return Uint8Array.of(_25[0], _25[1] & 0xff); }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(heap.d)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFrom(Uint8Array.from(heap.d)))), undefined, true); const _35: rt.Iter<[rt.u8, [rt.char, rt.u16]]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_26: rt.u8): [rt.u8, [rt.char, rt.u16]] => { const b3: rt.u8 = _26; return [b3, [b3 as rt.char, rt.u16Add(b3 as rt.u16, 1)] as [rt.char, rt.u16]] as [rt.u8, [rt.char, rt.u16]]; @@ -219,7 +219,7 @@ export function triples(data: rt.ByteSlice, out: rt.ByteVec): void { const v2: rt.ByteVec = _34[0]; const s2: string = _34[1][0]; const w: rt.u16[] = _34[1][1]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v2), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v2)), undefined, true); rt.iterExtendBytes(out, rt.strBytes(s2), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(w), (n2: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n2).reverse(); @@ -231,7 +231,7 @@ export function triples(data: rt.ByteSlice, out: rt.ByteVec): void { const _49: [rt.ByteVec, [rt.BTreeSet]] = rt.tupleExtend([new rt.ByteVec(), [rt.btreeNew(rt.cmp) as rt.BTreeSet]] as [rt.ByteVec, [rt.BTreeSet]], _50, [rt.byteVecPart(), rt.tuplePart([rt.btreeKeysPart()])]); const v3: rt.ByteVec = _49[0]; const tree2: rt.BTreeSet = _49[1][0]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v3), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v3)), undefined, true); rt.iterExtendBytes(out, rt.btreeKeys(tree2), undefined, true); } @@ -267,14 +267,14 @@ export function twelves(data: rt.ByteSlice, out: rt.ByteVec): void { const keys: rt.BTreeSet = _15[9]; const v: rt.ByteVec = _15[11][0]; const s: string = _15[11][1][0]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(bytes), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(wide), (n: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n).reverse(); }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); rt.iterExtendBytes(out, rt.strBytes(chars), undefined, true); rt.iterExtendBytes(out, rt.strBytes(texts), undefined, true); rt.iterExtendBytes(out, rt.dequeIter(q), undefined, true); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(heap.d)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFrom(Uint8Array.from(heap.d)))), undefined, true); entries(map, out); sorted(set, out); rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeIter(tree), (_210: [rt.u8, rt.u16]): Uint8Array => { @@ -284,7 +284,7 @@ export function twelves(data: rt.ByteSlice, out: rt.ByteVec): void { }); }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); rt.iterExtendBytes(out, rt.btreeKeys(keys), undefined, true); - rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); } @@ -293,7 +293,7 @@ export function twelves(data: rt.ByteSlice, out: rt.ByteVec): void { * and a map or set keeps an equal key already there. */ export function extended(data: rt.ByteSlice, out: rt.ByteVec): void { - const t: [rt.ByteVec, string, rt.BTreeMap, rt.VecDeque, rt.HashSet] = [rt.byteVecFrom(Uint8Array.of(9, 8)), "pre", rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterSlice([[3, 30] as [rt.u8, rt.u16]]), true, undefined, undefined, undefined, 4, true), rt.dequeFromVec([1], 2) as rt.VecDeque, rt.hashExtendKeys(rt.hashNew() as rt.HashSet, rt.iterSlice(Uint8Array.of(5)), undefined, undefined, 469762048)]; + const t: [rt.ByteVec, string, rt.BTreeMap, rt.VecDeque, rt.HashSet] = [rt.byteVecFrom(Uint8Array.of(9, 8)), "pre", rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterSlice([[3, 30] as [rt.u8, rt.u16]]), true, undefined, undefined, undefined, 4, true), rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice([1]), undefined, 2, true), rt.hashExtendKeys(rt.hashNew() as rt.HashSet, rt.iterSlice(Uint8Array.of(5)), undefined, undefined, 469762048)]; const _16: rt.Iter<[rt.u8, rt.char, [rt.u8, rt.u16], rt.u16, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): [rt.u8, rt.char, [rt.u8, rt.u16], rt.u16, rt.u8] => { const b: rt.u8 = _2; return [b, b as rt.char, [rt.u8Rem(b, 8), b as rt.u16] as [rt.u8, rt.u16], b as rt.u16, rt.u8Rem(b, 16)] as [rt.u8, rt.char, [rt.u8, rt.u16], rt.u16, rt.u8]; @@ -304,7 +304,7 @@ export function extended(data: rt.ByteSlice, out: rt.ByteVec): void { const tree: rt.BTreeMap = t[2]; const q: rt.VecDeque = t[3]; const set: rt.HashSet = t[4]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeIter(tree), (_22: [rt.u8, rt.u16]): Uint8Array => { return Uint8Array.of(_22[0], _22[1] & 0xff); @@ -319,7 +319,7 @@ export function extended(data: rt.ByteSlice, out: rt.ByteVec): void { return [b2, [rt.u8Rem(b2, 4), b2] as [rt.u8, rt.u8]] as [rt.u8, [rt.u8, rt.u8]]; }); rt.tupleExtend(t2, _45, [rt.heapPart(rt.le, 1), rt.hashPart(undefined, undefined, 469762048)]); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(t2[0].d)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFrom(Uint8Array.from(t2[0].d)))), undefined, true); entries(t2[1], out); } @@ -353,7 +353,7 @@ export function borrowed(data: rt.ByteSlice, out: rt.ByteVec): void { const copied: Spot.Spot[] = t[1]; const map: rt.HashMap = t[2]; const s: string = t[3]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterChain(rt.iterSlice(copied), rt.iterSlice(ones[0])), (p2: Spot.Spot): Uint8Array => { return Uint8Array.of(p2.x, p2.y & 0xff); }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); @@ -431,7 +431,7 @@ export function dropped(data: rt.ByteSlice, out: rt.ByteVec): void { const taken: tuples_Logged.Logged[] = _86[0]; const bytes: rt.ByteVec = _86[1]; flush(log.value, out); - rt.iterExtendBytes(out, rt.byteVecIntoIter(bytes), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); rt.dropAll(taken); flush(log.value, out); rt.hashDrop(keys, rt.drop); @@ -459,7 +459,7 @@ export function panicked(data: rt.ByteSlice, out: rt.ByteVec): void { const v: rt.ByteVec = _12[0]; const s: string = _12[1]; const w: rt.u16[] = _12[2]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(w), (n: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n).reverse(); @@ -525,7 +525,7 @@ export function shunted(data: rt.ByteSlice, out: rt.ByteVec): void { if (parsed.ok) { const v: rt.ByteVec = parsed.value[0]; const s: string = parsed.value[1]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); } else { rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(250, parsed.error)), undefined, true); @@ -621,7 +621,7 @@ export function own(data: rt.ByteSlice, out: rt.ByteVec): void { const _34: [rt.ByteVec, tuples_Tally.Tally] = rt.tupleExtend([new rt.ByteVec(), tuples_Tally.default$Default()] as [rt.ByteVec, tuples_Tally.Tally], _35, [rt.byteVecPart(), rt.ownPart(tuples_Tally.extend$iter_Extend_u8_Option_u8 as (a0: tuples_Tally.Tally, a1: rt.u8 | undefined) => undefined)]); const v: rt.ByteVec = _34[0]; const t2: tuples_Tally.Tally = _34[1]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); rt.byteVecPush(out, t2.sum); calls(out); const _47: rt.Iter<[rt.u8, rt.u16]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(data2))), (_210: rt.u8): [rt.u8, rt.u16] => { @@ -667,7 +667,7 @@ export function own(data: rt.ByteSlice, out: rt.ByteVec): void { const _96: [rt.ByteVec, [tuples_Tally.Tally]] = rt.tupleExtend([new rt.ByteVec(), [tuples_Tally.default$Default()]] as [rt.ByteVec, [tuples_Tally.Tally]], _97, [rt.byteVecPart(), rt.tuplePart([rt.ownPart(tuples_Tally.extend$iter_Extend_u8_Option_u8 as (a0: tuples_Tally.Tally, a1: rt.u8 | undefined) => undefined)])]); const v2: rt.ByteVec = _96[0]; const t5: tuples_Tally.Tally = _96[1][0]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v2), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v2)), undefined, true); rt.byteVecPush(out, t5.sum); calls(out); const _107: rt.Iter<[rt.char]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(data2))), (_216: rt.u8): [rt.char] => { @@ -685,7 +685,7 @@ export function own(data: rt.ByteSlice, out: rt.ByteVec): void { }); rt.tupleExtend(t6, _120, [rt.ownPart(tuples_Tally.extend$iter_Extend_u8_Option_u8 as (a0: tuples_Tally.Tally, a1: rt.u8 | undefined) => undefined), rt.byteVecPart(), rt.ownPart(Last.extend$iter_Extend_char_Option_char as (a0: rt.Place, a1: rt.char | undefined) => undefined, true)]); rt.byteVecPush(out, t6[0].sum); - rt.iterExtendBytes(out, rt.byteVecIntoIter(t6[1]), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(t6[1])), undefined, true); Last.put(t6[2], out); calls(out); const parsed: rt.Result<[tuples_Tally.Tally, rt.ByteVec], rt.u8> = rt.iterCollectResult(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(data2))), (_217: rt.u8): rt.Result<[rt.u8, rt.u8], rt.u8> => { @@ -699,7 +699,7 @@ export function own(data: rt.ByteSlice, out: rt.ByteVec): void { const t7: tuples_Tally.Tally = parsed.value[0]; const v3: rt.ByteVec = parsed.value[1]; rt.byteVecPush(out, t7.sum); - rt.iterExtendBytes(out, rt.byteVecIntoIter(v3), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v3)), undefined, true); } else { rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(250, parsed.error)), undefined, true); } @@ -715,7 +715,7 @@ export function own(data: rt.ByteSlice, out: rt.ByteVec): void { } else { const v4: rt.ByteVec = found[0]; const t8: tuples_Tally.Tally = found[1]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v4), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v4)), undefined, true); rt.byteVecPush(out, t8.sum); } calls(out); @@ -798,7 +798,7 @@ export function ownPanicked(data: rt.ByteSlice, out: rt.ByteVec): void { const v: rt.ByteVec = _24[0]; const t: tuples_Tally.Tally = _24[1]; const s: string = _24[2]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); rt.byteVecPush(out, t.sum); rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); } else { diff --git a/ts/fixtures/lang/expected/wrappers.ts b/ts/fixtures/lang/expected/wrappers.ts index 8deba14ce..1902bd177 100644 --- a/ts/fixtures/lang/expected/wrappers.ts +++ b/ts/fixtures/lang/expected/wrappers.ts @@ -342,7 +342,7 @@ export function wrappers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void rt.byteVecPush(out, rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.iterBorrow(_166), true, undefined, undefined, 8, true)) & 0xff); bounds$ops_RangeInclusive_u64(out, keyed); const queued: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u64Step); - rt.byteVecPush(out, ((rt.dequeFromVec(rt.iterToArray(rt.iterBorrow(queued), undefined, 8, true), 8) as rt.VecDeque)).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; @@ -354,7 +354,7 @@ export function wrappers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void rt.byteVecPush(out, held.length & 0xff); bounds$ops_RangeInclusive_u64(out, extended); const narrow: rt.RangeInclusive = new rt.RangeInclusive(rt.u64Low(lo) & 0xff, rt.u64Low(hi) & 0xff, rt.u8Step); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterBorrow(narrow), undefined, true)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterBorrow(narrow), undefined, true))), undefined, true); rt.byteVecPush(out, rt.rangeInclusiveStart(narrow)); rt.byteVecPush(out, rt.rangeInclusiveIsEmpty(narrow) ? 1 : 0); bounds$ops_RangeTo_u64(out, { end: b }); diff --git a/ts/fixtures/lang/expected/zeros.ts b/ts/fixtures/lang/expected/zeros.ts index e4f2e13c4..fd2849c05 100644 --- a/ts/fixtures/lang/expected/zeros.ts +++ b/ts/fixtures/lang/expected/zeros.ts @@ -143,7 +143,7 @@ export function zeros(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { 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, 0).length & 0xff); + rt.byteVecPush(out, rt.vecFromElem({}, n, undefined).length & 0xff); rt.byteVecPush(out, v2.length & 0xff); } else { rt.iterFromFn((): rt.u8 | undefined => { @@ -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; @@ -541,7 +541,7 @@ export function writes(kind: rt.u8, _dataData: Uint8Array, _dataStart: number, d rt.cellReplace(_113, undefined); rt.cellSet(_113, undefined); rt.sliceSwap([undefined, undefined, undefined], 0, n as rt.usize); - const v: zeros_Unit.Unit[] = rt.vecFromElem({}, 2, undefined, 0); + const v: zeros_Unit.Unit[] = rt.vecFromElem({}, 2, undefined); rt.sliceSwap(v, 0, 1); rt.byteVecPush(out, ([undefined, undefined, undefined].length & 0xff) | (((v.length & 0xff) << 4) & 0xff)); const _141: rt.Cell = new rt.Cell(undefined); diff --git a/ts/fixtures/lang/src/capacity.rs b/ts/fixtures/lang/src/capacity.rs index 947d59bb3..76e49af0e 100644 --- a/ts/fixtures/lang/src/capacity.rs +++ b/ts/fixtures/lang/src/capacity.rs @@ -1,6 +1,8 @@ //! 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. +//! 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; @@ -10,6 +12,50 @@ 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. @@ -56,35 +102,75 @@ fn vec_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec) 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()), - 3 => v.reserve(amount(arg, v.len(), size)), - 4 => v.reserve_exact(amount(arg, v.len(), size)), - 5 => v.shrink_to(usize::from(arg % 40)), - 6 => v.shrink_to_fit(), - 7 => v.truncate(usize::from(arg % 8)), + 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())), + 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)]), - 13 => v.clear(), + 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); } - 15 => drop(v.drain(..v.len().min(usize::from(arg % 4)))), - 16 => v = v.clone(), - 17 => v = v.into_boxed_slice().into_vec(), // 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(); @@ -92,16 +178,23 @@ fn vec_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec) drop(if i % 3 == 2 { it.next_back() } else { it.next() }); } v = it.collect(); + k.remade(false); } 20 => { let mut taken = mem::take(&mut v); taken.push(make(arg)); - put(out, taken.capacity()); + k.put(out, taken.len(), taken.capacity()); v = mem::replace(&mut taken, Vec::with_capacity(usize::from(arg % 6))); - put(out, taken.capacity()); + 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(); } - 21 if !v.is_empty() => drop(v.swap_remove(usize::from(arg) % v.len())), - 22 => v.dedup(), // A clone of one read from the front, a new `Vec` of what was left. 23 => { let mut it = v.into_iter(); @@ -109,12 +202,17 @@ fn vec_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec) drop(it.next()); } v = it.clone().collect(); - put(out, it.collect::>().capacity()); + k.remade(true); + let rest = it.collect::>(); + Known { exact: false, floor: 0 }.put(out, rest.len(), rest.capacity()); } - _ => v = vec![make(arg); usize::from(arg % 6)], + 24 => { + v = vec![make(arg); usize::from(arg % 6)]; + k.remade(false); + } + _ => {} } - put(out, v.len()); - put(out, v.capacity()); + k.put(out, v.len(), v.capacity()); } } @@ -130,35 +228,75 @@ fn deque_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec 1 => VecDeque::with_capacity(usize::from(first >> 3)), _ => VecDeque::new(), }; + let mut k = Known::new(q.capacity()); put(out, q.capacity()); for step in steps.chunks(2) { let (op, arg) = (step[0], step.get(1).copied().unwrap_or(0)); match op % 21 { 0 => q.push_back(make(arg)), 1 => q.push_front(make(arg)), - 2 => drop(q.pop_front()), - 3 => q.reserve(amount(arg, q.len(), size)), - 4 => q.reserve_exact(amount(arg, q.len(), size)), - 5 => q.shrink_to(usize::from(arg % 40)), - 6 => q.shrink_to_fit(), - 7 => q.truncate(usize::from(arg % 8)), + 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))), + 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(), + 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); } - 14 => drop(q.drain(..q.len().min(usize::from(arg % 4)))), - 15 => q = q.clone(), // Its own, and a `Vec`'s in place of one, and one it collects first. - 16 => q = q.into_iter().collect(), - 17 => q = VecDeque::from(q.into_iter().collect::>()), + 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(); @@ -166,12 +304,16 @@ fn deque_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec drop(it.next()); } q = it.clone().collect(); - put(out, it.collect::>().capacity()); + 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); } - _ => q = VecDeque::from([make(arg), make(arg), make(arg)]), } - put(out, q.len()); - put(out, q.capacity()); + k.put(out, q.len(), q.capacity()); } } @@ -187,39 +329,66 @@ fn heap_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec) 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()), - 3 => h.reserve(amount(arg, h.len(), size)), - 4 => h.reserve_exact(amount(arg, h.len(), size)), - 5 => h.shrink_to(usize::from(arg % 40)), - 6 => h.shrink_to_fit(), - 7 => h.clear(), + 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); - put(out, other.capacity()); + k.remade(false); + Known { exact: false, floor: 0 }.put(out, other.len(), other.capacity()); + } + 10 => { + drop(h.drain()); + k.loose(); } - 10 => drop(h.drain()), - // A guard that hid all but the top, forgotten, which leaves the allocation. + // 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()), } - put(out, h.len()); - put(out, h.capacity()); + k.put(out, h.len(), h.capacity()); } - put(out, h.clone().into_vec().capacity()); - put(out, h.into_sorted_vec().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 @@ -230,34 +399,37 @@ pub fn collects(kind: u8, data: &[u8], out: &mut Vec) { 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, which fit twice as many. + // Two `u32`s to one in place, which fit twice as many. 0 => { let halves: Vec = pairs.into_iter().map(|(a, _)| a).collect(); - put(out, halves.capacity()); + loose.put(out, halves.len(), halves.capacity()); } - // Bytes in place of bytes, and pairs of bytes in place of bytes, which fit half. + // 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(); - put(out, odd.capacity()); + loose.put(out, odd.len(), odd.capacity()); let wide: Vec = bytes.into_iter().map(u16::from).collect(); - put(out, wide.capacity()); + exact.put(out, wide.len(), wide.capacity()); } 2 => { let (a, b): (Vec, VecDeque) = pairs.iter().filter(|(a, _)| a % 2 == 0).copied().unzip(); - put(out, a.capacity()); - put(out, b.capacity()); + 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(); - put(out, c.capacity()); - put(out, d.capacity()); + exact.put(out, c.len(), c.capacity()); + exact.put(out, d.len(), d.capacity()); } 3 => { let filled = vec![0u16; n]; - put(out, filled.capacity()); + loose.put(out, filled.len(), filled.capacity()); let units = vec![(); n]; - put(out, units.capacity()); + exact.put(out, units.len(), units.capacity()); } 4 => { let v: Vec = Vec::with_capacity(usize::MAX - n); @@ -271,18 +443,20 @@ pub fn collects(kind: u8, data: &[u8], out: &mut Vec) { 6 => { let mut bytes = Vec::with_capacity(n + 5); bytes.extend_from_slice(&data[..n.min(data.len())]); - put(out, VecDeque::from(bytes.clone()).capacity()); + let q = VecDeque::from(bytes.clone()); + loose.put(out, q.len(), q.capacity()); let heap = BinaryHeap::from(bytes); - put(out, heap.capacity()); - put(out, heap.into_vec().capacity()); + 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)); - put(out, grown.capacity()); + exact.put(out, grown.len(), grown.capacity()); grown.shrink_to(n / 2); - put(out, grown.capacity()); + exact.put(out, grown.len(), grown.capacity()); } } } diff --git a/ts/runtime/rt.ts b/ts/runtime/rt.ts index 0b598a989..77ba8af7d 100644 --- a/ts/runtime/rt.ts +++ b/ts/runtime/rt.ts @@ -142,12 +142,12 @@ 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: Vec = p.slice(); - vecSetCapacity(old, (p as Vec).cap ?? p.length); + 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 as T; } @@ -681,196 +681,78 @@ function dedupAt(a: { [i: number]: T }, n: number, same: (i: number, kept: nu return write; } -// Capacity. A `Vec`, other than of bytes, is a JS array whose `cap` is std's capacity: -// `RawVec`'s, which `with_capacity` and `reserve_exact` make exactly what they ask for, -// and which grows as `grow_amortized` does. An array without one holds as many as its -// length, as one allocated for exactly its elements does, which `vec!`, a clone, and a -// `TrustedLen` collect make, so whatever drops its length keeps its capacity first. One -// of zero-sized elements holds `usize::MAX`, which it never fills. - -/** wasm32's `isize::MAX`, the most bytes std's `Layout` describes. */ -const ISIZE_MAX = 0x7fffffff; - -/** wasm32's `usize::MAX`. */ -const USIZE_MAX = 0xffffffff; - -/** A `Vec` other than of bytes: its elements, and its capacity where that may be past them. */ -export type Vec = T[] & { cap?: number }; - -/** How many `size`-byte elements a `Vec` 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 `cap` of `size`-byte elements grows to as std's `RawVec::grow_amortized` - * makes it to hold `required`: at least double, and at least the least it allocates for - * its size, or a panic past what it may hold. - */ -export function capGrow(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 `cap` of `size`-byte elements, holding `len`, once `reserve` made room for `additional` more. */ -export function capReserve(len: number, cap: number, additional: number, size: number): number { - return additional > cap - len ? capGrow(cap, len + additional, size) : cap; -} - -/** The capacity `cap` of `size`-byte elements, 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` of `size`-byte elements, holding `len`, once `shrink_to` of `min` shrank it: `shrink_to_fit`'s is 0. */ -export function capShrink(len: number, cap: number, min: number, size: number): number { - return size !== 0 && cap > min ? Math.max(len, min) : cap; -} - -/** `Vec::capacity` of `size`-byte elements. */ -export function vecCapacity(v: Vec, size: number): number { - return size === 0 ? USIZE_MAX : (v.cap ?? v.length); -} - -/** `v`'s capacity set to `cap`, which an array without one already has if it is its length. */ -export function vecSetCapacity(v: Vec, cap: number): void { - if (v.cap !== undefined || cap !== v.length) v.cap = cap; -} - -/** `v`'s capacity kept as its own, before its length drops. */ -export function vecHold(v: Vec): void { - v.cap ??= v.length; -} - -/** `Vec::with_capacity` of `size`-byte elements, which panics past what it may hold. */ -export function vecWithCapacity(n: number, size: number): Vec { - if (n > vecMax(size)) panic("capacity overflow"); - const v: Vec = []; - vecSetCapacity(v, n); - return v; -} - -/** `Vec::push` of `size`-byte elements, growing as `RawVec::grow_one` does once full. */ -export function vecPush(v: Vec, item: T, size: number): void { - // Kept small for engines to inline, as most pushes find room: on `just ts bench`'s - // `push/vec`, Bun took twice as long with the growth in line. - if (v.cap !== undefined && v.length < v.cap) v.push(item); - else vecGrowPush(v, item, size); -} - -/** `vecPush` where `v` may be full. */ -function vecGrowPush(v: Vec, item: T, size: number): void { - const cap = vecCapacity(v, size); - if (v.length === cap) v.cap = capGrow(cap, cap + 1, size); - v.push(item); -} - -/** `Vec::reserve` of `size`-byte elements. */ -export function vecReserve(v: Vec, additional: number, size: number): void { - vecSetCapacity(v, capReserve(v.length, vecCapacity(v, size), additional, size)); -} - -/** `Vec::reserve_exact` of `size`-byte elements. */ -export function vecReserveExact(v: Vec, additional: number, size: number): void { - vecSetCapacity(v, capReserveExact(v.length, vecCapacity(v, size), additional, size)); -} - -/** `Vec::shrink_to` of `size`-byte elements, and `shrink_to_fit` to 0. */ -export function vecShrinkTo(v: Vec, min: number, size: number): void { - vecSetCapacity(v, capShrink(v.length, vecCapacity(v, size), min, size)); -} - -/** `Vec::into_boxed_slice`, which shrinks it to its elements. */ -export function vecIntoBoxed(v: Vec): T[] { - vecSetCapacity(v, v.length); - return v; -} - /** `Vec::retain`, and `retain_mut` of an element that is an object. */ -export function vecRetain(v: Vec, f: (item: T) => boolean, drop?: (item: T) => void): void { - vecHold(v); +export function vecRetain(v: T[], f: (item: T) => boolean, drop?: (item: T) => void): void { v.length = retainAt(v, v.length, (i) => f(v[i]), drop); } /** `Vec::retain_mut` of an element JS copies, which `f` takes the place of. */ -export function vecRetainMut(v: Vec, f: (item: Place) => boolean, drop?: (item: T) => void): void { - vecHold(v); +export function vecRetainMut(v: T[], f: (item: Place) => boolean, drop?: (item: T) => void): void { v.length = retainAt(v, v.length, (i) => f(new AtIndex(v, i)), drop); } /** `Vec::dedup_by`: drops each element `same(element, previous kept)` is true for, in order. */ -export function vecDedupBy(v: Vec, same: (a: T, b: T) => boolean, drop?: (item: T) => void): void { - vecHold(v); +export function vecDedupBy(v: T[], same: (a: T, b: T) => boolean, drop?: (item: T) => void): void { v.length = dedupAt(v, v.length, (i, j) => same(v[i], v[j]), drop); } /** `Vec::dedup_by` of an element JS copies, whose places `same` takes. */ -export function vecDedupByMut(v: Vec, same: (a: Place, b: Place) => boolean, drop?: (item: T) => void): void { - vecHold(v); +export function vecDedupByMut(v: T[], same: (a: Place, b: Place) => boolean, drop?: (item: T) => void): void { v.length = dedupAt(v, v.length, (i, j) => same(new AtIndex(v, i), new AtIndex(v, j)), drop); } /** `Vec::dedup_by_key`: as `vecDedupBy`, by `eq` of `key` of each element, then of the previous kept. */ -export function vecDedupByKey(v: Vec, key: (item: T) => K, eq: (a: K, b: K) => boolean, drop?: (item: T) => void): void { +export function vecDedupByKey(v: T[], key: (item: T) => K, eq: (a: K, b: K) => boolean, drop?: (item: T) => void): void { vecDedupBy(v, (a, b) => eq(key(a), key(b)), drop); } /** `Vec::dedup_by_key` of an element JS copies, whose places `key` takes. */ -export function vecDedupByKeyMut(v: Vec, key: (item: Place) => K, eq: (a: K, b: K) => boolean, drop?: (item: T) => void): void { +export function vecDedupByKeyMut(v: T[], key: (item: Place) => K, eq: (a: K, b: K) => boolean, drop?: (item: T) => void): void { 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 and capacity, in place. */ -export function vecAssign(v: Vec, value: Vec): void { +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 ?? value.length; + if (v.cap !== undefined || value.cap !== undefined) v.cap = value.cap; } -/** `Vec::insert` of `size`-byte elements: `item` at `i`, with those from `i` on moved up. */ -export function vecInsert(v: Vec, i: number, item: T, size: number): void { +/** `Vec::insert`: `item` at `i`, with those from `i` on moved up. */ +export function vecInsert(v: T[], i: number, item: T): void { if (i > v.length) panic(`insertion index (is ${i}) should be <= len (is ${v.length})`); - const cap = vecCapacity(v, size); - if (v.length === cap) v.cap = capGrow(cap, cap + 1, size); v.splice(i, 0, item); } -/** `Vec::pop`: the last element, or `none` if empty, which is `undefined` but where an element can be. */ -export function vecPop(v: Vec): T | undefined; -export function vecPop(v: Vec, none: None): T | None; -export function vecPop(v: Vec, none?: None): T | None | undefined { - if (v.length === 0) return none; - vecHold(v); - return v.pop() as T; +/** `Vec::pop` of an element that can be `undefined`: the last element, or `none` if empty. */ +export function vecPop(v: T[], none: None): T | None { + return v.length === 0 ? none : (v.pop() as T); } /** * `Vec::pop_if`: the last element if `f` takes it, given the element, or else `none`. An * empty `v` drops `f` by `dropF` uncalled. */ -export function vecPopIf(v: Vec, f: (item: T) => boolean, dropF?: (f: (item: T) => boolean) => void): T | undefined; -export function vecPopIf(v: Vec, f: (item: T) => boolean, dropF: ((f: (item: T) => boolean) => void) | undefined, none: None): T | None; -export function vecPopIf(v: Vec, f: (item: T) => boolean, dropF?: (f: (item: T) => boolean) => void, none?: None): T | None | undefined { +export function vecPopIf(v: T[], f: (item: T) => boolean, dropF?: (f: (item: T) => boolean) => void): T | undefined; +export function vecPopIf(v: T[], f: (item: T) => boolean, dropF: ((f: (item: T) => boolean) => void) | undefined, none: None): T | None; +export function vecPopIf(v: T[], f: (item: T) => boolean, dropF?: (f: (item: T) => boolean) => void, none?: None): T | None | undefined { if (v.length === 0) { dropF?.(f); return none; } - return f(v[v.length - 1]) ? vecPop(v) : none; + return f(v[v.length - 1]) ? (v.pop() as T) : none; } /** `Vec::pop_if` of an element JS copies, which `f` takes the place of. */ -export function vecPopIfMut(v: Vec, f: (item: Place) => boolean, dropF?: (f: (item: Place) => boolean) => void): T | undefined; +export function vecPopIfMut(v: T[], f: (item: Place) => boolean, dropF?: (f: (item: Place) => boolean) => void): T | undefined; export function vecPopIfMut( - v: Vec, + v: T[], f: (item: Place) => boolean, dropF: ((f: (item: Place) => boolean) => void) | undefined, none: None, ): T | None; export function vecPopIfMut( - v: Vec, + v: T[], f: (item: Place) => boolean, dropF?: (f: (item: Place) => boolean) => void, none?: None, @@ -879,41 +761,33 @@ export function vecPopIfMut( dropF?.(f); return none; } - return f(new AtIndex(v, v.length - 1)) ? vecPop(v) : none; + return f(new AtIndex(v, v.length - 1)) ? (v.pop() as T) : none; } /** `Vec::remove`: the element at `i`, with those after it moved down. */ -export function vecRemove(v: Vec, i: number): T { +export function vecRemove(v: T[], i: number): T { if (i >= v.length) panic(`removal index (is ${i}) should be < len (is ${v.length})`); - vecHold(v); return v.splice(i, 1)[0]; } /** `Vec::truncate`, and `clear` to 0: the first `len` elements, if there are more, and then each other drops in order. */ -export function vecTruncate(v: Vec, len: number, drop?: (item: T) => void): void { +export function vecTruncate(v: T[], len: number, drop?: (item: T) => void): void { if (len >= v.length) return; - vecHold(v); const cut = v.splice(len); if (drop !== undefined) dropAll(cut, drop); } /** `Vec::swap_remove`: the element at `i`, with the last moved into its place. */ -export function vecSwapRemove(v: Vec, i: number): T { +export function vecSwapRemove(v: T[], i: number): T { if (i >= v.length) panic(`swap_remove index (is ${i}) should be < len (is ${v.length})`); - vecHold(v); const item = v[i]; v[i] = v[v.length - 1]; v.pop(); return item; } -/** - * `Vec::extend_from_slice`: a clone of each element of `s`, pushed in order, as far as - * they clone, once it reserved for them all as std's does where `size` is given. One made - * for exactly what it holds, as a `concat` reserves, takes none. - */ -export function vecExtendFromSlice(v: Vec, s: ArrayLike, clone?: (item: T) => T, size?: number): void { - if (size !== undefined) vecReserve(v, s.length, size); +/** `Vec::extend_from_slice`: a clone of each element of `s`, pushed in order, as far as they clone. */ +export function vecExtendFromSlice(v: T[], s: ArrayLike, clone?: (item: T) => T): void { for (let i = 0; i < s.length; i++) v.push(clone === undefined ? s[i] : clone(s[i])); } @@ -1109,16 +983,14 @@ export function byteSliceToByteVec(s: ByteSlice): ByteVec { return v; } -/** - * `vec![value; n]` of `size`-byte elements: `n - 1` clones of `value`, in order, then - * `value` itself; `clone` is `undefined` where a clone is the value. Its capacity is `n`, - * which panics past what it may hold before anything clones. - */ -export function vecFromElem(value: T, n: number, clone: ((value: T) => T) | undefined, size: number): T[] { - if (n > vecMax(size)) panic("capacity overflow"); - const v: T[] = []; +/** `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[] & 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; } @@ -1183,17 +1055,11 @@ export function arrayPlaces(a: { [i: number]: T; length: number }): Place[ return out; } -/** `Vec`: a growable byte buffer, whose storage's length is std's capacity. */ +/** `Vec`: a growable byte buffer. */ export class ByteVec { /** The storage; only the first `length` bytes are the vector. */ data: Uint8Array; length = 0; - /** - * Whether it was taken from `bytes`' storage, whose capacity, which `data` doesn't - * hold, depends on whether other handles of it dropped, until it shrinks to fit. - * Optional so that a `ByteSlice` still stands in for one, as a key it borrows as. - */ - unsure?: boolean; constructor(capacity = 0) { this.data = bytes(capacity); @@ -1208,67 +1074,22 @@ export function byteVecFrom(bytes: Uint8Array): ByteVec { return v; } -/** A `Vec` in place of the `Vec` of numbers `v`, of its capacity, as a heap's `into_vec` keeps it. */ -export function byteVecFromVec(v: Vec): ByteVec { - const out = new ByteVec(vecCapacity(v, 1)); - out.data.set(v); - out.length = v.length; - return out; -} - -/** A `Vec` of numbers in place of the `Vec` `v`, of its capacity, as a heap's or a deque's `From` keeps it. */ -export function byteVecToVec(v: ByteVec): Vec { - if (v.unsure) throw new Error("rust2-ts: a collection in place of a `Vec` taken from `bytes`' storage, whose capacity depends on whether other handles of it dropped"); - const out: Vec = Array.from(byteVecView(v)); - vecSetCapacity(out, v.data.length); - return out; -} - /** `vec![value; n]` of bytes. */ export function byteVecOf(value: number, n: number): ByteVec { - const v = byteVecWithCapacity(n); + const v = new ByteVec(n); v.data.fill(value); v.length = n; return v; } -/** `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::capacity` of bytes: its storage's length, which is std's. */ -export function byteVecCapacity(v: ByteVec): number { - if (v.unsure) throw new Error("rust2-ts: the capacity of a `Vec` taken from `bytes`' storage, which depends on whether other handles of it dropped"); - return v.data.length; -} - -/** Its storage moved to `cap` bytes, where that isn't its capacity. */ -function realloc(v: ByteVec, cap: number): void { - if (cap === v.data.length) return; - const data = bytes(cap); - // All of `data` where it fits, which costs less than making a view of its first `length` bytes. - if (cap >= v.data.length) data.set(v.data); - else copyBytes(data, 0, v.data, 0, v.length); - v.data = data; -} - -/** `Vec::reserve` of bytes. */ -export function byteVecReserve(v: ByteVec, additional: number): void { - if (additional > v.data.length - v.length) realloc(v, capGrow(v.data.length, v.length + additional, 1)); -} - -/** `Vec::reserve_exact` of bytes. */ -export function byteVecReserveExact(v: ByteVec, additional: number): void { - realloc(v, capReserveExact(v.length, v.data.length, additional, 1)); -} - -/** `Vec::shrink_to` of bytes, and `shrink_to_fit` to 0. */ -export function byteVecShrinkTo(v: ByteVec, min: number): void { - realloc(v, capShrink(v.length, v.data.length, min, 1)); - // Whatever it held, it now holds `length`. - if (min <= v.length) v.unsure = false; +/** Make room for `additional` more bytes. */ +function reserve(v: ByteVec, additional: number): void { + const needed = v.length + additional; + if (needed <= v.data.length) return; + const grown = bytes(Math.max(needed, v.data.length * 2, 8)); + // All of `data`, which costs less than making a view of its first `length` bytes. + grown.set(v.data); + v.data = grown; } /** The bytes, as a view that a later push may detach. */ @@ -1283,7 +1104,7 @@ export function byteVecSlice(v: ByteVec): ByteSlice { /** `Vec::push`. */ export function byteVecPush(v: ByteVec, byte: number): void { - byteVecReserve(v, 1); + reserve(v, 1); v.data[v.length++] = byte; } @@ -1307,7 +1128,7 @@ export function byteVecPopIf( /** `Vec::extend_from_slice`. */ export function byteVecExtendFromSlice(v: ByteVec, s: ByteSlice): void { - byteVecReserve(v, s.length); + reserve(v, s.length); copyBytes(v.data, v.length, s.data, s.start, s.length); v.length += s.length; } @@ -1325,7 +1146,7 @@ export function byteVecClear(v: ByteVec): void { /** `Vec::insert`: `byte` at `i`, with those from `i` on moved up. */ export function byteVecInsert(v: ByteVec, i: number, byte: number): void { if (i > v.length) panic(`insertion index (is ${i}) should be <= len (is ${v.length})`); - byteVecReserve(v, 1); + reserve(v, 1); v.data.copyWithin(i + 1, i, v.length); v.data[i] = byte; v.length++; @@ -1373,6 +1194,144 @@ 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; +} + +/** + * 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 { + capSet(v, v.length, 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 { + capSet(v, v.length, 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/bytes.ts b/ts/runtime/rt/bytes.ts index b94cad4ca..4aa237388 100644 --- a/ts/runtime/rt/bytes.ts +++ b/ts/runtime/rt/bytes.ts @@ -10,8 +10,6 @@ import { bytes, byteVecExtendFromSlice, byteVecPush, - byteVecReserve, - byteVecWithCapacity, copyBytes, type FmtResult, type Formatter, @@ -324,22 +322,9 @@ export function bytesMutFreeze(b: BytesMut): Bytes { return new ByteSlice(b.data, b.start, b.length); } -/** - * `From for Vec`: of a vector's own, the vector, holding as many as it did - * from its front, and else storage whose capacity is unsure. - */ +/** `From for Vec`. */ export function bytesMutToByteVec(b: BytesMut): ByteVec { - const v = byteVecWithCapacity(b.exact ? b.start + b.cap : b.length); - byteVecExtendFromSlice(v, bytesMutView(b)); - v.unsure = !b.exact; - return v; -} - -/** `From for Vec`: its bytes, in storage whose capacity is unsure. */ -export function bytesToByteVec(b: Bytes): ByteVec { - const v = byteSliceToByteVec(b); - v.unsure = true; - return v; + return byteSliceToByteVec(bytesMutView(b)); } /** @@ -526,7 +511,7 @@ export function byteVecPutBuf( chunk: (src: B) => ByteSlice, advance: (src: B, cnt: usize) => void, ): void { - byteVecReserve(v, remaining(src)); + if (v.length + remaining(src) > ISIZE_MAX) panic("capacity overflow"); while (hasRemaining(src)) { const s = chunk(src); byteVecExtendFromSlice(v, s); @@ -534,15 +519,13 @@ export function byteVecPutBuf( } } -/** `BufMut::put_u8` and the other writes of a narrow integer to a `Vec`, as `bytesMutPutWord`, which reserves for them all first. */ +/** `BufMut::put_u8` and the other writes of a narrow integer to a `Vec`, as `bytesMutPutWord`. */ export function byteVecPutWord(v: ByteVec, value: number, n: number, le: boolean): void { - byteVecReserve(v, n); for (let i = 0; i < n; i++) byteVecPush(v, value >>> (8 * (le ? i : n - 1 - i))); } -/** `BufMut::put_*` of big-endian bytes to a `Vec`, reversed if `le`, which reserves for them all first. */ +/** `BufMut::put_*` of big-endian bytes to a `Vec`, reversed if `le`. */ export function byteVecPutBytes(v: ByteVec, be: Uint8Array, le: boolean): void { - byteVecReserve(v, be.length); for (let i = 0; i < be.length; i++) byteVecPush(v, be[le ? be.length - 1 - i : i]); } @@ -552,8 +535,8 @@ export function byteVecPutInt(v: ByteVec, be: Uint8Array, nbytes: usize, le: boo byteVecPutBytes(v, be.subarray(be.length - nbytes), le); } -/** `BufMut::put_bytes` to a `Vec`: its `resize`, which reserves for them all first. */ +/** `BufMut::put_bytes` to a `Vec`: its `resize`, which panics past what a vector holds. */ export function byteVecPutFill(v: ByteVec, val: number, cnt: usize): void { - byteVecReserve(v, cnt); + if (v.length + cnt > ISIZE_MAX) panic("capacity overflow"); for (let i = 0; i < cnt; i++) byteVecPush(v, val); } diff --git a/ts/runtime/rt/collections.ts b/ts/runtime/rt/collections.ts index 2d4929863..a02e66223 100644 --- a/ts/runtime/rt/collections.ts +++ b/ts/runtime/rt/collections.ts @@ -14,33 +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, - byteVecReserve, - capGrow, - capReserve, - capReserveExact, - capShrink, - type None, - type Place, - panic, - type RangeBound, - rangeCheck, - sliceSort, - type Vec, - vecCapacity, - vecSetCapacity, - vecExtendFromSlice, - vecHold, - vecMax, - vecPop, - vecPush, - vecReserve, - vecTruncate, - vecWithCapacity, -} from "../rt.ts"; +import { ByteSlice, ByteVec, byteVecPush, byteVecReserve, type Capped, 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 { @@ -61,10 +35,6 @@ import { type SizeHint, type Take, capNext, - iterExtend, - iterToArray, - satAdd, - sourceCapacity, trustedUpper, } from "./iter.ts"; import { type Arc, drop as dispose, dropAll, dropRange } from "./task.ts"; @@ -934,22 +904,24 @@ function extending(c: C, items: Iter, add: (item: T) => void, take?: Ta } /** - * `extending` a collection that std's collects into a `Vec` of `size`-byte elements first, - * which panics as that `Vec` does past what it may hold: for a `trusted` iterator up - * front, and for any other by `next` as it fills. + * `extending` a `Vec` or `VecDeque` holding `len`, which with elements `size` bytes each + * reserves as `iterExtend` does, into the capacity `at` holds: a `trusted` iterator up + * front, and any other by `next`, a `deque`'s at its first item too. */ -function vecCollecting(c: C, items: Iter, add: (item: T) => void, take?: Take, size?: number, trusted = false): C { - if (size === undefined || trusted) { - if (size !== undefined) vecWithCapacity(trustedUpper(items), 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([], size); - let len = 0; for (let item = items.next(); item !== DONE; item = items.next()) { - if (len === cap) cap = capNext(items, cap, size); + if (deque || len === cap) cap = capNext(items, len, cap, size); + deque = false; add(item); len++; } + capSet(at, len, cap, size); if (take !== undefined) dispose(items); return c; } @@ -1831,7 +1803,7 @@ export function btreeExtend( l.v[i] = item[1]; } }; - return vecCollecting(m, items, add, take, size, trusted); + return vecExtending(m, 0, items, add, take, size, trusted); } /** `extend` of a set with keys, and with `last`, `collect` and `from`, as `btreeExtend`. */ @@ -1846,7 +1818,7 @@ export function btreeExtendKeys(m: BTreeSet, keys: Iter, last = false, if (i < 0) insertAt(m, l, ~i, key, undefined); else l.k[i] = key; }; - return vecCollecting(m, keys, add, take, size, trusted); + return vecExtending(m, 0, keys, add, take, size, trusted); } /** @@ -2384,72 +2356,53 @@ export function btreeFirstEntry(m: BTreeMap, last = false): Entry`: a ring buffer of `b.length` slots, a power of two, holding `n` items - * from `h` on, wrapping past the end, and `c`, std's capacity, which holds `usize::MAX` - * of zero-sized items. + * 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; - c: number; } /** `VecDeque::new`. */ export function dequeNew(): VecDeque { - return { b: [], h: 0, n: 0, c: 0 }; + 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"); - return { b: [], h: 0, n: 0, c: n }; -} - -/** A deque of `v`'s items, in place of the `Vec`, whose capacity it keeps: `From>`. */ -export function dequeFromVec(v: Vec, size: number): VecDeque { const q = dequeNew(); - for (const item of v) dequePut(q, item); - q.c = vecCapacity(v, size); + capSet(q, 0, n, size); return q; } -/** - * `collect` into a deque of `size`-byte items from `it`, a `vec::IntoIter` or a deque's - * `IntoIter`, taken as `take` says, which std's makes a deque of in place of what `it` - * reads, keeping its capacity. - */ -export function dequeFromIntoIter(it: Iter, size: number, take?: Take): VecDeque { - const [cap, unsure] = it instanceof DequeIter ? [it.cap ?? dequeCapacity(it.q, size), false] : sourceCapacity(it, size); - if (unsure) throw new Error("rust2-ts: a `VecDeque` in place of a `Vec` taken from `bytes`' storage, whose capacity depends on whether other handles of it dropped"); - const q = dequeFromVec(iterToArray(it, take, undefined, true), size); - q.c = cap; +/** 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 size === 0 ? vecMax(0) : q.c; + return capOf(q.n, q.cap, size); } /** `VecDeque::reserve` of `size`-byte items. */ export function dequeReserve(q: VecDeque, additional: number, size: number): void { - q.c = capReserve(q.n, dequeCapacity(q, size), additional, size); + capSet(q, q.n, 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 { - q.c = capReserveExact(q.n, dequeCapacity(q, size), additional, size); + capSet(q, q.n, capReserveExact(q.n, dequeCapacity(q, size), additional, size), size); } -/** `VecDeque::shrink_to` of `size`-byte items, and `shrink_to_fit` to 0. */ +/** `VecDeque::shrink_to` of `size`-byte items, and `shrink_to_fit` of 0. */ export function dequeShrinkTo(q: VecDeque, min: number, size: number): void { - q.c = capShrink(q.n, dequeCapacity(q, size), min, size); -} - -/** Room for one more of `size`-byte items, as std's `grow` makes once it is full. */ -function full(q: VecDeque, size: number): void { - const cap = dequeCapacity(q, size); - if (q.n === cap) q.c = capGrow(cap, cap + 1, size); + capSet(q, q.n, capShrink(q.n, dequeCapacity(q, size), min), size); } /** The slot of item `i`. */ @@ -2457,7 +2410,7 @@ function at(q: VecDeque, i: number): number { return (q.h + i) & (q.b.length - 1); } -/** Room in the buffer for one more item. */ +/** Room for one more item. */ function grow(q: VecDeque): void { if (q.n < q.b.length) return; const b = new Array(Math.max(4, q.b.length * 2)); @@ -2466,21 +2419,12 @@ function grow(q: VecDeque): void { q.h = 0; } -/** `item` added at the back, past what std's capacity says. */ -function dequePut(q: VecDeque, item: T): void { +export function dequePushBack(q: VecDeque, item: T): void { grow(q); q.b[at(q, q.n++)] = item; } -/** `push_back` of `size`-byte items. */ -export function dequePushBack(q: VecDeque, item: T, size: number): void { - if (q.n === q.c) full(q, size); - dequePut(q, item); -} - -/** `push_front` of `size`-byte items. */ -export function dequePushFront(q: VecDeque, item: T, size: number): void { - if (q.n === q.c) full(q, size); +export function dequePushFront(q: VecDeque, item: T): void { grow(q); q.h = (q.h - 1) & (q.b.length - 1); q.b[q.h] = item; @@ -2555,7 +2499,7 @@ export function dequeDrop(q: VecDeque, f: (item: T) => void): void { /** `clear`, which leaves the deque empty and then drops each item, front to back. */ export function dequeClear(q: VecDeque, f?: (item: T) => void): void { - const old: VecDeque = { b: q.b, h: q.h, n: q.n, c: q.c }; + const old: VecDeque = { b: q.b, h: q.h, n: q.n }; q.b = []; q.h = 0; q.n = 0; @@ -2630,10 +2574,10 @@ export function dequeRemove(q: VecDeque, i: number, none?: None): T | None return item; } -/** `insert` of `size`-byte items: `item` at `i`, with those from `i` on moved down. */ -export function dequeInsert(q: VecDeque, i: number, item: T, size: number): void { +/** `insert`: `item` at `i`, with those from `i` on moved down. */ +export function dequeInsert(q: VecDeque, i: number, item: T): void { if (i > q.n) panic("index out of bounds"); - dequePushBack(q, item, size); + dequePushBack(q, item); for (let j = q.n - 1; j > i; j--) q.b[at(q, j)] = q.b[at(q, j - 1)]; q.b[at(q, i)] = item; } @@ -2642,13 +2586,11 @@ export function dequeInsert(q: VecDeque, i: number, item: T, size: number) * An iterator of a deque's items from index `front` up to `back`, which drops those it * still holds by `drop` as it drops, if it owns them, as a `drain` does. */ -export class DequeIter extends Iter implements Disposable { - readonly q: VecDeque; +class DequeIter extends Iter implements Disposable { + private readonly q: VecDeque; private front: number; private back: number; private readonly drop: ((item: T) => void) | undefined; - /** The capacity of the deque a clone of `into_iter` owns, a new one of what was left, if not `q`'s. */ - cap: number | undefined; constructor(q: VecDeque, front: number, back: number, drop?: (item: T) => void) { super(); @@ -2668,11 +2610,7 @@ export class DequeIter extends Iter implements Disposable { /** std's: where it is, or of `into_iter`, what it has left, each cloned in order by `h.v`. */ override clone(h?: Clones): Iter { - if (h?.v === undefined) { - const it = new DequeIter(this.q, this.front, this.back, this.drop); - it.cap = this.back - this.front; - return it; - } + if (h?.v === undefined) return new DequeIter(this.q, this.front, this.back, this.drop); const clone = h.v as (item: T) => T; const items: T[] = []; for (let i = this.front; i < this.back; i++) items.push(clone(this.q.b[at(this.q, i)] as T)); @@ -2705,10 +2643,8 @@ export class DequeIter extends Iter implements Disposable { */ export function dequeIter(q: VecDeque, drop?: (item: T) => void): Iter { if (drop === undefined) return new DequeIter(q, 0, q.n); - // Of the deque's capacity, which a `collect` into another keeps. - const items: Vec = []; + const items: T[] = []; for (let i = 0; i < q.n; i++) items.push(q.b[at(q, i)] as T); - items.cap = q.c; return iterSlice(items, drop); } @@ -2749,8 +2685,8 @@ class DequePlaces extends Iter> { /** `drain`: the items within `r`, taken out at once, which drop by `drop` as `dequeIter`'s. */ export function dequeDrain(q: VecDeque, r: Bounds, drop?: (item: T) => void): Iter { const [start, end] = boundsRange(r, q.n); - const taken = dequeNew(); - for (let i = start; i < end; i++) dequePut(taken, q.b[at(q, i)] as T); + const taken: VecDeque = { b: [], h: 0, n: 0 }; + for (let i = start; i < end; i++) dequePushBack(taken, q.b[at(q, i)] as T); for (let i = end; i < q.n; i++) q.b[at(q, i - (end - start))] = q.b[at(q, i)]; dequeTruncate(q, q.n - (end - start)); return new DequeIter(taken, 0, taken.n, drop); @@ -2825,9 +2761,8 @@ function sliceIndexFail(start: number, end: number, n: number): never { * `Vec::drain`: the elements within `r`. Those it still holds as it drops each drop by * `drop`, front to back, before the tail moves back. */ -export function vecDrain(v: Vec, r: Bounds, drop?: (item: T) => void): Iter { +export function vecDrain(v: T[], r: Bounds, drop?: (item: T) => void): Iter { const [start, end] = boundsRange(r, v.length); - vecHold(v); return new VecDrain(v, v.splice(start), end - start, drop); } @@ -2936,30 +2871,18 @@ class ByteVecDrain extends Iter implements Disposable { } /** - * `extend` of `size`-byte items, which takes `items` as `take` says and reserves as std's - * does: a `trusted` iterator's upper bound, and any other's lower bound and one more at - * its first item and each that finds it full. + * `extend`, and `collect` into a deque through `dequeNew`, which takes `items` as `take` + * says and reserves as `iterExtend` does. */ export function dequeExtend(q: VecDeque, items: Iter, take?: Take, size?: number, trusted = false): VecDeque { - if (size === undefined || trusted) { - if (size !== undefined) dequeReserve(q, trustedUpper(items), size); - return extending(q, items, (item) => dequePut(q, item), take); - } - let first = true; - for (let item = items.next(); item !== DONE; item = items.next()) { - if (first || q.n === dequeCapacity(q, size)) dequeReserve(q, satAdd(items.sizeHint()[0], 1), size); - first = false; - dequePut(q, item); - } - if (take !== undefined) dispose(items); - return q; + 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, made for exactly as many. */ -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++) dequePut(out, item(q.b[at(q, i)] as T)); - out.c = q.n; + 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; } @@ -3281,9 +3204,9 @@ export function listCloneFrom(l: LinkedList, source: LinkedList, item: /** A `PartialOrd` test. */ type Test = (a: T, b: T) => boolean; -/** `BinaryHeap`: its elements in `d`, in std's order, a `Vec` with std's capacity. */ +/** `BinaryHeap`: its elements in `d`, in std's order. */ export interface BinaryHeap { - d: Vec; + d: T[]; } /** `BinaryHeap::new` and `default`. */ @@ -3291,20 +3214,20 @@ export function heapNew(): BinaryHeap { return { d: [] }; } -/** `BinaryHeap::with_capacity` of `size`-byte elements. */ +/** `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: Vec, le: Test, ge: Test, lt: Test): BinaryHeap { +export function heapFrom(d: T[], le: Test, ge: Test, lt: Test): BinaryHeap { rebuild(d, le, ge, lt); return { d }; } -/** `push` of `size`-byte elements: `item` sifted up from the end. */ -export function heapPush(h: BinaryHeap, item: T, le: Test, size: number): void { - vecPush(h.d, item, size); +/** `push`: `item` sifted up from the end. */ +export function heapPush(h: BinaryHeap, item: T, le: Test): void { + h.d.push(item); siftUp(h.d, 0, h.d.length - 1, le); } @@ -3319,7 +3242,7 @@ export function heapPop(h: BinaryHeap, le: Test, none: None): T | None; export function heapPop(h: BinaryHeap, le: Test, none?: None): T | None | undefined { const d = h.d; if (d.length === 0) return none; - let item = vecPop(d) as T; + let item = d.pop() as T; if (d.length > 0) { [item, d[0]] = [d[0], item]; siftDownToBottom(d, 0, le); @@ -3328,7 +3251,7 @@ export function heapPop(h: BinaryHeap, le: Test, none?: None): T | None } /** `into_sorted_vec`: the elements in ascending order, each greatest swapped to the end and the rest sifted. */ -export function heapIntoSortedVec(h: BinaryHeap, le: Test, ge: Test, lt: Test): Vec { +export function heapIntoSortedVec(h: BinaryHeap, le: Test, ge: Test, lt: Test): T[] { const d = h.d; for (let end = d.length - 1; end > 0; end--) { [d[0], d[end]] = [d[end], d[0]]; @@ -3337,15 +3260,12 @@ export function heapIntoSortedVec(h: BinaryHeap, le: Test, ge: Test, return d; } -/** - * `append` of `size`-byte elements: `other`'s elements added to the larger of the two, - * which `h` then holds, reserving for them all, and `other` left empty, keeping its capacity. - */ -export function heapAppend(h: BinaryHeap, other: BinaryHeap, le: Test, ge: Test, lt: Test, size: number): void { +/** `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; - vecExtendFromSlice(h.d, other.d, undefined, size); - vecTruncate(other.d, 0); + for (const item of other.d) h.d.push(item); + other.d.length = 0; rebuildTail(h.d, start, le, ge, lt); } @@ -3355,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; - iterExtend(h.d, items, 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; } @@ -3369,7 +3289,6 @@ export function heapRetain(h: BinaryHeap, f: (item: T) => boolean, le: Tes const n = d.length; let from = n; let kept = 0; - vecHold(d); for (let i = 0; i < n; i++) { const item = d[i]; if (f(item)) d[kept++] = item; @@ -3384,14 +3303,12 @@ export function heapRetain(h: BinaryHeap, f: (item: T) => boolean, le: Tes /** `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 { - vecTruncate(h.d, 0, drop); + dropAll(h.d.splice(0), 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.slice(); - vecTruncate(h.d, 0); - 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. */ @@ -3404,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) }; } /** @@ -3447,9 +3364,7 @@ export function peekMutDerefMut(p: PeekMut): void { const d = p.h.d; if (d.length > 1) { p.t = d; - // std's sets the length to 1, keeping the allocation, which a forgotten guard leaves. p.h.d = [d[0]]; - vecSetCapacity(p.h.d, d.cap ?? d.length); } } @@ -3603,37 +3518,33 @@ export function copiedPart(part: Part, copy: (item: T) => T): Part part.one(c, copy(item)) }; } -/** A `Vec` of `size`-byte elements, which reserves and pushes each as its own `extend_reserve` and `extend_one` do. */ -export function vecPart(size: number): Part { +/** 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: (v, additional) => vecReserve(v, additional, size), - one: (v, item) => { - vecPush(v, item, size); - return v; + reserve, + one: (c, item) => { + push(c, item); + return c; }, }; } +/** A `Vec` of `size`-byte elements, which pushes each. */ +export function vecPart(size?: number): Part { + return vectorPart( + (v, item) => v.push(item), + size === undefined ? undefined : (v, additional) => vecReserve(v, additional, size), + ); +} + /** A `Vec`, as `vecPart`. */ export function byteVecPart(): Part { - return { - reserve: byteVecReserve, - one: (v, item) => { - byteVecPush(v, item); - return v; - }, - }; + return vectorPart(byteVecPush, byteVecReserve); } -/** A `VecDeque` of `size`-byte elements, which pushes each at the back, as `vecPart`. */ -export function dequePart(size: number): Part, T> { - return { - reserve: (q, additional) => dequeReserve(q, additional, size), - one: (q, item) => { - dequePushBack(q, item, size); - return q; - }, - }; +/** A `VecDeque` of `size`-byte elements, which pushes each at the back. */ +export function dequePart(size?: number): Part, T> { + return vectorPart(dequePushBack, size === undefined ? undefined : (q, additional) => dequeReserve(q, additional, size)); } /** A `LinkedList`, which pushes each at the back, and never reserves. */ @@ -3646,15 +3557,12 @@ export function listPart(): Part, T> { }; } -/** A `BinaryHeap` of `size`-byte elements, which pushes each, sifting it up by `le`, as `vecPart`. */ -export function heapPart(le: Test, size: number): Part, T> { - return { - reserve: (h, additional) => vecReserve(h.d, additional, size), - one: (h, item) => { - heapPush(h, item, le, size); - return h; - }, - }; +/** 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, item) => heapPush(h, item, le), + size === undefined ? undefined : (h, additional) => vecReserve(h.d, additional, size), + ); } /** A `HashMap`, which inserts each entry as `hashExtend` does, and reserves as `hashReserve`. */ diff --git a/ts/runtime/rt/iter.ts b/ts/runtime/rt/iter.ts index 9beb22294..d22e79bb4 100644 --- a/ts/runtime/rt/iter.ts +++ b/ts/runtime/rt/iter.ts @@ -22,32 +22,7 @@ // `owned` functions follow it, dispatching on the kind, so a bundle that never drops an // item carries none of it. -import { - ByteSlice, - ByteVec, - byteVecExtendFromSlice, - byteVecPush, - byteVecReserve, - byteVecView, - byteVecWithCapacity, - capReserve, - Err, - type None, - Ok, - type Place, - panic, - place, - type RangeBound, - type Result, - sliceView, - type Vec, - vecCapacity, - vecExtendFromSlice, - vecMax, - vecReserve, - vecSetCapacity, - vecWithCapacity, -} 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, vecReserve, 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"; @@ -66,7 +41,7 @@ const USIZE_MAX = 0xffffffff; type Drop = (value: T) => void; /** `a + b`, saturating at `usize::MAX` as std's size hints do. */ -export function satAdd(a: number, b: number): number { +function satAdd(a: number, b: number): number { return Math.min(a + b, USIZE_MAX); } @@ -323,11 +298,6 @@ export function iterSlice(s: ArrayLike, drop?: Drop): Iter { return new SliceIter(s, drop); } -/** `IntoIterator::into_iter` of a `Vec`: its bytes, of the vector whose capacity a `collect` in place of it keeps. */ -export function byteVecIntoIter(v: ByteVec): Iter { - return new SliceIter(byteVecView(v), undefined, v); -} - /** `slice::IterMut` of elements JS copies: the place of each. */ export function iterSliceMut(s: { [i: number]: T; length: number }): Iter> { return new SliceMutIter(s); @@ -565,8 +535,7 @@ 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. A `Vec` that collects a `TrustedLen` -// one is made for exactly its upper bound. +// one more; as a tuple's part, the lower bound first. /** The upper bound of a `TrustedLen` iterator `it`, which std's reserves, panicking without one. */ export function trustedUpper(it: Iter): number { @@ -575,9 +544,9 @@ export function trustedUpper(it: Iter): number { return upper; } -/** The capacity `cap`, full of `size`-byte elements, grows to as std's reserves for the next item of `it` and those it holds past it. */ -export function capNext(it: Iter, cap: number, size: number): number { - return capReserve(cap, cap, satAdd(it.sizeHint()[0], 1), size); +/** 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); } /** @@ -632,14 +601,14 @@ function joinedLength(parts: readonly { length: number }[], sep: { length: numbe * `size` bytes each, reserves as std's does for a `trusted`, `TrustedLen`, iterator or any * other. */ -export function iterExtend(v: Vec, 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, size); for (let item = items.next(); item !== DONE; item = items.next()) { - if (v.length === cap) cap = capNext(items, cap, size); + if (v.length === cap) cap = capNext(items, v.length, cap, size); v.push(item); } - vecSetCapacity(v, cap); + capSet(v, v.length, cap, size); if (take !== undefined) dispose(items); return v; } @@ -1237,79 +1206,35 @@ export function iterGe(a: Iter, b: Iter, cmp: (x: T, y: U) => Orderi return order !== undefined && order >= 0; } -/** - * `collect` into a `Vec`: as `iterExtend` of an empty one, but for a `trusted` iterator, - * whose upper bound it is made for exactly. - */ +/** `collect` into a `Vec`, as `iterExtend` of an empty one. */ export function iterToArray(it: Iter, take?: Take, size?: number, trusted = false): T[] { - if (size !== undefined && trusted) { - const out = vecWithCapacity(trustedUpper(it), size); - return iterExtend(out, it, take, undefined, true); - } - return iterExtend([], it, take, size, trusted); -} - -/** - * The capacity of the `Vec` std's `SourceIter::as_inner` reaches from `it`, of `size`-byte - * elements, which a `collect` in place of it keeps, and whether that is unsure, as a - * `Vec`'s taken from `bytes`' storage is. - */ -export function sourceCapacity(it: Iter, size: number): [number, boolean] { - let at: Iter | undefined = it; - while (!(at instanceof SliceIter)) { - if (at instanceof Adaptor || at instanceof FuseIter) at = at.inner; - else if (at instanceof ZipIter) at = at.a; - else if (at instanceof FlattenIter) at = at.outer; - else at = undefined; - if (at === undefined) throw new Error("rust2-ts: a `collect` in place of an iterator whose `Vec` it can't find"); + if (size !== undefined && !trusted) { + const out: T[] = []; + let cap = capOf(0, undefined, size); + for (let item = it.next(); item !== DONE; item = it.next()) { + 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 (at.cap !== undefined) return [at.cap, false]; - if (at.bytes !== undefined) return [at.bytes.data.length, at.bytes.unsure === true]; - return [vecCapacity(at.s as Vec, size), false]; -} - -/** - * How many of `size`-byte elements a `collect` keeps room for in place of the `Vec` of - * `srcSize`-byte ones `it` reads, as std's does where its adaptors let it: as many as fit - * in that one's bytes. Of a `vec::IntoIter` itself, if `bare`, it keeps that one unless it - * read from the front and less than half of it is left, and else reserves for what is. - */ -function inPlace(it: Iter, srcSize: number, size: number, bare: boolean): [number, boolean] { - const [cap, unsure] = sourceCapacity(it, srcSize); - if (!bare) return [Math.floor((cap * srcSize) / size), unsure]; - const src = it as SliceIter; - const len = src.back - src.front; - if (src.front === src.start || len >= Math.floor(cap / 2)) return [cap, unsure]; - return [capReserve(0, 0, len, size), false]; -} - -/** `collect` into a `Vec` of `size`-byte elements in place of the one `it` reads, as `inPlace` says. */ -export function iterToArrayInPlace(it: Iter, srcSize: number, size: number, bare: boolean, take?: Take, trusted = false): T[] { - const [cap, unsure] = inPlace(it, srcSize, size, bare); - if (unsure) throw new Error("rust2-ts: a `collect` in place of a `Vec` taken from `bytes`' storage, whose capacity depends on whether other handles of it dropped"); - const out = iterToArray(it, take, undefined, trusted); - vecSetCapacity(out, cap); - return out; -} - -/** `collect` into a `Vec` in place of the one `it` reads, as `inPlace` says. */ -export function iterToByteVecInPlace(it: Iter, srcSize: number, bare: boolean, take?: Take, trusted = false): ByteVec { - const [cap, unsure] = inPlace(it, srcSize, 1, bare); - const out = byteVecWithCapacity(cap); - out.unsure = unsure; - if (take !== undefined) each(it, (item) => byteVecPush(out, item), take); - else { + // 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()) byteVecPush(out, item); + for (let item = folded.next(); item !== DONE; item = folded.next()) out.push(item); + return out; } + each(it, (item) => out.push(item), take); return out; } -/** `collect` into a `Vec`, as `iterToArray`. */ +/** `collect` into a `Vec`, as `iterExtendBytes` of an empty one. */ export function iterToByteVec(it: Iter, take?: Take, trusted = false): ByteVec { - const out = trusted ? byteVecWithCapacity(trustedUpper(it)) : new ByteVec(); // Its own loops: through `iterExtendBytes`, JavaScriptCore took 1.9x as long. if (!trusted) { + const out = new ByteVec(); for (let item = it.next(); item !== DONE; item = it.next()) { if (out.length === out.data.length) byteVecReserve(out, satAdd(it.sizeHint()[0], 1)); byteVecPush(out, item); @@ -1317,6 +1242,7 @@ export function iterToByteVec(it: Iter, take?: Take, trusted = false): B if (take !== undefined) dispose(it); return out; } + 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); @@ -1542,21 +1468,12 @@ class SliceIter extends Iter implements Disposable { back: number; /** What drops each item it still holds, if it owns them. */ private readonly drop: Drop | undefined; - /** The `Vec` whose bytes `s` views, which its `into_iter` owns. */ - readonly bytes: ByteVec | undefined; - /** - * Where in `s` the `Vec` it owns starts, and that one's capacity if not `s`'s: a clone's - * is a new one of what was left, which it shares `s` for rather than copy. - */ - start = 0; - cap: number | undefined; - constructor(s: ArrayLike, drop?: Drop, bytes?: ByteVec) { + constructor(s: ArrayLike, drop?: Drop) { super(); this.s = s; this.back = s.length; this.drop = drop; - this.bytes = bytes; } next(): T | Done { @@ -1587,9 +1504,8 @@ class SliceIter extends Iter implements Disposable { return new SliceIter(items, this.drop); } const it = new SliceIter(this.s, this.drop); - it.front = it.start = this.front; + it.front = this.front; it.back = this.back; - it.cap = this.back - this.front; return it; } diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index c760dcf50..6ba007e76 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -1153,35 +1153,30 @@ fn deque<'tcx>( let back = |values: Vec| flagged(values, true, none); let e = match (owner, name) { (_, "new") | ("Default", "default") => deque_new(b, coll, span), - // What changes or reads a capacity is given the size of its items, by which std's + // 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" | "push_back" | "push_front" | "insert" | "reserve" | "reserve_exact" | "shrink_to" - | "shrink_to_fit", - ) => { + (_, "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", - "push_back" => "dequePushBack", - "push_front" => "dequePushFront", - "insert" => "dequeInsert", "reserve" => "dequeReserve", "reserve_exact" => "dequeReserveExact", _ => "dequeShrinkTo", }; - if name == "shrink_to_fit" { - values.push(Expr::lit("0")); - } - values.push(super::iter::size_of(b, item, span)); Expr::rt(f, values) } (_, "len") => values.pop()?.member("n"), (_, "is_empty") => values.pop()?.member("n").binary("===", Expr::lit("0")), (_, "clear") => Expr::rt("dequeClear", values), + (_, "push_back") => Expr::rt("dequePushBack", values), + (_, "push_front") => Expr::rt("dequePushFront", values), (_, "pop_back") => Expr::rt("dequePopBack", values), (_, "pop_front") => Expr::rt("dequePopFront", values), (_, "front_mut") if b.t.needs_place(item) => Expr::rt("dequeEndMut", values), @@ -1196,6 +1191,7 @@ fn deque<'tcx>( (_, "retain_mut") if b.t.needs_place(item) => Expr::rt("dequeRetainMut", values), (_, "retain" | "retain_mut") => Expr::rt("dequeRetain", values), (_, "remove") => Expr::rt("dequeRemove", values), + (_, "insert") => Expr::rt("dequeInsert", values), (_, "contains") => { values.push(eq_fn(b, item, span)); Expr::rt("dequeContains", values) @@ -1211,23 +1207,17 @@ fn deque<'tcx>( ("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, and `From<[T; N]>` has room for `N`. - ("From", "from") - if matches!(library::targ(call.args, 1).kind(), ty::Array(..)) - || b.t.std_of(library::targ(call.args, 1)) == Some(Std::Vec) => - { - let from = library::targ(call.args, 1); - let bytes = matches!(item.kind(), ty::Uint(ty::UintTy::U8)); - let v = match (bytes, from.is_array(), b.t.copy_fn(item, span)) { - (true, true, _) => Expr::ident("Array").member("from").call(vec![values.pop()?]), - (true, false, _) => Expr::rt("byteVecToVec", vec![values.pop()?]), - (false, true, Some(copy)) => values.pop()?.member("map").call(vec![copy]), - _ => values.pop()?, + // `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, }; - let size = super::iter::size_of(b, item, span); - empty(b, Expr::rt("dequeFromVec", vec![v, size]), coll, span) + empty(b, Expr::rt("dequeFromVec", vec![v]), coll, span) } ("Extend", "extend") | ("From", "from") => { let (source, iter) = extend_source(b, coll, call, owner, values.pop()?)?; @@ -1352,8 +1342,8 @@ fn heap<'tcx>( empty(b, Expr::rt("heapWithCapacity", values), coll, span) } (_, "capacity" | "reserve" | "reserve_exact" | "shrink_to" | "shrink_to_fit") => { - let h = values.remove(0).member("d"); - let mut values = [vec![h], values].concat(); + let h = values.remove(0); + values.insert(0, h.member("d")); if name == "shrink_to_fit" { values.push(Expr::lit("0")); } @@ -1373,9 +1363,6 @@ fn heap<'tcx>( (_, "peek") => values.pop()?.member("d").index(Expr::lit("0")), (_, "push" | "pop" | "peek_mut" | "append" | "retain" | "into_sorted_vec") => { values.extend(heap_tests(b, item, !matches!(name, "push" | "pop"), span)); - if matches!(name, "push" | "append") { - values.push(super::iter::size_of(b, item, span)); - } let f = match name { "push" => "heapPush", "pop" => "heapPop", @@ -1403,8 +1390,9 @@ fn heap<'tcx>( } (_, "iter") => Expr::rt("heapIter", values), ("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. @@ -2675,24 +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 makes one in place of a `vec::IntoIter`'s `Vec` or an `IntoIter`'s deque, - // whose capacity it keeps, and else collects into a `Vec` first. + // std's collects into a `Vec` first, whose capacity it keeps. Std::VecDeque => { - let item = arg(ty, 0); - let size = super::iter::size_of(b, item, span); - let into_iter = super::iter::is_vec_into_iter(b.t.tcx, from) - || matches!(from.kind(), ty::Adt(adt, _) if library::std_path(b.t.tcx, adt.did()) == ["collections", "vec_deque", "into_iter", "IntoIter"]); - let q = match into_iter { - true => { - let take = super::iter::iter_take(b, from, true, span); - Expr::rt("dequeFromIntoIter", super::iter::tail(vec![iter, size], vec![take])) - } - false => { - let items = super::iter::to_array(b, iter, from, item, trusted, span); - Expr::rt("dequeFromVec", vec![items, size]) - } - }; - empty(b, q, ty, span) + 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/iter.rs b/ts/src/lower/iter.rs index 5d8b64485..73205ac10 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -180,10 +180,6 @@ pub fn into_iter<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr, sp Std::Vec if places(b, args.type_at(0)) => { Some(Expr::rt("iterSliceMut", vec![library::elements(value, ty)])) } - // An owned one's bytes, of the vector whose capacity a `collect` in place of it keeps. - Std::Vec if owned && matches!(args.type_at(0).kind(), ty::Uint(ty::UintTy::U8)) => { - Some(Expr::rt("byteVecIntoIter", vec![value])) - } Std::Vec => { let values = each(b, args.type_at(0), vec![library::elements(value, ty)]); Some(items(Expr::rt("iterSlice", values), args.type_at(0))) @@ -1231,8 +1227,17 @@ fn collect<'tcx>( _ => library::cow_slice(tcx, ty).or(boxed), }; if let Some(elem) = elem { - let bytes = matches!(elem.kind(), ty::Uint(ty::UintTy::U8)); - let v = collected(b, iter, from, elem, trusted, bytes, span); + let v = match elem.kind() { + ty::Uint(ty::UintTy::U8) => { + let (folds, by_index) = collect_folds(b, from, elem, span); + let take = iter_take(b, from, folds, span); + Expr::rt( + "iterToByteVec", + tail(vec![iter], vec![take, Expr::lit((trusted || by_index).to_string())]), + ) + } + _ => to_array(b, iter, from, elem, trusted, span), + }; return Some(match boxed { Some(elem) => library::vec_boxed(v, elem), None => v, @@ -1391,10 +1396,9 @@ fn drops_iter<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> boo true } -/// `iter`, an iterator of type `from`, collected into a `Vec` as `collect_folds` says -/// std's reads it, a JS array even of bytes. It reserves as std's does for a `TrustedLen` -/// iterator if `trusted`, and keeps the capacity of the `Vec` it reads where std's collects -/// in place of it. +/// `rt.iterToArray` of `iter`, an iterator of type `from`, collected into a `Vec` as +/// `collect_folds` says std's reads it. It reserves as std's does for a `TrustedLen` +/// iterator if `trusted`. pub(super) fn to_array<'tcx>( b: &mut Body<'_, '_, 'tcx>, iter: Expr, @@ -1402,62 +1406,17 @@ pub(super) fn to_array<'tcx>( elem: Ty<'tcx>, trusted: bool, span: Span, -) -> Expr { - collected(b, iter, from, elem, trusted, false, span) -} - -/// As `to_array`, an `rt.ByteVec` if `bytes`. -fn collected<'tcx>( - b: &mut Body<'_, '_, 'tcx>, - iter: Expr, - from: Ty<'tcx>, - elem: Ty<'tcx>, - trusted: bool, - bytes: bool, - span: Span, ) -> Expr { let (folds, by_index) = collect_folds(b, from, elem, span); let take = iter_take(b, from, folds, span); - let trusted = Expr::lit((trusted || by_index).to_string()); - if let Some(src) = in_place_source(b.t, from, elem) { - let bare = Expr::lit(is_vec_into_iter(b.t.tcx, from).to_string()); - let src_size = size_of(b, src, span); - return match bytes { - true => Expr::rt( - "iterToByteVecInPlace", - tail(vec![iter, src_size, bare], vec![take, trusted]), - ), - false => { - let size = size_of(b, elem, span); - Expr::rt( - "iterToArrayInPlace", - tail(vec![iter, src_size, size, bare], vec![take, trusted]), - ) - } - }; - } - match bytes { - true => Expr::rt("iterToByteVec", tail(vec![iter], vec![take, trusted])), - false => { - let size = size_of(b, elem, span); - Expr::rt("iterToArray", tail(vec![iter], vec![take, size, trusted])) - } - } -} - -/// Whether `ty` is a `vec::IntoIter`, whose `collect` into a `Vec` std's specializes. -pub(super) fn is_vec_into_iter(tcx: ty::TyCtxt<'_>, ty: Ty<'_>) -> bool { - matches!(ty.kind(), ty::Adt(adt, _) if library::std_path(tcx, adt.did()) == ["vec", "into_iter", "IntoIter"]) -} - -/// The element type of the `Vec` std's `collect` of an iterator of type `iter` into a -/// `Vec` writes in place of, if it does: a `vec::IntoIter`'s own, which std's keeps -/// whatever its elements, or an adaptor's source where each item's layout leaves room. -fn in_place_source<'tcx>(t: &Translator<'_, 'tcx>, iter: Ty<'tcx>, elem: Ty<'tcx>) -> Option> { - if is_vec_into_iter(t.tcx, iter) { - return Some(elem); - } - in_place(t, iter, elem) + let size = size_of(b, elem, span); + Expr::rt( + "iterToArray", + tail( + vec![iter], + vec![take, size, Expr::lit((trusted || by_index).to_string())], + ), + ) } /// Whether std's `collect` of an iterator of type `from` into a `Vec` folds it, and @@ -1469,7 +1428,7 @@ fn in_place_source<'tcx>(t: &Translator<'_, 'tcx>, iter: Ty<'tcx>, elem: Ty<'tcx /// as each fold ends. Elsewhere, it folds a `TrustedLen` one by its own `fold`, which drops /// them first, and reads any other by `next`. fn collect_folds<'tcx>(b: &mut Body<'_, '_, 'tcx>, from: Ty<'tcx>, elem: Ty<'tcx>, span: Span) -> (bool, bool) { - if in_place(b.t, from, elem).is_none() { + if !in_place(b.t, from, elem) { return (implements(b.t, from, "TrustedLen"), false); } let zips = from.walk().filter_map(|arg| arg.as_type()).any(|t| { @@ -1487,17 +1446,17 @@ fn collect_folds<'tcx>(b: &mut Body<'_, '_, 'tcx>, from: Ty<'tcx>, elem: Ty<'tcx (by_index, by_index) } -/// The element type of the `Vec` std's `collect` of an iterator of type `iter` into a -/// `Vec` writes in place of, as its adaptors let it where each item's layout leaves -/// room, if it does. -fn in_place<'tcx>(t: &Translator<'_, 'tcx>, iter: Ty<'tcx>, elem: Ty<'tcx>) -> Option> { +/// Whether std's `collect` of an iterator of type `iter` into a `Vec` writes in place +/// of the `Vec` its items come from, as its adaptors let it where each item's layout leaves +/// room. +fn in_place<'tcx>(t: &Translator<'_, 'tcx>, iter: Ty<'tcx>, elem: Ty<'tcx>) -> bool { let tcx = t.tcx; let env = t.typing_env_pub(); let (Some(steps), Some(source)) = (core_trait(tcx, "InPlaceIterable"), core_trait(tcx, "SourceIter")) else { - return None; + return false; }; if !implements(t, iter, "InPlaceIterable") || !implements(t, iter, "SourceIter") { - return None; + return false; } let assoc = |tr: DefId, name: &str| { tcx.associated_items(tr) @@ -1506,16 +1465,18 @@ fn in_place<'tcx>(t: &Translator<'_, 'tcx>, iter: Ty<'tcx>, elem: Ty<'tcx>) -> O .map(|item| item.def_id) }; // `::Source`, a `vec::IntoIter` of what it collects in place of. - let src = assoc(source, "Source").and_then(|item| { + let Some(src) = assoc(source, "Source").and_then(|item| { let projection = Ty::new_projection(tcx, ty::IsRigid::No, item, [iter]); tcx.try_normalize_erasing_regions(env, ty::Unnormalized::new_wip(projection)) .ok() - })?; + }) else { + return false; + }; let ty::Adt(adt, src_args) = src.kind() else { - return None; + return false; }; if library::std_path(tcx, adt.did()) != ["vec", "into_iter", "IntoIter"] { - return None; + return false; } // `MERGE_BY` and `EXPAND_BY`: how many source items make how many it collects, if known. let step = |name: &str| -> Option { @@ -1525,20 +1486,19 @@ fn in_place<'tcx>(t: &Translator<'_, 'tcx>, iter: Ty<'tcx>, elem: Ty<'tcx>) -> O Some(value.try_to_scalar_int()?.to_bits_unchecked()) }; let (Some(merge), Some(expand)) = (step("MERGE_BY"), step("EXPAND_BY")) else { - return None; + return false; }; let layout = |ty: Ty<'tcx>| tcx.layout_of(env.as_query_input(ty)).ok(); let (Some(from), Some(to)) = (layout(src_args.type_at(0)), layout(elem)) else { - return None; + return false; }; // As std's `in_place_collectible`, where `None`, an overflow, is 0. - let collectible = !from.is_zst() + !from.is_zst() && !to.is_zst() && from.align.abi == to.align.abi && merge > 0 && expand > 0 - && u128::from(from.size.bytes()) * merge >= u128::from(to.size.bytes()) * expand; - collectible.then(|| src_args.type_at(0)) + && u128::from(from.size.bytes()) * merge >= u128::from(to.size.bytes()) * expand } /// Whether the crate's own `Ord` of `ty` has its own `max` or `min`, by `name`, which diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index c8e3e074b..2b9f72d6c 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -1975,7 +1975,6 @@ fn mapping<'tcx>( true => Expr::rt("byteVecOf", values), false => { values.push(super::collections::clone_fn(b, elem, span)); - values.push(super::iter::size_of(b, elem, span)); Expr::rt("vecFromElem", values) } } @@ -1986,20 +1985,17 @@ fn mapping<'tcx>( true => Expr::New(Box::new(Expr::Rt("ByteVec".into())), Vec::new()), 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)) => Expr::rt("byteVecCapacity", args), - ("Vec", "push" | "reserve" | "reserve_exact" | "shrink_to") if is_u8(targ(gargs, 0)) => { + ("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")]) } - // What changes or reads a capacity is given the size of its elements, by which - // std's grows it. - ( - "Vec", - "with_capacity" | "capacity" | "push" | "reserve" | "reserve_exact" | "shrink_to" | "shrink_to_fit", - ) => { + ("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")); @@ -2011,10 +2007,20 @@ fn mapping<'tcx>( }; rt2(values, "vec", &f) } + ("Vec", "push") => { + let mut values = args; + match is_u8(targ(gargs, 0)) { + true => Expr::rt("byteVecPush", values), + false => { + let v = values.remove(0); + v.method("push", values) + } + } + } ("Vec", "pop") if is_u8(targ(gargs, 0)) => Expr::rt("byteVecPop", args), - // Its capacity is kept as its length drops, and an `rt.None` follows where an - // element can be `undefined`. - ("Vec", "pop") => Expr::rt("vecPop", args), + // JS's `pop` returns `undefined` for no element, where an `rt.None` must follow. + ("Vec", "pop") if sentinel_option(b.t, call).is_some() => Expr::rt("vecPop", args), + ("Vec", "pop") => args.pop()?.method("pop", vec![]), // The last element is lent to the test as its place where JS copies it. ("Vec", "pop_if") if is_u8(targ(gargs, 0)) => Expr::rt("byteVecPopIf", args), ("Vec", "pop_if") if b.t.needs_place(targ(gargs, 0)) => Expr::rt("vecPopIfMut", args), @@ -2026,19 +2032,16 @@ fn mapping<'tcx>( ("Vec", "extend_from_slice") if is_u8(targ(gargs, 0)) => Expr::rt("byteVecExtendFromSlice", args), ("Vec", "extend_from_slice") => { let mut values = args; - values.push(super::collections::clone_fn(b, targ(gargs, 0), span)); - values.push(super::iter::size_of(b, targ(gargs, 0), span)); + let clone = super::collections::clone_fn(b, targ(gargs, 0), span); + if !matches!(&clone, Expr::Lit(l) if l == "undefined") { + values.push(clone); + } Expr::rt("vecExtendFromSlice", values) } ("Vec", "insert" | "remove" | "swap_remove") if is_u8(targ(gargs, 0)) => { rt2(args, "byteVec", &super::camel(&name)) } - ("Vec", "insert") => { - let mut values = args; - values.push(super::iter::size_of(b, targ(gargs, 0), span)); - Expr::rt("vecInsert", values) - } - ("Vec", "remove" | "swap_remove" | "truncate") => rt2(args, "vec", &super::camel(&name)), + ("Vec", "insert" | "remove" | "swap_remove" | "truncate") => rt2(args, "vec", &super::camel(&name)), ("Vec", "clear") => { let mut values = args; values.push(Expr::lit("0")); @@ -2454,8 +2457,7 @@ fn clone_into<'tcx>(b: &mut Body<'_, '_, 'tcx>, elem: Ty<'tcx>, name: &str, span /// Whether `clone_from` of `ty` clones, and drops what it writes over, as /// `*self = source.clone()` would: `Clone`'s own, and std's own over such types, where it -/// only reuses memory, if nothing drops or it is an `Option`'s, but for a vector's, which -/// keeps its capacity where that holds the clones. +/// only reuses memory, if nothing drops or it is an `Option`'s. pub(super) fn clone_from_clones<'tcx>(t: &mut Translator<'_, 'tcx>, ty: Ty<'tcx>) -> bool { let tcx = t.tcx; let clone_from = super::collections::trait_fn(tcx, "Clone", "clone_from"); @@ -2466,9 +2468,6 @@ pub(super) fn clone_from_clones<'tcx>(t: &mut Translator<'_, 'tcx>, ty: Ty<'tcx> if instance.def_id() == clone_from { return true; } - if matches!(t.std_of(ty), Some(Std::Vec | Std::VecDeque | Std::BinaryHeap)) { - return false; - } let inner: Vec> = match ty.kind() { ty::Adt(adt, args) if is_std(tcx, adt.did()) => args.types().collect(), ty::Array(elem, _) => vec![*elem], @@ -2551,14 +2550,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` @@ -2569,16 +2574,16 @@ 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)), } } -/// The `Box<[elem]>` that a `Vec`, `v`, becomes: its elements, as many as it holds, -/// to which std's shrinks its capacity. +/// The `Box<[elem]>` that a `Vec`, `v`, becomes: its elements, as many as it holds. +/// std's shrinks its capacity to them, which no translated `Vec` reports. pub(super) fn vec_boxed(v: Expr, elem: Ty<'_>) -> Expr { match elem.kind() { ty::Uint(ty::UintTy::U8) => Expr::rt("byteVecSlice", vec![v]), - _ => Expr::rt("vecIntoBoxed", vec![v]), + _ => v, } } diff --git a/ts/src/lower/mir/step.rs b/ts/src/lower/mir/step.rs index bbbfd93c5..58119d720 100644 --- a/ts/src/lower/mir/step.rs +++ b/ts/src/lower/mir/step.rs @@ -271,8 +271,8 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { /// An iterator stepped in place, from the `rt.Iter` its mapping makes: `{ s, i: 0 }` /// from `rt.iterSlice(s)`, or `rt.iterSlice(s, drop)` of items it owns, which its drop - /// drops again, or `rt.byteVecIntoIter(v)` of a `Vec`'s bytes, and `{ start, end }` - /// from `new rt.Range(start, end)`. A moved one is already made. + /// drops again, and `{ start, end }` from `new rt.Range(start, end)`. A moved one is + /// already made. pub(super) fn stepped_make(&mut self, value: Expr, span: rustc_span::Span) -> Expr { let rt = |f: &Expr, name: &str| matches!(f, Expr::Rt(n) if n == name); let object = |fields: [(&str, Expr); 2]| { @@ -283,9 +283,6 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { args.truncate(1); object([("s", args.pop().unwrap()), ("i", Expr::lit("0"))]) } - Expr::Call(f, args) if rt(&f, "byteVecIntoIter") && args.len() == 1 => { - object([("s", Expr::rt("byteVecView", args)), ("i", Expr::lit("0"))]) - } Expr::New(f, args) if rt(&f, "Range") && args.len() == 2 => { let [start, end] = <[Expr; 2]>::try_from(args).expect("checked above"); object([("start", start), ("end", end)]) diff --git a/ts/src/lower/stock.rs b/ts/src/lower/stock.rs index 689dbfdc9..3fb9441e0 100644 --- a/ts/src/lower/stock.rs +++ b/ts/src/lower/stock.rs @@ -309,7 +309,7 @@ fn from<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Vec) -> }; return Ok(Some(bytes)); } - (_, Some(Std::Bytes)) if byte_vec(to) => "bytesToByteVec", + (_, Some(Std::Bytes)) if byte_vec(to) => "byteSliceToByteVec", (_, Some(Std::BytesMut)) if byte_vec(to) => "bytesMutToByteVec", (_, Some(Std::Bytes | Std::BytesMut)) => return Ok(None), _ => return Err(args.collect()), From b049eb5310c3b40129931749994980e985d16562 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sun, 1 Nov 2026 06:13:26 -0800 Subject: [PATCH 11/14] test(ts): refresh the lang snapshots for capacity Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/expected/capacity.ts | 8 ++++---- ts/fixtures/lang/expected/orders.ts | 4 ++-- ts/fixtures/lang/expected/tuples.ts | 12 ++++++------ 3 files changed, 12 insertions(+), 12 deletions(-) diff --git a/ts/fixtures/lang/expected/capacity.ts b/ts/fixtures/lang/expected/capacity.ts index cea4855fd..fe21f1184 100644 --- a/ts/fixtures/lang/expected/capacity.ts +++ b/ts/fixtures/lang/expected/capacity.ts @@ -1759,15 +1759,15 @@ export function heapSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: n } Known.remade(k, false); } else { - h = rt.heapFrom(rt.byteVecToVec(rt.byteVecFrom(Uint8Array.from(h.d))), rt.le, rt.ge, rt.lt); + 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.byteVecFrom(Uint8Array.from(rt.heapClone(h, undefined, 1).d)); + 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.byteVecFrom(Uint8Array.from(rt.heapIntoSortedVec(h, rt.le, rt.ge, rt.lt))); + const sorted: rt.ByteVec = rt.byteVecFromVec(rt.heapIntoSortedVec(h, rt.le, rt.ge, rt.lt)); Known.put(k, out, sorted.length, sorted.data.length); } @@ -1947,7 +1947,7 @@ export function collects(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void 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.byteVecFrom(Uint8Array.from(heap.d)); + 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))); diff --git a/ts/fixtures/lang/expected/orders.ts b/ts/fixtures/lang/expected/orders.ts index 3962bc1b6..0c9a4a0b7 100644 --- a/ts/fixtures/lang/expected/orders.ts +++ b/ts/fixtures/lang/expected/orders.ts @@ -382,10 +382,10 @@ export function values(data: rt.ByteSlice, out: rt.ByteVec): void { const bytes: rt.BinaryHeap = rt.heapFrom(rt.byteVecToVec(rt.byteSliceToByteVec(data)), rt.le, rt.ge, rt.lt); rt.heapPush(bytes, data.length & 0xff, rt.le); rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.from(bytes.d)))), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFrom(Uint8Array.from(rt.heapIntoSortedVec(rt.heapClone(bytes, undefined, 1), 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))); 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); } From 5fd3d99b2ab1f357f1a81964aaf4b0b62d130e12 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sun, 1 Nov 2026 06:42:39 -0800 Subject: [PATCH 12/14] test(ts): refresh the codec, stock, and task snapshots for capacity Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/codec/expected/bench.ts | 8 +- .../codec/expected/coding/version.Versions.ts | 4 +- ts/fixtures/codec/expected/harness.ts | 8 +- ts/fixtures/lang/src/harness.rs | 10 +- ts/fixtures/stock/expected/buf.ts | 12 +- ts/fixtures/stock/expected/harness.ts | 2 +- ts/fixtures/task/expected/drops.ts | 108 +++++----- ts/fixtures/task/expected/drops/closures.ts | 42 ++-- ts/fixtures/task/expected/drops/folds.ts | 40 ++-- ts/fixtures/task/expected/drops/inside.ts | 2 +- ts/fixtures/task/expected/drops/iters.ts | 204 +++++++++--------- ts/fixtures/task/expected/drops/objects.ts | 28 +-- ts/fixtures/task/expected/drops/once.ts | 6 +- ts/fixtures/task/expected/kio.Producer.ts | 2 +- ts/fixtures/task/expected/kio.WaiterList.ts | 4 +- ts/fixtures/task/expected/log.Log.ts | 2 +- ts/fixtures/task/expected/model.Channel.ts | 6 +- ts/fixtures/task/expected/model.ts | 8 +- 18 files changed, 248 insertions(+), 248 deletions(-) diff --git a/ts/fixtures/codec/expected/bench.ts b/ts/fixtures/codec/expected/bench.ts index 64c08c8dd..b8efe1def 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -348,12 +348,12 @@ export function order(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi } else { const heap: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; for (const _87 of rt.replaceIn(v, [])) { - rt.heapPush(heap, _87, rt.le, 4); + rt.heapPush(heap, _87, rt.le); } while (true) { const _93: rt.u32 | undefined = rt.heapPop(heap, rt.le); if (_93 !== undefined) { - rt.vecPush(v, _93, 4); + v.push(_93); } else { break; } @@ -388,7 +388,7 @@ export function push(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void let iterStart: rt.u32 = 0; const iterEnd: rt.u32 = count2; while ((_18 = iterStart++) < iterEnd) { - rt.dequePushBack(q, _18, 4); + rt.dequePushBack(q, _18); } _13 = [q.n, rt.dequeGet(q, rt.usizeDiv(q.n, 2))] as [rt.usize, rt.u32 | undefined]; } else { @@ -396,7 +396,7 @@ export function push(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void let iterStart2: rt.u32 = 0; const iterEnd2: rt.u32 = count2; while ((_37 = iterStart2++) < iterEnd2) { - rt.vecPush(v, _37, 4); + v.push(_37); } _13 = [v.length, rt.sliceGet(v, rt.usizeDiv(v.length, 2))] as [rt.usize, rt.u32 | undefined]; } diff --git a/ts/fixtures/codec/expected/coding/version.Versions.ts b/ts/fixtures/codec/expected/coding/version.Versions.ts index b2a7cd209..fcb00a09f 100644 --- a/ts/fixtures/codec/expected/coding/version.Versions.ts +++ b/ts/fixtures/codec/expected/coding/version.Versions.ts @@ -34,7 +34,7 @@ export function decode$coding_decode_Decode_coding_varint_Form(r: Decoder.Decode while (iter.next() !== rt.DONE) { const _15: rt.Result = coding_version_Version.decode$coding_decode_Decode_coding_varint_Form(r, version); if (_15.ok) { - rt.vecPush(vs, _15.value, 8); + vs.push(_15.value); } else { return _15; } @@ -75,7 +75,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/harness.ts b/ts/fixtures/codec/expected/harness.ts index df9a421d9..9387c42a1 100644 --- a/ts/fixtures/codec/expected/harness.ts +++ b/ts/fixtures/codec/expected/harness.ts @@ -372,10 +372,10 @@ export function encodeScript(dataData: Uint8Array, dataStart: number, dataLen: n } else { _74 = Encoder.prefixU16(w); } - rt.vecPush(prefixes, _74, 8); + prefixes.push(_74); result = rt.OK as rt.Result; } else if (_33 === 8) { - const _79: Prefix.Prefix | undefined = rt.vecPop(prefixes); + const _79: Prefix.Prefix | undefined = prefixes.pop(); if (_79 === undefined) { result = rt.OK as rt.Result; } else { @@ -384,7 +384,7 @@ export function encodeScript(dataData: Uint8Array, dataStart: number, dataLen: n result = Encoder.fill(w, prefix); } } else { - const _88: Prefix.Prefix | undefined = rt.vecPop(prefixes); + const _88: Prefix.Prefix | undefined = prefixes.pop(); if (_88 !== undefined) { Encoder.discard(w, _88); } @@ -395,7 +395,7 @@ export function encodeScript(dataData: Uint8Array, dataStart: number, dataLen: n } } while (true) { - const _98: Prefix.Prefix | undefined = rt.vecPop(prefixes); + const _98: Prefix.Prefix | undefined = prefixes.pop(); if (_98 !== undefined) { const _102: rt.Result = Encoder.fill(w, _98); if (!_102.ok) { diff --git a/ts/fixtures/lang/src/harness.rs b/ts/fixtures/lang/src/harness.rs index 7763354ff..0711b9b76 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, 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, + 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 diff --git a/ts/fixtures/stock/expected/buf.ts b/ts/fixtures/stock/expected/buf.ts index e6814e36b..20715faa8 100644 --- a/ts/fixtures/stock/expected/buf.ts +++ b/ts/fixtures/stock/expected/buf.ts @@ -33,12 +33,12 @@ export function bytesMut(data: rt.ByteSlice, out: rt.ByteVec): void { rt.bytesMutPutWord(buf, rt.u16Mul(n & 0xffff, 257), 2, false); } else if (_20 === 3) { const _34: rt.BytesMut = rt.bytesMutSplitTo(buf, rt.usizeRem(n, rt.usizeAdd(buf.length, 2))); - rt.vecPush(pieces, _34, 16); + pieces.push(_34); } else if (_20 === 4) { - const _42: rt.BytesMut | undefined = rt.vecPop(pieces); + const _42: rt.BytesMut | undefined = pieces.pop(); if (_42 !== undefined) { const _48: rt.ByteSlice = rt.bytesMutFreeze(_42); - rt.vecPush(frozen, _48, 16); + frozen.push(_48); } } else if (_20 === 5) { rt.bytesMutTruncate(buf, rt.usizeRem(n, rt.usizeAdd(buf.length, 2))); @@ -63,7 +63,7 @@ export function bytesMut(data: rt.ByteSlice, out: rt.ByteVec): void { rt.bytesMutReserve(fresh, _80); } } else if (_20 === 8) { - const _95: rt.BytesMut | undefined = rt.vecPop(pieces); + const _95: rt.BytesMut | undefined = pieces.pop(); if (_95 !== undefined) { rt.bytesMutUnsplit(buf, _95); } @@ -76,10 +76,10 @@ export function bytesMut(data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_20 === 12) { const buf2 = buf; const _115: rt.BytesMut = rt.bytesMutSplitTo(buf2, buf2.length); - rt.vecPush(pieces, _115, 16); + pieces.push(_115); } else if (_20 === 13) { const _118: rt.ByteSlice = rt.bytesMutFreeze(rt.bytesMutSplitTo(buf, rt.usizeRem(n, rt.usizeAdd(buf.length, 2)))); - rt.vecPush(frozen, _118, 16); + frozen.push(_118); } else if (_20 === 14) { rt.bytesMutPutFill(buf, n & 0xff, rt.usizeRem(n, 9)); } else if (_20 === 15) { diff --git a/ts/fixtures/stock/expected/harness.ts b/ts/fixtures/stock/expected/harness.ts index dc7ad7a99..4209af111 100644 --- a/ts/fixtures/stock/expected/harness.ts +++ b/ts/fixtures/stock/expected/harness.ts @@ -106,7 +106,7 @@ export function slices(dataData: Uint8Array, dataStart: number, dataLen: number, rt.byteVecPush(out, rt.byteSliceEq(part, bytes) ? 1 : 0); rt.byteVecPush(out, rt.byteSliceEq(part, rt.byteSliceRange(part, 0)) ? 1 : 0); rt.byteVecPush(out, rt.byteSliceEq(rt.bytesSlice(rt.bytesSlice(bytes, rt.min(a, dataLen - 3)), 0, 0), rt.bytesNew()) ? 1 : 0); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.bytesToByteVec(part))); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.byteSliceToByteVec(part))); } } diff --git a/ts/fixtures/task/expected/drops.ts b/ts/fixtures/task/expected/drops.ts index 0f01943a2..71ca1c4cf 100644 --- a/ts/fixtures/task/expected/drops.ts +++ b/ts/fixtures/task/expected/drops.ts @@ -78,10 +78,10 @@ export function run(log: Log.Log, id: rt.u32, arg: rt.u8): void { } else if (_6 === 0) { const v: Held.Held[] = []; const _12 = { tag: "One", _0: guard(1) } as Held.Held; - rt.vecPush(v, _12, 20); - rt.vecPush(v, { tag: "Empty" } as Held.Held, 20); + v.push(_12); + v.push({ tag: "Empty" } as Held.Held); const _21 = { tag: "Two", _0: guard(2), _1: guard(3) } as Held.Held; - rt.vecPush(v, _21, 20); + v.push(_21); const held: Held.Held[] = v; const arc: rt.Arc = new rt.Arc({ tag: "One", _0: guard(4) } as Held.Held); const shared: rt.Arc = rt.arcClone(arc); @@ -96,7 +96,7 @@ export function run(log: Log.Log, id: rt.u32, arg: rt.u8): void { rt.arcDrop(cloned, lib_drop$drops_Held); const v2: Held.Held[] = []; const _70 = { tag: "One", _0: guard(5) } as Held.Held; - rt.vecPush(v2, _70, 20); + v2.push(_70); const mutex: rt.Mutex = new rt.Mutex(v2); const boxed: Held.Held = { tag: "Two", _0: guard(6), _1: guard(7) }; const maybe = (({ tag: "One", _0: guard(8) } as Held.Held)) as Held.Held | undefined; @@ -115,9 +115,9 @@ export function run(log: Log.Log, id: rt.u32, arg: rt.u8): void { const pair: Pair.Pair = new Pair.Pair({ tag: "Two", _0: guard(31), _1: guard(32) } as Held.Held, guard(33)); const v3: Pair.Pair[] = []; const _136: Pair.Pair = new Pair.Pair(guard(41), guard(42)); - rt.vecPush(v3, _136, 16); + v3.push(_136); const _145: Pair.Pair = new Pair.Pair(guard(43), guard(44)); - rt.vecPush(v3, _145, 16); + v3.push(_145); const pairs: Pair.Pair[] = v3; const _owned: Named.Named = new Named.Named({ tag: "Owned", _0: guard(45) } as Text.Text); const _161: rt.u32 = rt.u32Add(id, 50); @@ -125,7 +125,7 @@ export function run(log: Log.Log, id: rt.u32, arg: rt.u8): void { const v4: Wrap.Wrap[] = []; const _borrowed: Named.Named = new Named.Named({ tag: "Borrowed", _0: "text" } as Text.Text); const _168: Wrap.Wrap = new Wrap.Wrap(rt.u32Add(id, 60), Log.clone$Clone(log), { tag: "One", _0: guard(61) } as Held.Held); - rt.vecPush(v4, _168, 28); + v4.push(_168); const nested: Wrap.Wrap[]> = new Wrap.Wrap(_161, _163, v4); lib_drop$drops_Pair_drops_Held(pair); const _183: boolean = Held.isSome(wrapped.inner); @@ -143,9 +143,9 @@ export function run(log: Log.Log, id: rt.u32, arg: rt.u8): void { const shared2: rt.Arc>> = new rt.Arc(new Wrap.Wrap(rt.u32Add(id, 70), Log.clone$Clone(log), new Pair.Pair({ tag: "One", _0: guard(71) } as Held.Held, guard(72)))); const v5: rt.Arc>>[] = []; const _227: rt.Arc>> = rt.arcClone(shared2); - rt.vecPush(v5, _227, 4); + v5.push(_227); const _231: rt.Arc>> = rt.arcClone(shared2); - rt.vecPush(v5, _231, 4); + v5.push(_231); const clones: rt.Arc>>[] = v5; rt.arcDrop(shared2, lib_drop$drops_Wrap_drops_Pair_drops_Held); const part2 = clones.length; @@ -187,7 +187,7 @@ export function run(log: Log.Log, id: rt.u32, arg: rt.u8): void { export function bail(log: Log.Log, id: rt.u32, fails: boolean): rt.Result { const v: Held.Held[] = []; const _8 = { tag: "One", _0: Guard.new(rt.u32Add(id, 90), Log.clone$Clone(log)) } as Held.Held; - rt.vecPush(v, _8, 20); + v.push(_8); const held: Held.Held[] = v; const wrap: Wrap.Wrap = new Wrap.Wrap(rt.u32Add(id, 91), Log.clone$Clone(log), { tag: "Empty" } as Held.Held); const _18: rt.Result = failed(fails); @@ -257,8 +257,8 @@ export class heldFuture { this.#id = Guard.id(this.#guard); const v: Held.Held[] = []; const _9 = { tag: "One", _0: Guard.new(rt.u32Add(this.#id, 500), Log.clone$Clone(this.#log)) } as Held.Held; - rt.vecPush(v, _9, 20); - rt.vecPush(v, { tag: "Empty" } as Held.Held, 20); + v.push(_9); + v.push({ tag: "Empty" } as Held.Held); this.#held = v; this.#wrap = new Wrap.Wrap(rt.u32Add(this.#id, 510), Log.clone$Clone(this.#log), new rt.Arc({ tag: "One", _0: Guard.new(rt.u32Add(this.#id, 520), Log.clone$Clone(this.#log)) } as Held.Held)); this.#awaitee = new recvFuture$kio_Consumer(this.#rx); @@ -384,10 +384,10 @@ export function ordered(log: Log.Log, id: rt.u32): void { const iterEnd: rt.u32 = 26; while ((_208 = iterStart++) < iterEnd) { const _214: Guard.Guard = guard(_208); - rt.dequePushBack(queue, _214, 8); + rt.dequePushBack(queue, _214); } const _219: Guard.Guard = guard(19); - rt.dequePushFront(queue, _219, 8); + rt.dequePushFront(queue, _219); rt.dequeRetain(queue, (g: Guard.Guard): boolean => { return rt.u32Rem(Guard.id(g), 3) !== 0; }, rt.drop); @@ -811,11 +811,11 @@ export function elements(log: Log.Log, id: rt.u32): void { }; const v2: Array = []; const _12: Guard.Guard | undefined = guard(1); - rt.vecPush(v2, _12, 8); - rt.vecPush(v2, undefined as Guard.Guard | undefined, 8); + v2.push(_12); + v2.push(undefined as Guard.Guard | undefined); const _21: Guard.Guard | undefined = guard(2); - rt.vecPush(v2, _21, 8); - rt.vecPush(v2, undefined as Guard.Guard | undefined, 8); + v2.push(_21); + v2.push(undefined as Guard.Guard | undefined); const v: Array = v2; const _34: rt.u32 | undefined | rt.None = option_map$0ccnsmq(rt.sliceFirst(v, rt.None), (o5: Guard.Guard | undefined): rt.u32 | undefined => { return option_map$0lq7mno(o5, Guard.id); @@ -894,7 +894,7 @@ export function elements(log: Log.Log, id: rt.u32): void { const _145: string = rt.fmtFormat(["uncalled ", args12[0]]); rt.drop(_151); Log.note(log, _145); - rt.vecPush(v, undefined as Guard.Guard | undefined, 8); + v.push(undefined as Guard.Guard | undefined); const captured2 = guard(15); const part8 = option_map$0ccnsmq(rt.vecPopIfMut(v, rt.closure((o13: rt.Place): boolean => { const part6 = Guard.id(captured2); @@ -913,12 +913,12 @@ export function elements(log: Log.Log, id: rt.u32): void { const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part8, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; Log.note(log, rt.fmtFormat(["called ", args14[0]])); const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; - rt.dequePushBack(q, undefined as Guard.Guard | undefined, 8); + rt.dequePushBack(q, undefined as Guard.Guard | undefined); const _186: Guard.Guard | undefined = guard(4); - rt.dequePushBack(q, _186, 8); + rt.dequePushBack(q, _186); const _192: Guard.Guard | undefined = guard(5); - rt.dequePushFront(q, _192, 8); - rt.dequePushBack(q, undefined as Guard.Guard | undefined, 8); + rt.dequePushFront(q, _192); + rt.dequePushBack(q, undefined as Guard.Guard | undefined); const _205: rt.u32 | undefined | rt.None = option_map$0ccnsmq(rt.dequeEnd(q, false, rt.None), (o15: Guard.Guard | undefined): rt.u32 | undefined => { return option_map$0lq7mno(o15, Guard.id); }); @@ -948,10 +948,10 @@ export function elements(log: Log.Log, id: rt.u32): void { Log.note(log, rt.fmtFormat(["remove ", args18[0], " ", args18[1]])); rt.drop(removed); const _252: Guard.Guard | undefined = guard(6); - rt.dequePushBack(q, _252, 8); + rt.dequePushBack(q, _252); const _258: Guard.Guard | undefined = guard(13); - rt.dequePushBack(q, _258, 8); - rt.dequePushFront(q, undefined as Guard.Guard | undefined, 8); + rt.dequePushBack(q, _258); + rt.dequePushFront(q, undefined as Guard.Guard | undefined); const back: Guard.Guard | undefined | rt.None = rt.dequeSwapRemove(q, 0, true, rt.None); const _273: rt.u32 | undefined | rt.None = option_map$0ccnsmq(back, (o20: Guard.Guard | undefined): rt.u32 | undefined => { return option_map$0lq7mno(o20, Guard.id); @@ -1001,10 +1001,10 @@ export function elements(log: Log.Log, id: rt.u32): void { Log.note(log, rt.fmtFormat(["emptied ", args26[0], " ", args26[1]])); const heap: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; const _352: Key.Key | undefined = key(7); - rt.heapPush(heap, _352, rt.cmpLe(rt.cmpOption(Key.partialCmp$cmp_PartialOrd)), 12); - rt.heapPush(heap, undefined as Key.Key | undefined, rt.cmpLe(rt.cmpOption(Key.partialCmp$cmp_PartialOrd)), 12); + rt.heapPush(heap, _352, rt.cmpLe(rt.cmpOption(Key.partialCmp$cmp_PartialOrd))); + rt.heapPush(heap, undefined as Key.Key | undefined, rt.cmpLe(rt.cmpOption(Key.partialCmp$cmp_PartialOrd))); const _361: Key.Key | undefined = key(8); - rt.heapPush(heap, _361, rt.cmpLe(rt.cmpOption(Key.partialCmp$cmp_PartialOrd)), 12); + rt.heapPush(heap, _361, rt.cmpLe(rt.cmpOption(Key.partialCmp$cmp_PartialOrd))); const part17 = option_map$0hegtde(rt.heapPeek(heap, rt.None), (o26: Key.Key | undefined): rt.u32 | undefined => { return option_map$0782hf5(o26, (k2: Key.Key): rt.u32 => { return k2.id; @@ -1302,13 +1302,13 @@ export function edited(log: Log.Log, id: rt.u32, arg: rt.u8): void { if (_8 === 0) { const v2: Key.Key[] = []; const _14: Key.Key = key(1); - rt.vecPush(v2, _14, 12); + v2.push(_14); const _19: Key.Key = key(2); - rt.vecPush(v2, _19, 12); + v2.push(_19); const _24: Key.Key = key(3); - rt.vecPush(v2, _24, 12); + v2.push(_24); const _29: Key.Key = key(4); - rt.vecPush(v2, _29, 12); + v2.push(_29); const v: Key.Key[] = v2; rt.vecRetain(v, (k6: Key.Key): boolean => { return rt.u32Rem(rt.u32Sub(k6.id, id), 2) === 1; @@ -1326,15 +1326,15 @@ export function edited(log: Log.Log, id: rt.u32, arg: rt.u8): void { } else if (_8 === 1) { const v4: Key.Key[] = []; const _74: Key.Key = key(1); - rt.vecPush(v4, _74, 12); + v4.push(_74); const _79: Key.Key = key(1); - rt.vecPush(v4, _79, 12); + v4.push(_79); const _84: Key.Key = key(2); - rt.vecPush(v4, _84, 12); + v4.push(_84); const _89: Key.Key = key(2); - rt.vecPush(v4, _89, 12); + v4.push(_89); const _94: Key.Key = key(3); - rt.vecPush(v4, _94, 12); + v4.push(_94); const v3: Key.Key[] = v4; rt.vecDedupBy(v3, Key.eq$cmp_PartialEq, rt.drop); const part19 = ids(v3); @@ -1356,11 +1356,11 @@ export function edited(log: Log.Log, id: rt.u32, arg: rt.u8): void { } else if (_8 === 2) { const v6: Key.Key[] = []; const _152: Key.Key = key(1); - rt.vecPush(v6, _152, 12); + v6.push(_152); const _157: Key.Key = key(2); - rt.vecPush(v6, _157, 12); + v6.push(_157); const _162: Key.Key = key(3); - rt.vecPush(v6, _162, 12); + v6.push(_162); const v5: Key.Key[] = v6; rt.vecSwapRemove(v5, 0)[Symbol.dispose](); const part17 = ids(v5); @@ -1371,11 +1371,11 @@ export function edited(log: Log.Log, id: rt.u32, arg: rt.u8): void { } else if (_8 === 3) { const v8: Key.Key[] = []; const _190: Key.Key = key(1); - rt.vecPush(v8, _190, 12); + v8.push(_190); const _195: Key.Key = key(2); - rt.vecPush(v8, _195, 12); + 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]]); @@ -1389,14 +1389,14 @@ export function edited(log: Log.Log, id: rt.u32, arg: rt.u8): void { } else if (_8 === 5) { const v10: Key.Key[] = []; const _229: Key.Key = key(1); - rt.vecPush(v10, _229, 12); + v10.push(_229); const _234: Key.Key = key(2); - rt.vecPush(v10, _234, 12); + v10.push(_234); const _239: Key.Key = key(3); - rt.vecPush(v10, _239, 12); + v10.push(_239); const v9: Key.Key[] = v10; const _244: Key.Key = key(4); - rt.vecInsert(v9, 1, _244, 12); + rt.vecInsert(v9, 1, _244); const part9 = ids(v9); const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part9)]; Log.note(log, rt.fmtFormat(["inserted ", args16[0]])); @@ -1413,11 +1413,11 @@ export function edited(log: Log.Log, id: rt.u32, arg: rt.u8): void { } else if (_8 === 6) { const v11: Key.Key[] = []; const _305: Key.Key = key(1); - rt.vecPush(v11, _305, 12); + v11.push(_305); const _310: Key.Key = key(3); - rt.vecPush(v11, _310, 12); + v11.push(_310); const _315: Key.Key = key(5); - rt.vecPush(v11, _315, 12); + v11.push(_315); const part6 = option_mapOr$1w10sgd(rt.iterMaxByKey(rt.iterSlice(v11, rt.drop), (k2: Key.Key): rt.u32 => { return rt.u32Rem(rt.u32Sub(k2.id, id), 3); }, rt.lt, true, rt.drop), 0, (k3: Key.Key): rt.u32 => { @@ -1429,11 +1429,11 @@ export function edited(log: Log.Log, id: rt.u32, arg: rt.u8): void { Log.note(log, rt.fmtFormat(["max ", args22[0]])); const v12: Key.Key[] = []; const _339: Key.Key = key(3); - rt.vecPush(v12, _339, 12); + v12.push(_339); const _344: Key.Key = key(1); - rt.vecPush(v12, _344, 12); + v12.push(_344); const _349: Key.Key = key(2); - rt.vecPush(v12, _349, 12); + v12.push(_349); const part7 = option_mapOr$1w10sgd(rt.iterMin(rt.iterSlice(v12, rt.drop), rt.cmpLt(Key.partialCmp$cmp_PartialOrd), true, rt.drop), 0, (k4: Key.Key): rt.u32 => { const _06: rt.u32 = rt.u32Sub(k4.id, id); k4[Symbol.dispose](); diff --git a/ts/fixtures/task/expected/drops/closures.ts b/ts/fixtures/task/expected/drops/closures.ts index 796881140..e0e53ec42 100644 --- a/ts/fixtures/task/expected/drops/closures.ts +++ b/ts/fixtures/task/expected/drops/closures.ts @@ -125,7 +125,7 @@ export function scoped(log: Log.Log, id: rt.u32): void { const held: Guard.Guard[] = []; let captured11 = held; const push: (a0: Guard.Guard) => rt.usize = rt.closure((g2: Guard.Guard): rt.usize => { - rt.vecPush(captured11, g2, 8); + captured11.push(g2); return captured11.length; }, (): void => { rt.dropAll(captured11); @@ -362,11 +362,11 @@ export function iterated(log: Log.Log, id: rt.u32): void { const a: Guard.Guard = guard(1); const v: Guard.Guard[] = []; const _14: Guard.Guard = guard(2); - rt.vecPush(v, _14, 8); + v.push(_14); const _19: Guard.Guard = guard(3); - rt.vecPush(v, _19, 8); + v.push(_19); const _24: Guard.Guard = guard(4); - rt.vecPush(v, _24, 8); + v.push(_24); const _9: rt.Iter = rt.iterSlice(v, rt.drop); const captured = a; const mapped: rt.Iter = rt.iterMap(_9, rt.closure((g3: Guard.Guard): rt.u32 => { @@ -384,11 +384,11 @@ export function iterated(log: Log.Log, id: rt.u32): void { const b: Guard.Guard = guard(5); const v2: Guard.Guard[] = []; const _56: Guard.Guard = guard(6); - rt.vecPush(v2, _56, 8); + v2.push(_56); const _61: Guard.Guard = guard(7); - rt.vecPush(v2, _61, 8); + v2.push(_61); const _66: Guard.Guard = guard(8); - rt.vecPush(v2, _66, 8); + v2.push(_66); const _51: rt.Iter = rt.iterSlice(v2, rt.drop); const captured2 = b; const iter: rt.Iter = rt.iterFilter(_51, rt.closure((g4: Guard.Guard): boolean => { @@ -419,13 +419,13 @@ export function iterated(log: Log.Log, id: rt.u32): void { const e: Guard.Guard = _95[2]; const v3: Guard.Guard[] = []; const _113: Guard.Guard = guard(12); - rt.vecPush(v3, _113, 8); + v3.push(_113); const _118: Guard.Guard = guard(13); - rt.vecPush(v3, _118, 8); + v3.push(_118); const _123: Guard.Guard = guard(14); - rt.vecPush(v3, _123, 8); + v3.push(_123); const _128: Guard.Guard = guard(15); - rt.vecPush(v3, _128, 8); + v3.push(_128); const _108: rt.Iter = rt.iterSlice(v3, rt.drop); const captured3 = c; const _107: rt.Iter = rt.iterSkipWhile(_108, rt.closure((g5: Guard.Guard): boolean => { @@ -467,9 +467,9 @@ export function iterated(log: Log.Log, id: rt.u32): void { f = _164[0]; const g2: Guard.Guard = _164[1]; const v4: rt.u32[] = []; - rt.vecPush(v4, 1, 4); - rt.vecPush(v4, 2, 4); - rt.vecPush(v4, 3, 4); + v4.push(1); + v4.push(2); + v4.push(3); const _173: rt.Iter = rt.iterSlice(v4); const captured6 = f; const _172: rt.Iter = rt.iterFilterMap(_173, rt.closure((n4: rt.u32): rt.u32 | undefined => { @@ -480,9 +480,9 @@ export function iterated(log: Log.Log, id: rt.u32): void { const captured7 = g2; const flat: rt.Iter = rt.iterFlatMap(_172, rt.closure((n5: rt.u32): rt.u32[] => { const v7: rt.u32[] = []; - rt.vecPush(v7, n5, 4); + v7.push(n5); const _8: rt.u32 = rt.u32Add(n5, Guard.id(captured7)); - rt.vecPush(v7, _8, 4); + v7.push(_8); return v7; }, (): void => { captured7[Symbol.dispose](); @@ -557,11 +557,11 @@ export function iterated(log: Log.Log, id: rt.u32): void { rt.drop(chain); const v5: Guard.Guard[] = []; const _297: Guard.Guard = guard(21); - rt.vecPush(v5, _297, 8); + v5.push(_297); const _302: Guard.Guard = guard(22); - rt.vecPush(v5, _302, 8); + v5.push(_302); const _307: Guard.Guard = guard(23); - rt.vecPush(v5, _307, 8); + v5.push(_307); const items: Guard.Guard[] = v5; const _313: [Guard.Guard, Guard.Guard, Guard.Guard] = [guard(24), guard(25), guard(26)]; const k: Guard.Guard = _313[0]; @@ -680,9 +680,9 @@ export function iterated(log: Log.Log, id: rt.u32): void { rt.dropAfter(_475, () => rt.btreeRetain(map, _475, undefined, rt.drop)); const queue: rt.VecDeque = rt.dequeNew() as rt.VecDeque; const _479: Guard.Guard = guard(33); - rt.dequePushBack(queue, _479, 8); + rt.dequePushBack(queue, _479); const _484: Guard.Guard = guard(34); - rt.dequePushBack(queue, _484, 8); + rt.dequePushBack(queue, _484); const captured24 = guard(35); const _492: (a0: Guard.Guard) => boolean = rt.closure((g19: Guard.Guard): boolean => { return rt.u32Add(Guard.id(g19), 2) !== Guard.id(captured24); diff --git a/ts/fixtures/task/expected/drops/folds.ts b/ts/fixtures/task/expected/drops/folds.ts index f85fecc92..143c50552 100644 --- a/ts/fixtures/task/expected/drops/folds.ts +++ b/ts/fixtures/task/expected/drops/folds.ts @@ -186,7 +186,7 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { const _169: rt.Iter = rt.iterSlice(guards(1, 4), rt.drop); _1090 = false; const captured56 = c; - const same: Guard.Guard[] = rt.iterToArrayInPlace(rt.iterMap(_169, rt.closure((g68: Guard.Guard): Guard.Guard => { + const same: Guard.Guard[] = rt.iterToArray(rt.iterMap(_169, rt.closure((g68: Guard.Guard): Guard.Guard => { const _976: rt.u32 = Guard.id(g68); const _1224: rt.u32 = Guard.id(captured56); const args102: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_976, f), (f: rt.Formatter) => rt.u32Display(_1224, f)]; @@ -194,7 +194,7 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { return g68; }, (): void => { captured56[Symbol.dispose](); - })), 8, 8, false, "next", true); + })), "next", 8, true); const _176: rt.Iter = rt.iterSlice(guards(4, 7), rt.drop); _1089 = false; const captured57 = d; @@ -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 queue: rt.VecDeque = rt.dequeFromVec(rt.iterToArrayInPlace(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,7 +221,7 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { return g66; }, (): void => { captured54[Symbol.dispose](); - })), 8, 8, false, "next", true), 8) as rt.VecDeque; + })), "next", 8, true)) as rt.VecDeque; const _206: rt.Iter = rt.iterSlice(guards(4, 7), rt.drop); _1089 = false; const captured55 = d; @@ -523,9 +523,9 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { const n11: rt.usize = rt.ownedCount(rt.iterFlatMap(_553, rt.closure((n33: rt.u32): Guard.Guard[] => { const v6: Guard.Guard[] = []; const _659: Guard.Guard = captured29(n33); - rt.vecPush(v6, _659, 8); + v6.push(_659); const _1128: Guard.Guard = captured29(rt.u32Add(n33, 1)); - rt.vecPush(v6, _1128, 8); + v6.push(_1128); const _226: rt.u32 = Guard.id(captured30); const args88: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n33, f), (f: rt.Formatter) => rt.u32Display(_226, f)]; Log.note(log, rt.fmtFormat(["flat ", args88[0], " ", args88[1]])); @@ -544,9 +544,9 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { const captured25 = id; const flat: rt.Iter = rt.iterFlatten(rt.iterMap(_572, rt.closure((g35: Guard.Guard): Guard.Guard[] => { const v3: Guard.Guard[] = []; - rt.vecPush(v3, g35, 8); + v3.push(g35); const _818: Guard.Guard = captured23(rt.u32Add(rt.u32Sub(Guard.id(captured24), captured25), 1)); - rt.vecPush(v3, _818, 8); + v3.push(_818); return v3; }, (): void => { captured24[Symbol.dispose](); @@ -571,9 +571,9 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { const _606: rt.u32 | undefined = option_map$1raha9y(rt.ownedLast(rt.iterFlatMap(_597, rt.closure((n32: rt.u32): Guard.Guard[] => { const v4: Guard.Guard[] = []; const _658: Guard.Guard = captured26(n32); - rt.vecPush(v4, _658, 8); + v4.push(_658); const _1125: Guard.Guard = captured26(rt.u32Add(rt.u32Sub(Guard.id(captured27), captured28), n32)); - rt.vecPush(v4, _1125, 8); + v4.push(_1125); return v4; }, (): void => { captured27[Symbol.dispose](); @@ -590,7 +590,7 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { let captured19 = held; const captured20 = c; const n13: rt.usize = rt.ownedCount(rt.iterFromFn(rt.closure((): rt.u32 | undefined => { - const _336: Guard.Guard | undefined = rt.vecPop(captured19); + const _336: Guard.Guard | undefined = captured19.pop(); if (_336 !== undefined) { const g32: Guard.Guard = _336; const _034: rt.u32 | undefined = rt.u32Add(Guard.id(g32), Guard.id(captured20)); @@ -763,9 +763,9 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { const captured9 = id; const flat2: rt.Iter = rt.iterFlatten(rt.iterMap(_843, rt.closure((g14: Guard.Guard): Guard.Guard[] => { const v2: Guard.Guard[] = []; - rt.vecPush(v2, g14, 8); + v2.push(g14); const _86: Guard.Guard = captured7(rt.u32Add(rt.u32Sub(Guard.id(captured8), captured9), 1)); - rt.vecPush(v2, _86, 8); + v2.push(_86); return v2; }, (): void => { captured8[Symbol.dispose](); @@ -1238,8 +1238,8 @@ export function rfolded(log: Log.Log, id: rt.u32, arg: rt.u8): void { Log.note(log, rt.fmtFormat(["map ", args24[0], " ", args24[1]])); const v: Guard.Guard[] = []; const _225: Guard.Guard = captured2(rt.u32Add(rt.u32Sub(Guard.id(g), captured3), 3)); - rt.vecPush(v, _225, 8); - rt.vecPush(v, g, 8); + v.push(_225); + v.push(g); return v; }, (): void => { captured[Symbol.dispose](); @@ -1460,7 +1460,7 @@ export function closures(log: Log.Log, id: rt.u32): void { const _33: rt.Iter = rt.iterSlice(guards(1, 7), rt.drop); const captured = c; const captured2 = pick; - const part2 = rt.iterToArrayInPlace(rt.iterMap(rt.iterFilterMap(_33, rt.closure((g2: Guard.Guard): Guard.Guard | undefined | rt.None => { + const part2 = rt.iterToArray(rt.iterMap(rt.iterFilterMap(_33, rt.closure((g2: Guard.Guard): Guard.Guard | undefined | rt.None => { const _92: rt.u32 = Guard.id(g2); const _127: rt.u32 = Guard.id(captured); const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_92, f), (f: rt.Formatter) => rt.u32Display(_127, f)]; @@ -1474,7 +1474,7 @@ export function closures(log: Log.Log, id: rt.u32): void { g3[Symbol.dispose](); return _06; }); - }), 8, 8, false, "next"); + }), "next", 8); const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part2, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug))]; Log.note(log, rt.fmtFormat(["kept ", args2[0]])); const part3 = rt.iterFold(rt.iterFilterMap(rt.iterSlice(guards(1, 7), rt.drop), pick, rt.None), 0, (n3: rt.u32, o2: Guard.Guard | undefined): rt.u32 => { @@ -1541,7 +1541,7 @@ export function closures(log: Log.Log, id: rt.u32): void { let captured7 = guards(1, 6); const captured8 = f; const made: rt.Iter = rt.iterFromFn(rt.closure((): Guard.Guard | undefined | rt.None => { - const _310: Guard.Guard | undefined = rt.vecPop(captured7); + const _310: Guard.Guard | undefined = captured7.pop(); if (_310 !== undefined) { const g10: Guard.Guard = _310; const _144: rt.u32 = Guard.id(g10); @@ -1725,11 +1725,11 @@ export function zips(log: Log.Log, id: rt.u32, arg: rt.u8): void { })); const captured3 = d; const captured4 = id; - const kept: rt.u32[] = rt.iterToArrayInPlace(rt.iterMap(_190, rt.closure((x2: rt.u32): rt.u32 => { + const kept: rt.u32[] = rt.iterToArray(rt.iterMap(_190, rt.closure((x2: rt.u32): rt.u32 => { return rt.u32Sub(rt.u32Add(x2, Guard.id(captured3)), captured4); }, (): void => { captured3[Symbol.dispose](); - })), 4, 4, false, "next", true); + })), "next", 4, true); const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(n3, f), (f: rt.Formatter) => rt.fmtOption(at, f, rt.usizeDebug), (f: rt.Formatter) => rt.u32Display(sum, f), (f: rt.Formatter) => rt.usizeDisplay(skipped, f), (f: rt.Formatter) => rt.fmtList(kept, f, rt.u32Debug)]; Log.note(log, rt.fmtFormat(["no coerce ", args8[0], " ", args8[1], " ", args8[2], " ", args8[3], " ", args8[4]])); } else if (arg === 4) { diff --git a/ts/fixtures/task/expected/drops/inside.ts b/ts/fixtures/task/expected/drops/inside.ts index 9238113f8..06049bc4d 100644 --- a/ts/fixtures/task/expected/drops/inside.ts +++ b/ts/fixtures/task/expected/drops/inside.ts @@ -70,7 +70,7 @@ export function inside(log: Log.Log, id: rt.u32, arg: rt.u8): void { const _139: rt.usize = v.length; const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_136, f), (f: rt.Formatter) => rt.usizeDisplay(_139, f)]; Log.note(log, rt.fmtFormat(["drained ", args10[0], " ", args10[1]])); - const q: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(new rt.Range(6, 9), guard), undefined, 8, true), 8) as rt.VecDeque; + 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 55e410109..6a423d68e 100644 --- a/ts/fixtures/task/expected/drops/iters.ts +++ b/ts/fixtures/task/expected/drops/iters.ts @@ -14,11 +14,11 @@ export function looped(log: Log.Log, id: rt.u32): void { }; const v: Guard.Guard[] = []; const _10: Guard.Guard = guard(1); - rt.vecPush(v, _10, 8); + v.push(_10); const _15: Guard.Guard = guard(2); - rt.vecPush(v, _15, 8); + v.push(_15); const _20: Guard.Guard = guard(3); - rt.vecPush(v, _20, 8); + v.push(_20); const iterS: Guard.Guard[] = v; let iterI: number = 0; while (true) { @@ -63,30 +63,30 @@ export function looped(log: Log.Log, id: rt.u32): void { rt.drop(iter3); const v2: Guard.Guard[] = []; const _90: Guard.Guard = guard(8); - rt.vecPush(v2, _90, 8); + v2.push(_90); const _95: Guard.Guard = guard(9); - rt.vecPush(v2, _95, 8); + v2.push(_95); const _100: Guard.Guard = guard(10); - rt.vecPush(v2, _100, 8); + v2.push(_100); const _105: Guard.Guard = guard(11); - rt.vecPush(v2, _105, 8); - const even: Guard.Guard[] = rt.iterToArrayInPlace(rt.iterFilter(rt.iterSlice(v2, rt.drop), (g4: Guard.Guard): boolean => { + v2.push(_105); + const even: Guard.Guard[] = rt.iterToArray(rt.iterFilter(rt.iterSlice(v2, rt.drop), (g4: Guard.Guard): boolean => { return rt.u32Rem(Guard.id(g4), 2) === 0; - }, rt.drop), 8, 8, false, "next"); + }, rt.drop), "next", 8); const part3 = even.length; const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part3, f)]; Log.note(log, rt.fmtFormat(["even ", args6[0]])); const v3: Guard.Guard[] = []; const _127: Guard.Guard = guard(12); - rt.vecPush(v3, _127, 8); + v3.push(_127); const _132: Guard.Guard = guard(13); - rt.vecPush(v3, _132, 8); + v3.push(_132); const _137: Guard.Guard = guard(14); - rt.vecPush(v3, _137, 8); + v3.push(_137); const _142: Guard.Guard = guard(15); - rt.vecPush(v3, _142, 8); + v3.push(_142); const _147: Guard.Guard = guard(16); - rt.vecPush(v3, _147, 8); + v3.push(_147); const rest: rt.Iter = rt.iterTake(rt.iterSkip(rt.iterSlice(v3, rt.drop), 1, rt.drop), 3, rt.drop); const part4 = option_mapOr$01ozsk3(rt.iterToOption(rest.next()), 0, (g5: Guard.Guard): rt.u32 => { const _03: rt.u32 = Guard.id(g5); @@ -100,9 +100,9 @@ export function looped(log: Log.Log, id: rt.u32): void { Log.note(log, rt.fmtFormat(["count ", args10[0]])); const v4: Guard.Guard[] = []; const _181: Guard.Guard = guard(17); - rt.vecPush(v4, _181, 8); + v4.push(_181); const _186: Guard.Guard = guard(18); - rt.vecPush(v4, _186, 8); + v4.push(_186); const peek: rt.Peekable = rt.iterPeekable(rt.iterSlice(v4, rt.drop), rt.drop); const first: Guard.Guard | undefined = rt.peekableNextIf(peek, (g6: Guard.Guard): boolean => { return Guard.id(g6) === rt.u32Add(id, 17); @@ -117,27 +117,27 @@ export function looped(log: Log.Log, id: rt.u32): void { rt.drop(peek); const v5: Guard.Guard[] = []; const _221: Guard.Guard = guard(20); - rt.vecPush(v5, _221, 8); + v5.push(_221); const _226: Guard.Guard = guard(21); - rt.vecPush(v5, _226, 8); + v5.push(_226); const _231: Guard.Guard = guard(22); - rt.vecPush(v5, _231, 8); + v5.push(_231); const _216: rt.Iter = rt.iterSlice(v5, rt.drop); const v6: Guard.Guard[] = []; const _238: Guard.Guard = guard(23); - rt.vecPush(v6, _238, 8); + v6.push(_238); const part6 = rt.ownedCount(rt.iterZip(_216, rt.iterSlice(v6, rt.drop), "len", rt.drop, rt.drop), lib_drop$tuple2_model_Guard_model_Guard); const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part6, f)]; Log.note(log, rt.fmtFormat(["zip ", args14[0]])); const v7: Guard.Guard[] = []; const _261: Guard.Guard = guard(24); - rt.vecPush(v7, _261, 8); + v7.push(_261); const _256: rt.Iter = rt.iterSlice(v7, rt.drop); const v8: Guard.Guard[] = []; const _268: Guard.Guard = guard(25); - rt.vecPush(v8, _268, 8); + v8.push(_268); const _273: Guard.Guard = guard(26); - rt.vecPush(v8, _273, 8); + v8.push(_273); const _254: rt.Iter = rt.iterRev(rt.iterChain(_256, rt.iterSlice(v8, rt.drop))); const nth: Guard.Guard | undefined = rt.iterNth(_254, 1, rt.drop); rt.drop(_254); @@ -150,22 +150,22 @@ export function looped(log: Log.Log, id: rt.u32): void { Log.note(log, rt.fmtFormat(["nth ", args16[0]])); const v9: Guard.Guard[] = []; const _293: Guard.Guard = guard(27); - rt.vecPush(v9, _293, 8); + v9.push(_293); const _298: Guard.Guard = guard(28); - rt.vecPush(v9, _298, 8); + v9.push(_298); const _303: Guard.Guard = guard(29); - rt.vecPush(v9, _303, 8); + v9.push(_303); const best: Guard.Guard | undefined = rt.iterMaxByKey(rt.iterSlice(v9, rt.drop), (g9: Guard.Guard): rt.u32 => { return rt.u32Rem(Guard.id(g9), 2); }, rt.lt, true, rt.drop); const v10: Array = []; const _314: Guard.Guard | undefined = guard(30); - rt.vecPush(v10, _314, 8); - rt.vecPush(v10, undefined as Guard.Guard | undefined, 8); + v10.push(_314); + v10.push(undefined as Guard.Guard | undefined); const _323: Guard.Guard | undefined = guard(31); - rt.vecPush(v10, _323, 8); + v10.push(_323); const _329: Guard.Guard | undefined = guard(32); - rt.vecPush(v10, _329, 8); + v10.push(_329); const _308: rt.Iter = rt.iterFlatten(rt.iterSlice(v10, rt.drop), (value: Guard.Guard | undefined) => rt.iterOption(value, rt.drop), true, undefined, true); const found: Guard.Guard | undefined = rt.iterFind(_308, (g10: Guard.Guard): boolean => { return Guard.id(g10) === rt.u32Add(id, 31); @@ -181,11 +181,11 @@ export function looped(log: Log.Log, id: rt.u32): void { Log.note(log, rt.fmtFormat(["found ", args18[0], " ", args18[1]])); const v11: Guard.Guard[] = []; const _356: Guard.Guard = guard(33); - rt.vecPush(v11, _356, 8); + v11.push(_356); const _361: Guard.Guard = guard(34); - rt.vecPush(v11, _361, 8); + v11.push(_361); const _366: Guard.Guard = guard(35); - rt.vecPush(v11, _366, 8); + v11.push(_366); const folded: rt.u32 = rt.iterFold(rt.iterSlice(v11, rt.drop), 0, (n2: rt.u32, g12: Guard.Guard): rt.u32 => { const _010: rt.u32 = rt.u32Sub(rt.u32Add(n2, Guard.id(g12)), id); g12[Symbol.dispose](); @@ -193,11 +193,11 @@ export function looped(log: Log.Log, id: rt.u32): void { }, true); const v12: Guard.Guard[] = []; const _378: Guard.Guard = guard(36); - rt.vecPush(v12, _378, 8); + v12.push(_378); const _383: Guard.Guard = guard(37); - rt.vecPush(v12, _383, 8); + v12.push(_383); const _388: Guard.Guard = guard(38); - rt.vecPush(v12, _388, 8); + v12.push(_388); const _397: rt.u32 = option_mapOr$01ozsk3(rt.ownedLast(rt.iterStepBy(rt.iterSlice(v12, rt.drop), 2, rt.drop), rt.drop), 0, (g13: Guard.Guard): rt.u32 => { const _011: rt.u32 = Guard.id(g13); g13[Symbol.dispose](); @@ -208,20 +208,20 @@ export function looped(log: Log.Log, id: rt.u32): void { const v13: Guard.Guard[][] = []; const v14: Guard.Guard[] = []; const _414: Guard.Guard = guard(39); - rt.vecPush(v14, _414, 8); + v14.push(_414); const _419: Guard.Guard = guard(40); - rt.vecPush(v14, _419, 8); - rt.vecPush(v13, v14, 12); + v14.push(_419); + v13.push(v14); const v15: Guard.Guard[] = []; const _428: Guard.Guard = guard(41); - rt.vecPush(v15, _428, 8); - rt.vecPush(v13, v15, 12); + v15.push(_428); + v13.push(v15); const v16: Guard.Guard[] = []; const _437: Guard.Guard = guard(42); - rt.vecPush(v16, _437, 8); + v16.push(_437); const _442: Guard.Guard = guard(43); - rt.vecPush(v16, _442, 8); - rt.vecPush(v13, v16, 12); + v16.push(_442); + v13.push(v16); const flat: rt.Iter = rt.iterFlatten(rt.iterSlice(v13, lib_drop$Vec_model_Guard), (value: Guard.Guard[]) => rt.iterSlice(value, rt.drop), true); const front: rt.u32 = option_mapOr$01ozsk3(rt.iterToOption(flat.next()), 0, (g14: Guard.Guard): rt.u32 => { const _012: rt.u32 = Guard.id(g14); @@ -239,15 +239,15 @@ export function looped(log: Log.Log, id: rt.u32): void { const five: (a0: rt.u32) => Guard.Guard[] = (n3: rt.u32): Guard.Guard[] => { const v17: Guard.Guard[] = []; const _610: Guard.Guard = guard(n3); - rt.vecPush(v17, _610, 8); + v17.push(_610); const _103: Guard.Guard = guard(rt.u32Add(n3, 1)); - rt.vecPush(v17, _103, 8); + v17.push(_103); const _162: Guard.Guard = guard(rt.u32Add(n3, 2)); - rt.vecPush(v17, _162, 8); + v17.push(_162); const _222: Guard.Guard = guard(rt.u32Add(n3, 3)); - rt.vecPush(v17, _222, 8); + v17.push(_222); const _283: Guard.Guard = guard(rt.u32Add(n3, 4)); - rt.vecPush(v17, _283, 8); + v17.push(_283); return v17; }; const _471: rt.Iter = rt.iterSkip(rt.iterSlice(five(44), rt.drop), 2, rt.drop); @@ -311,31 +311,31 @@ export function collected(log: Log.Log, id: rt.u32): void { }; const v: Guard.Guard[] = []; const _13: Guard.Guard = guard(1); - rt.vecPush(v, _13, 8); + v.push(_13); const _18: Guard.Guard = guard(2); - rt.vecPush(v, _18, 8); + v.push(_18); const _23: Guard.Guard = guard(3); - rt.vecPush(v, _23, 8); - const same: Guard.Guard[] = rt.iterToArrayInPlace(rt.iterSlice(v, rt.drop), 8, 8, true, "next", true); + v.push(_23); + const same: Guard.Guard[] = rt.iterToArray(rt.iterSlice(v, rt.drop), "next", 8, true); const v2: Guard.Guard[] = []; const _33: Guard.Guard = guard(4); - rt.vecPush(v2, _33, 8); + v2.push(_33); const _38: Guard.Guard = guard(5); - rt.vecPush(v2, _38, 8); + v2.push(_38); const _43: Guard.Guard = guard(6); - rt.vecPush(v2, _43, 8); + v2.push(_43); const wider: [Guard.Guard, rt.u32][] = rt.iterToArray(rt.iterMap(rt.iterSlice(v2, rt.drop), (g: Guard.Guard): [Guard.Guard, rt.u32] => { return [g, 0] as [Guard.Guard, rt.u32]; }), "fold", 12, true); const v3: Guard.Guard[] = []; const _53: Guard.Guard = guard(7); - rt.vecPush(v3, _53, 8); + v3.push(_53); const _48: rt.Iter = rt.iterSlice(v3, rt.drop); const v4: Guard.Guard[] = []; const _60: Guard.Guard = guard(8); - rt.vecPush(v4, _60, 8); + v4.push(_60); const _65: Guard.Guard = guard(9); - rt.vecPush(v4, _65, 8); + v4.push(_65); const chained: Guard.Guard[] = rt.iterToArray(rt.iterChain(_48, rt.iterSlice(v4, rt.drop)), "fold", 8, true); const _74: rt.usize = same.length; const _77: rt.usize = wider.length; @@ -344,31 +344,31 @@ export function collected(log: Log.Log, id: rt.u32): void { Log.note(log, rt.fmtFormat(["vecs ", args2[0], " ", args2[1], " ", args2[2]])); const v5: Guard.Guard[] = []; const _95: Guard.Guard = guard(10); - rt.vecPush(v5, _95, 8); + v5.push(_95); const _100: Guard.Guard = guard(11); - rt.vecPush(v5, _100, 8); + v5.push(_100); const _105: Guard.Guard = guard(12); - rt.vecPush(v5, _105, 8); + v5.push(_105); const results: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterSlice(v5, rt.drop), (g2: Guard.Guard): rt.Result => { if (!(Guard.id(g2) === rt.u32Add(id, 11))) { return rt.Ok(g2); } return rt.Err(g2); - }), (values: rt.Iter) => rt.iterToArrayInPlace(values, 8, 8, false, "next"), lib_drop$Vec_model_Guard); + }), (values: rt.Iter) => rt.iterToArray(values, "next", 8), lib_drop$Vec_model_Guard); const part = results.ok; const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part, f)]; Log.note(log, rt.fmtFormat(["result ", args4[0]])); lib_drop$Result_Vec_model_Guard_model_Guard(results); const v6: Guard.Guard[] = []; const _130: Guard.Guard = guard(13); - rt.vecPush(v6, _130, 8); + v6.push(_130); const _135: Guard.Guard = guard(14); - rt.vecPush(v6, _135, 8); + v6.push(_135); const _140: Guard.Guard = guard(15); - rt.vecPush(v6, _140, 8); + v6.push(_140); const part2 = option_mapOr$0vxyhav(rt.iterCollectOption(rt.iterMap(rt.iterSlice(v6, rt.drop), (g3: Guard.Guard): Guard.Guard | undefined => { return g3; - }), (values: rt.Iter) => rt.iterToArrayInPlace(values, 8, 8, false, "next"), lib_drop$Vec_model_Guard), 0, (v12: Guard.Guard[]): rt.usize => { + }), (values: rt.Iter) => rt.iterToArray(values, "next", 8), lib_drop$Vec_model_Guard), 0, (v12: Guard.Guard[]): rt.usize => { const _06: rt.usize = v12.length; rt.dropAll(v12); return _06; @@ -377,46 +377,46 @@ export function collected(log: Log.Log, id: rt.u32): void { Log.note(log, rt.fmtFormat(["option ", args6[0]])); const v7: [rt.u32, Guard.Guard][] = []; const _160: [rt.u32, Guard.Guard] = [2, guard(16)]; - rt.vecPush(v7, _160, 12); + v7.push(_160); const _166: [rt.u32, Guard.Guard] = [1, guard(17)]; - rt.vecPush(v7, _166, 12); + v7.push(_166); const _172: [rt.u32, Guard.Guard] = [2, guard(18)]; - rt.vecPush(v7, _172, 12); + v7.push(_172); const _155: rt.Iter<[rt.u32, Guard.Guard]> = rt.iterSlice(v7, lib_drop$tuple2_u32_model_Guard); - const tree: rt.BTreeMap = rt.btreeCollect(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterToArrayInPlace(_155, 12, 12, true, "next", true), true, undefined, undefined, rt.drop); + const tree: rt.BTreeMap = rt.btreeCollect(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterToArray(_155, "next", 12, true), true, undefined, undefined, rt.drop); const part3 = rt.btreeLen(tree); const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part3, f)]; Log.note(log, rt.fmtFormat(["tree ", args8[0]])); const v8: Guard.Guard[] = []; const _195: Guard.Guard = guard(24); - rt.vecPush(v8, _195, 8); + v8.push(_195); const _200: Guard.Guard = guard(25); - rt.vecPush(v8, _200, 8); - const part4 = rt.iterToArrayInPlace(rt.iterMap(rt.iterSlice(v8, rt.drop), (_2: Guard.Guard): Guard.Guard => { + v8.push(_200); + const part4 = rt.iterToArray(rt.iterMap(rt.iterSlice(v8, rt.drop), (_2: Guard.Guard): Guard.Guard => { const at = rt.idx(same, 0); _2[Symbol.dispose](); return same[at]; - }), 8, 4, false, "next", true).length; + }), "next", 4, true).length; const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part4, f)]; Log.note(log, rt.fmtFormat(["refs ", args10[0]])); const v9: Guard.Guard[] = []; const _223: Guard.Guard = guard(19); - rt.vecPush(v9, _223, 8); + v9.push(_223); const _228: Guard.Guard = guard(20); - rt.vecPush(v9, _228, 8); - const queue: rt.VecDeque = rt.dequeFromIntoIter(rt.iterSlice(v9, rt.drop), 8, "fold") as rt.VecDeque; + v9.push(_228); + 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)]; - rt.vecPush(v10, _237, 12); + v10.push(_237); const _243: [rt.u32, Guard.Guard] = [1, guard(22)]; - rt.vecPush(v10, _243, 12); + v10.push(_243); const _232: rt.Iter<[rt.u32, Guard.Guard]> = rt.iterSlice(v10, lib_drop$tuple2_u32_model_Guard); const hashed: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, _232, undefined, rt.drop, "fold", 117440512); const v11: Key.Key[] = []; const _253: Key.Key = key(23); - rt.vecPush(v11, _253, 12); + v11.push(_253); const _258: Key.Key = key(23); - rt.vecPush(v11, _258, 12); + v11.push(_258); const _248: rt.Iter = rt.iterSlice(v11, rt.drop); const set: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rt.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rt.HashSet, _248, rt.drop, "fold", 117440512); const _267: rt.usize = queue.n; @@ -499,7 +499,7 @@ export function drained(log: Log.Log, id: rt.u32): void { const iterEnd: rt.u32 = 20; while ((_80 = iterStart++) < iterEnd) { const _86: Guard.Guard = guard(_80); - rt.dequePushBack(queue, _86, 8); + rt.dequePushBack(queue, _86); } const range: rt.Iter = rt.dequeDrain(queue, new rt.Range(1, 4), rt.drop); const part2 = option_mapOr$01ozsk3(rt.iterToOption(range.next()), 0, (g2: Guard.Guard): rt.u32 => { @@ -590,23 +590,23 @@ export function extended(log: Log.Log, id: rt.u32): void { }; const v: Guard.Guard[] = []; const _11: Guard.Guard = guard(1); - rt.vecPush(v, _11, 8); + v.push(_11); const list: Guard.Guard[] = v; const v2: Guard.Guard[] = []; const _20: Guard.Guard = guard(2); - rt.vecPush(v2, _20, 8); + v2.push(_20); const _25: Guard.Guard = guard(3); - rt.vecPush(v2, _25, 8); + v2.push(_25); const _30: Guard.Guard = guard(4); - rt.vecPush(v2, _30, 8); + v2.push(_30); rt.iterExtend(list, rt.iterSlice(v2, rt.drop), "fold", 8, true); const v3: Guard.Guard[] = []; const _41: Guard.Guard = guard(5); - rt.vecPush(v3, _41, 8); + v3.push(_41); const _46: Guard.Guard = guard(6); - rt.vecPush(v3, _46, 8); + v3.push(_46); const _51: Guard.Guard = guard(7); - rt.vecPush(v3, _51, 8); + v3.push(_51); const _35: rt.Iter = rt.iterFilter(rt.iterSlice(v3, rt.drop), (g: Guard.Guard): boolean => { return Guard.id(g) !== rt.u32Add(id, 5); }, rt.drop); @@ -620,18 +620,18 @@ export function extended(log: Log.Log, id: rt.u32): void { rt.drop(rt.hashInsert(map, _71, _74, rt.drop)); const v4: [Key.Key, Guard.Guard][] = []; const _83: [Key.Key, Guard.Guard] = [key(8), guard(9)]; - rt.vecPush(v4, _83, 20); + v4.push(_83); const _92: [Key.Key, Guard.Guard] = [key(8), guard(10)]; - rt.vecPush(v4, _92, 20); + v4.push(_92); rt.hashExtend(map, rt.iterSlice(v4, lib_drop$tuple2_drops_Key_model_Guard), rt.drop, rt.drop, "fold", 58720256); const set: rt.HashSet = rt.hashNew(rt.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rt.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rt.HashSet; const _102: Key.Key = key(11); rt.hashAdd(set, _102, rt.drop); const v5: Key.Key[] = []; const _111: Key.Key = key(11); - rt.vecPush(v5, _111, 12); + v5.push(_111); const _116: Key.Key = key(11); - rt.vecPush(v5, _116, 12); + v5.push(_116); rt.hashExtendKeys(set, rt.iterSlice(v5, rt.drop), rt.drop, "fold", 117440512); const _125: rt.usize = rt.hashLen(map); const _128: rt.usize = rt.hashLen(set); @@ -643,29 +643,29 @@ export function extended(log: Log.Log, id: rt.u32): void { rt.drop(rt.btreeInsert(tree, _138, _141, rt.drop)); const v6: [Key.Key, Guard.Guard][] = []; const _150: [Key.Key, Guard.Guard] = [key(13), guard(13)]; - rt.vecPush(v6, _150, 20); + v6.push(_150); const _159: [Key.Key, Guard.Guard] = [key(12), guard(14)]; - rt.vecPush(v6, _159, 20); + v6.push(_159); const _168: [Key.Key, Guard.Guard] = [key(15), guard(15)]; - rt.vecPush(v6, _168, 20); + v6.push(_168); rt.btreeExtend(tree, rt.iterSlice(v6, lib_drop$tuple2_drops_Key_model_Guard), false, rt.drop, rt.drop, "fold"); const ordered: rt.BTreeSet = rt.btreeNew(Key.cmp$cmp_Ord) as rt.BTreeSet; const _178: Key.Key = key(16); rt.btreeAdd(ordered, _178, rt.drop); const v7: Key.Key[] = []; const _187: Key.Key = key(17); - rt.vecPush(v7, _187, 12); + v7.push(_187); const _192: Key.Key = key(16); - rt.vecPush(v7, _192, 12); + v7.push(_192); rt.btreeExtendKeys(ordered, rt.iterSlice(v7, rt.drop), false, rt.drop, "fold"); const queue: rt.VecDeque = rt.dequeNew() as rt.VecDeque; const _198: Guard.Guard = guard(18); - rt.dequePushBack(queue, _198, 8); + rt.dequePushBack(queue, _198); const v8: Guard.Guard[] = []; const _207: Guard.Guard = guard(19); - rt.vecPush(v8, _207, 8); + v8.push(_207); const _212: Guard.Guard = guard(20); - rt.vecPush(v8, _212, 8); + v8.push(_212); rt.dequeExtend(queue, rt.iterSlice(v8, rt.drop), "fold", 8, true); const _221: rt.usize = rt.btreeLen(tree); const _224: rt.usize = rt.btreeLen(ordered); diff --git a/ts/fixtures/task/expected/drops/objects.ts b/ts/fixtures/task/expected/drops/objects.ts index 138a59719..b605107bd 100644 --- a/ts/fixtures/task/expected/drops/objects.ts +++ b/ts/fixtures/task/expected/drops/objects.ts @@ -28,13 +28,13 @@ export function boxed(log: Log.Log, id: rt.u32): void { const first: Part.Part = new Part.of$model_Guard(guard(1)); const parts: Part.Part[] = []; const _13: Part.Part = new Part.of$drops_Held({ tag: "Two", _0: guard(2), _1: guard(3) } as Held.Held); - rt.vecPush(parts, _13, 8); + parts.push(_13); const _24: Part.Part = new Part.of$u32(7); - rt.vecPush(parts, _24, 8); + parts.push(_24); const _28: Part.Part = new Part.of$drops_Wrap_u32(new Wrap.Wrap(rt.u32Add(id, 4), Log.clone$Clone(log), 0)); - rt.vecPush(parts, _28, 8); + parts.push(_28); const _36: Part.Part = new Part.of$drops_Held({ tag: "One", _0: guard(5) } as Held.Held); - rt.vecPush(parts, _36, 8); + parts.push(_36); rt.sliceSwap(parts, 2, 3); const part = rt.iterFold(rt.iterMap(rt.iterSlice(parts), (p: Part.Part): rt.u32 => { return p.id$Part(); @@ -59,7 +59,7 @@ export function boxed(log: Log.Log, id: rt.u32): void { const part4 = first.take$Part(); const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part4, f)]; Log.note(log, rt.fmtFormat(["took ", args8[0]])); - const part5 = option_map$0s8hob8(rt.vecPop(parts), (a02: Part.Part): rt.u32 => { + const part5 = option_map$0s8hob8(parts.pop(), (a02: Part.Part): rt.u32 => { return a02.take$Part(); }); const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part5, f, rt.u32Debug)]; @@ -102,13 +102,13 @@ export function shared(log: Log.Log, id: rt.u32): void { const wrap: rt.Arc> = new rt.Arc(new Wrap.Wrap(rt.u32Add(id, 4), Log.clone$Clone(log), 0)); const parts: rt.Arc[] = []; const _63: rt.Arc> = rt.arcClone(wrap); - rt.vecPush(parts, new rt.ArcDyn(_63, new Part.of$drops_Wrap_u32(_63.value)), 8); + parts.push(new rt.ArcDyn(_63, new Part.of$drops_Wrap_u32(_63.value))); const _68: rt.Arc = rt.arcClone(kept); - rt.vecPush(parts, new rt.ArcDyn(_68, new Part.of$model_Guard(_68.value)), 8); + parts.push(new rt.ArcDyn(_68, new Part.of$model_Guard(_68.value))); const _72: rt.Arc = rt.arcClone(second); - rt.vecPush(parts, _72, 8); + parts.push(_72); const _77: rt.Arc = new rt.Arc(7); - rt.vecPush(parts, new rt.ArcDyn(_77, new Part.of$u32(_77.value)), 8); + parts.push(new rt.ArcDyn(_77, new Part.of$u32(_77.value))); const weak: rt.Weak = new rt.Weak(parts[rt.idx(parts, 1)]); second[Symbol.dispose](); const part2 = rt.iterFold(rt.iterMap(rt.iterSlice(parts), (p: rt.Arc): rt.u32 => { @@ -180,14 +180,14 @@ export function anys(log: Log.Log, id: rt.u32): void { }; const boxes: Any.Any[] = []; const _8: Any.Any = new Any.of$model_Guard(guard(1)); - rt.vecPush(boxes, _8, 8); + boxes.push(_8); const _15: Any.Any = new Any.of$drops_Held({ tag: "Two", _0: guard(2), _1: guard(3) } as Held.Held); - rt.vecPush(boxes, _15, 8); + boxes.push(_15); const _26: Any.Any = new Any.of$u32(7); - rt.vecPush(boxes, _26, 8); + boxes.push(_26); const _30: Any.Any = new Any.of$model_Guard(guard(4)); - rt.vecPush(boxes, _30, 8); - const last: rt.Result | undefined = option_map$09vq4lk(rt.vecPop(boxes), (b2: Any.Any): rt.Result => { + boxes.push(_30); + const last: rt.Result | undefined = option_map$09vq4lk(boxes.pop(), (b2: Any.Any): rt.Result => { return b2 instanceof Any.of$model_Guard ? rt.Ok(b2.v) : rt.Err(b2); }); const part = option_map$19e1ji3(last, (g: rt.Result): boolean => { diff --git a/ts/fixtures/task/expected/drops/once.ts b/ts/fixtures/task/expected/drops/once.ts index 955013deb..9854fd888 100644 --- a/ts/fixtures/task/expected/drops/once.ts +++ b/ts/fixtures/task/expected/drops/once.ts @@ -154,11 +154,11 @@ export function run(log: Log.Log, id: rt.u32, arg: rt.u8): void { other2[Symbol.dispose](); const v: rt.OnceCell[] = []; const _274: rt.OnceCell = new rt.OnceCell(guard(63)); - rt.vecPush(v, _274, 8); + v.push(_274); const _280: rt.OnceCell = new rt.OnceCell(undefined); - rt.vecPush(v, _280, 8); + v.push(_280); const _283: rt.OnceCell = new rt.OnceCell(guard(64)); - rt.vecPush(v, _283, 8); + v.push(_283); const cells: rt.OnceCell[] = v; const part7 = cells.length; const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part7, f)]; diff --git a/ts/fixtures/task/expected/kio.Producer.ts b/ts/fixtures/task/expected/kio.Producer.ts index eab95def7..bcaef6f59 100644 --- a/ts/fixtures/task/expected/kio.Producer.ts +++ b/ts/fixtures/task/expected/kio.Producer.ts @@ -27,7 +27,7 @@ function new_(): Producer { /** Queue `value` and wake every consumer, after releasing the lock. */ export function send(self: Producer, value: rt.u64): void { const state: rt.Mutex = rt.mutexLock(self.state.value); - rt.vecPush(state.value.queue, value, 8); + state.value.queue.push(value); const waiters: WaiterList.WaiterList = WaiterList.take(state.value.waiters); rt.mutexUnlock(state); WaiterList.wake(waiters); diff --git a/ts/fixtures/task/expected/kio.WaiterList.ts b/ts/fixtures/task/expected/kio.WaiterList.ts index 153b69047..73f50c762 100644 --- a/ts/fixtures/task/expected/kio.WaiterList.ts +++ b/ts/fixtures/task/expected/kio.WaiterList.ts @@ -58,7 +58,7 @@ export function register(self: WaiterList, waiter: Waiter.Waiter): void { const entry: rt.Weak = _43; if (entry.arc.strong > 0) { _57 = false; - rt.vecPush(live, entry, 4); + live.push(entry); } if (_57) { entry[Symbol.dispose](); @@ -71,7 +71,7 @@ export function register(self: WaiterList, waiter: Waiter.Waiter): void { self.cursor = 0; } _58 = false; - rt.vecPush(self.entries, weak, 4); + self.entries.push(weak); _58 = false; break b0; } diff --git a/ts/fixtures/task/expected/log.Log.ts b/ts/fixtures/task/expected/log.Log.ts index 3357e9417..c1fd2bbe9 100644 --- a/ts/fixtures/task/expected/log.Log.ts +++ b/ts/fixtures/task/expected/log.Log.ts @@ -27,7 +27,7 @@ function new_(): Log { /** Append one event. */ export function note(self: Log, event: string): void { const _6: rt.Mutex = rt.mutexLock(self._0.value); - rt.vecPush(_6.value, event, 12); + _6.value.push(event); rt.mutexUnlock(_6); } diff --git a/ts/fixtures/task/expected/model.Channel.ts b/ts/fixtures/task/expected/model.Channel.ts index 6b240cdbb..fcbe16380 100644 --- a/ts/fixtures/task/expected/model.Channel.ts +++ b/ts/fixtures/task/expected/model.Channel.ts @@ -24,7 +24,7 @@ export function open(): Channel { const producer: Producer.Producer = Producer.new(); const consumer: Consumer.Consumer = Producer.consume(producer); const producers: Producer.Producer[] = []; - rt.vecPush(producers, producer, 4); + producers.push(producer); return new Channel(producers, consumer); } @@ -45,7 +45,7 @@ export function send(self: Channel, value: rt.u64): boolean { /** Drop the last producer, if one is open: the last closes the channel. */ export function close(self: Channel): boolean { - const _2: Producer.Producer | undefined = rt.vecPop(self.producers); + const _2: Producer.Producer | undefined = self.producers.pop(); if (_2 === undefined) { return false; } @@ -60,7 +60,7 @@ export function cloneProducer(self: Channel): boolean { return false; } const clone: Producer.Producer = Producer.clone$Clone(_3); - rt.vecPush(self.producers, clone, 4); + self.producers.push(clone); return true; } diff --git a/ts/fixtures/task/expected/model.ts b/ts/fixtures/task/expected/model.ts index 2685cce50..b8738281b 100644 --- a/ts/fixtures/task/expected/model.ts +++ b/ts/fixtures/task/expected/model.ts @@ -376,8 +376,8 @@ export class frontFuture { this.#listing = Listing.default$Default(); } (this.#listing as Listing.Listing).last = value; - rt.vecPush((this.#listing as Listing.Listing).listed, value, 8); - rt.vecPush(this.#inFlight, value, 8); + (this.#listing as Listing.Listing).listed.push(value); + this.#inFlight.push(value); if (!(rt.u64Rem(value, 3) === 2)) { bb0 = 1; continue; @@ -407,7 +407,7 @@ export class frontFuture { if (next === undefined) { return this.#inFlight.length; } - rt.vecPush(this.#inFlight, next, 8); + this.#inFlight.push(next); } else { break; } @@ -419,7 +419,7 @@ export class frontFuture { if (half === 0) { Guard.note(this.#guard, "released"); } else { - rt.vecPush(this.#inFlight, half, 8); + this.#inFlight.push(half); } } return rt.Pending; From 4301ad80cc1209296ce76e6342b26251a949d60c Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sun, 1 Nov 2026 07:09:39 -0800 Subject: [PATCH 13/14] fix(ts): keep the room reserve asked for as a vector's length drops capSet skipped storing a capacity the lazy doubling would read at the current length, so a clear after push and reserve(3) lost the floor reserve guarantees. reserve and reserve_exact now always store theirs. Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/caller.ts | 8 ++++++-- ts/runtime/rt.ts | 9 +++++++-- ts/runtime/rt/collections.ts | 6 +++--- ts/runtime/rt/iter.ts | 4 ++-- 4 files changed, 18 insertions(+), 9 deletions(-) diff --git a/ts/fixtures/lang/caller.ts b/ts/fixtures/lang/caller.ts index 366e81c76..8b588da7f 100644 --- a/ts/fixtures/lang/caller.ts +++ b/ts/fixtures/lang/caller.ts @@ -787,8 +787,9 @@ const gets = [0, 0x10].flatMap((text) => { /** * `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`; a run of pushes that doubles it - * from each; and each way `collects` makes one, of each length it tries. + * 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]) => @@ -797,6 +798,9 @@ const capacityCases = [ 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())), ), diff --git a/ts/runtime/rt.ts b/ts/runtime/rt.ts index 77ba8af7d..619c03c53 100644 --- a/ts/runtime/rt.ts +++ b/ts/runtime/rt.ts @@ -1229,6 +1229,11 @@ export function capSet(c: object & Capped, len: number, cap: number, size: numbe 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. @@ -1267,12 +1272,12 @@ export function vecCapacity(v: T[] & Capped, size: number): number { /** `Vec::reserve` of `size`-byte elements. */ export function vecReserve(v: T[] & Capped, additional: number, size: number): void { - capSet(v, v.length, capReserve(v.length, vecCapacity(v, size), additional, size), size); + 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 { - capSet(v, v.length, capReserveExact(v.length, vecCapacity(v, size), additional, size), size); + capHold(v, capReserveExact(v.length, vecCapacity(v, size), additional, size), size); } /** `Vec::shrink_to` of `size`-byte elements, and `shrink_to_fit` of 0. */ diff --git a/ts/runtime/rt/collections.ts b/ts/runtime/rt/collections.ts index a02e66223..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, byteVecReserve, type Capped, capOf, capReserve, capReserveExact, capSet, capShrink, type None, type Place, panic, type RangeBound, rangeCheck, sliceSort, vecExact, vecMax, vecReserve, vecWithCapacity } 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 { @@ -2392,12 +2392,12 @@ export function dequeCapacity(q: VecDeque, size: number): number { /** `VecDeque::reserve` of `size`-byte items. */ export function dequeReserve(q: VecDeque, additional: number, size: number): void { - capSet(q, q.n, capReserve(q.n, dequeCapacity(q, size), additional, size), size); + 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 { - capSet(q, q.n, capReserveExact(q.n, dequeCapacity(q, size), additional, size), size); + capHold(q, capReserveExact(q.n, dequeCapacity(q, size), additional, size), size); } /** `VecDeque::shrink_to` of `size`-byte items, and `shrink_to_fit` of 0. */ diff --git a/ts/runtime/rt/iter.ts b/ts/runtime/rt/iter.ts index d22e79bb4..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, byteVecReserve, byteVecWithCapacity, type Capped, capOf, capReserve, capSet, Err, type None, Ok, type Place, panic, place, type RangeBound, type Result, sliceView, vecCapacity, vecExtendFromSlice, vecMax, vecReserve, vecWithCapacity } 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"; @@ -612,7 +612,7 @@ export function iterExtend(v: T[] & Capped, items: Iter, take?: Take, size if (take !== undefined) dispose(items); return v; } - if (size !== undefined) vecReserve(v, trustedUpper(items), 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); From a39a6b3380f8cbabfac5abac0bcfe3a9ae241120 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Sun, 1 Nov 2026 07:24:09 -0800 Subject: [PATCH 14/14] test(ts): refresh the lang snapshots after merging main Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/expected/core/option.ts | 4 ++-- ts/fixtures/lang/expected/generics.Runs.ts | 8 ++++---- ts/fixtures/lang/expected/generics.ts | 6 +++--- ts/fixtures/lang/expected/harness.ts | 15 +++++++++++---- 4 files changed, 20 insertions(+), 13 deletions(-) diff --git a/ts/fixtures/lang/expected/core/option.ts b/ts/fixtures/lang/expected/core/option.ts index 1c0a34231..efd655972 100644 --- a/ts/fixtures/lang/expected/core/option.ts +++ b/ts/fixtures/lang/expected/core/option.ts @@ -1885,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/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 de59f4707..e26b4709a 100644 --- a/ts/fixtures/lang/expected/generics.ts +++ b/ts/fixtures/lang/expected/generics.ts @@ -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. */