diff --git a/driver/src/cargo.rs b/driver/src/cargo.rs index 2ccdf7e6b..0242d333d 100644 --- a/driver/src/cargo.rs +++ b/driver/src/cargo.rs @@ -15,8 +15,6 @@ pub struct Args { pub manifest: PathBuf, /// Passed on to `cargo check`. pub cargo: Vec, - /// The driver's own options, each with its value. - pub options: Vec<(String, String)>, } /// What a driver writes, absolute. @@ -29,11 +27,9 @@ pub enum Output { impl Args { /// Parse `args`, without the program name, or `None` after printing `usage` for - /// `--help`. `options` are the driver's own, each taking a value. An error ends with - /// `usage`. - pub fn parse(args: &[String], usage: &str, options: &[&str]) -> Result, String> { + /// `--help`. An error ends with `usage`. + pub fn parse(args: &[String], usage: &str) -> Result, String> { let mut config = None; - let mut own = Vec::new(); let mut out = None; let mut census = None; let mut manifest = None; @@ -55,13 +51,6 @@ impl Args { }; *slot = Some(absolute(Path::new(value))?); } - option if options.contains(&option) => { - let [value, tail @ ..] = rest else { - return Err(format!("{arg} needs a value\n\n{usage}")); - }; - rest = tail; - own.push((option.to_string(), value.clone())); - } "--" => { cargo = rest; break; @@ -91,7 +80,6 @@ impl Args { output, manifest, cargo: cargo.to_vec(), - options: own, })) } } diff --git a/ffi/src/cli.rs b/ffi/src/cli.rs index d209854d0..8ffa09670 100644 --- a/ffi/src/cli.rs +++ b/ffi/src/cli.rs @@ -27,7 +27,7 @@ pub fn run(args: &[String]) -> ExitCode { } fn try_run(args: &[String]) -> Result { - let Some(args) = Args::parse(args, USAGE, &[])? else { + let Some(args) = Args::parse(args, USAGE)? else { return Ok(ExitCode::SUCCESS); }; let config = Config::load(&args.config)?; diff --git a/quest/m2/README.md b/quest/m2/README.md index 8b7700607..28aa917e1 100644 --- a/quest/m2/README.md +++ b/quest/m2/README.md @@ -21,8 +21,9 @@ The fork's feature quests folded into the [exporter](/quest/m1/ffi-export.md); ## Required -- [Lower bodies from MIR](/quest/m2/ts-mir.md) - the MIR spike's prototype becomes the only lowering, and the THIR one goes - [Cheaper byte slices](/quest/m2/ts-byte-views.md) - splitting a `&[u8]` stops making a `Uint8Array` view per split +- [MIR's own census refusals](/quest/m2/ts-mir-census.md) - the census refuses no function THIR translated, and points type refusals at their locals +- [Smaller output from MIR](/quest/m2/ts-mir-size.md) - the bench's bundles shrink back to THIR's sizes, coroutine classes first - [Wide-integer runtime off bigint](/quest/m2/ts-wide-bigint.md) - checked sums, 128-bit quotients, and comparisons with numbers stop going through `bigint`, kept only if measured faster - [Drop in the TypeScript translator](/quest/m2/ts-drop.md) - every value that drops in moq-net and kio drops where Rust drops it - [Async in the TypeScript translator](/quest/m2/ts-async.md) - moq-net's and kio's async code translates with Rust's lazy futures diff --git a/quest/m2/ts-async.md b/quest/m2/ts-async.md index 49bbbaab4..064be2dcc 100644 --- a/quest/m2/ts-async.md +++ b/quest/m2/ts-async.md @@ -24,7 +24,6 @@ What moq-net still needs, by its census from MIR at the pinned revision: `map_err`), `pin!` (50 with `PinMacroHelper`), `poll_fn` (31), `future::pending` (5), and `Box::pin` (29, a boxed future that binds to hand-written TS at the boundary, per the [model](/quest/m2/ts-model.md)). -- `?` inside a function that returns `Poll`, as `ready!(..)?` writes it: 284 sites. - Async closures. - kio's own API, reached across crates (`Pending`, `Consumer::poll`, `Waiter::poll_future`, `Tasks`), with the atomics, `OnceLock`, and coop budget behind @@ -38,5 +37,4 @@ Public API: the translator's output for async code. ## Required -- [Lower bodies from MIR](/quest/m2/ts-mir.md) - async bodies come from the coroutine transform - [Drop in the TypeScript translator](/quest/m2/ts-drop.md) - async bodies hold the values that drop it still refuses diff --git a/quest/m2/ts-drop.md b/quest/m2/ts-drop.md index 97e183af0..93cf71880 100644 --- a/quest/m2/ts-drop.md +++ b/quest/m2/ts-drop.md @@ -45,7 +45,3 @@ before each call that can panic and wraps its body in a `try`; measure any chang the [TS benchmark](/ts/README.md#bench). Public API: the translator's output for values that drop. - -## Required - -- [Lower bodies from MIR](/quest/m2/ts-mir.md) - drops come from MIR's elaboration diff --git a/quest/m2/ts-mir-census.md b/quest/m2/ts-mir-census.md new file mode 100644 index 000000000..be4b2abba --- /dev/null +++ b/quest/m2/ts-mir-census.md @@ -0,0 +1,30 @@ +# [S] MIR's own census refusals + +## Goal + +[rust2-ts](/ts/README.md)'s census of moq-net and kio refuses no function the THIR +lowering translated, and each refusal of a type points at the local or expression that +holds it rather than at its function. + +## Plan + +At the move to MIR, 16 function instances of moq-net and kio that THIR translated +clean, before collections landed, are refused: + +- `unsupported type ... from another crate` for temporaries THIR never declared + (`Patterns`, `Duration`, kio's `Mut`, `Shared`, and `Consumer`, an atomic, + `MaybeUninit`), reported at the function's span. Each should carry its local's span, + from `local_decls`. +- Drops THIR's scopes never saw: `Option>`, `AdapterSend`, `Box<[..]>`, + `Box`'s `Drop`, and an `Option` replaced through a `&mut`. + +MIR also refuses constructs THIR wrote differently: + +- `ControlFlow` values other than the one `?` makes (27 sites): pick a representation, + such as `rt.Result`'s shape or a tagged object, by what `try_fold` and moq's own uses + need. +- A switch on, or a field of, a type from another crate without a mapping + (`kio::Unused`, `Bound`, `MaybeUninit`, `ManuallyDrop`). +- A switch on `char` (6), once `char` has a representation. + +Public API: the translator's output for the functions it newly translates. diff --git a/quest/m2/ts-mir-size.md b/quest/m2/ts-mir-size.md new file mode 100644 index 000000000..7c30a0e17 --- /dev/null +++ b/quest/m2/ts-mir-size.md @@ -0,0 +1,26 @@ +# [M] Smaller output from MIR + +## Goal + +[rust2-ts](/ts/README.md)'s bundles on `just ts bench` are no larger than the THIR +lowering's were, without giving up the speed MIR gained: the codec's at most 27483 +bytes minified and 8437 gzipped, and the async handoff's at most 10901 and 3446. + +## Plan + +At the move to MIR, the codec's bundle was 27750 bytes minified and 8876 gzipped (+1%, ++5%), and the async handoff's 18258 and 3993 (+67%, +16%), against THIR's numbers +above. Each candidate is measured on the bench's sizes and timings before it lands: + +- A coroutine's class, about 520 bytes minified each against about 140 for a THIR + generator: a base class in the runtime for the state and `poll` scaffolding, fields + only for what lives across an `.await`, and a resume function structured where the + graph allows (a dispatch at each loop header it enters) rather than a `switch` over + every block. Generators stay out: they measured 1.4-5.5x slower on the handoff. +- Tuple temporaries a destructuring `const [a, b] = ..` would avoid, and the `let` + list at the top of each function, where a local assigned once could be declared at + its assignment. +- The codec's `fill`, `encodeFrames`, and `decodeSplit`, whose blocks nest deeper than + THIR's loops did. + +Public API: the translator's output, which changes shape but not behavior. diff --git a/quest/m2/ts-mir.md b/quest/m2/ts-mir.md deleted file mode 100644 index e19027571..000000000 --- a/quest/m2/ts-mir.md +++ /dev/null @@ -1,49 +0,0 @@ -# [L] Lower bodies from MIR - -## Goal - -[rust2-ts](/ts/README.md) lowers every body from MIR, as the -[MIR spike](https://github.com/kixelated/rust2/pull/36) decided: `--lower` goes, -the THIR lowering (`src/lower/body.rs`, `pat.rs`, the drop scopes in `drop.rs`, and -`rt.future`'s generators) is deleted, and every fixture passes its snapshot, -differential, unwinding, and census tests from MIR. - -## Plan - -The spike's prototype (`src/lower/mir/`) already passes the codec, lang, and task -fixtures' differential tests and the task fixture's unwinding test. What the move -still needs: - -- The reject fixture and its census, rewritten to what MIR refuses (`reject_mir` - already checks MIR's errors), and snapshots of MIR's output. Constructs THIR refuses that MIR lowers move into the differential - fixtures, such as a `move` closure taking a reference from a variable assigned again - after (`a closure that copies a mutable variable`), which the prototype snapshots. -- The census to at least THIR's coverage of moq-net and kio. MIR types each - intermediate it holds, so a gap in the library or model shows up once more per - temporary; read the census by construct, not by total. MIR-only refusals to close: - `?` on `Poll>` (284, which THIR refused as 235 too), `ControlFlow` other - than from `?`, switches on and fields of types without a mapping, and a reference - copied out of a field and then passed on. -- `?` on an `Option` returned through a `next` whose item can be `undefined`, and the - other THIR special cases the prototype mirrors (`for` loops by the iterator protocol, - `from_be_bytes` of bytes made in place): keep each only where `just ts bench` - measures it. Ranges stepped in place stay: a `for` over `0..n` read through - `rt.Range.next` or as a number-or-`rt.DONE` was up to 1.3x slower in V8. -- A signed `%` by a constant leaves its overflow check's operands as statements - (`4 === -1;`), which `tsc` rejects. -- Size: the task fixture's bundle is 35% larger gzipped than THIR's, the codec's 9%. - Likely wins, each to measure: a coroutine resume function structured where the - graph allows (a dispatch at each loop header the resume enters, rather than a - `switch` over every block), temporaries folded through reads of borrowed places, and - `_0 = v; return _0` returned in place. -- Source maps: MIR spans point at calls and asserts; check stack traces read well. -- Panics unwind (`-C panic=unwind`), as decided in - [#36](https://github.com/kixelated/rust2/pull/36) at a measured 4-6% on V8's async - handoff; `RUST2_TS_ABORT`, kept only to measure aborting, goes with `--lower`. - -Watch what the prototype's comments say it relies on: MIR's single-assignment -temporaries, `Box` derefs elaborated into `BoxDerefTransmute`, and drop shims that -take a raw pointer. A nightly bump that changes them should fail loudly, as each does -now. - -Public API: the translator's whole output, and the `--lower` option, which goes. diff --git a/ts/README.md b/ts/README.md index 96773f3f5..4516f2aa5 100644 --- a/ts/README.md +++ b/ts/README.md @@ -3,7 +3,7 @@ A rustc driver that translates a subset of Rust to TypeScript with source maps. No WASM: the output is plain ES modules that Node, Bun, and bundlers run as is. ```bash -rust2-ts --config ts.toml (--out dir | --census file.md) [--manifest-path Cargo.toml] [--lower thir|mir] [-- cargo args] +rust2-ts --config ts.toml (--out dir | --census file.md) [--manifest-path Cargo.toml] [-- cargo args] ``` It runs `cargo check` on the package with itself as `RUSTC_WRAPPER`, for @@ -28,10 +28,6 @@ ignore-macros = ["tracing::trace"] moq consumes it as the `ts` package of this repository's flake. In this repository, `just ts run ...` runs it from source on the pinned nightly. -`--lower mir` lowers bodies from MIR instead of THIR: the prototype the MIR spike -built, which the translator is moving to ([quest](/quest/m2/ts-mir.md)). The rest of -this page describes the THIR lowering, the default, except where it says MIR. - ## Census `--census file.md` translates nothing. It treats every item in the library as a root, @@ -75,7 +71,7 @@ runtime: what std does that JS does not, with iterators in `rt/iter.ts`, collect | a type that drops | a class with `[Symbol.dispose]`: its `Drop` impl, then its fields | | a type's function | a function of the type's module, taking `self` first: `Decoder.slice(dec, 4)` after `import * as Decoder` | | `Arc`, `Weak`, `Mutex` | `rt.Arc`, counted; `rt.Weak`; `rt.Mutex`, its own guard | -| `async fn` | a function returning `rt.Future`, around a generator | +| `async fn` | a function returning `rt.Future`: a class of its own, its coroutine's state machine | | `Poll`, `Waker`, `Context` | `T \| typeof rt.Pending`, refused if `T` can already be pending; `rt.Waker`, which is also the context | `Vec` storage and `[x; N]` byte arrays up to 1 KiB share 8 KiB `ArrayBuffer`s, as Node's @@ -96,8 +92,8 @@ object of 32-bit limbs, `{ hi, lo }`, with `w2` and `w1` between them at 128 bit `hi` signed in a signed type. Each value has one form, so `x === 0` is exact; a caller makes one past 2^53 with `rt.u64Of(18446744073709551615n)`. Its other operators and comparisons are runtime calls, `rt.u64Add(a, b)` and `rt.u64Lt(a, b)`, and `x as u32` -is `rt.u64Low(x)`. From MIR, `((hi as u64) << 32) | lo as u64` of halves of at most 32 -bits is one call, `rt.u64FromHalves(hi, lo)`. +is `rt.u64Low(x)`. `((hi as u64) << 32) | lo as u64` of halves of at most 32 bits is +one call, `rt.u64FromHalves(hi, lo)`. `format!`, `write!`, `panic!`, `assert!`, and the other macros of `format_args!` translate, as do `Display` and `Debug` impls, derived and thiserror's included. The @@ -115,9 +111,10 @@ would: `rt.fmtToString((f) => DecodeError.fmt$Display(err, f))` and An iterator's `next()` returns its next item or `rt.DONE`, never `undefined`, so an iterator of `Option` keeps each `None` apart from its end. std's adaptors and consumers are runtime functions taking the iterator first, `rt.iterMap(it, f)`, lazy and -short-circuiting as std's are, and call their closures in the same order and as often. A `for` loop reads an iterator by that protocol, a slice, -array, `Vec`, or `slice.iter()` with `for ... of`, and a range written in place with a -counter. The crate's own `impl Iterator` returns `rt.DONE` from its `next` too, and joins +short-circuiting as std's are, and call their closures in the same order and as often. +An iterator over a slice, array, or `Vec`, or a small range, that only its `next` and +moves read steps in place, as two variables: the array and an index into it, or the +range's bounds, with no `rt.Iter` made. The crate's own `impl Iterator` returns `rt.DONE` from its `next` too, and joins std's adaptors through `rt.iterFrom`. A caller calls `next()` for one item, or iterates an `rt.Iter` with `for ... of`. @@ -146,16 +143,16 @@ calls a key's `Hash`, `Eq`, or `Ord`. Its iterators are `rt.Iter`s, so std's adaptors run over them. A value drops where Rust drops it, if dropping it does something JS can see: a `Drop` -impl, an `Arc`'s count, or a waker. A variable drops at the end of its scope through a -`finally`, so an early return, `?`, a panic, or a cancelled future drops it too, and a -move leaves `undefined` where it was, which drops as nothing. - -An `async fn` returns a future without running anything: `rt.future(body, drop, -...upvars)`, whose body is a module-level generator of what the function captured. Each -`.await` polls in a loop around `yield`. A poll after the future returned panics, and -dropping it cancels it: unpolled, it drops what it captured by value; suspended, its -generator returns through the `finally` blocks that drop its locals and captures. -`rt.spawn(future)` runs one as a promise, polling woken tasks in a batch from a +impl, an `Arc`'s count, or a waker. Bodies lower from MIR, so each drop is where drop +elaboration put it. A panic unwinds: a function with cleanup to run catches `rt.Panic`, +runs the cleanup blocks MIR has under `-C panic=unwind`, and throws it on, so what a +panic drops matches native Rust's. + +An `async fn` returns a future without running anything: an instance of a class of its +own (`sumFuture`), the state machine MIR's coroutine transform makes. Its fields are the +arguments and the locals held across an `.await`, and its `poll` resumes at the state it +stopped in. A poll after the future returned panics, and dropping it cancels it, +dropping what its state holds. `rt.spawn(future)` runs one as a promise, polling woken tasks in a batch from a microtask and yielding to a macrotask after 128 polls. A file's items follow the Rust source, whatever @@ -247,23 +244,23 @@ they need. by their translated hash, chained by `Eq`. `VecDeque` is a ring buffer over an array whose length is a power of two. - Iterators are the runtime's lazy classes rather than generators or ES iterator - helpers: std's adaptors have no THIR to lower, ES helpers lack most of them + helpers: std's adaptors would lower from std's own bodies, whose slice iterators are + raw pointers, ES helpers lack most of them (`rev`, `zip`, `peekable`), and a `next` returning an item or `rt.DONE` allocates nothing per item. `just ts bench` measures chains of `map`, `filter`, `any`, `skip`, and `take` 1.4-8x faster than the same ES helpers in Node, Bun, and Chrome. -- Bodies lower from MIR ([moving](/quest/m2/ts-mir.md)): drops are where drop - elaboration put them, exact by construction, with no `finally` per scope or - `undefined` left by a move, and a panic runs the cleanup blocks `-C panic=unwind` - MIR has, from a `catch`. Async bodies are the coroutine transform's state machines, - a class each. The MIR spike ([#36](https://github.com/kixelated/rust2/pull/36)) ported - the whole lowering and measured it against THIR's: every fixture's differential test - passes either way, but MIR closes about 1,100 of the 1,400 drop refusals in moq-net's - census, runs an async handoff 1.4-5.5x faster at depths 1 to 16 in Node, Bun, and - Chrome, and runs the codec 2-12% slower than THIR, for 9% more gzip on the codec's - bundle and 35% on the async fixture's. Blocks become nested blocks, loops, and `if`s by Ramsey's - "Beyond Relooper", except a coroutine's resume function, which enters loops in the - middle and becomes a loop over a `switch` on the next block. Temporaries assigned - once and read once fold back into the expression that reads them unless that +- Bodies lower from MIR, not THIR: drops are where drop elaboration put them, exact by + construction, with no `finally` per scope or `undefined` left by a move, and a panic + runs the cleanup blocks `-C panic=unwind` MIR has, from a `catch`. Async bodies are + the coroutine transform's state machines, a class each. Against the THIR lowering it + replaced, MIR closes about 1,100 of the 1,400 drop refusals in moq-net's census, and + runs `just ts bench`'s codec 2-6% faster at the geometric mean and the async handoff + 1.4-5.9x faster at depths 1 to 16 in Node, Bun, and Chrome, for 4% more gzip on the + codec's bundle and 16% on the async fixture's + ([size](/quest/m2/ts-mir-size.md)). Blocks become nested blocks, loops, and `if`s by + Ramsey's "Beyond Relooper", except a coroutine's resume function, which enters loops + in the middle and becomes a loop over a `switch` on the next block. Temporaries + assigned once and read once fold back into the expression that reads them unless that would reorder an effect. ## Never @@ -275,21 +272,20 @@ bind to hand-written TS through config ([model](/quest/m2/ts-model.md)). ## Not yet These fail translation: floats, `char`, statics, async blocks that borrow a number -mutably and async closures, values that drop as temporaries not moved whole, in a -closure's captures, in an iterator, in an enum, tuple, or generic `Drop` type, passed to -a std function that may discard them (`unwrap_or`), borrowed in an `Arc` or `Mutex`, or -moved ahead of an `.await` in the same call or assignment, or in a collection -([Drop](/quest/m2/ts-drop.md)), a collection holding a type that can be `undefined`, as -`()` and `Option` can, a collection's `capacity`, looking up a key by another type it -borrows as (`Arc` by `str`), `Hasher::write` of bytes, the adaptors without a mapping in -`src/lower/iter.rs` (such as `cycle`, `unzip`, and `partition`), an own -`impl Iterator` with `next_back`, `len`, or another provided method of its own, `while -let` or `match` on the `next` of an iterator of `Option`, or-patterns that bind, other +mutably and async closures, values that drop in a closure dropped without a call that +takes it, in an iterator, in an enum or generic `Drop` type, passed to a std function +that may discard them (`unwrap_or`), borrowed in an `Arc` or `Mutex`, or in a +collection ([Drop](/quest/m2/ts-drop.md)), a collection holding a type that can be +`undefined`, as `()` and `Option` can, a collection's `capacity`, looking up a key by +another type it borrows as (`Arc` by `str`), `Hasher::write` of bytes, the adaptors +without a mapping in `src/lower/iter.rs` (such as `cycle`, `unzip`, and `partition`), an +own `impl Iterator` with `next_back`, `len`, or another provided method of its own, other format specs (a precision, `+`, `{:b}`, `{:x?}`, and widths from arguments), writing to a -`String` with `write!`, a `move` closure copying a mutable variable, `mem::swap`, +`String` with `write!`, a copy of a closure that changes what it captured, `mem::swap`, `replace`, or `take` of a reference's whole pointee, assigning an `Arc`, a waker, a -`MutexGuard`, a pinned reference, or a future through a reference, and std functions -without a mapping in `src/lower/library.rs`. +`MutexGuard`, a pinned reference, or a future through a reference, a `ControlFlow` other +than the one `?` makes, a switch on or a field of another crate's type without a mapping, +and std functions without a mapping in `src/lower/library.rs`. ## Tests @@ -327,10 +323,7 @@ built natively for wasm32 and run beside its translation on the same inputs by unwinds, catching and logging each step's panic and going on, so what a panic drops must match too. - `reject` holds constructs outside the subset; its expected errors are `expected.txt`, - those from MIR `expected-mir.txt`, and its expected census is `census.md`. - -The codec, lang, and task fixtures also run their differential tests from MIR -(`codec_mir`, `lang_mir`, and `task_mir`), without snapshots. + and its expected census is `census.md`. `tests/spawn.ts` checks that `rt.spawn` yields to a timer after its 128-poll budget, and rejects when a future panics as it drops. `tests/retain.ts` panics in a collection's diff --git a/ts/fixtures/codec/expected/bench.ts b/ts/fixtures/codec/expected/bench.ts index 4efcc5ba0..92515e2ed 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -13,88 +13,116 @@ import type * as Version from "./lite/version.Version.ts"; /** Run one workload. */ export function run(input: Uint8Array): rt.ByteVec { - let out: rt.ByteVec = new rt.ByteVec(); - const splitFirst = rt.sliceSplitFirst(input); - if (splitFirst === undefined) { - return out; - } - const op = splitFirst[0]; - const data = splitFirst[1]; - const splitFirst2 = rt.sliceSplitFirst(data); - if (splitFirst2 === undefined) { - return out; - } - const selector = splitFirst2[0]; - const data2 = splitFirst2[1]; - if (op === 0) { - encoded(encodeVarints(data2, form(selector), out), out); - } else if (op === 1) { - decoded(decodeVarints(data2, form(selector), out), out); - } else if (op === 2) { - encoded(encodeFrames(data2, liteVersion(selector), out), out); - } else if (op === 3) { - decoded(decodeFrames(data2, liteVersion(selector), out), out); - } else if (op === 4) { - encoded(encodeGroup(data2, liteVersion(selector), out), out); - } else if (op === 6) { - iterate(selector, data2, out); - } else if (op === 7) { - decoded(decodeSplit(data2, liteVersion(selector), out), out); - } else if (op === 8) { - ordered(data2, out); - } else if (op === 9) { - rescale(selector, data2, out); + let out!: rt.ByteVec; + let op!: rt.u8; + let _5!: [rt.u8, Uint8Array] | undefined; + let selector!: rt.u8; + let _9!: [rt.u8, Uint8Array] | undefined; + out = new rt.ByteVec(); + _5 = rt.sliceSplitFirst(input); + if (_5 !== undefined) { + op = _5[0]; + _9 = rt.sliceSplitFirst(_5[1]); + if (_9 !== undefined) { + selector = _9[0]; + if (op === 0) { + encoded(encodeVarints(_9[1], form(selector), out), out); + } else if (op === 1) { + decoded(decodeVarints(_9[1], form(selector), out), out); + } else if (op === 2) { + encoded(encodeFrames(_9[1], liteVersion(selector), out), out); + } else if (op === 3) { + decoded(decodeFrames(_9[1], liteVersion(selector), out), out); + } else if (op === 4) { + encoded(encodeGroup(_9[1], liteVersion(selector), out), out); + } else if (op === 6) { + iterate(selector, _9[1], out); + } else if (op === 7) { + decoded(decodeSplit(_9[1], liteVersion(selector), out), out); + } else if (op === 8) { + ordered(_9[1], out); + } else if (op === 9) { + rescale(selector, _9[1], out); + } else { + decoded(decodeGroup(_9[1], liteVersion(selector), out), out); + } + return out; + } else { + return out; + } } else { - decoded(decodeGroup(data2, liteVersion(selector), out), out); + return out; } - return out; } export function encoded(result: rt.Result, out: rt.ByteVec): void { if (!result.ok) { - const err = result.error; - encodeError(out, err); + encodeError(out, result.error); } } export function decoded(result: rt.Result, out: rt.ByteVec): void { + let err!: DecodeError.DecodeError; if (!result.ok) { - const err = result.error; + err = result.error; decodeError(out, err); } } /** The same value, `count` times. */ export function encodeVarints(data: Uint8Array, form_: Form.Form, out: rt.ByteVec): rt.Result { - const [count, data2] = takeU64(data); - const [value, ] = takeU64(data2); - let w: Encoder.Encoder = Encoder.new(out, form_); - const end = rt.u64Low(count); - for (let _ = 0; _ < end; _++) { - const varint = Encoder.varint(w, value); - if (!varint.ok) { - return rt.Err(varint.error); + let count!: rt.u64; + let _6!: [rt.u64, Uint8Array]; + let value!: rt.u64; + let w!: Encoder.Encoder; + let iterStart!: rt.usize; + let iterEnd!: rt.usize; + let _17!: rt.Result; + _6 = takeU64(data); + count = _6[0]; + value = takeU64(_6[1])[0]; + w = Encoder.new(out, form_); + iterStart = 0; + iterEnd = rt.u64Low(count); + l0: while (true) { + if (!(iterStart++ < iterEnd)) { + return rt.Ok(undefined); + } else { + _17 = Encoder.varint(w, value); + if (_17.ok) { + continue l0; + } else { + return _17; + } } } - return rt.Ok(undefined); } /** Every varint on the wire: how many, and the last. */ export function decodeVarints(wire: Uint8Array, form_: Form.Form, out: rt.ByteVec): rt.Result { - let r: Decoder.Decoder = Decoder.new(wire, form_); - let count: rt.usize = 0; - let last: rt.u64 = 0; - while (!Decoder.isEmpty(r)) { - const varint = Decoder.varint(r); - if (!varint.ok) { - return rt.Err(varint.error); + let r!: Decoder.Decoder; + let count!: rt.usize; + let last!: rt.u64; + let _9!: rt.Result; + r = Decoder.new(wire, form_); + count = 0; + last = 0; + l0: while (true) { + if (!Decoder.isEmpty(r)) { + _9 = Decoder.varint(r); + if (_9.ok) { + last = _9.value; + count = rt.usizeAdd(count, 1); + continue l0; + } else { + return _9; + } + } else { + putUsize(out, count); + putU64(out, last); + return rt.Ok(undefined); } - last = varint.value; - count = rt.usizeAdd(count, 1); } - putUsize(out, count); - putU64(out, last); - return rt.Ok(undefined); } /** @@ -103,65 +131,121 @@ export function decodeVarints(wire: Uint8Array, form_: Form.Form, out: rt.ByteVe * and every `key_every`th frame after it is `key_size`, as moq's benchmark samples are. */ export function encodeFrames(data: Uint8Array, version: Version.Version, out: rt.ByteVec): rt.Result { - const [count, data2] = takeU64(data); - const [delta, data3] = takeU64(data2); - const [first, data4] = takeU64(data3); - const [size, data5] = takeU64(data4); - const [keyEvery, data6] = takeU64(data5); - const [keySize, ] = takeU64(data6); - const [delta2, keyEvery2] = [rt.i64Cast(delta), rt.u64Low(keyEvery)] as [rt.i64, rt.usize]; - let w: Encoder.Encoder = Encoder.new(out, Form.from$From_Version(version)); - const end = rt.u64Low(count); - for (let n = 0; n < end; n++) { - let value: [rt.i64, rt.u64]; - arms: { - if (n === 0) { - value = [0, first]; - break arms; + let count!: rt.u64; + let _6!: [rt.u64, Uint8Array]; + let delta!: rt.u64; + let _9!: [rt.u64, Uint8Array]; + let first!: rt.u64; + let _12!: [rt.u64, Uint8Array]; + let size!: rt.u64; + let _15!: [rt.u64, Uint8Array]; + let keyEvery!: rt.u64; + let _18!: [rt.u64, Uint8Array]; + let keySize!: rt.u64; + let delta2!: rt.i64; + let keyEvery2!: rt.usize; + let _23!: [rt.i64, rt.usize]; + let _24!: rt.i64; + let w!: Encoder.Encoder; + let iterStart!: rt.usize; + let iterEnd!: rt.usize; + let _32!: rt.usize; + let n!: rt.usize; + let delta3!: rt.i64; + let size2!: rt.u64; + let _38!: [rt.i64, rt.u64]; + let _45!: rt.Result; + let _48!: rt.u64; + let _51!: rt.Result; + _6 = takeU64(data); + count = _6[0]; + _9 = takeU64(_6[1]); + delta = _9[0]; + _12 = takeU64(_9[1]); + first = _12[0]; + _15 = takeU64(_12[1]); + size = _15[0]; + _18 = takeU64(_15[1]); + keyEvery = _18[0]; + keySize = takeU64(_18[1])[0]; + _24 = rt.i64Cast(delta); + _23 = [_24, rt.u64Low(keyEvery)] as [rt.i64, rt.usize]; + delta2 = _24; + keyEvery2 = _23[1]; + w = Encoder.new(out, Form.from$From_Version(version)); + iterStart = 0; + iterEnd = rt.u64Low(count); + l0: while (true) { + if (!((_32 = iterStart++) < iterEnd)) { + return rt.Ok(undefined); + } else { + b2: { + n = _32; + if (n === 0) { + _38 = [0, first] as [rt.i64, rt.u64]; + } else { + if (keyEvery2 !== 0) { + if (rt.usizeRem(n, keyEvery2) === 0) { + _38 = [delta2, keySize] as [rt.i64, rt.u64]; + break b2; + } + } + _38 = [delta2, size] as [rt.i64, rt.u64]; + } } - const n2 = n; - if (keyEvery2 !== 0 && rt.usizeRem(n2, keyEvery2) === 0) { - value = [delta2, keySize]; - break arms; + delta3 = _38[0]; + size2 = _38[1]; + _48 = zigzag(delta3); + _45 = Encoder.varint(w, _48); + if (_45.ok) { + _51 = Encoder.varint(w, size2); + if (_51.ok) { + continue l0; + } else { + return _51; + } + } else { + return _45; } - value = [delta2, size]; - } - const [delta3, size2] = value; - const varint = Encoder.varint(w, zigzag(delta3)); - if (!varint.ok) { - return rt.Err(varint.error); - } - const varint2 = Encoder.varint(w, size2); - if (!varint2.ok) { - return rt.Err(varint2.error); } } - return rt.Ok(undefined); } /** Every FRAME header on the wire: how many, their total size, and the last delta. */ export function decodeFrames(wire: Uint8Array, version: Version.Version, out: rt.ByteVec): rt.Result { - let r: Decoder.Decoder = Decoder.new(wire, Form.from$From_Version(version)); - let count: rt.usize = 0; - let total: rt.u64 = 0; - let last: rt.i64 = 0; - while (!Decoder.isEmpty(r)) { - const varint = Decoder.varint(r); - if (!varint.ok) { - return rt.Err(varint.error); - } - last = unzigzag(varint.value); - const varint2 = Decoder.varint(r); - if (!varint2.ok) { - return rt.Err(varint2.error); + let r!: Decoder.Decoder; + let count!: rt.usize; + let total!: rt.u64; + let last!: rt.i64; + let _12!: rt.Result; + let _18!: rt.Result; + r = Decoder.new(wire, Form.from$From_Version(version)); + count = 0; + total = 0; + last = 0; + l0: while (true) { + if (!Decoder.isEmpty(r)) { + _12 = Decoder.varint(r); + if (_12.ok) { + last = unzigzag(_12.value); + _18 = Decoder.varint(r); + if (_18.ok) { + total = rt.u64Add(total, _18.value); + count = rt.usizeAdd(count, 1); + continue l0; + } else { + return _18; + } + } else { + return _12; + } + } else { + putUsize(out, count); + putU64(out, total); + putU64(out, rt.u64Cast(last)); + return rt.Ok(undefined); } - total = rt.u64Add(total, varint2.value); - count = rt.usizeAdd(count, 1); } - putUsize(out, count); - putU64(out, total); - putU64(out, rt.u64Cast(last)); - return rt.Ok(undefined); } /** @@ -172,66 +256,95 @@ export function decodeFrames(wire: Uint8Array, version: Version.Version, out: rt * and how many decodes came up short. */ export function decodeSplit(data: Uint8Array, version: Version.Version, out: rt.ByteVec): rt.Result { - const [read, wire] = takeU64(data); - const read2 = rt.max(rt.u64Low(read), 1); - let start: rt.usize = 0; - let end: rt.usize = 0; - let count: rt.usize = 0; - let total: rt.u64 = 0; - let last: rt.i64 = 0; - let short: rt.usize = 0; - while (end < wire.length) { - end = rt.min(wire.length, rt.usizeAdd(end, read2)); - while (start < end) { - let r: Decoder.Decoder = Decoder.new(rt.sliceRange(wire, start, end), Form.from$From_Version(version)); - const frameHeader_ = frameHeader(r); - if (frameHeader_.ok) { - const delta = frameHeader_.value[0]; - const size = frameHeader_.value[1]; - start = rt.usizeSub(end, Decoder.remaining(r)); - last = delta; - total = rt.u64Add(total, size); - count = rt.usizeAdd(count, 1); - } else if (!frameHeader_.ok && frameHeader_.error.tag === "Short") { - short = rt.usizeAdd(short, 1); - break; + let _0!: rt.Result; + let _6!: [rt.u64, Uint8Array]; + let read2!: rt.usize; + let start!: rt.usize; + let end!: rt.usize; + let count!: rt.usize; + let total!: rt.u64; + let last!: rt.i64; + let short!: rt.usize; + let r!: Decoder.Decoder; + let _32!: rt.Result<[rt.i64, rt.u64], DecodeError.DecodeError>; + let delta!: rt.i64; + let size!: rt.u64; + _6 = takeU64(data); + read2 = rt.max(rt.u64Low(_6[0]), 1); + start = 0; + end = 0; + count = 0; + total = 0; + last = 0; + short = 0; + l0: while (true) { + if (!(end < _6[1].length)) { + if (!(start < end)) { + putUsize(out, count); + putU64(out, total); + putU64(out, rt.u64Cast(last)); + putUsize(out, short); + return rt.Ok(undefined); } else { - const err = frameHeader_.error; - return rt.Err(err); + return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + } + } else { + end = rt.min(_6[1].length, rt.usizeAdd(end, read2)); + while (true) { + if (!(start < end)) { + continue l0; + } else { + const slice = _6[1]; + r = Decoder.new(rt.sliceRange(slice, start, end), Form.from$From_Version(version)); + _32 = frameHeader(r); + if (_32.ok) { + delta = _32.value[0]; + size = _32.value[1]; + start = rt.usizeSub(end, Decoder.remaining(r)); + last = delta; + total = rt.u64Add(total, size); + count = rt.usizeAdd(count, 1); + } else if (_32.error.tag === "Short") { + short = rt.usizeAdd(short, 1); + continue l0; + } else { + _0 = rt.Err(_32.error); + return _0; + } + } } } } - if (start < end) { - return rt.Err({ tag: "Short" }); - } - putUsize(out, count); - putU64(out, total); - putU64(out, rt.u64Cast(last)); - putUsize(out, short); - return rt.Ok(undefined); } /** One FRAME header: the zigzag timestamp delta, then the size. */ export function frameHeader(r: Decoder.Decoder): rt.Result<[rt.i64, rt.u64], DecodeError.DecodeError> { - const varint = Decoder.varint(r); - if (!varint.ok) { - return rt.Err(varint.error); - } - const delta = unzigzag(varint.value); - const arg = delta; - const varint2 = Decoder.varint(r); - if (!varint2.ok) { - return rt.Err(varint2.error); + let delta!: rt.i64; + let _3!: rt.Result; + let _9!: rt.Result; + _3 = Decoder.varint(r); + if (_3.ok) { + delta = unzigzag(_3.value); + _9 = Decoder.varint(r); + if (_9.ok) { + return rt.Ok([delta, _9.value] as [rt.i64, rt.u64]); + } else { + return _9; + } + } else { + return _3; } - return rt.Ok([arg, varint2.value]); } /** One size-prefixed GROUP header, starting at the first frame. */ export function encodeGroup(data: Uint8Array, version: Version.Version, out: rt.ByteVec): rt.Result { - const [subscribe, data2] = takeU64(data); - const [sequence, ] = takeU64(data2); - const group = { subscribe, sequence, frameStart: 0 }; - return Group.encode$Encode_Version(group, Encoder.new(out, Form.from$From_Version(version)), version); + let _6!: [rt.u64, Uint8Array]; + let group!: Group.Group; + let _12!: Encoder.Encoder; + _6 = takeU64(data); + group = { subscribe: _6[0], sequence: takeU64(_6[1])[0], frameStart: 0 }; + _12 = Encoder.new(out, Form.from$From_Version(version)); + return Group.encode$Encode_Version(group, _12, version); } /** @@ -240,37 +353,76 @@ export function encodeGroup(data: Uint8Array, version: Version.Version, out: rt. * found. */ export function ordered(data: Uint8Array, out: rt.ByteVec): void { - const [count, ] = takeU64(data); - const count2 = rt.u64Low(rt.u64Min(count, 65536)); - const key = (i: rt.u32): rt.u32 => { - return rt.u32Rem(rt.u32Mul(i, 40503), 1 << 16); + let count2!: rt.u32; + let _10!: (a0: rt.u32) => rt.u32; + let map!: rt.BTreeMap; + let iterStart!: rt.u32; + let iterEnd!: rt.u32; + let _15!: rt.u32; + let i!: rt.u32; + let _21!: rt.u32; + let sum!: rt.u64; + let iterStart2!: rt.u32; + let iterEnd2!: rt.u32; + let _28!: rt.u32; + let i2!: rt.u32; + let _38!: rt.u32; + let _42!: rt.u32; + let _49!: rt.Range; + let iter3!: rt.Iter<[rt.u32, rt.u32]>; + let _57!: [rt.u32, rt.u32] | rt.Done; + let iterStart3!: rt.u32; + let iterEnd3!: rt.u32; + let _66!: rt.u32; + let _73!: rt.u32; + _10 = (i4: rt.u32): rt.u32 => { + return rt.u32Rem(rt.u32Mul(i4, 40503), 1 << 16); }; - let map: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - const end = count2; - for (let i2 = 0; i2 < end; i2++) { - rt.btreeInsert(map, key(i2), i2); - } - let sum: rt.u64 = 0; - const end2 = count2; - for (let i3 = 0; i3 < end2; i3++) { - const value = rt.optionUnwrapOr(rt.btreeGet(map, key(rt.u32Sub(rt.u32Sub(count2, 1), i3))), 0) as rt.u64; - sum = rt.u64Add(sum, value); - } - const iter = rt.btreeRange(map, new rt.Range(1 << 14, 2 << 14)); + count2 = rt.u64Low(rt.u64Min(takeU64(data)[0], 65536)); + map = rt.btreeNew(rt.cmp) as rt.BTreeMap; + iterStart = 0; + iterEnd = count2; while (true) { - const item = iter.next(); - if (item === rt.DONE) { - break; + if (!((_15 = iterStart++) < iterEnd)) { + sum = 0; + iterStart2 = 0; + iterEnd2 = count2; + while (true) { + if (!((_28 = iterStart2++) < iterEnd2)) { + _49 = new rt.Range(1 << 14, 2 << 14); + iter3 = rt.btreeRange(map, _49); + while (true) { + _57 = iter3.next(); + if (_57 === rt.DONE) { + iterStart3 = 0; + iterEnd3 = count2; + while (true) { + if (!((_66 = iterStart3++) < iterEnd3)) { + putU64(out, sum); + return; + } else { + _73 = _10(_66); + rt.btreeRemove(map, _73); + } + } + } else { + sum = rt.u64Add(sum, _57[1] as rt.u64); + } + } + } else { + i2 = _28; + _42 = rt.u32Sub(count2, 1); + const part = rt.u32Sub(_42, i2); + _38 = _10(part); + sum = rt.u64Add(sum, rt.optionUnwrapOr(rt.btreeGet(map, _38), 0) as rt.u64); + } + } + } else { + i = _15; + _21 = _10(i); + rt.btreeInsert(map, _21, i); } - const v = item[1]; - const value2 = v as rt.u64; - sum = rt.u64Add(sum, value2); } - const end3 = count2; - for (let i4 = 0; i4 < end3; i4++) { - rt.btreeRemove(map, key(i4)); - } - putU64(out, sum); } /** @@ -278,50 +430,53 @@ export function ordered(data: Uint8Array, out: rt.ByteVec): void { * next to the iterator protocol they run through. */ export function iterate(chain: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - if (chain === 0) { - putUsize(out, rt.iterCount(rt.iterFilter(rt.iterMap(rt.iterSlice(data), (arg: rt.u8): rt.u8 => { - const b = arg; - return b >> 1; - }), (arg2: rt.u8): boolean => { - const b2 = arg2; - return (b2 & 1) === 0; - }))); - } else if (chain === 1) { - rt.byteVecPush(out, rt.iterAny(rt.iterSlice(data), (arg3: rt.u8): boolean => { - const b3 = arg3; - return b3 === 0xff; - }) ? 1 : 0); - } else if (chain === 2) { - const odd = rt.iterToByteVec(rt.iterFilter(rt.iterSlice(data), (arg4: rt.u8): boolean => { - const b4 = arg4; - return (b4 & 1) === 1; - })); - putUsize(out, odd.length); - } else if (chain === 3) { - putU64(out, rt.iterSum(rt.iterMap(rt.iterSlice(data), (arg5: rt.u8): rt.u32 => { - const b5 = arg5; - return b5 as rt.u32; - }), rt.u32Add, 0) as rt.u64); - } else if (chain === 4) { - putU64(out, rt.iterFold(rt.iterTake(rt.iterSkip(rt.iterSlice(data), 16), 512), 0, (acc: rt.u32, arg6: rt.u8): rt.u32 => { - const b6 = arg6; - return (acc ^ b6 as rt.u32) >>> 0; - }) as rt.u64); - } else { - let last: rt.usize = 0; - const iter = rt.iterEnumerate(rt.iterSlice(data)); - while (true) { - const item = iter.next(); - if (item === rt.DONE) { - break; - } - const i = item[0]; - const b7 = item[1]; - if (b7 === 0x80) { - last = i; + let _11!: rt.Iter; + let odd!: rt.ByteVec; + let last!: rt.usize; + let iter!: rt.Iter<[rt.usize, rt.u8]>; + let _33!: [rt.usize, rt.u8] | rt.Done; + let i!: rt.usize; + b0: { + if (chain === 0) { + putUsize(out, rt.iterCount(rt.iterFilter(rt.iterMap(rt.iterSlice(data), (_211: rt.u8): rt.u8 => { + return _211 >> 1; + }), (_212: rt.u8): boolean => { + return (_212 & 1) === 0; + }))); + } else if (chain === 1) { + _11 = rt.iterSlice(data); + rt.byteVecPush(out, rt.iterAny(_11, (_210: rt.u8): boolean => { + return _210 === 255; + }) ? 1 : 0); + } else if (chain === 2) { + odd = rt.iterToByteVec(rt.iterFilter(rt.iterSlice(data), (_28: rt.u8): boolean => { + return (_28 & 1) === 1; + })); + putUsize(out, odd.length); + } else if (chain === 3) { + putU64(out, rt.iterSum(rt.iterMap(rt.iterSlice(data), (_2: rt.u8): rt.u32 => { + return _2 as rt.u32; + }), rt.u32Add, 0) as rt.u64); + } else if (chain === 4) { + putU64(out, rt.iterFold(rt.iterTake(rt.iterSkip(rt.iterSlice(data), 16), 512), 0, (acc: rt.u32, _3: rt.u8): rt.u32 => { + return (acc ^ _3 as rt.u32) >>> 0; + }) as rt.u64); + } else { + last = 0; + iter = rt.iterEnumerate(rt.iterSlice(data)); + while (true) { + _33 = iter.next(); + if (_33 === rt.DONE) { + putUsize(out, last); + break b0; + } else { + i = _33[0]; + if (_33[1] === 128) { + last = i; + } + } } } - putUsize(out, last); } } @@ -331,72 +486,105 @@ export function iterate(chain: rt.u8, data: Uint8Array, out: rt.ByteVec): void { * sooner. How many converted, how many overflowed, and the last converted. */ export function rescale(selector: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const [count, data2] = takeU64(data); - const [start, data3] = takeU64(data2); - const [step, data4] = takeU64(data3); - const [from, data5] = takeU64(data4); - const [to, ] = takeU64(data5); - let [converted, overflowed, last] = [0, 0, 0] as [rt.u64, rt.u64, rt.u64]; - const end = rt.u64Low(count); - for (let i = 0; i < end; i++) { - const value = rt.u64Add(start, rt.u64Mul(i as rt.u64, step)); - let scaled: rt.u64 | undefined; - if (selector === 0) { - const checkedMul = rt.u128CheckedMul(rt.u128Cast(value), rt.u128Cast(to)); - if (checkedMul !== undefined) { - const scaled2 = checkedMul; - scaled = bounded(rt.u128Div(scaled2, rt.u128Cast(from))); - } else { - scaled = undefined; - } + let count!: rt.u64; + let _6!: [rt.u64, Uint8Array]; + let start!: rt.u64; + let _9!: [rt.u64, Uint8Array]; + let step!: rt.u64; + let _12!: [rt.u64, Uint8Array]; + let from!: rt.u64; + let _15!: [rt.u64, Uint8Array]; + let to!: rt.u64; + let converted!: rt.u64; + let overflowed!: rt.u64; + let last!: rt.u64; + let iterStart!: rt.usize; + let iterEnd!: rt.usize; + let _26!: rt.usize; + let value!: rt.u64; + let scaled!: rt.u64 | undefined; + let _36!: rt.u128 | undefined; + let _44!: rt.u64 | undefined; + _6 = takeU64(data); + count = _6[0]; + _9 = takeU64(_6[1]); + start = _9[0]; + _12 = takeU64(_9[1]); + step = _12[0]; + _15 = takeU64(_12[1]); + from = _15[0]; + to = takeU64(_15[1])[0]; + converted = 0; + overflowed = 0; + last = 0; + iterStart = 0; + iterEnd = rt.u64Low(count); + while (true) { + if (!((_26 = iterStart++) < iterEnd)) { + putU64(out, converted); + putU64(out, overflowed); + putU64(out, last); + return; } else { - const map = rt.optionMap(rt.u64CheckedMul(value, to), (scaled3: rt.u64): rt.u64 => { - return rt.u64Div(scaled3, from); - }); - arms: { - if (map !== undefined) { - const v = map; - if (rt.u64Le(v, rt.u64Of(2305843009213693951n))) { - scaled = v; - break arms; + b1: { + value = rt.u64Add(start, rt.u64Mul(_26 as rt.u64, step)); + if (selector === 0) { + _36 = rt.u128CheckedMul(rt.u128Cast(value), rt.u128Cast(to)); + if (_36 === undefined) { + scaled = undefined; + } else { + scaled = bounded(rt.u128Div(_36, rt.u128Cast(from))); + } + } else { + _44 = rt.optionMap(rt.u64CheckedMul(value, to), (scaled3: rt.u64): rt.u64 => { + return rt.u64Div(scaled3, from); + }); + if (_44 !== undefined) { + if (rt.u64Le(_44, rt.u64Of(2305843009213693951n))) { + scaled = _44; + break b1; + } } + scaled = undefined; } - scaled = undefined; } - } - if (scaled !== undefined) { - const v2 = scaled; - last = v2; - converted = rt.u64Add(converted, 1); - } else { - overflowed = rt.u64Add(overflowed, 1); + if (scaled === undefined) { + overflowed = rt.u64Add(overflowed, 1); + } else { + last = scaled; + converted = rt.u64Add(converted, 1); + } } } - putU64(out, converted); - putU64(out, overflowed); - putU64(out, last); } /** `value`, or `None` past [`MAX_TIMESTAMP`], as moq-net bounds a converted timestamp. */ export function bounded(value: rt.u128): rt.u64 | undefined { - if (rt.u128Le(value, rt.u128Cast(rt.u64Of(2305843009213693951n)))) { - return rt.u64Cast(value); - } else { + if (!rt.u128Le(value, rt.u128Cast(rt.u64Of(2305843009213693951n)))) { return undefined; + } else { + return rt.u64Cast(value); } } export function decodeGroup(wire: Uint8Array, version: Version.Version, out: rt.ByteVec): rt.Result { - const decodeSlice = Group.decodeSlice$Decode_Version(wire, version); - if (!decodeSlice.ok) { - return rt.Err(decodeSlice.error); + let group!: Group.Group; + let used!: rt.usize; + let _6!: rt.Result<[Group.Group, rt.usize], DecodeError.DecodeError>; + let val!: [Group.Group, rt.usize]; + _6 = Group.decodeSlice$Decode_Version(wire, version); + if (_6.ok) { + val = _6.value; + group = val[0]; + used = val[1]; + putU64(out, group.subscribe); + putU64(out, group.sequence); + putU64(out, group.frameStart); + putUsize(out, used); + return rt.Ok(undefined); + } else { + return _6; } - const [group, used] = decodeSlice.value; - putU64(out, group.subscribe); - putU64(out, group.sequence); - putU64(out, group.frameStart); - putUsize(out, used); - return rt.Ok(undefined); } //# sourceMappingURL=bench.ts.map diff --git a/ts/fixtures/codec/expected/coding/decode.DecodeError.ts b/ts/fixtures/codec/expected/coding/decode.DecodeError.ts index 118e4d74a..80fad020f 100644 --- a/ts/fixtures/codec/expected/coding/decode.DecodeError.ts +++ b/ts/fixtures/codec/expected/coding/decode.DecodeError.ts @@ -5,6 +5,8 @@ import type * as BoundsExceeded from "../coding/varint.BoundsExceeded.ts"; import * as SessionError from "../lib.SessionError.ts"; export function fmt$Display(self: DecodeError, __formatter: rt.Formatter): rt.Result { + let args2!: rt.Fmt[]; + let args4!: rt.Fmt[]; if (self.tag === "Short") { return rt.fmtWriteStr(__formatter, "short buffer"); } else if (self.tag === "Long") { @@ -12,10 +14,9 @@ export function fmt$Display(self: DecodeError, __formatter: rt.Formatter): rt.Re } else if (self.tag === "InvalidString") { return rt.fmtWriteStr(__formatter, "invalid string"); } else if (self.tag === "InvalidMessage") { - const _0 = self._0; - const value = [_0] as [rt.u64]; - const __field0 = value[0]; - return rt.fmtWriteFmt(__formatter, ["invalid message: ", (f: rt.Formatter) => rt.u64Display(__field0, f)]); + const arg = ([([self._0] as [rt.u64])[0]] as [rt.u64])[0]; + args2 = [(f: rt.Formatter) => rt.u64Display(arg, f)]; + return rt.fmtWriteFmt(__formatter, ["invalid message: ", args2[0]]); } else if (self.tag === "InvalidSubscribeLocation") { return rt.fmtWriteStr(__formatter, "invalid subscribe location"); } else if (self.tag === "InvalidValue") { @@ -27,12 +28,8 @@ export function fmt$Display(self: DecodeError, __formatter: rt.Formatter): rt.Re } else if (self.tag === "ExpectedEnd") { return rt.fmtWriteStr(__formatter, "expected end"); } else if (self.tag === "MessageTooLarge") { - const size = self.size; - const max = self.max; - const value2 = [size, max] as [rt.usize, rt.usize]; - const __displaySize = value2[0]; - const __displayMax = value2[1]; - return rt.fmtWriteFmt(__formatter, ["message too large: ", (f: rt.Formatter) => rt.usizeDisplay(__displaySize, f), " bytes exceeds ", (f: rt.Formatter) => rt.usizeDisplay(__displayMax, f), " byte limit"]); + args4 = [(f: rt.Formatter) => rt.usizeDisplay(self.size, f), (f: rt.Formatter) => rt.usizeDisplay(self.max, f)]; + return rt.fmtWriteFmt(__formatter, ["message too large: ", args4[0], " bytes exceeds ", args4[1], " byte limit"]); } else if (self.tag === "ExpectedData") { return rt.fmtWriteStr(__formatter, "expected data"); } else if (self.tag === "Duplicate") { @@ -46,8 +43,7 @@ export function fmt$Display(self: DecodeError, __formatter: rt.Formatter): rt.Re } else if (self.tag === "Version") { return rt.fmtWriteStr(__formatter, "unsupported version"); } else if (self.tag === "Session") { - const _02 = self._0; - return SessionError.fmt$Display(_02, __formatter); + return SessionError.fmt$Display(self._0, __formatter); } else if (self.tag === "MalformedAuthToken") { return rt.fmtWriteStr(__formatter, "malformed authorization token"); } else { @@ -56,20 +52,33 @@ export function fmt$Display(self: DecodeError, __formatter: rt.Formatter): rt.Re } export function from$From_FromUtf8Error(source: rt.FromUtf8Error): DecodeError { - return { tag: "InvalidString", _0: source }; + return { tag: "InvalidString", _0: source } as DecodeError; } export function fmt$Debug(self: DecodeError, f: rt.Formatter): rt.Result { + let _7!: string; + let _8!: rt.Fmt; + let _11!: string; + let _12!: rt.Fmt; + let _21!: string; + let _22!: string; + let _23!: rt.Fmt; + let _24!: string; + let _25!: rt.Fmt; + let _34!: string; + let _35!: rt.Fmt; if (self.tag === "Short") { return rt.fmtWriteStr(f, "Short"); } else if (self.tag === "Long") { return rt.fmtWriteStr(f, "Long"); } else if (self.tag === "InvalidString") { - const __self0 = self._0; - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, "InvalidString"), (f: rt.Formatter) => rt.fmtFromUtf8ErrorDebug(__self0, f))); + _7 = "InvalidString"; + _8 = (f: rt.Formatter) => rt.fmtFromUtf8ErrorDebug(self._0, f); + return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _7), _8)); } else if (self.tag === "InvalidMessage") { - const __self02 = self._0; - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, "InvalidMessage"), (f: rt.Formatter) => rt.u64Display(__self02, f))); + _11 = "InvalidMessage"; + _12 = (f: rt.Formatter) => rt.u64Display(self._0, f); + return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _11), _12)); } else if (self.tag === "InvalidSubscribeLocation") { return rt.fmtWriteStr(f, "InvalidSubscribeLocation"); } else if (self.tag === "InvalidValue") { @@ -81,9 +90,12 @@ export function fmt$Debug(self: DecodeError, f: rt.Formatter): rt.Result rt.usizeDisplay(__self03, f)), "max", (f: rt.Formatter) => rt.usizeDisplay(__self1, f))); + _21 = "MessageTooLarge"; + _22 = "size"; + _23 = (f: rt.Formatter) => rt.usizeDisplay(self.size, f); + _24 = "max"; + _25 = (f: rt.Formatter) => rt.usizeDisplay(self.max, f); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _21), _22, _23), _24, _25)); } else if (self.tag === "ExpectedData") { return rt.fmtWriteStr(f, "ExpectedData"); } else if (self.tag === "Duplicate") { @@ -97,8 +109,9 @@ export function fmt$Debug(self: DecodeError, f: rt.Formatter): rt.Result SessionError.fmt$Debug(__self04, f))); + _34 = "Session"; + _35 = (f: rt.Formatter) => SessionError.fmt$Debug(self._0, f); + return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _34), _35)); } else if (self.tag === "MalformedAuthToken") { return rt.fmtWriteStr(f, "MalformedAuthToken"); } else { @@ -131,15 +144,14 @@ export type DecodeError = /** A complete frame cannot be extended by reading more stream bytes. */ export function complete(self: DecodeError): DecodeError { if (self.tag === "Short") { - return { tag: "InvalidValue" }; + return { tag: "InvalidValue" } as DecodeError; } else { - const other = self; - return other; + return self; } } -export function from$From_BoundsExceeded(_: BoundsExceeded.BoundsExceeded): DecodeError { - return { tag: "BoundsExceeded" }; +export function from$From_BoundsExceeded(_1: BoundsExceeded.BoundsExceeded): DecodeError { + return { tag: "BoundsExceeded" } as DecodeError; } //# sourceMappingURL=decode.DecodeError.ts.map diff --git a/ts/fixtures/codec/expected/coding/decode.Decoder.ts b/ts/fixtures/codec/expected/coding/decode.Decoder.ts index 5ac1b88ce..a317ff116 100644 --- a/ts/fixtures/codec/expected/coding/decode.Decoder.ts +++ b/ts/fixtures/codec/expected/coding/decode.Decoder.ts @@ -44,9 +44,12 @@ export function need(self: Decoder): rt.usize { /** Record that a read wanted `more` bytes past the current position. */ export function short(self: Decoder, more: rt.usize): DecodeError.DecodeError { - const need_ = rt.usizeSaturatingAdd(rt.usizeSub(self.len, self.buf.length), more); - self.need = rt.max(self.need, need_); - return { tag: "Short" }; + let need_!: rt.usize; + let _9!: rt.usize; + need_ = rt.usizeSaturatingAdd(rt.usizeSub(self.len, self.buf.length), more); + _9 = self.need; + self.need = rt.max(_9, need_); + return { tag: "Short" } as DecodeError.DecodeError; } /** The number of unread bytes. */ @@ -61,14 +64,14 @@ export function isEmpty(self: Decoder): boolean { /** Read `len` raw bytes. */ export function slice(self: Decoder, len: rt.usize): rt.Result { - const splitAtChecked = rt.sliceSplitAtChecked(self.buf, len); - if (splitAtChecked === undefined) { + let _6!: [Uint8Array, Uint8Array] | undefined; + _6 = rt.sliceSplitAtChecked(self.buf, len); + if (_6 !== undefined) { + self.buf = _6[1]; + return rt.Ok(_6[0]); + } else { return rt.Err(short(self, len)); } - const head = splitAtChecked[0]; - const rest_ = splitAtChecked[1]; - self.buf = rest_; - return rt.Ok(head); } /** Read every remaining byte. */ @@ -80,102 +83,134 @@ export function rest(self: Decoder): Uint8Array { /** Split off the next `len` bytes as their own decoder, e.g. a size-prefixed body. */ export function sub(self: Decoder, len: rt.usize): rt.Result { - const slice_ = slice(self, len); - if (!slice_.ok) { - return rt.Err(slice_.error); + let _4!: rt.Result; + _4 = slice(self, len); + if (_4.ok) { + return rt.Ok(new_(_4.value, self.form)); + } else { + return _4; } - return rt.Ok(new_(slice_.value, self.form)); } /** Read a single byte. */ export function u8(self: Decoder): rt.Result { - const slice_ = slice(self, 1); - if (!slice_.ok) { - return rt.Err(slice_.error); + let _3!: rt.Result; + _3 = slice(self, 1); + if (_3.ok) { + rt.idx(_3.value, 0); + return rt.Ok(_3.value[0]); + } else { + return _3; } - return rt.Ok(rt.at(slice_.value, 0)); } /** Read a big-endian `u16`. */ export function u16(self: Decoder): rt.Result { - const slice_ = slice(self, 2); - if (!slice_.ok) { - return rt.Err(slice_.error); + let _2!: rt.Result; + let _9!: rt.u8; + _2 = slice(self, 2); + if (_2.ok) { + rt.idx(_2.value, 0); + _9 = _2.value[0]; + rt.idx(_2.value, 1); + return rt.Ok((_9 << 8) | _2.value[1]); + } else { + return _2; } - const b = slice_.value; - return rt.Ok((rt.at(b, 0) << 8) | rt.at(b, 1)); } /** Read a byte that must be 0 or 1. */ export function bool(self: Decoder): rt.Result { - const u8_ = u8(self); - if (!u8_.ok) { - return rt.Err(u8_.error); - } - if (u8_.value === 0) { - return rt.Ok(false); - } else if (u8_.value === 1) { - return rt.Ok(true); + let _2!: rt.Result; + let val!: rt.u8; + _2 = u8(self); + if (_2.ok) { + val = _2.value; + if (val === 0) { + return rt.Ok(false); + } else if (val === 1) { + return rt.Ok(true); + } else { + return rt.Err({ tag: "InvalidValue" } as DecodeError.DecodeError); + } } else { - return rt.Err({ tag: "InvalidValue" }); + return _2; } } /** Read a varint. */ export function varint(self: Decoder): rt.Result { - const read_ = read(self.buf, self.form); - if (read_.ok) { - const value = read_.value[0]; - const rest_ = read_.value[1]; - self.buf = rest_; - return rt.Ok(value); - } else if (!read_.ok && read_.error.tag === "Short") { - return rt.Err(short(self, rt.usizeAdd(self.buf.length, 1))); + let _0!: rt.Result; + let _2!: rt.Result<[rt.u64, Uint8Array], DecodeError.DecodeError>; + let _3!: Form.Form; + let value!: rt.u64; + let _13!: Uint8Array; + _13 = self.buf; + _3 = self.form; + _2 = read(_13, _3); + if (_2.ok) { + value = _2.value[0]; + self.buf = _2.value[1]; + _0 = rt.Ok(value); + } else if (_2.error.tag === "Short") { + _0 = rt.Err(short(self, rt.usizeAdd(self.buf.length, 1))); } else { - const err = read_.error; - return rt.Err(err); + _0 = rt.Err(_2.error); } + return _0; } /** Read an optional varint: 0 is `None`, and `n + 1` is `Some(n)`. */ export function varintOpt(self: Decoder): rt.Result { - const varint_ = varint(self); - if (!varint_.ok) { - return rt.Err(varint_.error); + let _3!: rt.Result; + _3 = varint(self); + if (_3.ok) { + return rt.Ok(rt.u64CheckedSub(_3.value, 1)); + } else { + return _3; } - return rt.Ok(rt.u64CheckedSub(varint_.value, 1)); } /** Read a varint length, then that many raw bytes. */ export function bytes(self: Decoder): rt.Result { - const start = self.buf; - const varint_ = varint(self); - if (!varint_.ok) { - return rt.Err(varint_.error); - } - const mapErr = rt.resultMapErr(rt.usizeTryFrom(varint_.value), (_: rt.TryFromIntError): DecodeError.DecodeError => { - return { tag: "BoundsExceeded" }; - }); - if (!mapErr.ok) { - return rt.Err(mapErr.error); + let start!: Uint8Array; + let _3!: rt.Result; + let _6!: rt.Result; + start = self.buf; + _6 = varint(self); + if (_6.ok) { + _3 = rt.resultMapErr(rt.usizeTryFrom(_6.value), (_2: rt.TryFromIntError): DecodeError.DecodeError => { + return { tag: "BoundsExceeded" } as DecodeError.DecodeError; + }); + if (_3.ok) { + return rt.resultInspectErr(slice(self, _3.value), (_22: DecodeError.DecodeError): void => { + self.buf = start; + }); + } else { + return _3; + } + } else { + return _6; } - const len = mapErr.value; - return rt.resultInspectErr(slice(self, len), (_2: DecodeError.DecodeError): void => { - self.buf = start; - }); } /** Read a varint length, then that many bytes of UTF-8. */ export function string(self: Decoder): rt.Result { - const bytes_ = bytes(self); - if (!bytes_.ok) { - return rt.Err(bytes_.error); - } - const fromUtf8 = rt.stringFromUtf8(rt.sliceToByteVec(bytes_.value)); - if (!fromUtf8.ok) { - return rt.Err(DecodeError.from$From_FromUtf8Error(fromUtf8.error)); + let _2!: rt.Result; + let _5!: rt.Result; + let residual2!: rt.Result; + _5 = bytes(self); + if (_5.ok) { + _2 = rt.stringFromUtf8(rt.sliceToByteVec(_5.value)); + if (_2.ok) { + return rt.Ok(_2.value); + } else { + residual2 = _2; + return rt.Err(DecodeError.from$From_FromUtf8Error((residual2 as { ok: false; error: rt.FromUtf8Error }).error)); + } + } else { + return _5; } - return rt.Ok(fromUtf8.value); } export { new_ as new }; diff --git a/ts/fixtures/codec/expected/coding/encode.EncodeError.ts b/ts/fixtures/codec/expected/coding/encode.EncodeError.ts index bb973eeae..2d4adefd2 100644 --- a/ts/fixtures/codec/expected/coding/encode.EncodeError.ts +++ b/ts/fixtures/codec/expected/coding/encode.EncodeError.ts @@ -22,7 +22,23 @@ export function fmt$Display(self: EncodeError, __formatter: rt.Formatter): rt.Re } export function fmt$Debug(self: EncodeError, f: rt.Formatter): rt.Result { - return rt.fmtWriteStr(f, self === "BoundsExceeded" ? "BoundsExceeded" : self === "TooLarge" ? "TooLarge" : self === "Short" ? "Short" : self === "InvalidState" ? "InvalidState" : self === "TooMany" ? "TooMany" : self === "Version" ? "Version" : "Unsupported"); + let _3!: string; + if (self === "BoundsExceeded") { + _3 = "BoundsExceeded"; + } else if (self === "TooLarge") { + _3 = "TooLarge"; + } else if (self === "Short") { + _3 = "Short"; + } else if (self === "InvalidState") { + _3 = "InvalidState"; + } else if (self === "TooMany") { + _3 = "TooMany"; + } else if (self === "Version") { + _3 = "Version"; + } else { + _3 = "Unsupported"; + } + return rt.fmtWriteStr(f, _3); } /** An error that occurs during encoding. */ @@ -35,8 +51,8 @@ export type EncodeError = | "Version" | "Unsupported"; -export function from$From_BoundsExceeded(_: BoundsExceeded.BoundsExceeded): EncodeError { - return "BoundsExceeded"; +export function from$From_BoundsExceeded(_1: BoundsExceeded.BoundsExceeded): EncodeError { + return "BoundsExceeded" as EncodeError; } //# sourceMappingURL=encode.EncodeError.ts.map diff --git a/ts/fixtures/codec/expected/coding/encode.Encoder.ts b/ts/fixtures/codec/expected/coding/encode.Encoder.ts index ede1a9e32..e6acf2c51 100644 --- a/ts/fixtures/codec/expected/coding/encode.Encoder.ts +++ b/ts/fixtures/codec/expected/coding/encode.Encoder.ts @@ -3,7 +3,9 @@ import * as rt from "../rt.ts"; import * as EncodeError from "../coding/encode.EncodeError.ts"; import type * as Prefix from "../coding/encode.Prefix.ts"; +import type * as PrefixKind from "../coding/encode.PrefixKind.ts"; import { write } from "../coding/varint.ts"; +import type * as BoundsExceeded from "../coding/varint.BoundsExceeded.ts"; import type * as Form from "../coding/varint.Form.ts"; import type * as Control from "../stats.Control.ts"; @@ -45,37 +47,42 @@ export function bool(self: Encoder, v: boolean): void { /** Write a varint, or fail with [`EncodeError::BoundsExceeded`] if the form cannot carry it. */ export function varint(self: Encoder, v: rt.u64): rt.Result { - const write_ = write(v, self.form, self.buf); - if (!write_.ok) { - return rt.Err(EncodeError.from$From_BoundsExceeded(write_.error)); + let _3!: rt.Result; + _3 = write(v, self.form, self.buf); + if (_3.ok) { + return rt.Ok(undefined); + } else { + return rt.Err(EncodeError.from$From_BoundsExceeded({})); } - return rt.Ok(write_.value); } /** Write an optional varint: `None` as 0, and `Some(n)` as `n + 1`. */ export function varintOpt(self: Encoder, v: rt.u64 | undefined): rt.Result { - let v2: rt.u64; - if (v !== undefined) { - const v3 = v; - const okOr = rt.optionOkOr(rt.u64CheckedAdd(v3, 1), "TooLarge" as EncodeError.EncodeError); - if (!okOr.ok) { - return rt.Err(okOr.error); - } - v2 = okOr.value; - } else { + let v2!: rt.u64; + let _6!: rt.Result; + if (v === undefined) { v2 = 0; + } else { + _6 = rt.optionOkOr(rt.u64CheckedAdd(v, 1), "TooLarge" as EncodeError.EncodeError); + if (_6.ok) { + v2 = _6.value; + } else { + return _6; + } } return varint(self, v2); } /** Write a varint length, then the raw bytes. */ export function bytes(self: Encoder, v: Uint8Array): rt.Result { - const varint_ = varint(self, v.length as rt.u64); - if (!varint_.ok) { - return rt.Err(varint_.error); + let _3!: rt.Result; + _3 = varint(self, v.length as rt.u64); + if (_3.ok) { + slice(self, v); + return rt.Ok(undefined); + } else { + return _3; } - slice(self, v); - return rt.Ok(undefined); } /** Write a varint length, then the UTF-8 bytes. */ @@ -90,13 +97,13 @@ export function string(self: Encoder, v: string): rt.Result { - const body = prefix.body; - const end = self.buf.length; - if (prefix.kind === "U16") { - const mapErr = rt.resultMapErr(rt.u16TryFrom(rt.usizeSub(end, body)), (_: rt.TryFromIntError): EncodeError.EncodeError => { - return "TooLarge"; - }); - if (!mapErr.ok) { - return rt.Err(mapErr.error); + let body!: rt.usize; + let end!: rt.usize; + let _7!: rt.Result; + let size!: rt.u16; + let _23!: rt.Result; + let len!: rt.usize; + let _35!: rt.u8; + let _39!: rt.usize; + let size2!: Uint8Array; + let _44!: Uint8Array; + let _56!: Uint8Array; + let _58!: rt.usize; + let _75!: rt.ByteVec; + let _79!: rt.ByteVec; + let _84!: rt.ByteVec; + body = prefix.body; + end = self.buf.length; + if (prefix.kind === "Varint") { + _23 = write(rt.usizeSub(end, body) as rt.u64, self.form, self.buf); + if (_23.ok) { + len = rt.usizeSub(self.buf.length, end); + if (!(len === 1)) { + size2 = rt.bytes(9); + _44 = rt.sliceRange(size2, 0, len); + const slice4 = rt.byteVecView(self.buf); + rt.sliceCopyFromSlice(_44, rt.sliceRange(slice4, end)); + rt.byteVecTruncate(self.buf, rt.usizeSub(rt.usizeAdd(end, len), 1)); + _58 = rt.usizeSub(rt.usizeAdd(body, len), 1); + _56 = rt.byteVecView(self.buf); + rt.sliceCopyWithin(_56, body, end, _58); + _84 = self.buf; + const part2 = rt.usizeSub(body, 1); + const part3 = rt.usizeAdd(rt.usizeSub(body, 1), len); + const slice5 = rt.byteVecView(_84); + rt.sliceCopyFromSlice(rt.sliceRange(slice5, part2, part3), rt.sliceRange(size2, 0, len)); + } else { + const slice2 = rt.byteVecView(self.buf); + const at = rt.idx(slice2, end); + _35 = slice2[at]; + _79 = self.buf; + _39 = rt.usizeSub(body, 1); + const slice3 = rt.byteVecView(_79); + const at2 = rt.idx(slice3, _39); + slice3[at2] = _35; + rt.byteVecTruncate(self.buf, end); + return rt.Ok(undefined); + } + } else { + return rt.Err(EncodeError.from$From_BoundsExceeded({})); } - const size = mapErr.value; - rt.sliceCopyFromSlice(rt.sliceRange(rt.byteVecView(self.buf), rt.usizeSub(body, 2), body), rt.u16ToBeBytes(size)); } else { - const write_ = write(rt.usizeSub(end, body) as rt.u64, self.form, self.buf); - if (!write_.ok) { - return rt.Err(EncodeError.from$From_BoundsExceeded(write_.error)); - } - const len = rt.usizeSub(self.buf.length, end); - if (len === 1) { - const value = rt.at(rt.byteVecView(self.buf), end); - const slice_ = rt.byteVecView(self.buf); - const index = rt.usizeSub(body, 1); - slice_[rt.idx(slice_, index)] = value; - rt.byteVecTruncate(self.buf, end); - return rt.Ok(undefined); + _7 = rt.resultMapErr(rt.u16TryFrom(rt.usizeSub(end, body)), (_2: rt.TryFromIntError): EncodeError.EncodeError => { + return "TooLarge" as EncodeError.EncodeError; + }); + if (_7.ok) { + size = _7.value; + _75 = self.buf; + const part = rt.usizeSub(body, 2); + const slice_ = rt.byteVecView(_75); + rt.sliceCopyFromSlice(rt.sliceRange(slice_, part, body), rt.u16ToBeBytes(size)); + } else { + return _7; } - let size2: Uint8Array = rt.bytes(9); - rt.sliceCopyFromSlice(rt.sliceRange(size2, 0, len), rt.sliceRange(rt.byteVecView(self.buf), end)); - rt.byteVecTruncate(self.buf, rt.usizeSub(rt.usizeAdd(end, len), 1)); - rt.sliceCopyWithin(rt.byteVecView(self.buf), body, end, rt.usizeSub(rt.usizeAdd(body, len), 1)); - rt.sliceCopyFromSlice(rt.sliceRange(rt.byteVecView(self.buf), rt.usizeSub(body, 1), rt.usizeAdd(rt.usizeSub(body, 1), len)), rt.sliceRange(size2, 0, len)); } return rt.Ok(undefined); } diff --git a/ts/fixtures/codec/expected/coding/varint.Form.ts b/ts/fixtures/codec/expected/coding/varint.Form.ts index 35c33abb4..a674376a7 100644 --- a/ts/fixtures/codec/expected/coding/varint.Form.ts +++ b/ts/fixtures/codec/expected/coding/varint.Form.ts @@ -7,9 +7,9 @@ export type Form = { tag: "Quic" } | { tag: "LeadingOnes"; seven: boolean }; export function from$From_Version(version: Version.Version): Form { if (version === "Lite01" || version === "Lite02" || version === "Lite03" || version === "Lite04" || version === "Lite05" || version === "Lite06") { - return { tag: "Quic" }; + return { tag: "Quic" } as Form; } else { - return { tag: "LeadingOnes", seven: true }; + return { tag: "LeadingOnes", seven: true } as Form; } } diff --git a/ts/fixtures/codec/expected/coding/varint.ts b/ts/fixtures/codec/expected/coding/varint.ts index 2170e1627..927ff7d3f 100644 --- a/ts/fixtures/codec/expected/coding/varint.ts +++ b/ts/fixtures/codec/expected/coding/varint.ts @@ -7,46 +7,89 @@ import type * as Form from "../coding/varint.Form.ts"; /** The high and low 32 bits: the only place the codec splits a `u64`. */ export function toHalves(value: rt.u64): [rt.u32, rt.u32] { - return [rt.u64Low(rt.u64Shr(value, 32)), rt.u64Low(value)]; + return [rt.u64Low(rt.u64Shr(value, 32)), rt.u64Low(value)] as [rt.u32, rt.u32]; } /** The inverse of [`to_halves`]. */ export function fromHalves(hi: rt.u32, lo: rt.u32): rt.u64 { - return rt.u64Or(rt.u64Shl(hi as rt.u64, 32), lo as rt.u64); + return rt.u64FromHalves(hi, lo); } /** The bytes `value` takes on the wire in `form`, or [`BoundsExceeded`] if it does not fit. */ export function size(value: rt.u64, form: Form.Form): rt.Result { - const [hi, lo] = toHalves(value); - let value2: rt.usize; - if (form.tag === "Quic" && hi === 0 && lo < (1 << 6)) { - value2 = 1; - } else if (form.tag === "Quic" && hi === 0 && lo < (1 << 14)) { - value2 = 2; - } else if (form.tag === "Quic" && hi === 0 && lo < (1 << 30)) { - value2 = 4; - } else if (form.tag === "Quic" && hi < (1 << 30)) { - value2 = 8; - } else if (form.tag === "Quic") { - return rt.Err({}); - } else if (form.tag === "LeadingOnes" && hi === 0 && lo < (1 << 7)) { - value2 = 1; - } else if (form.tag === "LeadingOnes" && hi === 0 && lo < (1 << 14)) { - value2 = 2; - } else if (form.tag === "LeadingOnes" && hi === 0 && lo < (1 << 21)) { - value2 = 3; - } else if (form.tag === "LeadingOnes" && hi === 0 && lo < (1 << 28)) { - value2 = 4; - } else if (form.tag === "LeadingOnes" && hi < (1 << 3)) { - value2 = 5; - } else if (form.tag === "LeadingOnes" && hi < (1 << 10)) { - value2 = 6; - } else if (form.tag === "LeadingOnes" && hi < (1 << 24)) { - value2 = 8; - } else { - value2 = 9; + let hi!: rt.u32; + let lo!: rt.u32; + let _5!: [rt.u32, rt.u32]; + let _6!: rt.usize; + _5 = toHalves(value); + b1: { + hi = _5[0]; + lo = _5[1]; + if (form.tag === "Quic") { + if (hi === 0) { + if (lo < 64) { + _6 = 1; + break b1; + } + } + if (hi === 0) { + if (lo < 16384) { + _6 = 2; + break b1; + } + } + if (hi === 0) { + if (lo < 1073741824) { + _6 = 4; + break b1; + } + } + if (!(hi < 1073741824)) { + return rt.Err({}); + } else { + _6 = 8; + } + } else { + if (hi === 0) { + if (lo < 128) { + _6 = 1; + break b1; + } + } + if (hi === 0) { + if (lo < 16384) { + _6 = 2; + break b1; + } + } + if (hi === 0) { + if (lo < 2097152) { + _6 = 3; + break b1; + } + } + if (hi === 0) { + if (lo < 268435456) { + _6 = 4; + break b1; + } + } + if (!(hi < 8)) { + if (!(hi < 1024)) { + if (!(hi < 16777216)) { + _6 = 9; + } else { + _6 = 8; + } + } else { + _6 = 6; + } + } else { + _6 = 5; + } + } } - return rt.Ok(value2); + return rt.Ok(_6); } /** @@ -64,63 +107,111 @@ export function write(value: rt.u64, form: Form.Form, out: rt.ByteVec): rt.Resul } export function writeQuic(value: rt.u64, out: rt.ByteVec): rt.Result { - const [hi, lo] = toHalves(value); - if (hi === 0 && lo < (1 << 6)) { - rt.byteVecPush(out, lo & 0xff); - } else if (hi === 0 && lo < (1 << 14)) { - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(0x4000 | (lo & 0xffff))); - } else if (hi === 0 && lo < (1 << 30)) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes((0x8000_0000 | lo) >>> 0)); - } else if (hi < (1 << 30)) { - const toBeBytes = rt.u32ToBeBytes((0xc000_0000 | hi) >>> 0); - const a = toBeBytes[0]; - const b = toBeBytes[1]; - const c = toBeBytes[2]; - const d = toBeBytes[3]; - const toBeBytes2 = rt.u32ToBeBytes(lo); - const e = toBeBytes2[0]; - const f = toBeBytes2[1]; - const g = toBeBytes2[2]; - const h = toBeBytes2[3]; - rt.byteVecExtendFromSlice(out, Uint8Array.of(a, b, c, d, e, f, g, h)); - } else { - return rt.Err({}); + let hi!: rt.u32; + let lo!: rt.u32; + let _5!: [rt.u32, rt.u32]; + let a!: rt.u8; + let b!: rt.u8; + let c!: rt.u8; + let d!: rt.u8; + let _42!: Uint8Array; + let _48!: Uint8Array; + _5 = toHalves(value); + b1: { + hi = _5[0]; + lo = _5[1]; + if (hi === 0) { + if (lo < 64) { + rt.byteVecPush(out, lo & 0xff); + break b1; + } + } + if (hi === 0) { + if (lo < 16384) { + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(16384 | (lo & 0xffff))); + break b1; + } + } + if (hi === 0) { + if (lo < 1073741824) { + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes((2147483648 | lo) >>> 0)); + break b1; + } + } + if (!(hi < 1073741824)) { + return rt.Err({}); + } else { + _42 = rt.u32ToBeBytes((3221225472 | hi) >>> 0); + a = _42[0]; + b = _42[1]; + c = _42[2]; + d = _42[3]; + _48 = rt.u32ToBeBytes(lo); + rt.byteVecExtendFromSlice(out, Uint8Array.of(a, b, c, d, _48[0], _48[1], _48[2], _48[3])); + } } return rt.Ok(undefined); } export function writeLeadingOnes(value: rt.u64, out: rt.ByteVec): void { - const [hi, lo] = toHalves(value); - const toBeBytes = rt.u32ToBeBytes(lo); - const a = toBeBytes[0]; - const b = toBeBytes[1]; - const c = toBeBytes[2]; - const d = toBeBytes[3]; - if (hi === 0 && lo < (1 << 7)) { - rt.byteVecPush(out, d); - } else if (hi === 0 && lo < (1 << 14)) { - rt.byteVecExtendFromSlice(out, Uint8Array.of(0x80 | c, d)); - } else if (hi === 0 && lo < (1 << 21)) { - rt.byteVecExtendFromSlice(out, Uint8Array.of(0xc0 | b, c, d)); - } else if (hi === 0 && lo < (1 << 28)) { - rt.byteVecExtendFromSlice(out, Uint8Array.of(0xe0 | a, b, c, d)); - } else if (hi < (1 << 3)) { - rt.byteVecExtendFromSlice(out, Uint8Array.of(0xf0 | (hi & 0xff), a, b, c, d)); - } else if (hi < (1 << 10)) { - rt.byteVecExtendFromSlice(out, Uint8Array.of(0xf8 | ((hi >>> 8) & 0xff), hi & 0xff, a, b, c, d)); - } else if (hi < (1 << 24)) { - const toBeBytes2 = rt.u32ToBeBytes(hi); - const f = toBeBytes2[1]; - const g = toBeBytes2[2]; - const h = toBeBytes2[3]; - rt.byteVecExtendFromSlice(out, Uint8Array.of(0xfe, f, g, h, a, b, c, d)); - } else { - const toBeBytes3 = rt.u32ToBeBytes(hi); - const e = toBeBytes3[0]; - const f2 = toBeBytes3[1]; - const g2 = toBeBytes3[2]; - const h2 = toBeBytes3[3]; - rt.byteVecExtendFromSlice(out, Uint8Array.of(0xff, e, f2, g2, h2, a, b, c, d)); + let hi!: rt.u32; + let lo!: rt.u32; + let _5!: [rt.u32, rt.u32]; + let a!: rt.u8; + let b!: rt.u8; + let c!: rt.u8; + let d!: rt.u8; + let _10!: Uint8Array; + let _78!: Uint8Array; + let _87!: Uint8Array; + _5 = toHalves(value); + hi = _5[0]; + lo = _5[1]; + _10 = rt.u32ToBeBytes(lo); + b0: { + a = _10[0]; + b = _10[1]; + c = _10[2]; + d = _10[3]; + if (hi === 0) { + if (lo < 128) { + rt.byteVecPush(out, d); + break b0; + } + } + if (hi === 0) { + if (lo < 16384) { + rt.byteVecExtendFromSlice(out, Uint8Array.of(128 | c, d)); + break b0; + } + } + if (hi === 0) { + if (lo < 2097152) { + rt.byteVecExtendFromSlice(out, Uint8Array.of(192 | b, c, d)); + break b0; + } + } + if (hi === 0) { + if (lo < 268435456) { + rt.byteVecExtendFromSlice(out, Uint8Array.of(224 | a, b, c, d)); + break b0; + } + } + if (!(hi < 8)) { + if (!(hi < 1024)) { + if (!(hi < 16777216)) { + _87 = rt.u32ToBeBytes(hi); + rt.byteVecExtendFromSlice(out, Uint8Array.of(255, _87[0], _87[1], _87[2], _87[3], a, b, c, d)); + } else { + _78 = rt.u32ToBeBytes(hi); + rt.byteVecExtendFromSlice(out, Uint8Array.of(254, _78[1], _78[2], _78[3], a, b, c, d)); + } + } else { + rt.byteVecExtendFromSlice(out, Uint8Array.of(248 | ((hi >>> 8) & 0xff), hi & 0xff, a, b, c, d)); + } + } else { + rt.byteVecExtendFromSlice(out, Uint8Array.of(240 | (hi & 0xff), a, b, c, d)); + } } } @@ -129,153 +220,164 @@ export function read(buf: Uint8Array, form: Form.Form): rt.Result<[rt.u64, Uint8 if (form.tag === "Quic") { return readQuic(buf); } else { - const seven = form.seven; - return readLeadingOnes(buf, seven); + return readLeadingOnes(buf, form.seven); } } export function readQuic(buf: Uint8Array): rt.Result<[rt.u64, Uint8Array], DecodeError.DecodeError> { - const splitFirst = rt.sliceSplitFirst(buf); - if (splitFirst === undefined) { - return rt.Err({ tag: "Short" }); - } - const first = splitFirst[0]; - const rest = splitFirst[1]; - if (first < 0x40) { - return rt.Ok([first as rt.u64, rest]); - } else if (first < 0x80) { - const okOr = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 2), { tag: "Short" } as DecodeError.DecodeError); - if (!okOr.ok) { - return rt.Err(okOr.error); - } - const a = okOr.value[0][0]; - const b = okOr.value[0][1]; - const rest2 = okOr.value[1]; - return rt.Ok([((((a & 0x3f) << 8) | b)) as rt.u64, rest2]); - } else if (first < 0xc0) { - const okOr2 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 4), { tag: "Short" } as DecodeError.DecodeError); - if (!okOr2.ok) { - return rt.Err(okOr2.error); + let first!: rt.u8; + let _5!: [rt.u8, Uint8Array] | undefined; + let _14!: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError>; + let val!: [Uint8Array, Uint8Array]; + let _33!: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError>; + let val2!: [Uint8Array, Uint8Array]; + let _54!: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError>; + let val3!: [Uint8Array, Uint8Array]; + _5 = rt.sliceSplitFirst(buf); + if (_5 !== undefined) { + first = _5[0]; + if (!(first < 64)) { + if (!(first < 128)) { + if (!(first < 192)) { + _54 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 8), { tag: "Short" } as DecodeError.DecodeError); + if (_54.ok) { + val3 = _54.value; + const slice = val3[0]; + return rt.Ok([fromHalves((((val3[0][0] & 63) << 24) | (val3[0][1] << 16) | (val3[0][2] << 8) | val3[0][3]) >>> 0, rt.u32FromBeBytes(slice.subarray(4, 8))), val3[1]] as [rt.u64, Uint8Array]); + } else { + return _54; + } + } else { + _33 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 4), { tag: "Short" } as DecodeError.DecodeError); + if (_33.ok) { + val2 = _33.value; + return rt.Ok([(((val2[0][0] & 63) << 24) | (val2[0][1] << 16) | (val2[0][2] << 8) | val2[0][3]) >>> 0 as rt.u64, val2[1]] as [rt.u64, Uint8Array]); + } else { + return _33; + } + } + } else { + _14 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 2), { tag: "Short" } as DecodeError.DecodeError); + if (_14.ok) { + val = _14.value; + return rt.Ok([(((val[0][0] & 63) << 8) | val[0][1]) as rt.u64, val[1]] as [rt.u64, Uint8Array]); + } else { + return _14; + } + } + } else { + return rt.Ok([first as rt.u64, _5[1]] as [rt.u64, Uint8Array]); } - const a2 = okOr2.value[0][0]; - const b2 = okOr2.value[0][1]; - const c = okOr2.value[0][2]; - const d = okOr2.value[0][3]; - const rest3 = okOr2.value[1]; - return rt.Ok([(((a2 & 0x3f) << 24) | (b2 << 16) | (c << 8) | d) >>> 0 as rt.u64, rest3]); } else { - const okOr3 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 8), { tag: "Short" } as DecodeError.DecodeError); - if (!okOr3.ok) { - return rt.Err(okOr3.error); - } - const a3 = okOr3.value[0][0]; - const b3 = okOr3.value[0][1]; - const c2 = okOr3.value[0][2]; - const d2 = okOr3.value[0][3]; - const lo = okOr3.value[0].subarray(4, 8); - const rest4 = okOr3.value[1]; - return rt.Ok([fromHalves((((a3 & 0x3f) << 24) | (b3 << 16) | (c2 << 8) | d2) >>> 0, rt.u32FromBeBytes(lo)), rest4]); + return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } } export function readLeadingOnes(buf: Uint8Array, seven: boolean): rt.Result<[rt.u64, Uint8Array], DecodeError.DecodeError> { - const splitFirst = rt.sliceSplitFirst(buf); - if (splitFirst === undefined) { - return rt.Err({ tag: "Short" }); - } - const first = splitFirst[0]; - const rest = splitFirst[1]; - let value: [rt.u64, Uint8Array]; - const leadingOnes = rt.u8LeadingOnes(first); - if (leadingOnes === 0) { - value = [first as rt.u64, rest]; - } else if (leadingOnes === 1) { - const okOr = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 2), { tag: "Short" } as DecodeError.DecodeError); - if (!okOr.ok) { - return rt.Err(okOr.error); - } - const a = okOr.value[0][0]; - const b = okOr.value[0][1]; - const rest2 = okOr.value[1]; - value = [((((a & 0x3f) << 8) | b)) as rt.u64, rest2]; - } else if (leadingOnes === 2) { - const okOr2 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 3), { tag: "Short" } as DecodeError.DecodeError); - if (!okOr2.ok) { - return rt.Err(okOr2.error); + let first!: rt.u8; + let _6!: [rt.u8, Uint8Array] | undefined; + let _8!: [rt.u64, Uint8Array]; + let _9!: rt.u32; + let _14!: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError>; + let val!: [Uint8Array, Uint8Array]; + let _30!: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError>; + let val2!: [Uint8Array, Uint8Array]; + let _48!: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError>; + let val3!: [Uint8Array, Uint8Array]; + let _65!: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError>; + let val4!: [Uint8Array, Uint8Array]; + let _81!: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError>; + let val5!: [Uint8Array, Uint8Array]; + let _101!: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError>; + let val6!: [Uint8Array, Uint8Array]; + let _121!: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError>; + let val7!: [Uint8Array, Uint8Array]; + let _142!: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError>; + let val8!: [Uint8Array, Uint8Array]; + _6 = rt.sliceSplitFirst(buf); + if (_6 !== undefined) { + first = _6[0]; + _9 = rt.u8LeadingOnes(first); + if (_9 === 0) { + _8 = [first as rt.u64, _6[1]] as [rt.u64, Uint8Array]; + } else if (_9 === 1) { + _14 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 2), { tag: "Short" } as DecodeError.DecodeError); + if (_14.ok) { + val = _14.value; + _8 = [(((val[0][0] & 63) << 8) | val[0][1]) as rt.u64, val[1]] as [rt.u64, Uint8Array]; + } else { + return _14; + } + } else if (_9 === 2) { + _30 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 3), { tag: "Short" } as DecodeError.DecodeError); + if (_30.ok) { + val2 = _30.value; + _8 = [(((val2[0][0] & 31) << 16) | (val2[0][1] << 8) | val2[0][2]) as rt.u64, val2[1]] as [rt.u64, Uint8Array]; + } else { + return _30; + } + } else if (_9 === 3) { + _48 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 4), { tag: "Short" } as DecodeError.DecodeError); + if (_48.ok) { + val3 = _48.value; + _8 = [(((val3[0][0] & 15) << 24) | (val3[0][1] << 16) | (val3[0][2] << 8) | val3[0][3]) >>> 0 as rt.u64, val3[1]] as [rt.u64, Uint8Array]; + } else { + return _48; + } + } else if (_9 === 4) { + _65 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 5), { tag: "Short" } as DecodeError.DecodeError); + if (_65.ok) { + val4 = _65.value; + const slice5 = val4[0]; + _8 = [fromHalves(((val4[0][0] & 7)) as rt.u32, rt.u32FromBeBytes(slice5.subarray(1, 5))), val4[1]] as [rt.u64, Uint8Array]; + } else { + return _65; + } + } else if (_9 === 5) { + _81 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 6), { tag: "Short" } as DecodeError.DecodeError); + if (_81.ok) { + val5 = _81.value; + const slice4 = val5[0]; + _8 = [fromHalves(((val5[0][0] & 3) << 8) | val5[0][1], rt.u32FromBeBytes(slice4.subarray(2, 6))), val5[1]] as [rt.u64, Uint8Array]; + } else { + return _81; + } + } else if (_9 === 6) { + if (!seven) { + return rt.Err({ tag: "InvalidValue" } as DecodeError.DecodeError); + } else { + _101 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 7), { tag: "Short" } as DecodeError.DecodeError); + if (_101.ok) { + val6 = _101.value; + const slice3 = val6[0]; + _8 = [fromHalves(((val6[0][0] & 1) << 16) | (val6[0][1] << 8) | val6[0][2], rt.u32FromBeBytes(slice3.subarray(3, 7))), val6[1]] as [rt.u64, Uint8Array]; + } else { + return _101; + } + } + } else if (_9 === 7) { + _121 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 8), { tag: "Short" } as DecodeError.DecodeError); + if (_121.ok) { + val7 = _121.value; + const slice2 = val7[0]; + _8 = [fromHalves((val7[0][1] << 16) | (val7[0][2] << 8) | val7[0][3], rt.u32FromBeBytes(slice2.subarray(4, 8))), val7[1]] as [rt.u64, Uint8Array]; + } else { + return _121; + } + } else { + _142 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 9), { tag: "Short" } as DecodeError.DecodeError); + if (_142.ok) { + val8 = _142.value; + const slice = val8[0]; + _8 = [fromHalves(rt.u32FromBeBytes(slice.subarray(1, 5)), ((val8[0][5] << 24) | (val8[0][6] << 16) | (val8[0][7] << 8) | val8[0][8]) >>> 0), val8[1]] as [rt.u64, Uint8Array]; + } else { + return _142; + } } - const a2 = okOr2.value[0][0]; - const b2 = okOr2.value[0][1]; - const c = okOr2.value[0][2]; - const rest3 = okOr2.value[1]; - value = [((((a2 & 0x1f) << 16) | (b2 << 8) | c)) as rt.u64, rest3]; - } else if (leadingOnes === 3) { - const okOr3 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 4), { tag: "Short" } as DecodeError.DecodeError); - if (!okOr3.ok) { - return rt.Err(okOr3.error); - } - const a3 = okOr3.value[0][0]; - const b3 = okOr3.value[0][1]; - const c2 = okOr3.value[0][2]; - const d = okOr3.value[0][3]; - const rest4 = okOr3.value[1]; - value = [(((a3 & 0x0f) << 24) | (b3 << 16) | (c2 << 8) | d) >>> 0 as rt.u64, rest4]; - } else if (leadingOnes === 4) { - const okOr4 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 5), { tag: "Short" } as DecodeError.DecodeError); - if (!okOr4.ok) { - return rt.Err(okOr4.error); - } - const a4 = okOr4.value[0][0]; - const lo = okOr4.value[0].subarray(1, 5); - const rest5 = okOr4.value[1]; - value = [fromHalves(((a4 & 0x07)) as rt.u32, rt.u32FromBeBytes(lo)), rest5]; - } else if (leadingOnes === 5) { - const okOr5 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 6), { tag: "Short" } as DecodeError.DecodeError); - if (!okOr5.ok) { - return rt.Err(okOr5.error); - } - const a5 = okOr5.value[0][0]; - const b4 = okOr5.value[0][1]; - const lo2 = okOr5.value[0].subarray(2, 6); - const rest6 = okOr5.value[1]; - value = [fromHalves(((a5 & 0x03) << 8) | b4, rt.u32FromBeBytes(lo2)), rest6]; - } else if (leadingOnes === 6 && !seven) { - return rt.Err({ tag: "InvalidValue" }); - } else if (leadingOnes === 6) { - const okOr6 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 7), { tag: "Short" } as DecodeError.DecodeError); - if (!okOr6.ok) { - return rt.Err(okOr6.error); - } - const a6 = okOr6.value[0][0]; - const b5 = okOr6.value[0][1]; - const c3 = okOr6.value[0][2]; - const lo3 = okOr6.value[0].subarray(3, 7); - const rest7 = okOr6.value[1]; - value = [fromHalves(((a6 & 0x01) << 16) | (b5 << 8) | c3, rt.u32FromBeBytes(lo3)), rest7]; - } else if (leadingOnes === 7) { - const okOr7 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 8), { tag: "Short" } as DecodeError.DecodeError); - if (!okOr7.ok) { - return rt.Err(okOr7.error); - } - const b6 = okOr7.value[0][1]; - const c4 = okOr7.value[0][2]; - const d2 = okOr7.value[0][3]; - const lo4 = okOr7.value[0].subarray(4, 8); - const rest8 = okOr7.value[1]; - value = [fromHalves((b6 << 16) | (c4 << 8) | d2, rt.u32FromBeBytes(lo4)), rest8]; + return rt.Ok(_8); } else { - const okOr8 = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 9), { tag: "Short" } as DecodeError.DecodeError); - if (!okOr8.ok) { - return rt.Err(okOr8.error); - } - const e = okOr8.value[0][5]; - const f = okOr8.value[0][6]; - const g = okOr8.value[0][7]; - const h = okOr8.value[0][8]; - const hi = okOr8.value[0].subarray(1, 5); - const rest9 = okOr8.value[1]; - value = [fromHalves(rt.u32FromBeBytes(hi), ((e << 24) | (f << 16) | (g << 8) | h) >>> 0), rest9]; + return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } - return rt.Ok(value); } /** diff --git a/ts/fixtures/codec/expected/coding/version.Version.ts b/ts/fixtures/codec/expected/coding/version.Version.ts index 06ed65a7c..092e3355a 100644 --- a/ts/fixtures/codec/expected/coding/version.Version.ts +++ b/ts/fixtures/codec/expected/coding/version.Version.ts @@ -14,30 +14,36 @@ export interface Version { } /** Decode the version number. */ -export function decode$Decode_Form(r: Decoder.Decoder, _: Form.Form): rt.Result { - const varint = Decoder.varint(r); - if (!varint.ok) { - return rt.Err(varint.error); +export function decode$Decode_Form(r: Decoder.Decoder, _2: Form.Form): rt.Result { + let _4!: rt.Result; + _4 = Decoder.varint(r); + if (_4.ok) { + return rt.Ok({ _0: _4.value }); + } else { + return _4; } - return rt.Ok({ _0: varint.value }); } /** Encode the value to the given encoder, which may hold partial output on error. */ -export function encode$Encode_Form(self: Version, w: Encoder.Encoder, _: Form.Form): rt.Result { - const varint = Encoder.varint(w, self._0); - if (!varint.ok) { - return rt.Err(varint.error); +export function encode$Encode_Form(self: Version, w: Encoder.Encoder, _3: Form.Form): rt.Result { + let _4!: rt.Result; + _4 = Encoder.varint(w, self._0); + if (_4.ok) { + return rt.Ok(undefined); + } else { + return _4; } - return rt.Ok(undefined); } /** Encode the value to the given encoder, which may hold partial output on error. */ -export function encode$Encode_Version(self: Version, w: Encoder.Encoder, _: version_Version.Version): rt.Result { - const varint = Encoder.varint(w, self._0); - if (!varint.ok) { - return rt.Err(varint.error); +export function encode$Encode_Version(self: Version, w: Encoder.Encoder, _3: version_Version.Version): rt.Result { + let _4!: rt.Result; + _4 = Encoder.varint(w, self._0); + if (_4.ok) { + return rt.Ok(undefined); + } else { + return _4; } - return rt.Ok(undefined); } //# sourceMappingURL=version.Version.ts.map diff --git a/ts/fixtures/codec/expected/coding/version.Versions.ts b/ts/fixtures/codec/expected/coding/version.Versions.ts index 2cda18088..5b129819d 100644 --- a/ts/fixtures/codec/expected/coding/version.Versions.ts +++ b/ts/fixtures/codec/expected/coding/version.Versions.ts @@ -11,13 +11,23 @@ import type * as version_Version from "../lite/version.Version.ts"; /** Decode the value from the front of `buf`, returning it and the bytes it took. */ export function decodeSlice$Decode_Form(buf: Uint8Array, version: Form.Form): rt.Result<[Versions, rt.usize], DecodeError.DecodeError> { - let r: Decoder.Decoder = Decoder.new(buf, version); - const decode = decode$Decode_Form(r, version); - if (!decode.ok) { - return rt.Err(decode.error); + let _0!: rt.Result<[Versions, rt.usize], DecodeError.DecodeError>; + let r!: Decoder.Decoder; + let value!: Versions; + let _6!: rt.Result; + let val!: Versions; + let _13!: Versions; + r = Decoder.new(buf, version); + _6 = decode$Decode_Form(r, version); + if (_6.ok) { + val = _6.value; + value = val; + _13 = value; + _0 = rt.Ok([_13, rt.usizeSub(buf.length, Decoder.remaining(r))] as [Versions, rt.usize]); + return _0; + } else { + return _6; } - const value = decode.value; - return rt.Ok([value, rt.usizeSub(buf.length, Decoder.remaining(r))]); } /** A list of versions in preferred order. */ @@ -27,52 +37,87 @@ export interface Versions { /** Decode the version list. */ export function decode$Decode_Form(r: Decoder.Decoder, version: Form.Form): rt.Result { - const varint = Decoder.varint(r); - if (!varint.ok) { - return rt.Err(varint.error); - } - const count = varint.value; - let vs: Version.Version[] = []; - const end = count; - for (const _ of new rt.Range(0, end, rt.u64Step)) { - const decode = Version.decode$Decode_Form(r, version); - if (!decode.ok) { - return rt.Err(decode.error); + let _3!: rt.Result; + let count!: rt.u64; + let vs!: Version.Version[]; + let iter!: rt.Range; + let _12!: rt.u64 | rt.Done; + let _15!: rt.Result; + _3 = Decoder.varint(r); + if (_3.ok) { + count = _3.value; + vs = []; + iter = new rt.Range(0, count, rt.u64Step); + while (true) { + _12 = iter.next(); + if (_12 === rt.DONE) { + return rt.Ok({ _0: vs }); + } else { + _15 = Version.decode$Decode_Form(r, version); + if (_15.ok) { + vs.push(_15.value); + } else { + return _15; + } + } } - const v = decode.value; - vs.push(rt.copy(v)); + } else { + return _3; } - return rt.Ok({ _0: vs }); } /** Encode the version list. */ export function encode$Encode_Form(self: Versions, w: Encoder.Encoder, version: Form.Form): rt.Result { - const varint = Encoder.varint(w, self._0.length as rt.u64); - if (!varint.ok) { - return rt.Err(varint.error); - } - for (const v of self._0) { - const encode = Version.encode$Encode_Form(v, w, version); - if (!encode.ok) { - return rt.Err(encode.error); + let _4!: rt.Result; + let iterS!: Version.Version[]; + let iterI!: number; + let _14!: Version.Version | rt.Done; + let _18!: rt.Result; + _4 = Encoder.varint(w, self._0.length as rt.u64); + if (_4.ok) { + iterS = self._0; + iterI = 0; + while (true) { + _14 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_14 === rt.DONE) { + return rt.Ok(undefined); + } else { + _18 = Version.encode$Encode_Form(_14, w, version); + if (!_18.ok) { + return _18; + } + } } + } else { + return _4; } - return rt.Ok(undefined); } /** Encode the version list. */ export function encode$Encode_Version(self: Versions, w: Encoder.Encoder, version: version_Version.Version): rt.Result { - const varint = Encoder.varint(w, self._0.length as rt.u64); - if (!varint.ok) { - return rt.Err(varint.error); - } - for (const v of self._0) { - const encode = Version.encode$Encode_Version(v, w, version); - if (!encode.ok) { - return rt.Err(encode.error); + let _4!: rt.Result; + let iterS!: Version.Version[]; + let iterI!: number; + let _14!: Version.Version | rt.Done; + let _18!: rt.Result; + _4 = Encoder.varint(w, self._0.length as rt.u64); + if (_4.ok) { + iterS = self._0; + iterI = 0; + while (true) { + _14 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_14 === rt.DONE) { + return rt.Ok(undefined); + } else { + _18 = Version.encode$Encode_Version(_14, w, version); + if (!_18.ok) { + return _18; + } + } } + } else { + return _4; } - return rt.Ok(undefined); } export function from$From_Versions(vs: Version.Version[]): Versions { diff --git a/ts/fixtures/codec/expected/harness.ts b/ts/fixtures/codec/expected/harness.ts index c8ba2c0f0..ef3e0a9d2 100644 --- a/ts/fixtures/codec/expected/harness.ts +++ b/ts/fixtures/codec/expected/harness.ts @@ -17,63 +17,67 @@ import type * as Version from "./lite/version.Version.ts"; /** Run one case. */ export function run(input: Uint8Array): rt.ByteVec { - let out: rt.ByteVec = new rt.ByteVec(); - const splitFirst = rt.sliceSplitFirst(input); - if (splitFirst === undefined) { + let out!: rt.ByteVec; + let _5!: [rt.u8, Uint8Array] | undefined; + let _8!: rt.u8; + out = new rt.ByteVec(); + _5 = rt.sliceSplitFirst(input); + if (_5 !== undefined) { + _8 = rt.u8Rem(_5[0], 9); + if (_8 === 0) { + decodeScript(_5[1], out); + } else if (_8 === 1) { + encodeScript(_5[1], out); + } else if (_8 === 2) { + zigzag(_5[1], out); + } else if (_8 === 3) { + sizes(_5[1], out); + } else if (_8 === 4) { + roundtrip$Versions(_5[1], out); + } else if (_8 === 5) { + roundtripLite$Group(_5[1], out); + } else if (_8 === 6) { + roundtripLite$Probe(_5[1], out); + } else if (_8 === 7) { + encodeMessages(_5[1], out); + } else { + errors(_5[1], out); + } return out; - } - const op = splitFirst[0]; - const data = splitFirst[1]; - const value = rt.u8Rem(op, 9); - if (value === 0) { - decodeScript(data, out); - } else if (value === 1) { - encodeScript(data, out); - } else if (value === 2) { - zigzag(data, out); - } else if (value === 3) { - sizes(data, out); - } else if (value === 4) { - roundtrip$Versions(data, out); - } else if (value === 5) { - roundtripLite$Group(data, out); - } else if (value === 6) { - roundtripLite$Probe(data, out); - } else if (value === 7) { - encodeMessages(data, out); } else { - errors(data, out); + return out; } - return out; } export function form(selector: rt.u8): Form.Form { - const value = rt.u8Rem(selector, 3); - if (value === 0) { - return { tag: "Quic" }; - } else if (value === 1) { - return { tag: "LeadingOnes", seven: false }; + let _2!: rt.u8; + _2 = rt.u8Rem(selector, 3); + if (_2 === 0) { + return { tag: "Quic" } as Form.Form; + } else if (_2 === 1) { + return { tag: "LeadingOnes", seven: false } as Form.Form; } else { - return { tag: "LeadingOnes", seven: true }; + return { tag: "LeadingOnes", seven: true } as Form.Form; } } export function liteVersion(selector: rt.u8): Version.Version { - const value = rt.u8Rem(selector, 7); - if (value === 0) { - return "Lite01"; - } else if (value === 1) { - return "Lite02"; - } else if (value === 2) { - return "Lite03"; - } else if (value === 3) { - return "Lite04"; - } else if (value === 4) { - return "Lite05"; - } else if (value === 5) { - return "Lite06"; + let _2!: rt.u8; + _2 = rt.u8Rem(selector, 7); + if (_2 === 0) { + return "Lite01" as Version.Version; + } else if (_2 === 1) { + return "Lite02" as Version.Version; + } else if (_2 === 2) { + return "Lite03" as Version.Version; + } else if (_2 === 3) { + return "Lite04" as Version.Version; + } else if (_2 === 4) { + return "Lite05" as Version.Version; + } else if (_2 === 5) { + return "Lite06" as Version.Version; } else { - return "Lite07"; + return "Lite07" as Version.Version; } } @@ -87,22 +91,38 @@ export function putUsize(out: rt.ByteVec, value: rt.usize): void { /** Take up to 8 big-endian bytes as a `u64`, zero-padded on the right. */ export function takeU64(data: Uint8Array): [rt.u64, Uint8Array] { - let buf: Uint8Array = rt.bytes(8); - const n = rt.min(data.length, 8); + let buf!: Uint8Array; + let n!: rt.usize; + buf = rt.bytes(8); + n = rt.min(data.length, 8); rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - return [rt.u64FromBeBytes(buf), rt.sliceRange(data, n)]; + return [rt.u64FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.u64, Uint8Array]; } /** A decode error's code, then its text. */ export function decodeFailed(out: rt.ByteVec, err: DecodeError.DecodeError): void { + let _5!: string; + let _6!: string; + let args2!: rt.Fmt[]; decodeError(out, err); - putText(out, rt.fmtToString((f: rt.Formatter) => DecodeError.fmt$Display(err, f)), rt.fmtFormat([(f: rt.Formatter) => DecodeError.fmt$Debug(err, f)])); + _5 = rt.fmtToString((f: rt.Formatter) => DecodeError.fmt$Display(err, f)); + const arg = ([err] as [DecodeError.DecodeError])[0]; + args2 = [(f: rt.Formatter) => DecodeError.fmt$Debug(arg, f)]; + _6 = rt.fmtFormat([args2[0]]); + putText(out, _5, _6); } /** An encode error's code, then its text. */ export function encodeFailed(out: rt.ByteVec, err: EncodeError.EncodeError): void { + let _5!: string; + let _6!: string; + let args2!: rt.Fmt[]; encodeError(out, err); - putText(out, rt.fmtToString((f: rt.Formatter) => EncodeError.fmt$Display(err, f)), rt.fmtFormat([(f: rt.Formatter) => EncodeError.fmt$Debug(err, f)])); + _5 = rt.fmtToString((f: rt.Formatter) => EncodeError.fmt$Display(err, f)); + const arg = ([err] as [EncodeError.EncodeError])[0]; + args2 = [(f: rt.Formatter) => EncodeError.fmt$Debug(arg, f)]; + _6 = rt.fmtFormat([args2[0]]); + putText(out, _5, _6); } /** An error's thiserror `Display` and derived `Debug`, which callers see. */ @@ -114,7 +134,7 @@ export function putText(out: rt.ByteVec, display: string, debug: string): void { } export function decodeError(out: rt.ByteVec, err: DecodeError.DecodeError): void { - rt.byteVecPush(out, 0xee); + rt.byteVecPush(out, 238); if (err.tag === "Short") { rt.byteVecPush(out, 0); } else if (err.tag === "Long") { @@ -122,9 +142,8 @@ export function decodeError(out: rt.ByteVec, err: DecodeError.DecodeError): void } else if (err.tag === "InvalidString") { rt.byteVecPush(out, 2); } else if (err.tag === "InvalidMessage") { - const id = err._0; rt.byteVecPush(out, 3); - putU64(out, id); + putU64(out, err._0); } else if (err.tag === "InvalidSubscribeLocation") { rt.byteVecPush(out, 4); } else if (err.tag === "InvalidValue") { @@ -136,11 +155,9 @@ export function decodeError(out: rt.ByteVec, err: DecodeError.DecodeError): void } else if (err.tag === "ExpectedEnd") { rt.byteVecPush(out, 8); } else if (err.tag === "MessageTooLarge") { - const size_ = err.size; - const max = err.max; rt.byteVecPush(out, 9); - putUsize(out, size_); - putUsize(out, max); + putUsize(out, err.size); + putUsize(out, err.max); } else if (err.tag === "ExpectedData") { rt.byteVecPush(out, 10); } else if (err.tag === "Duplicate") { @@ -163,8 +180,24 @@ export function decodeError(out: rt.ByteVec, err: DecodeError.DecodeError): void } export function encodeError(out: rt.ByteVec, err: EncodeError.EncodeError): void { - rt.byteVecPush(out, 0xef); - rt.byteVecPush(out, err === "BoundsExceeded" ? 0 : err === "TooLarge" ? 1 : err === "Short" ? 2 : err === "InvalidState" ? 3 : err === "TooMany" ? 4 : err === "Version" ? 5 : 6); + let _5!: rt.u8; + rt.byteVecPush(out, 239); + if (err === "BoundsExceeded") { + _5 = 0; + } else if (err === "TooLarge") { + _5 = 1; + } else if (err === "Short") { + _5 = 2; + } else if (err === "InvalidState") { + _5 = 3; + } else if (err === "TooMany") { + _5 = 4; + } else if (err === "Version") { + _5 = 5; + } else { + _5 = 6; + } + rt.byteVecPush(out, _5); } /** @@ -172,113 +205,148 @@ export function encodeError(out: rt.ByteVec, err: EncodeError.EncodeError): void * `data[1]` bytes after the form selector, and the wire is everything after it. */ export function decodeScript(data: Uint8Array, out: rt.ByteVec): void { - const splitFirst = rt.sliceSplitFirst(data); - if (splitFirst === undefined) { - return; - } - const selector = splitFirst[0]; - const data2 = splitFirst[1]; - const splitFirst2 = rt.sliceSplitFirst(data2); - if (splitFirst2 === undefined) { - return; - } - const len = splitFirst2[0]; - const data3 = splitFirst2[1]; - const [script, wire] = rt.sliceSplitAt(data3, rt.min(data3.length, len as rt.usize)); - let r: Decoder.Decoder = Decoder.new(wire, form(selector)); - for (const item of script) { - const step = item; - const decodeStep_ = decodeStep(r, step, out); - if (decodeStep_.ok) { - rt.byteVecPush(out, 0); - } else { - const err = decodeStep_.error; - decodeFailed(out, err); - putUsize(out, Decoder.need(r)); - break; + let selector!: rt.u8; + let _5!: [rt.u8, Uint8Array] | undefined; + let len!: rt.u8; + let _9!: [rt.u8, Uint8Array] | undefined; + let _13!: [Uint8Array, Uint8Array]; + let _15!: rt.usize; + let r!: Decoder.Decoder; + let iterS!: Uint8Array; + let iterI!: number; + let _21!: rt.u8 | rt.Done; + let _26!: rt.Result; + let err!: DecodeError.DecodeError; + _5 = rt.sliceSplitFirst(data); + b0: { + if (_5 !== undefined) { + selector = _5[0]; + _9 = rt.sliceSplitFirst(_5[1]); + if (_9 !== undefined) { + len = _9[0]; + _15 = _9[1].length; + _13 = rt.sliceSplitAt(_9[1], rt.min(_15, len as rt.usize)); + r = Decoder.new(_13[1], form(selector)); + iterS = _13[0]; + iterI = 0; + l1: while (true) { + _21 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_21 !== rt.DONE) { + _26 = decodeStep(r, _21, out); + if (_26.ok) { + rt.byteVecPush(out, 0); + putUsize(out, Decoder.remaining(r)); + continue l1; + } else { + err = _26.error; + decodeFailed(out, err); + putUsize(out, Decoder.need(r)); + } + } + rt.byteVecPush(out, Decoder.isEmpty(r) ? 1 : 0); + break b0; + } + } } - putUsize(out, Decoder.remaining(r)); } - rt.byteVecPush(out, Decoder.isEmpty(r) ? 1 : 0); } export function decodeStep(r: Decoder.Decoder, step: rt.u8, out: rt.ByteVec): rt.Result { - const value = rt.u8Rem(step, 10); - if (value === 0) { - const arg = out; - const u8 = Decoder.u8(r); - if (!u8.ok) { - return rt.Err(u8.error); - } - rt.byteVecPush(arg, u8.value); - } else if (value === 1) { - const arg2 = out; - const u16 = Decoder.u16(r); - if (!u16.ok) { - return rt.Err(u16.error); - } - rt.byteVecExtendFromSlice(arg2, rt.u16ToBeBytes(u16.value)); - } else if (value === 2) { - const arg3 = out; - const bool = Decoder.bool(r); - if (!bool.ok) { - return rt.Err(bool.error); + let _5!: rt.u8; + let _7!: rt.Result; + let _15!: rt.Result; + let _21!: rt.Result; + let _26!: rt.Result; + let _31!: rt.Result; + let val5!: rt.u64 | undefined; + let v!: rt.u64; + let _40!: rt.Result; + let s!: string; + let _49!: rt.Result; + let _57!: rt.Result; + let sub!: Decoder.Decoder; + let _67!: rt.Result; + let _76!: rt.Result; + _5 = rt.u8Rem(step, 10); + if (_5 === 0) { + _7 = Decoder.u8(r); + if (_7.ok) { + rt.byteVecPush(out, _7.value); + } else { + return _7; } - rt.byteVecPush(arg3, bool.value ? 1 : 0); - } else if (value === 3) { - const arg4 = out; - const varint = Decoder.varint(r); - if (!varint.ok) { - return rt.Err(varint.error); + } else if (_5 === 1) { + _15 = Decoder.u16(r); + if (_15.ok) { + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(_15.value)); + } else { + return _15; } - putU64(arg4, varint.value); - } else if (value === 4) { - const varintOpt = Decoder.varintOpt(r); - if (!varintOpt.ok) { - return rt.Err(varintOpt.error); + } else if (_5 === 2) { + _21 = Decoder.bool(r); + if (_21.ok) { + rt.byteVecPush(out, _21.value ? 1 : 0); + } else { + return _21; } - if (varintOpt.value !== undefined) { - const v = varintOpt.value; - rt.byteVecPush(out, 1); - putU64(out, v); + } else if (_5 === 3) { + _26 = Decoder.varint(r); + if (_26.ok) { + putU64(out, _26.value); } else { - rt.byteVecPush(out, 0); + return _26; } - } else if (value === 5) { - const bytes = Decoder.bytes(r); - if (!bytes.ok) { - return rt.Err(bytes.error); + } else if (_5 === 4) { + _31 = Decoder.varintOpt(r); + if (_31.ok) { + val5 = _31.value; + if (val5 === undefined) { + rt.byteVecPush(out, 0); + } else { + v = val5; + rt.byteVecPush(out, 1); + putU64(out, v); + } + } else { + return _31; } - const bytes2 = bytes.value; - putUsize(out, bytes2.length); - rt.byteVecExtendFromSlice(out, bytes2); - } else if (value === 6) { - const string = Decoder.string(r); - if (!string.ok) { - return rt.Err(string.error); + } else if (_5 === 5) { + _40 = Decoder.bytes(r); + if (_40.ok) { + putUsize(out, _40.value.length); + rt.byteVecExtendFromSlice(out, _40.value); + } else { + return _40; } - const s = string.value; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - } else if (value === 7) { - const slice = Decoder.slice(r, rt.u8Div(step, 10) as rt.usize); - if (!slice.ok) { - return rt.Err(slice.error); + } else if (_5 === 6) { + _49 = Decoder.string(r); + if (_49.ok) { + s = _49.value; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); + } else { + return _49; } - const slice2 = slice.value; - rt.byteVecExtendFromSlice(out, slice2); - } else if (value === 8) { - const sub = Decoder.sub(r, rt.u8Div(step, 10) as rt.usize); - if (!sub.ok) { - return rt.Err(sub.error); + } else if (_5 === 7) { + _57 = Decoder.slice(r, rt.u8Div(step, 10) as rt.usize); + if (_57.ok) { + rt.byteVecExtendFromSlice(out, _57.value); + } else { + return _57; } - let sub2: Decoder.Decoder = sub.value; - const arg5 = out; - const varint2 = Decoder.varint(sub2); - if (!varint2.ok) { - return rt.Err(varint2.error); + } else if (_5 === 8) { + _67 = Decoder.sub(r, rt.u8Div(step, 10) as rt.usize); + if (_67.ok) { + sub = _67.value; + _76 = Decoder.varint(sub); + if (_76.ok) { + putU64(out, _76.value); + putUsize(out, Decoder.rest(sub).length); + } else { + return _76; + } + } else { + return _67; } - putU64(arg5, varint2.value); - putUsize(out, Decoder.rest(sub2).length); } else { putUsize(out, Decoder.rest(r).length); } @@ -287,295 +355,418 @@ export function decodeStep(r: Decoder.Decoder, step: rt.u8, out: rt.ByteVec): rt /** Write primitives as a script says, taking each value from the data that follows. */ export function encodeScript(data: Uint8Array, out: rt.ByteVec): void { - const splitFirst = rt.sliceSplitFirst(data); - if (splitFirst === undefined) { - return; - } - const selector = splitFirst[0]; - const data2 = splitFirst[1]; - const splitFirst2 = rt.sliceSplitFirst(data2); - if (splitFirst2 === undefined) { - return; - } - const len = splitFirst2[0]; - const data3 = splitFirst2[1]; - let [script, values] = rt.sliceSplitAt(data3, rt.min(data3.length, len as rt.usize)); - let buf: rt.ByteVec = new rt.ByteVec(); - let w: Encoder.Encoder = Encoder.new(buf, form(selector)); - let prefixes: Prefix.Prefix[] = []; - for (const item of script) { - const step = item; - const [value, rest] = takeU64(values); - values = rest; - let result: rt.Result; - const value2 = rt.u8Rem(step, 10); - if (value2 === 0) { - Encoder.u8(w, rt.u64Low(value) & 0xff); - result = rt.Ok(undefined); - } else if (value2 === 1) { - Encoder.u16(w, rt.u64Low(value) & 0xffff); - result = rt.Ok(undefined); - } else if (value2 === 2) { - Encoder.bool(w, rt.u64And(value, 1) === 1); - result = rt.Ok(undefined); - } else if (value2 === 3) { - result = Encoder.varint(w, value); - } else if (value2 === 4) { - const arg = w; - const value3 = rt.u64Rem(value, 3); - result = Encoder.varintOpt(arg, value3 === 0 ? undefined : value3 === 1 ? value : rt.u64Of(18446744073709551615n)); - } else if (value2 === 5) { - result = Encoder.bytes(w, rt.sliceRange(rt.u64ToBeBytes(value), 0, rt.u8Rem(rt.u8Div(step, 10), 9) as rt.usize)); - } else if (value2 === 6) { - const fromUtf8 = rt.stringFromUtf8(rt.sliceToByteVec(rt.u64ToBeBytes(value))); - if (fromUtf8.ok) { - const s = fromUtf8.value; - result = Encoder.string(w, s); - } else { - result = Encoder.string(w, "not utf-8"); - } - } else if (value2 === 7) { - prefixes.push(rt.u64Rem(value, 2) === 0 ? Encoder.prefixVarint(w) : Encoder.prefixU16(w)); - result = rt.Ok(undefined); - } else if (value2 === 8) { - const pop = prefixes.pop(); - if (pop !== undefined) { - const prefix = pop; - putUsize(out, Encoder.since(w, prefix)); - result = Encoder.fill(w, prefix); - } else { - result = rt.Ok(undefined); - } - } else { - const pop2 = prefixes.pop(); - if (pop2 !== undefined) { - const prefix2 = pop2; - Encoder.discard(w, prefix2); - } - result = rt.Ok(undefined); - } - if (!result.ok) { - const err = result.error; - encodeFailed(out, err); - } - } - while (true) { - const pop3 = prefixes.pop(); - if (pop3 !== undefined) { - const prefix3 = pop3; - const fill = Encoder.fill(w, prefix3); - if (!fill.ok) { - const err2 = fill.error; - encodeFailed(out, err2); + let selector!: rt.u8; + let _5!: [rt.u8, Uint8Array] | undefined; + let len!: rt.u8; + let _9!: [rt.u8, Uint8Array] | undefined; + let values!: Uint8Array; + let _13!: [Uint8Array, Uint8Array]; + let _15!: rt.usize; + let buf!: rt.ByteVec; + let w!: Encoder.Encoder; + let _20!: Form.Form; + let prefixes!: Prefix.Prefix[]; + let iterS!: Uint8Array; + let iterI!: number; + let _24!: rt.u8 | rt.Done; + let step!: rt.u8; + let value!: rt.u64; + let _30!: [rt.u64, Uint8Array]; + let result!: rt.Result; + let _33!: rt.u8; + let _47!: rt.u64 | undefined; + let _48!: rt.u64; + let _51!: Uint8Array; + let _53!: Uint8Array; + let _60!: rt.Result; + let s!: string; + let _68!: string; + let _74!: Prefix.Prefix; + let _79!: Prefix.Prefix | undefined; + let prefix!: Prefix.Prefix; + let _88!: Prefix.Prefix | undefined; + let _98!: Prefix.Prefix | undefined; + let _102!: rt.Result; + _5 = rt.sliceSplitFirst(data); + b0: { + if (_5 !== undefined) { + selector = _5[0]; + _9 = rt.sliceSplitFirst(_5[1]); + if (_9 !== undefined) { + len = _9[0]; + _15 = _9[1].length; + _13 = rt.sliceSplitAt(_9[1], rt.min(_15, len as rt.usize)); + values = _13[1]; + buf = new rt.ByteVec(); + _20 = form(selector); + w = Encoder.new(buf, _20); + prefixes = []; + iterS = _13[0]; + iterI = 0; + while (true) { + _24 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_24 === rt.DONE) { + while (true) { + _98 = prefixes.pop(); + if (_98 !== undefined) { + _102 = Encoder.fill(w, _98); + if (!_102.ok) { + encodeFailed(out, _102.error); + } + } else { + putUsize(out, buf.length); + rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); + break b0; + } + } + } else { + step = _24; + _30 = takeU64(values); + value = _30[0]; + values = _30[1]; + _33 = rt.u8Rem(step, 10); + if (_33 === 0) { + Encoder.u8(w, rt.u64Low(value) & 0xff); + result = rt.Ok(undefined); + } else if (_33 === 1) { + Encoder.u16(w, rt.u64Low(value) & 0xffff); + result = rt.Ok(undefined); + } else if (_33 === 2) { + Encoder.bool(w, rt.u64And(value, 1) === 1); + result = rt.Ok(undefined); + } else if (_33 === 3) { + result = Encoder.varint(w, value); + } else if (_33 === 4) { + _48 = rt.u64Rem(value, 3); + if (_48 === 0) { + _47 = undefined; + } else if (_48 === 1) { + _47 = value; + } else { + _47 = rt.u64Of(18446744073709551615n); + } + result = Encoder.varintOpt(w, _47); + } else if (_33 === 5) { + const part = rt.u8Rem(rt.u8Div(step, 10), 9) as rt.usize; + _53 = rt.u64ToBeBytes(value); + _51 = rt.sliceRange(_53, 0, part); + result = Encoder.bytes(w, _51); + } else if (_33 === 6) { + _60 = rt.stringFromUtf8(rt.sliceToByteVec(rt.u64ToBeBytes(value))); + if (_60.ok) { + s = _60.value; + _68 = s; + result = Encoder.string(w, _68); + } else { + result = Encoder.string(w, "not utf-8"); + } + } else if (_33 === 7) { + if (rt.u64Rem(value, 2) === 0) { + _74 = Encoder.prefixVarint(w); + } else { + _74 = Encoder.prefixU16(w); + } + prefixes.push(_74); + result = rt.Ok(undefined); + } else if (_33 === 8) { + _79 = prefixes.pop(); + if (_79 === undefined) { + result = rt.Ok(undefined); + } else { + prefix = _79; + putUsize(out, Encoder.since(w, prefix)); + result = Encoder.fill(w, prefix); + } + } else { + _88 = prefixes.pop(); + if (_88 !== undefined) { + Encoder.discard(w, _88); + } + result = rt.Ok(undefined); + } + if (!result.ok) { + encodeFailed(out, result.error); + } + } + } } - } else { - break; } } - putUsize(out, buf.length); - rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); } export function zigzag(data: Uint8Array, out: rt.ByteVec): void { - const [value, ] = takeU64(data); - const signed = rt.i64Cast(value); + let value!: rt.u64; + let signed!: rt.i64; + value = takeU64(data)[0]; + signed = rt.i64Cast(value); putU64(out, varint_zigzag(signed)); putU64(out, rt.u64Cast(unzigzag(value))); putU64(out, rt.u64Cast(unzigzag(varint_zigzag(signed)))); } export function sizes(data: Uint8Array, out: rt.ByteVec): void { - const [value, ] = takeU64(data); - for (let selector = 0; selector < 3; selector++) { - const size_ = size(value, form(selector)); - if (size_.ok) { - const size2 = size_.value; - putUsize(out, size2); + let value!: rt.u64; + let iterStart!: rt.u8; + let iterEnd!: rt.u8; + let _9!: rt.u8; + let _13!: rt.Result; + value = takeU64(data)[0]; + iterStart = 0; + iterEnd = 3; + while (true) { + if (!((_9 = iterStart++) < iterEnd)) { + return; } else { - rt.byteVecPush(out, 0xff); + _13 = size(value, form(_9)); + if (_13.ok) { + putUsize(out, _13.value); + } else { + rt.byteVecPush(out, 255); + } } } } /** Decode a `T` from the wire, then encode what came out. */ export function roundtrip$Versions(data: Uint8Array, out: rt.ByteVec): void { - const splitFirst = rt.sliceSplitFirst(data); - if (splitFirst === undefined) { - return; - } - const selector = splitFirst[0]; - const wire = splitFirst[1]; - const form_ = form(selector); - const decodeSlice = Versions.decodeSlice$Decode_Form(wire, form_); - if (decodeSlice.ok) { - const value = decodeSlice.value[0]; - const used = decodeSlice.value[1]; - putUsize(out, used); - let buf: rt.ByteVec = new rt.ByteVec(); - const encode = Versions.encode$Encode_Form(value, Encoder.new(buf, form_), form_); - if (encode.ok) { - rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); + let _5!: [rt.u8, Uint8Array] | undefined; + let form_!: Form.Form; + let _8!: rt.Result<[Versions.Versions, rt.usize], DecodeError.DecodeError>; + let value!: Versions.Versions; + let buf!: rt.ByteVec; + let _14!: rt.Result; + let _17!: Encoder.Encoder; + let err2!: DecodeError.DecodeError; + _5 = rt.sliceSplitFirst(data); + if (_5 !== undefined) { + form_ = form(_5[0]); + _8 = Versions.decodeSlice$Decode_Form(_5[1], form_); + if (_8.ok) { + value = _8.value[0]; + putUsize(out, _8.value[1]); + buf = new rt.ByteVec(); + _17 = Encoder.new(buf, form_); + _14 = Versions.encode$Encode_Form(value, _17, form_); + if (_14.ok) { + rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); + } else { + encodeFailed(out, _14.error); + } } else { - const err = encode.error; - encodeFailed(out, err); + err2 = _8.error; + decodeFailed(out, err2); } - } else { - const err2 = decodeSlice.error; - decodeFailed(out, err2); } } /** [`roundtrip`] for a lite message, size-prefixed at a lite version. */ export function roundtripLite$Group(data: Uint8Array, out: rt.ByteVec): void { - const splitFirst = rt.sliceSplitFirst(data); - if (splitFirst === undefined) { - return; - } - const selector = splitFirst[0]; - const wire = splitFirst[1]; - const version = liteVersion(selector); - const decodeSlice = Group.decodeSlice$Decode_Version(wire, version); - if (decodeSlice.ok) { - const value = decodeSlice.value[0]; - const used = decodeSlice.value[1]; - putUsize(out, used); - let buf: rt.ByteVec = new rt.ByteVec(); - const encode = Group.encode$Encode_Version(value, Encoder.new(buf, Form.from$From_Version(version)), version); - if (encode.ok) { - rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); + let _5!: [rt.u8, Uint8Array] | undefined; + let version!: Version.Version; + let _8!: rt.Result<[Group.Group, rt.usize], DecodeError.DecodeError>; + let value!: Group.Group; + let buf!: rt.ByteVec; + let _14!: rt.Result; + let _17!: Encoder.Encoder; + let _19!: Form.Form; + let err2!: DecodeError.DecodeError; + _5 = rt.sliceSplitFirst(data); + if (_5 !== undefined) { + version = liteVersion(_5[0]); + _8 = Group.decodeSlice$Decode_Version(_5[1], version); + if (_8.ok) { + value = _8.value[0]; + putUsize(out, _8.value[1]); + buf = new rt.ByteVec(); + _19 = Form.from$From_Version(version); + _17 = Encoder.new(buf, _19); + _14 = Group.encode$Encode_Version(value, _17, version); + if (_14.ok) { + rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); + } else { + encodeFailed(out, _14.error); + } } else { - const err = encode.error; - encodeFailed(out, err); + err2 = _8.error; + decodeFailed(out, err2); } - } else { - const err2 = decodeSlice.error; - decodeFailed(out, err2); } } /** [`roundtrip`] for a lite message, size-prefixed at a lite version. */ export function roundtripLite$Probe(data: Uint8Array, out: rt.ByteVec): void { - const splitFirst = rt.sliceSplitFirst(data); - if (splitFirst === undefined) { - return; - } - const selector = splitFirst[0]; - const wire = splitFirst[1]; - const version = liteVersion(selector); - const decodeSlice = Probe.decodeSlice$Decode_Version(wire, version); - if (decodeSlice.ok) { - const value = decodeSlice.value[0]; - const used = decodeSlice.value[1]; - putUsize(out, used); - let buf: rt.ByteVec = new rt.ByteVec(); - const encode = Probe.encode$Encode_Version(value, Encoder.new(buf, Form.from$From_Version(version)), version); - if (encode.ok) { - rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); + let _5!: [rt.u8, Uint8Array] | undefined; + let version!: Version.Version; + let _8!: rt.Result<[Probe.Probe, rt.usize], DecodeError.DecodeError>; + let value!: Probe.Probe; + let buf!: rt.ByteVec; + let _14!: rt.Result; + let _17!: Encoder.Encoder; + let _19!: Form.Form; + let err2!: DecodeError.DecodeError; + _5 = rt.sliceSplitFirst(data); + if (_5 !== undefined) { + version = liteVersion(_5[0]); + _8 = Probe.decodeSlice$Decode_Version(_5[1], version); + if (_8.ok) { + value = _8.value[0]; + putUsize(out, _8.value[1]); + buf = new rt.ByteVec(); + _19 = Form.from$From_Version(version); + _17 = Encoder.new(buf, _19); + _14 = Probe.encode$Encode_Version(value, _17, version); + if (_14.ok) { + rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); + } else { + encodeFailed(out, _14.error); + } } else { - const err = encode.error; - encodeFailed(out, err); + err2 = _8.error; + decodeFailed(out, err2); } - } else { - const err2 = decodeSlice.error; - decodeFailed(out, err2); } } /** Encode messages built from the data, at a lite version. */ export function encodeMessages(data: Uint8Array, out: rt.ByteVec): void { - const splitFirst = rt.sliceSplitFirst(data); - if (splitFirst === undefined) { - return; - } - const selector = splitFirst[0]; - const data2 = splitFirst[1]; - const version = liteVersion(selector); - const [subscribe, data3] = takeU64(data2); - const [sequence, data4] = takeU64(data3); - const [frameStart, data5] = takeU64(data4); - const [bitrate, data6] = takeU64(data5); - const [rtt, ] = takeU64(data6); - const group = { subscribe, sequence, frameStart: rt.u64Rem(frameStart, 4) }; - encodeMessage$Group(group, version, out); - const probe = { bitrate: rt.u64CheckedSub(bitrate, 1), rtt: rt.thenSome(rt.u64Rem(rtt, 3) !== 0, rtt) }; - encodeMessage$Probe(probe, version, out); - const versions = Versions.from$From_Versions([{ _0: subscribe }, { _0: sequence }]); - let buf: rt.ByteVec = new rt.ByteVec(); - const encode = Versions.encode$Encode_Version(versions, Encoder.new(buf, Form.from$From_Version(version)), version); - if (encode.ok) { - rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); - } else { - const err = encode.error; - encodeFailed(out, err); + let _5!: [rt.u8, Uint8Array] | undefined; + let version!: Version.Version; + let subscribe!: rt.u64; + let _10!: [rt.u64, Uint8Array]; + let sequence!: rt.u64; + let _13!: [rt.u64, Uint8Array]; + let frameStart!: rt.u64; + let _16!: [rt.u64, Uint8Array]; + let bitrate!: rt.u64; + let _19!: [rt.u64, Uint8Array]; + let rtt!: rt.u64; + let versions!: Versions.Versions; + let buf!: rt.ByteVec; + let _40!: rt.Result; + let _43!: Encoder.Encoder; + let _45!: Form.Form; + _5 = rt.sliceSplitFirst(data); + if (_5 !== undefined) { + version = liteVersion(_5[0]); + _10 = takeU64(_5[1]); + subscribe = _10[0]; + _13 = takeU64(_10[1]); + sequence = _13[0]; + _16 = takeU64(_13[1]); + frameStart = _16[0]; + _19 = takeU64(_16[1]); + bitrate = _19[0]; + rtt = takeU64(_19[1])[0]; + encodeMessage$Group({ subscribe, sequence, frameStart: rt.u64Rem(frameStart, 4) }, version, out); + encodeMessage$Probe({ bitrate: rt.u64CheckedSub(bitrate, 1), rtt: rt.thenSome(rt.u64Rem(rtt, 3) !== 0, rtt) }, version, out); + versions = Versions.from$From_Versions([{ _0: subscribe }, { _0: sequence }]); + buf = new rt.ByteVec(); + _45 = Form.from$From_Version(version); + _43 = Encoder.new(buf, _45); + _40 = Versions.encode$Encode_Version(versions, _43, version); + if (_40.ok) { + rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); + } else { + encodeFailed(out, _40.error); + } } } export function encodeMessage$Group(msg: Group.Group, version: Version.Version, out: rt.ByteVec): void { - let buf: rt.ByteVec = new rt.ByteVec(); - let w: Encoder.Encoder = Encoder.new(buf, Form.from$From_Version(version)); - const encode = Group.encode$Encode_Version(msg, w, version); - if (encode.ok) { + let buf!: rt.ByteVec; + let w!: Encoder.Encoder; + let _7!: Form.Form; + let _8!: rt.Result; + buf = new rt.ByteVec(); + _7 = Form.from$From_Version(version); + w = Encoder.new(buf, _7); + _8 = Group.encode$Encode_Version(msg, w, version); + if (_8.ok) { rt.byteVecPush(out, w.control !== undefined ? 1 : 0); putUsize(out, buf.length); rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); } else { - const err = encode.error; - encodeFailed(out, err); + encodeFailed(out, _8.error); } } export function encodeMessage$Probe(msg: Probe.Probe, version: Version.Version, out: rt.ByteVec): void { - let buf: rt.ByteVec = new rt.ByteVec(); - let w: Encoder.Encoder = Encoder.new(buf, Form.from$From_Version(version)); - const encode = Probe.encode$Encode_Version(msg, w, version); - if (encode.ok) { + let buf!: rt.ByteVec; + let w!: Encoder.Encoder; + let _7!: Form.Form; + let _8!: rt.Result; + buf = new rt.ByteVec(); + _7 = Form.from$From_Version(version); + w = Encoder.new(buf, _7); + _8 = Probe.encode$Encode_Version(msg, w, version); + if (_8.ok) { rt.byteVecPush(out, w.control !== undefined ? 1 : 0); putUsize(out, buf.length); rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); } else { - const err = encode.error; - encodeFailed(out, err); + encodeFailed(out, _8.error); } } /** Each error the codec can return, built from the data, as callers see it. */ export function errors(data: Uint8Array, out: rt.ByteVec): void { - const splitFirst = rt.sliceSplitFirst(data); - if (splitFirst === undefined) { - return; - } - const selector = splitFirst[0]; - const data2 = splitFirst[1]; - const [value, ] = takeU64(data2); - let err: DecodeError.DecodeError; - const value2 = rt.u8Rem(selector, 8); - if (value2 === 0) { - err = { tag: "InvalidMessage", _0: value }; - } else if (value2 === 1) { - err = { tag: "MessageTooLarge", size: rt.u64Low(value), max: rt.u64Low(rt.u64Shr(value, 32)) }; - } else if (value2 === 2) { - err = { tag: "Session", _0: { tag: "App", _0: rt.u64Low(value) & 0xffff } as SessionError.SessionError }; - } else if (value2 === 3) { - err = { tag: "Session", _0: { tag: "ProtocolViolation" } as SessionError.SessionError }; - } else if (value2 === 4) { - const fromUtf8 = rt.stringFromUtf8(rt.sliceToByteVec(data2)); - if (fromUtf8.ok) { - err = { tag: "Missing" }; - } else { - const e = fromUtf8.error; - err = { tag: "InvalidString", _0: e }; + let selector!: rt.u8; + let _5!: [rt.u8, Uint8Array] | undefined; + let value!: rt.u64; + let err!: DecodeError.DecodeError; + let _10!: rt.u8; + let _20!: rt.Result; + let _26!: string; + let _28!: string; + let args2!: rt.Fmt[]; + let _38!: string; + let args4!: rt.Fmt[]; + let _47!: string; + let args6!: rt.Fmt[]; + _5 = rt.sliceSplitFirst(data); + b0: { + if (_5 !== undefined) { + selector = _5[0]; + value = takeU64(_5[1])[0]; + _10 = rt.u8Rem(selector, 8); + if (_10 === 0) { + err = { tag: "InvalidMessage", _0: value } as DecodeError.DecodeError; + } else if (_10 === 1) { + err = { tag: "MessageTooLarge", size: rt.u64Low(value), max: rt.u64Low(rt.u64Shr(value, 32)) } as DecodeError.DecodeError; + } else if (_10 === 2) { + err = { tag: "Session", _0: { tag: "App", _0: rt.u64Low(value) & 0xffff } as SessionError.SessionError } as DecodeError.DecodeError; + } else if (_10 === 3) { + err = { tag: "Session", _0: { tag: "ProtocolViolation" } as SessionError.SessionError } as DecodeError.DecodeError; + } else if (_10 === 4) { + _20 = rt.stringFromUtf8(rt.sliceToByteVec(_5[1])); + if (_20.ok) { + err = { tag: "Missing" } as DecodeError.DecodeError; + } else { + err = { tag: "InvalidString", _0: _20.error } as DecodeError.DecodeError; + } + } else if (_10 === 5) { + err = DecodeError.from$From_BoundsExceeded({}); + } else if (_10 === 6) { + const arg = {}; + _26 = rt.fmtToString((f: rt.Formatter) => BoundsExceeded.fmt$Display(arg, f)); + const arg2 = ([{}] as [BoundsExceeded.BoundsExceeded])[0]; + args2 = [(f: rt.Formatter) => BoundsExceeded.fmt$Debug(arg2, f)]; + _28 = rt.fmtFormat([args2[0], " ", rt.fmtSpec({ alternate: true }, args2[0])]); + putText(out, _26, _28); + break b0; + } else { + err = { tag: "MalformedAuthToken" } as DecodeError.DecodeError; + } + const arg3 = ([err] as [DecodeError.DecodeError])[0]; + args4 = [(f: rt.Formatter) => DecodeError.fmt$Display(arg3, f)]; + _38 = rt.fmtFormat([args4[0], " ", rt.fmtSpec({ align: ">", width: 30 }, args4[0]), "|"]); + const arg4 = ([err] as [DecodeError.DecodeError])[0]; + args6 = [(f: rt.Formatter) => DecodeError.fmt$Debug(arg4, f)]; + _47 = rt.fmtFormat([rt.fmtSpec({ alternate: true }, args6[0])]); + putText(out, _38, _47); + decodeFailed(out, err); } - } else if (value2 === 5) { - err = DecodeError.from$From_BoundsExceeded({}); - } else if (value2 === 6) { - const bounds = {}; - putText(out, rt.fmtToString((f: rt.Formatter) => BoundsExceeded.fmt$Display(bounds, f)), rt.fmtFormat([(f: rt.Formatter) => BoundsExceeded.fmt$Debug(bounds, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => BoundsExceeded.fmt$Debug(bounds, f))])); - return; - } else { - err = { tag: "MalformedAuthToken" }; } - putText(out, rt.fmtFormat([(f: rt.Formatter) => DecodeError.fmt$Display(err, f), " ", rt.fmtSpec({ align: ">", width: 30 }, (f: rt.Formatter) => DecodeError.fmt$Display(err, f)), "|"]), rt.fmtFormat([rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => DecodeError.fmt$Debug(err, f))])); - decodeFailed(out, err); } //# sourceMappingURL=harness.ts.map diff --git a/ts/fixtures/codec/expected/lib.SessionError.ts b/ts/fixtures/codec/expected/lib.SessionError.ts index 4d33f5ae5..be9bbe845 100644 --- a/ts/fixtures/codec/expected/lib.SessionError.ts +++ b/ts/fixtures/codec/expected/lib.SessionError.ts @@ -3,22 +3,25 @@ import * as rt from "./rt.ts"; export function fmt$Display(self: SessionError, __formatter: rt.Formatter): rt.Result { + let args2!: rt.Fmt[]; if (self.tag === "ProtocolViolation") { return rt.fmtWriteStr(__formatter, "protocol violation"); } else { - const _0 = self._0; - const value = [_0] as [rt.u16]; - const __display0 = value[0]; - return rt.fmtWriteFmt(__formatter, ["app code=", (f: rt.Formatter) => rt.u16Display(__display0, f)]); + const arg = ([([self._0] as [rt.u16])[0]] as [rt.u16])[0]; + args2 = [(f: rt.Formatter) => rt.u16Display(arg, f)]; + return rt.fmtWriteFmt(__formatter, ["app code=", args2[0]]); } } export function fmt$Debug(self: SessionError, f: rt.Formatter): rt.Result { + let _6!: string; + let _7!: rt.Fmt; if (self.tag === "ProtocolViolation") { return rt.fmtWriteStr(f, "ProtocolViolation"); } else { - const __self0 = self._0; - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, "App"), (f: rt.Formatter) => rt.u16Display(__self0, f))); + _6 = "App"; + _7 = (f: rt.Formatter) => rt.u16Display(self._0, f); + return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _6), _7)); } } diff --git a/ts/fixtures/codec/expected/lite/group.Group.ts b/ts/fixtures/codec/expected/lite/group.Group.ts index 9c9c525f9..7efaf484d 100644 --- a/ts/fixtures/codec/expected/lite/group.Group.ts +++ b/ts/fixtures/codec/expected/lite/group.Group.ts @@ -5,19 +5,30 @@ import type * as DecodeError from "../coding/decode.DecodeError.ts"; import * as Decoder from "../coding/decode.Decoder.ts"; import type * as EncodeError from "../coding/encode.EncodeError.ts"; import * as Encoder from "../coding/encode.Encoder.ts"; +import type * as Prefix from "../coding/encode.Prefix.ts"; import * as Form from "../coding/varint.Form.ts"; import { decodeWith$Group_decode_closure0 } from "../lite/message.ts"; import * as Version from "../lite/version.Version.ts"; /** Decode the value from the front of `buf`, returning it and the bytes it took. */ export function decodeSlice$Decode_Version(buf: Uint8Array, version: Version.Version): rt.Result<[Group, rt.usize], DecodeError.DecodeError> { - let r: Decoder.Decoder = Decoder.new(buf, Form.from$From_Version(version)); - const decode = decode$Decode_Version(r, version); - if (!decode.ok) { - return rt.Err(decode.error); + let _0!: rt.Result<[Group, rt.usize], DecodeError.DecodeError>; + let r!: Decoder.Decoder; + let value!: Group; + let _6!: rt.Result; + let val!: Group; + let _13!: Group; + r = Decoder.new(buf, Form.from$From_Version(version)); + _6 = decode$Decode_Version(r, version); + if (_6.ok) { + val = _6.value; + value = val; + _13 = value; + _0 = rt.Ok([_13, rt.usizeSub(buf.length, Decoder.remaining(r))] as [Group, rt.usize]); + return _0; + } else { + return _6; } - const value = decode.value; - return rt.Ok([value, rt.usizeSub(buf.length, Decoder.remaining(r))]); } export interface Group { @@ -28,67 +39,88 @@ export interface Group { /** Decode a message body (without size prefix). */ export function decodeMsg$Message(r: Decoder.Decoder, version: Version.Version): rt.Result { - const varint = Decoder.varint(r); - if (!varint.ok) { - return rt.Err(varint.error); - } - const subscribe = varint.value; - const varint2 = Decoder.varint(r); - if (!varint2.ok) { - return rt.Err(varint2.error); - } - const sequence = varint2.value; - let frameStart: rt.u64; - if (Version.hasFrameBounds(version)) { - const varint3 = Decoder.varint(r); - if (!varint3.ok) { - return rt.Err(varint3.error); + let _3!: rt.Result; + let subscribe!: rt.u64; + let _8!: rt.Result; + let sequence!: rt.u64; + let frameStart!: rt.u64; + let _15!: rt.Result; + _3 = Decoder.varint(r); + if (_3.ok) { + subscribe = _3.value; + _8 = Decoder.varint(r); + if (_8.ok) { + sequence = _8.value; + if (!Version.hasFrameBounds(version)) { + frameStart = 0; + } else { + _15 = Decoder.varint(r); + if (_15.ok) { + frameStart = _15.value; + } else { + return _15; + } + } + return rt.Ok({ subscribe, sequence, frameStart }); + } else { + return _8; } - frameStart = varint3.value; } else { - frameStart = 0; + return _3; } - return rt.Ok({ subscribe, sequence, frameStart }); } /** Encode this message body (without size prefix). */ export function encodeMsg$Message(self: Group, w: Encoder.Encoder, version: Version.Version): rt.Result { - const varint = Encoder.varint(w, self.subscribe); - if (!varint.ok) { - return rt.Err(varint.error); - } - const varint2 = Encoder.varint(w, self.sequence); - if (!varint2.ok) { - return rt.Err(varint2.error); - } - if (Version.hasFrameBounds(version)) { - const varint3 = Encoder.varint(w, self.frameStart); - if (!varint3.ok) { - return rt.Err(varint3.error); + let _4!: rt.Result; + let _9!: rt.Result; + let _15!: rt.Result; + _4 = Encoder.varint(w, self.subscribe); + if (_4.ok) { + _9 = Encoder.varint(w, self.sequence); + if (_9.ok) { + if (!Version.hasFrameBounds(version)) { + if (self.frameStart !== 0) { + return rt.Err("Version" as EncodeError.EncodeError); + } + } else { + _15 = Encoder.varint(w, self.frameStart); + if (!_15.ok) { + return _15; + } + } + return rt.Ok(undefined); + } else { + return _9; } - } else if (self.frameStart !== 0) { - return rt.Err("Version"); + } else { + return _4; } - return rt.Ok(undefined); } /** Encode the value to the given encoder, which may hold partial output on error. */ export function encode$Encode_Version(self: Group, w: Encoder.Encoder, version: Version.Version): rt.Result { - const prefix = Encoder.prefixVarint(w); - const encodeMsg = encodeMsg$Message(self, w, version); - if (!encodeMsg.ok) { - return rt.Err(encodeMsg.error); - } - if (Encoder.since(w, prefix) > 65535) { - Encoder.discard(w, prefix); - return rt.Err("TooLarge"); - } - const fill = Encoder.fill(w, prefix); - if (!fill.ok) { - return rt.Err(fill.error); + let prefix!: Prefix.Prefix; + let _39!: rt.Result; + let _49!: rt.Result; + prefix = Encoder.prefixVarint(w); + _39 = encodeMsg$Message(self, w, version); + if (_39.ok) { + if (!(Encoder.since(w, prefix) > 65535)) { + _49 = Encoder.fill(w, prefix); + if (_49.ok) { + w.control = undefined; + return rt.Ok(undefined); + } else { + return _49; + } + } else { + Encoder.discard(w, prefix); + return rt.Err("TooLarge" as EncodeError.EncodeError); + } + } else { + return _39; } - w.control = undefined; - return rt.Ok(undefined); } /** Decode the value from the front of the decoder. */ diff --git a/ts/fixtures/codec/expected/lite/message.ts b/ts/fixtures/codec/expected/lite/message.ts index b3f545b1a..3dd51d249 100644 --- a/ts/fixtures/codec/expected/lite/message.ts +++ b/ts/fixtures/codec/expected/lite/message.ts @@ -9,20 +9,21 @@ import type * as Control from "../stats.Control.ts"; /** Read a lite message's varint size prefix, refusing one past `max`. */ export function decodeSize(r: Decoder.Decoder, max: rt.usize): rt.Result { - const varint = Decoder.varint(r); - if (!varint.ok) { - return rt.Err(varint.error); - } - const size = varint.value; - const tryFrom = rt.usizeTryFrom(size); - arms: { - if (tryFrom.ok) { - const size2 = tryFrom.value; - if (size2 <= max) { - return rt.Ok(size2); + let _3!: rt.Result; + let size!: rt.u64; + let _8!: rt.Result; + _3 = Decoder.varint(r); + if (_3.ok) { + size = _3.value; + _8 = rt.usizeTryFrom(size); + if (_8.ok) { + if (_8.value <= max) { + return rt.Ok(_8.value); } } - return rt.Err({ tag: "MessageTooLarge", size: rt.resultUnwrapOr(rt.usizeTryFrom(size), 4294967295), max }); + return rt.Err({ tag: "MessageTooLarge", size: rt.resultUnwrapOr(rt.usizeTryFrom(size), 4294967295), max } as DecodeError.DecodeError); + } else { + return _3; } } @@ -31,27 +32,32 @@ export function decodeSize(r: Decoder.Decoder, max: rt.usize): rt.Result rt.Result): rt.Result { - const decodeSize_ = decodeSize(r, 65535); - if (!decodeSize_.ok) { - return rt.Err(decodeSize_.error); - } - const size = decodeSize_.value; - const sub = Decoder.sub(r, size); - if (!sub.ok) { - return rt.Err(sub.error); - } - let body: Decoder.Decoder = sub.value; - const result = rt.resultAndThen(rt.resultMapErr(decode(body), DecodeError.complete), (msg: Group.Group): rt.Result => { - if (Decoder.isEmpty(body)) { - return rt.Ok(msg); + let _3!: rt.Result; + let body!: Decoder.Decoder; + let _9!: rt.Result; + let result!: rt.Result; + _3 = decodeSize(r, 65535); + if (_3.ok) { + _9 = Decoder.sub(r, _3.value); + if (_9.ok) { + body = _9.value; + result = rt.resultAndThen(rt.resultMapErr(decode(body), DecodeError.complete), (msg: Group.Group): rt.Result => { + if (!Decoder.isEmpty(body)) { + return rt.Err({ tag: "Long" } as DecodeError.DecodeError); + } else { + return rt.Ok(msg); + } + }); + if (result.ok) { + r.control = undefined; + } + return result; } else { - return rt.Err({ tag: "Long" }); + return _9; } - }); - if (result.ok) { - r.control = undefined; + } else { + return _3; } - return result; } /** @@ -59,27 +65,32 @@ export function decodeWith$Group_decode_closure0(r: Decoder.Decoder, decode: (a0 * [`Message::decode_msg`], for a body whose bounds come from the session. */ export function decodeWith$Probe_decode_closure0(r: Decoder.Decoder, decode: (a0: Decoder.Decoder) => rt.Result): rt.Result { - const decodeSize_ = decodeSize(r, 65535); - if (!decodeSize_.ok) { - return rt.Err(decodeSize_.error); - } - const size = decodeSize_.value; - const sub = Decoder.sub(r, size); - if (!sub.ok) { - return rt.Err(sub.error); - } - let body: Decoder.Decoder = sub.value; - const result = rt.resultAndThen(rt.resultMapErr(decode(body), DecodeError.complete), (msg: Probe.Probe): rt.Result => { - if (Decoder.isEmpty(body)) { - return rt.Ok(msg); + let _3!: rt.Result; + let body!: Decoder.Decoder; + let _9!: rt.Result; + let result!: rt.Result; + _3 = decodeSize(r, 65535); + if (_3.ok) { + _9 = Decoder.sub(r, _3.value); + if (_9.ok) { + body = _9.value; + result = rt.resultAndThen(rt.resultMapErr(decode(body), DecodeError.complete), (msg: Probe.Probe): rt.Result => { + if (!Decoder.isEmpty(body)) { + return rt.Err({ tag: "Long" } as DecodeError.DecodeError); + } else { + return rt.Ok(msg); + } + }); + if (result.ok) { + r.control = "Probe" as Control.Control; + } + return result; } else { - return rt.Err({ tag: "Long" }); + return _9; } - }); - if (result.ok) { - r.control = "Probe" as Control.Control; + } else { + return _3; } - return result; } //# sourceMappingURL=message.ts.map diff --git a/ts/fixtures/codec/expected/lite/probe.Probe.ts b/ts/fixtures/codec/expected/lite/probe.Probe.ts index 4ba96d851..304a8da52 100644 --- a/ts/fixtures/codec/expected/lite/probe.Probe.ts +++ b/ts/fixtures/codec/expected/lite/probe.Probe.ts @@ -5,6 +5,7 @@ import type * as DecodeError from "../coding/decode.DecodeError.ts"; import * as Decoder from "../coding/decode.Decoder.ts"; import type * as EncodeError from "../coding/encode.EncodeError.ts"; import * as Encoder from "../coding/encode.Encoder.ts"; +import type * as Prefix from "../coding/encode.Prefix.ts"; import * as Form from "../coding/varint.Form.ts"; import { decodeWith$Probe_decode_closure0 } from "../lite/message.ts"; import * as Version from "../lite/version.Version.ts"; @@ -12,32 +13,48 @@ import type * as Control from "../stats.Control.ts"; /** Decode the value from the front of `buf`, returning it and the bytes it took. */ export function decodeSlice$Decode_Version(buf: Uint8Array, version: Version.Version): rt.Result<[Probe, rt.usize], DecodeError.DecodeError> { - let r: Decoder.Decoder = Decoder.new(buf, Form.from$From_Version(version)); - const decode = decode$Decode_Version(r, version); - if (!decode.ok) { - return rt.Err(decode.error); + let _0!: rt.Result<[Probe, rt.usize], DecodeError.DecodeError>; + let r!: Decoder.Decoder; + let value!: Probe; + let _6!: rt.Result; + let val!: Probe; + let _13!: Probe; + r = Decoder.new(buf, Form.from$From_Version(version)); + _6 = decode$Decode_Version(r, version); + if (_6.ok) { + val = _6.value; + value = val; + _13 = value; + _0 = rt.Ok([_13, rt.usizeSub(buf.length, Decoder.remaining(r))] as [Probe, rt.usize]); + return _0; + } else { + return _6; } - const value = decode.value; - return rt.Ok([value, rt.usizeSub(buf.length, Decoder.remaining(r))]); } /** Encode the value to the given encoder, which may hold partial output on error. */ export function encode$Encode_Version(self: Probe, w: Encoder.Encoder, version: Version.Version): rt.Result { - const prefix = Encoder.prefixVarint(w); - const encodeMsg = encodeMsg$Message(self, w, version); - if (!encodeMsg.ok) { - return rt.Err(encodeMsg.error); - } - if (Encoder.since(w, prefix) > 65535) { - Encoder.discard(w, prefix); - return rt.Err("TooLarge"); - } - const fill = Encoder.fill(w, prefix); - if (!fill.ok) { - return rt.Err(fill.error); + let prefix!: Prefix.Prefix; + let _39!: rt.Result; + let _49!: rt.Result; + prefix = Encoder.prefixVarint(w); + _39 = encodeMsg$Message(self, w, version); + if (_39.ok) { + if (!(Encoder.since(w, prefix) > 65535)) { + _49 = Encoder.fill(w, prefix); + if (_49.ok) { + w.control = "Probe" as Control.Control; + return rt.Ok(undefined); + } else { + return _49; + } + } else { + Encoder.discard(w, prefix); + return rt.Err("TooLarge" as EncodeError.EncodeError); + } + } else { + return _39; } - w.control = "Probe" as Control.Control; - return rt.Ok(undefined); } /** Decode the value from the front of the decoder. */ @@ -60,60 +77,69 @@ export interface Probe { /** Decode a message body (without size prefix). */ export function decodeMsg$Message(r: Decoder.Decoder, version: Version.Version): rt.Result { + let bitrate!: rt.u64 | undefined; + let _6!: rt.Result; + let val!: rt.u64; + let rtt!: rt.u64 | undefined; + let _13!: rt.Result; + let val2!: rt.u64; if (version === "Lite01" || version === "Lite02") { - return rt.Err({ tag: "Version" }); - } - let bitrate: rt.u64 | undefined; - const varint = Decoder.varint(r); - if (!varint.ok) { - return rt.Err(varint.error); - } - if (varint.value === 0) { - bitrate = undefined; + return rt.Err({ tag: "Version" } as DecodeError.DecodeError); } else { - const v = varint.value; - bitrate = v; - } - let rtt: rt.u64 | undefined; - if (!Version.hasProbeRtt(version)) { - rtt = undefined; - } else { - const varint2 = Decoder.varint(r); - if (!varint2.ok) { - return rt.Err(varint2.error); - } - if (varint2.value === 0) { - rtt = undefined; + _6 = Decoder.varint(r); + if (_6.ok) { + val = _6.value; + if (val === 0) { + bitrate = undefined; + } else { + bitrate = val; + } + if (!Version.hasProbeRtt(version)) { + rtt = undefined; + } else { + _13 = Decoder.varint(r); + if (_13.ok) { + val2 = _13.value; + if (val2 === 0) { + rtt = undefined; + } else { + rtt = val2; + } + } else { + return _13; + } + } + return rt.Ok({ bitrate, rtt }); } else { - const v2 = varint2.value; - rtt = v2; + return _6; } } - return rt.Ok({ bitrate, rtt }); } /** Encode this message body (without size prefix). */ export function encodeMsg$Message(self: Probe, w: Encoder.Encoder, version: Version.Version): rt.Result { + let _9!: rt.Result; + let _17!: rt.Result; if (version === "Lite01" || version === "Lite02") { - return rt.Err("Version"); - } - const wire = rt.optionUnwrapOr(rt.optionMap(self.bitrate, (v: rt.u64): rt.u64 => { - return rt.u64Max(v, 1); - }), 0); - const varint = Encoder.varint(w, wire); - if (!varint.ok) { - return rt.Err(varint.error); - } - if (Version.hasProbeRtt(version)) { - const wire2 = rt.optionUnwrapOr(rt.optionMap(self.rtt, (v2: rt.u64): rt.u64 => { - return rt.u64Max(v2, 1); - }), 0); - const varint2 = Encoder.varint(w, wire2); - if (!varint2.ok) { - return rt.Err(varint2.error); + return rt.Err("Version" as EncodeError.EncodeError); + } else { + _9 = Encoder.varint(w, rt.optionUnwrapOr(rt.optionMap(self.bitrate, (v: rt.u64): rt.u64 => { + return rt.u64Max(v, 1); + }), 0)); + if (_9.ok) { + if (Version.hasProbeRtt(version)) { + _17 = Encoder.varint(w, rt.optionUnwrapOr(rt.optionMap(self.rtt, (v2: rt.u64): rt.u64 => { + return rt.u64Max(v2, 1); + }), 0)); + if (!_17.ok) { + return _17; + } + } + return rt.Ok(undefined); + } else { + return _9; } } - return rt.Ok(undefined); } //# sourceMappingURL=probe.Probe.ts.map diff --git a/ts/fixtures/codec/expected/lite/version.Version.ts b/ts/fixtures/codec/expected/lite/version.Version.ts index a3931888d..ca2caf859 100644 --- a/ts/fixtures/codec/expected/lite/version.Version.ts +++ b/ts/fixtures/codec/expected/lite/version.Version.ts @@ -9,7 +9,13 @@ export type Version = "Lite01" | "Lite02" | "Lite03" | "Lite04" | "Lite05" | "Li * there and must not be sent. */ export function hasProbeRtt(self: Version): boolean { - return !(self === "Lite01" || self === "Lite02" || self === "Lite03"); + let _2!: boolean; + if (self === "Lite01" || self === "Lite02" || self === "Lite03") { + _2 = true; + } else { + _2 = false; + } + return !_2; } /** @@ -21,7 +27,13 @@ export function hasProbeRtt(self: Version): boolean { * next group before it can resume. */ export function hasFrameBounds(self: Version): boolean { - return !(self === "Lite01" || self === "Lite02" || self === "Lite03" || self === "Lite04" || self === "Lite05"); + let _2!: boolean; + if (self === "Lite01" || self === "Lite02" || self === "Lite03" || self === "Lite04" || self === "Lite05") { + _2 = true; + } else { + _2 = false; + } + return !_2; } //# sourceMappingURL=version.Version.ts.map diff --git a/ts/fixtures/lang/expected/collections.Clash.ts b/ts/fixtures/lang/expected/collections.Clash.ts index 3e678f0b8..992bb172f 100644 --- a/ts/fixtures/lang/expected/collections.Clash.ts +++ b/ts/fixtures/lang/expected/collections.Clash.ts @@ -11,7 +11,7 @@ export interface Clash { _0: rt.u8; } -export function hash$Hash_DefaultHasher(_self: Clash, _: rt.Hasher): void { +export function hash$Hash_DefaultHasher(_self: Clash, _2: rt.Hasher): void { } //# sourceMappingURL=collections.Clash.ts.map diff --git a/ts/fixtures/lang/expected/collections.Dir.ts b/ts/fixtures/lang/expected/collections.Dir.ts index a5ece0b34..f37b833be 100644 --- a/ts/fixtures/lang/expected/collections.Dir.ts +++ b/ts/fixtures/lang/expected/collections.Dir.ts @@ -9,7 +9,13 @@ import * as rt from "./rt.ts"; export type Dir = "Up" | "Top" | "Down"; export function rising(self: Dir): boolean { - return self !== "Down"; + let _2!: boolean; + if (self === "Down") { + _2 = true; + } else { + _2 = false; + } + return !_2; } export function eq$PartialEq(self: Dir, other: Dir): boolean { diff --git a/ts/fixtures/lang/expected/collections.Fussy.ts b/ts/fixtures/lang/expected/collections.Fussy.ts index 83b31e017..42be78ffd 100644 --- a/ts/fixtures/lang/expected/collections.Fussy.ts +++ b/ts/fixtures/lang/expected/collections.Fussy.ts @@ -12,10 +12,14 @@ export interface Fussy { } export function clone$Clone(self: Fussy): Fussy { - if (rt.u8Rem(self._0, 7) === 0) { - rt.panicFmt(["cloning ", (f: rt.Formatter) => rt.u8Display(self._0, f)]); + let args2!: rt.Fmt[]; + if (!(rt.u8Rem(self._0, 7) === 0)) { + return { _0: self._0 }; + } else { + const arg = ([self._0] as [rt.u8])[0]; + args2 = [(f: rt.Formatter) => rt.u8Display(arg, f)]; + rt.panicFmt(["cloning ", args2[0]]); } - return { _0: self._0 }; } //# sourceMappingURL=collections.Fussy.ts.map diff --git a/ts/fixtures/lang/expected/collections.Nibble.ts b/ts/fixtures/lang/expected/collections.Nibble.ts index 7e02cf404..58dcc18a9 100644 --- a/ts/fixtures/lang/expected/collections.Nibble.ts +++ b/ts/fixtures/lang/expected/collections.Nibble.ts @@ -11,15 +11,15 @@ export interface Nibble { } export function eq$PartialEq(self: Nibble, other: Nibble): boolean { - return (self._0 & 0xf) === (other._0 & 0xf); + return (self._0 & 15) === (other._0 & 15); } export function hash$Hash_DefaultHasher(self: Nibble, state: rt.Hasher): void { - rt.hashInt(self._0 & 0xf, state); + rt.hashInt(self._0 & 15, state); } export function cmp$Ord(self: Nibble, other: Nibble): rt.Ordering { - return rt.cmp(other._0 & 0xf, self._0 & 0xf); + return rt.cmp(other._0 & 15, self._0 & 15); } //# sourceMappingURL=collections.Nibble.ts.map diff --git a/ts/fixtures/lang/expected/collections.Pair.ts b/ts/fixtures/lang/expected/collections.Pair.ts index 371b9cb1f..1cdfb7c1e 100644 --- a/ts/fixtures/lang/expected/collections.Pair.ts +++ b/ts/fixtures/lang/expected/collections.Pair.ts @@ -3,7 +3,11 @@ import * as rt from "./rt.ts"; export function eq$PartialEq(self: Pair, other: Pair): boolean { - return self.a === other.a && self.b === other.b; + if (!(self.a === other.a)) { + return false; + } else { + return self.b === other.b; + } } export function hash$Hash_DefaultHasher(self: Pair, state: rt.Hasher): void { @@ -12,12 +16,12 @@ export function hash$Hash_DefaultHasher(self: Pair, state: rt.Hasher): void { } export function cmp$Ord(self: Pair, other: Pair): rt.Ordering { - const cmp = rt.cmp(self.a, other.a); + let cmp!: rt.Ordering; + cmp = rt.cmp(self.a, other.a); if (cmp === 0) { return rt.cmp(self.b, other.b); } else { - const cmp2 = cmp; - return cmp2; + return cmp; } } diff --git a/ts/fixtures/lang/expected/collections.Rank.ts b/ts/fixtures/lang/expected/collections.Rank.ts index e74a79caa..9291638f2 100644 --- a/ts/fixtures/lang/expected/collections.Rank.ts +++ b/ts/fixtures/lang/expected/collections.Rank.ts @@ -3,62 +3,53 @@ import * as rt from "./rt.ts"; export function eq$PartialEq(self: Rank, other: Rank): boolean { - let cond: boolean = { Low: 0, Mid: 1, High: 2 }[self.tag] === { Low: 0, Mid: 1, High: 2 }[other.tag]; - if (cond) { - let value: boolean; - const value2 = [self, other] as [Rank, Rank]; - if (value2[0].tag === "Mid" && value2[1].tag === "Mid") { - const __self0 = value2[0]._0; - const __arg10 = value2[1]._0; - value = __self0 === __arg10; - } else if (value2[0].tag === "High" && value2[1].tag === "High") { - const __self02 = value2[0].x; - const __self1 = value2[0].y; - const __arg102 = value2[1].x; - const __arg11 = value2[1].y; - value = __self02 === __arg102 && __self1 === __arg11; - } else { - value = true; + if (!({ Low: 0, Mid: 1, High: 2 }[self.tag] === { Low: 0, Mid: 1, High: 2 }[other.tag])) { + return false; + } else { + if (self.tag === "Mid") { + if (other.tag === "Mid") { + return self._0 === other._0; + } + } else if (self.tag === "High") { + if (other.tag === "High") { + if (!((self.x === other.x))) { + return false; + } else { + return self.y === other.y; + } + } } - cond = value; + return true; } - return cond; } export function hash$Hash_DefaultHasher(self: Rank, state: rt.Hasher): void { rt.hashInt({ Low: 0, Mid: 1, High: 2 }[self.tag], state); if (self.tag === "Mid") { - const __self0 = self._0; - rt.hashInt(__self0, state); + rt.hashInt(self._0, state); } else if (self.tag === "High") { - const __self02 = self.x; - const __self1 = self.y; - rt.hashInt(__self02, state); - rt.hashInt(__self1, state); + rt.hashInt(self.x, state); + rt.hashInt(self.y, state); } } export function cmp$Ord(self: Rank, other: Rank): rt.Ordering { - const value = [self, other] as [Rank, Rank]; - if (value[0].tag === "Mid" && value[1].tag === "Mid") { - const __self0 = value[0]._0; - const __arg10 = value[1]._0; - return rt.cmp(__self0, __arg10); - } else if (value[0].tag === "High" && value[1].tag === "High") { - const __self02 = value[0].x; - const __self1 = value[0].y; - const __arg102 = value[1].x; - const __arg11 = value[1].y; - const cmp = rt.cmp(__self02, __arg102); - if (cmp === 0) { - return rt.cmp(__self1, __arg11); - } else { - const cmp2 = cmp; - return cmp2; + let cmp!: rt.Ordering; + if (self.tag === "Mid") { + if (other.tag === "Mid") { + return rt.cmp(self._0, other._0); + } + } else if (self.tag === "High") { + if (other.tag === "High") { + cmp = rt.cmp(self.x, other.x); + if (cmp === 0) { + return rt.cmp(self.y, other.y); + } else { + return cmp; + } } - } else { - return rt.cmp({ Low: 0, Mid: 1, High: 2 }[self.tag], { Low: 0, Mid: 1, High: 2 }[other.tag]); } + return rt.cmp({ Low: 0, Mid: 1, High: 2 }[self.tag], { Low: 0, Mid: 1, High: 2 }[other.tag]); } export type Rank = { tag: "Low" } | { tag: "Mid"; _0: rt.u8 } | { tag: "High"; x: rt.u8; y: rt.u8 }; diff --git a/ts/fixtures/lang/expected/collections.ts b/ts/fixtures/lang/expected/collections.ts index 7092f43ee..d19e58acc 100644 --- a/ts/fixtures/lang/expected/collections.ts +++ b/ts/fixtures/lang/expected/collections.ts @@ -11,10 +11,11 @@ import * as Tally from "./collections.Tally.ts"; /** A 64-bit key: small, or past 2^53, where it is no longer a JS number. */ export function wide(b: rt.u8): rt.u64 { - const value = rt.u8Rem(b, 3); - if (value === 0) { + let _2!: rt.u8; + _2 = rt.u8Rem(b, 3); + if (_2 === 0) { return b as rt.u64; - } else if (value === 1) { + } else if (_2 === 1) { return rt.u64Shl(b as rt.u64, 50); } else { return rt.u64Sub(rt.u64Of(18446744073709551615n), b as rt.u64); @@ -22,374 +23,581 @@ export function wide(b: rt.u8): rt.u64 { } export function rank(b: rt.u8, c: rt.u8): Rank.Rank { - const value = rt.u8Rem(b, 3); - if (value === 0) { - return { tag: "Low" }; - } else if (value === 1) { - return { tag: "Mid", _0: rt.u8Rem(c, 4) }; + let _3!: rt.u8; + _3 = rt.u8Rem(b, 3); + if (_3 === 0) { + return { tag: "Low" } as Rank.Rank; + } else if (_3 === 1) { + return { tag: "Mid", _0: rt.u8Rem(c, 4) } as Rank.Rank; } else { - return { tag: "High", x: rt.u8Rem(c, 2), y: rt.u8Rem(c, 3) }; + return { tag: "High", x: rt.u8Rem(c, 2), y: rt.u8Rem(c, 3) } as Rank.Rank; } } export function rankByte(r: Rank.Rank): rt.u8 { + let x!: rt.u8; + let y!: rt.u8; if (r.tag === "Low") { return 0; } else if (r.tag === "Mid") { - const m = r._0; - return 0x10 | m; + return 16 | r._0; } else { - const x = r.x; - const y = r.y; - return 0x20 | ((x << 2) & 0xff) | y; + x = r.x; + y = r.y; + return 32 | ((x << 2) & 0xff) | y; } } /** A `HashMap` by each kind of key, through a script of inserts, lookups, and removals. */ export function hashMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const value = rt.u8Rem(kind, 4); - if (value === 0) { - let map: rt.HashMap = rt.hashNew() as rt.HashMap; - const iter = rt.iterStepBy(new rt.Range(0, data.length), 2); - while (true) { - const i = iter.next(); - if (i === rt.DONE) { - break; - } - const [k, v] = [rt.u8Rem(rt.at(data, i), 16), rt.optionUnwrapOr(rt.sliceGet(data, rt.usizeAdd(i, 1)), 0) as rt.u16] as [rt.u8, rt.u16]; - const value2 = rt.u16Rem(v, 5); - if (value2 === 0) { - rt.byteVecPush(out, rt.optionMapOr(rt.hashRemove(map, k), 0xee, (old: rt.u16): rt.u8 => { - return old & 0xff; - })); - } else if (value2 === 1) { - rt.byteVecPush(out, rt.hashContains(map, k) ? 1 : 0); - } else if (value2 === 2) { - rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(map, k), 0xdd, (v2: rt.u16): rt.u8 => { - return v2 & 0xff; - })); - } else { - rt.byteVecPush(out, rt.optionMapOr(rt.hashInsert(map, k, rt.u16Mul(v, 3)), 0xcc, (old2: rt.u16): rt.u8 => { - return old2 & 0xff; - })); - } - } - rt.byteVecPush(out, rt.hashLen(map) & 0xff); - rt.byteVecPush(out, rt.hashLen(map) === 0 ? 1 : 0); - const total = rt.iterSum(rt.iterMap(rt.hashValues(map), (v3: rt.u16): rt.u16 => { - return rt.u16Rem(v3, 256); - }), rt.u16Add, 0); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(total)); - const sorted = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterMap(rt.hashIter(map), (arg: [rt.u8, rt.u16]): [rt.u8, rt.u16] => { - const k2 = arg[0]; - const v4 = arg[1]; - return [k2, v4]; - }), true); - const iter2 = rt.btreeIter(sorted); - while (true) { - const item = iter2.next(); - if (item === rt.DONE) { - break; - } - const k3 = item[0]; - const v5 = item[1]; - rt.byteVecPush(out, k3); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v5)); - } - rt.hashClear(map); - rt.byteVecPush(out, rt.hashLen(map) & 0xff); - } else if (value === 1) { - let map2: rt.HashMap = rt.hashNew(rt.hashing(rt.hashInt, rt.u64Eq)) as rt.HashMap; - const iter3 = rt.iterEnumerate(rt.iterSlice(data)); - while (true) { - const item2 = iter3.next(); - if (item2 === rt.DONE) { - break; - } - const i2 = item2[0]; - const b = item2[1]; - const k4 = wide(rt.u8Rem(b, 12)); - const value3 = rt.u8Rem(rt.u8Div(b, 12), 4); - if (value3 === 0) { - rt.byteVecPush(out, rt.optionUnwrapOr(rt.hashRemove(map2, k4), 0xee)); - } else if (value3 === 1) { - rt.byteVecPush(out, rt.optionUnwrapOr(rt.hashGet(map2, k4), 0xdd)); - } else { - rt.byteVecPush(out, rt.optionUnwrapOr(rt.hashInsert(map2, k4, i2 & 0xff), 0xcc)); - } - } - const keys = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.hashKeys(map2), true); - const iter4 = rt.btreeKeys(keys); - while (true) { - const k5 = iter4.next(); - if (k5 === rt.DONE) { - break; - } - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(k5)); - rt.byteVecPush(out, rt.hashIndex(map2, k5)); - } - const first = rt.sliceFirst(data); - if (first !== undefined) { - const b2 = first; - rt.byteVecPush(out, rt.hashIndex(map2, wide(rt.u8Rem(b2, 13)))); - } - } else if (value === 2) { - let map3: rt.HashMap = rt.hashNew(rt.hashing(Nibble.hash$Hash_DefaultHasher, Nibble.eq$PartialEq)) as rt.HashMap; - let pairs: rt.HashMap = rt.hashNew(rt.hashing(Pair.hash$Hash_DefaultHasher, Pair.eq$PartialEq)) as rt.HashMap; - let ranks: rt.HashMap = rt.hashNew(rt.hashing(Rank.hash$Hash_DefaultHasher, Rank.eq$PartialEq)) as rt.HashMap; - let tuples: rt.HashMap<[rt.u8, string], rt.u8> = rt.hashNew(rt.hashing(rt.hashTuple([rt.hashInt, rt.hashStr]), rt.eqTuple([rt.same, rt.same]))) as rt.HashMap<[rt.u8, string], rt.u8>; - const end = data.length; - for (let i3 = 1; i3 < end; i3++) { - const [a, b3] = [rt.at(data, rt.usizeSub(i3, 1)), rt.at(data, i3)] as [rt.u8, rt.u8]; - rt.byteVecPush(out, rt.optionUnwrapOr(rt.hashInsert(map3, { _0: a }, b3), 0xcc)); - const pair = { a: rt.u8Rem(a, 4), b: rt.u16Rem(b3 as rt.u16, 3) }; - const t = rt.entryOrInsertWith(rt.entry(pairs, rt.copy(pair)), Tally.default$Default); - t.n = rt.u16Add(t.n, 1); - const r = rank(a, b3); - const getMut = rt.hashGet(ranks, r); - if (getMut !== undefined) { - const t2 = getMut; - t2.n = rt.u16Add(t2.n, 1); - } else { - rt.hashInsert(ranks, r, { n: i3 & 0xffff }); - } - const arg2 = rt.u8Rem(a, 3); - const value4 = ["", "a", "ab", "b", "é", "", "￿", "𐀀"]; - const t3 = [arg2, rt.at(value4, rt.usizeRem(b3 as rt.usize, ["", "a", "ab", "b", "é", "", "￿", "𐀀"].length))] as [rt.u8, string]; - rt.byteVecPush(out, rt.optionUnwrapOr(rt.hashRemove(tuples, t3), 0xbb)); - if (rt.u8Rem(a, 2) === 0) { - rt.hashInsert(tuples, rt.copy(t3), a); - } - } - const raw = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterMap(rt.hashIter(map3), (arg3: [Nibble.Nibble, rt.u8]): [rt.u8, rt.u8] => { - const k6 = arg3[0]; - const v6 = arg3[1]; - return [k6._0, v6]; - }), true); - const iter5 = rt.btreeIter(raw); - while (true) { - const item3 = iter5.next(); - if (item3 === rt.DONE) { - break; - } - const k7 = item3[0]; - const v7 = item3[1]; - rt.byteVecPush(out, k7); - rt.byteVecPush(out, v7); - } - const key = { a: 9, b: 9 }; - let local: Tally.Tally = { n: 7 }; - rt.hashInsert(pairs, rt.copy(key), rt.copy(local)); - local.n = 8; - const before = rt.copy(rt.hashIndex(pairs, key)); - const getMut2 = rt.hashGet(pairs, key); - if (getMut2 !== undefined) { - const t4 = getMut2; - t4.n = rt.u16Add(t4.n, 2); - } - rt.byteVecPush(out, local.n & 0xff); - rt.byteVecPush(out, before.n & 0xff); - rt.byteVecPush(out, rt.hashIndex(pairs, key).n & 0xff); - const pairs2 = rt.btreeExtend(rt.btreeNew(Pair.cmp$Ord) as rt.BTreeMap, rt.hashIter(pairs), true); - const iter6 = rt.btreeIter(pairs2); - while (true) { - const item4 = iter6.next(); - if (item4 === rt.DONE) { - break; - } - const p = item4[0]; - const t5 = item4[1]; - rt.byteVecPush(out, p.a); - rt.byteVecPush(out, p.b & 0xff); - rt.byteVecPush(out, t5.n & 0xff); - } - const end2 = data.length; - for (let i4 = 1; i4 < end2; i4++) { - const [a2, b4] = [rt.at(data, rt.usizeSub(i4, 1)), rt.at(data, i4)] as [rt.u8, rt.u8]; - const t7 = rt.entryOrInsertWith(rt.entryAndModify(rt.entry(ranks, rank(b4, a2)), (t6: Tally.Tally): void => { - t6.n = t6.n ^ 3; - }), (): Tally.Tally => { - return { n: b4 as rt.u16 }; - }); - t7.n = rt.u16WrappingAdd(t7.n, t7.n); - const e = rt.entry(ranks, rank(rt.at(data, i4), 0)); - rt.byteVecPush(out, rankByte(rt.entryKey(e))); - rt.byteVecPush(out, rt.entryOrInsertWith(e, (k8: Rank.Rank): Tally.Tally => { - return { n: rankByte(k8) as rt.u16 }; - }).n & 0xff); - } - let copy: rt.HashMap = rt.hashClone(ranks, undefined, rt.copy); - const getMut3 = rt.hashGet(copy, { tag: "Low" } as Rank.Rank); - if (getMut3 !== undefined) { - const t8 = getMut3; - t8.n = 0x77; - } - rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(ranks, { tag: "Low" } as Rank.Rank), 0xff, (t9: Tally.Tally): rt.u8 => { - return t9.n & 0xff; - })); - rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(copy, { tag: "Low" } as Rank.Rank), 0xff, (t10: Tally.Tally): rt.u8 => { - return t10.n & 0xff; - })); - rt.byteVecPush(out, rt.optionMapOr(rt.hashRemoveEntry(copy, { tag: "Mid", _0: 1 } as Rank.Rank), 0xff, (arg4: [Rank.Rank, Tally.Tally]): rt.u8 => { - const k9 = arg4[0]; - const t11 = rt.copy(arg4[1]); - return rankByte(k9) ^ (t11.n & 0xff); - })); - const bytes = rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterMap(rt.iterSlice(data), (arg5: rt.u8): [rt.u8, Tally.Tally] => { - const b5 = arg5; - return [rt.u8Rem(b5, 8), { n: b5 as rt.u16 }]; - })); - let copy2: rt.HashMap = rt.hashClone(bytes, undefined, rt.copy); - const iter7 = rt.hashValues(copy2); - while (true) { - const t12 = iter7.next(); - if (t12 === rt.DONE) { - break; - } - t12.n = rt.u16Add(t12.n, 1); - } - for (let k10 = 0; k10 < 8; k10++) { - rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(bytes, k10), 0xff, (t13: Tally.Tally): rt.u8 => { - return t13.n & 0xff; - })); - rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(copy2, k10), 0xff, (t14: Tally.Tally): rt.u8 => { - return t14.n & 0xff; - })); - } - for (const item5 of data) { - const b6 = item5; - rt.byteVecPush(out, claim(copy2, rt.u8Rem(b6, 8), b6 as rt.u16)); - } - let stamped: rt.HashMap = rt.hashNew() as rt.HashMap; - stamp(stamped); - stamp(stamped); - rt.byteVecPush(out, rt.hashLen(stamped) & 0xff); - let extended: rt.HashMap = rt.hashNew() as rt.HashMap; - rt.hashExtend(extended, rt.iterMap(rt.hashIter(bytes), rt.copy)); - const iter8 = rt.hashValues(extended); - while (true) { - const t15 = iter8.next(); - if (t15 === rt.DONE) { - break; - } - t15.n = t15.n ^ 0x11; - } - for (let k11 = 0; k11 < 8; k11++) { - rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(bytes, k11), 0xff, (t16: Tally.Tally): rt.u8 => { - return t16.n & 0xff; - })); - rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(extended, k11), 0xff, (t17: Tally.Tally): rt.u8 => { - return t17.n & 0xff; - })); - } - const hash = (n: Nibble.Nibble): rt.u64 => { - let h: rt.Hasher = rt.hasher(); - Nibble.hash$Hash_DefaultHasher(n, h); - return rt.hashFinish(h); - }; - const first2 = rt.optionUnwrapOr(rt.sliceFirst(data), 0); - rt.byteVecPush(out, rt.u64Eq(hash({ _0: first2 }), hash({ _0: first2 ^ 0xf0 })) ? 1 : 0); - const value5 = [rt.hasher(), { n: first2 as rt.u16 }] as [rt.Hasher, Tally.Tally]; - let h2: rt.Hasher = value5[0]; - let counted: Tally.Tally = value5[1]; - const state = countedHasher(h2, counted); - rt.hashInt(counted.n, state); - let want: rt.Hasher = rt.hasher(); - rt.hashInt(rt.u16Add(first2 as rt.u16, 1), want); - rt.byteVecPush(out, rt.u64Eq(rt.hashFinish(h2), rt.hashFinish(want)) ? 1 : 0); - rt.hashRetain(ranks, (r2: Rank.Rank, t18: Tally.Tally): boolean => { - return rt.u16Rem(t18.n, 2) === 0 || Rank.eq$PartialEq(r2, { tag: "Low" }); - }); - const ranks2 = rt.btreeExtend(rt.btreeNew(Rank.cmp$Ord) as rt.BTreeMap, rt.iterMap(rt.hashIter(ranks), (arg6: [Rank.Rank, Tally.Tally]): [Rank.Rank, rt.u16] => { - const r3 = arg6[0]; - const t19 = arg6[1]; - return [r3, t19.n]; - }), true); - const iter9 = rt.btreeIter(ranks2); - while (true) { - const item6 = iter9.next(); - if (item6 === rt.DONE) { - break; - } - const r4 = item6[0]; - const n2 = item6[1]; - rt.byteVecPush(out, rankByte(r4)); - rt.byteVecPush(out, n2 & 0xff); - } - rt.byteVecPush(out, rt.hashLen(tuples) & 0xff); - } else { - let words: rt.HashMap = rt.hashNew() as rt.HashMap; - for (const item7 of data) { - const b7 = item7; - const value6 = ["", "a", "ab", "b", "é", "", "￿", "𐀀"]; - const word = rt.at(value6, rt.usizeRem(b7 as rt.usize, ["", "a", "ab", "b", "é", "", "￿", "𐀀"].length)); - rt.byteVecPush(rt.entryOrInsertWith(rt.entry(words, word), (): rt.ByteVec => { - return new rt.ByteVec(); - }), b7); - } - let lens: rt.BTreeMap = rt.btreeNew(rt.cmpStr) as rt.BTreeMap; - const iter10 = rt.hashIter(words); - while (true) { - const item8 = iter10.next(); - if (item8 === rt.DONE) { - break; + let _4!: rt.u8; + let map!: rt.HashMap; + let iter!: rt.Iter; + let _13!: rt.usize | rt.Done; + let i!: rt.usize; + let k!: rt.u8; + let v!: rt.u16; + let _19!: [rt.u8, rt.u16]; + let _31!: rt.u16; + let _48!: rt.u16; + let sorted!: rt.BTreeMap; + let _67!: rt.Iter<[rt.u8, rt.u16]>; + let iter2!: rt.Iter<[rt.u8, rt.u16]>; + let _73!: [rt.u8, rt.u16] | rt.Done; + let map2!: rt.HashMap; + let iter3!: rt.Iter<[rt.usize, rt.u8]>; + let _97!: [rt.usize, rt.u8] | rt.Done; + let i2!: rt.usize; + let b!: rt.u8; + let k2!: rt.u64; + let _105!: rt.u8; + let keys!: rt.BTreeSet; + let _123!: rt.Iter; + let iter4!: rt.Iter; + let _129!: rt.u64 | rt.Done; + let _142!: rt.u8 | undefined; + let _150!: rt.u64; + let map3!: rt.HashMap; + let pairs!: rt.HashMap; + let ranks!: rt.HashMap; + let tuples!: rt.HashMap<[rt.u8, string], rt.u8>; + let iterStart!: rt.usize; + let iterEnd!: rt.usize; + let _161!: rt.usize; + let i3!: rt.usize; + let a!: rt.u8; + let b3!: rt.u8; + let _167!: [rt.u8, rt.u8]; + let _168!: rt.u8; + let _169!: rt.usize; + let pair!: Pair.Pair; + let t!: Tally.Tally; + let r!: Rank.Rank; + let _192!: Tally.Tally | undefined; + let t2!: [rt.u8, string]; + let _203!: rt.u8; + let _207!: rt.usize; + let _225!: rt.Iter<[rt.u8, rt.u8]>; + let iter6!: rt.Iter<[rt.u8, rt.u8]>; + let _230!: [rt.u8, rt.u8] | rt.Done; + let k3!: rt.u8; + let v2!: rt.u8; + let key!: Pair.Pair; + let local!: Tally.Tally; + let before!: Tally.Tally; + let _246!: Tally.Tally | undefined; + let _265!: rt.Iter<[Pair.Pair, Tally.Tally]>; + let iter7!: rt.Iter<[Pair.Pair, Tally.Tally]>; + let _269!: [Pair.Pair, Tally.Tally] | rt.Done; + let p!: Pair.Pair; + let t3!: Tally.Tally; + let iterStart2!: rt.usize; + let iterEnd2!: rt.usize; + let _286!: rt.usize; + let i4!: rt.usize; + let a2!: rt.u8; + let b4!: rt.u8; + let _292!: [rt.u8, rt.u8]; + let _293!: rt.u8; + let _294!: rt.usize; + let t4!: Tally.Tally; + let _305!: Rank.Rank; + let e!: rt.Entry; + let _313!: Rank.Rank; + let copy!: rt.HashMap; + let _327!: Tally.Tally | undefined; + let bytes!: rt.HashMap; + let _348!: rt.Iter<[rt.u8, Tally.Tally]>; + let copy2!: rt.HashMap; + let iter9!: rt.Iter; + let _356!: Tally.Tally | rt.Done; + let iterStart3!: rt.u8; + let iterEnd3!: rt.u8; + let _364!: rt.u8; + let k4!: rt.u8; + let iterS!: Uint8Array; + let iterI!: number; + let _380!: rt.u8 | rt.Done; + let b5!: rt.u8; + let _387!: rt.u8; + let _389!: rt.u16; + let stamped!: rt.HashMap; + let extended!: rt.HashMap; + let iter12!: rt.Iter; + let _409!: Tally.Tally | rt.Done; + let iterStart4!: rt.u8; + let iterEnd4!: rt.u8; + let _416!: rt.u8; + let k5!: rt.u8; + let _430!: (a0: Nibble.Nibble) => rt.u64; + let first!: rt.u8; + let h!: rt.Hasher; + let counted!: Tally.Tally; + let _448!: [rt.Hasher, Tally.Tally]; + let _453!: rt.Hasher; + let _456!: rt.u16; + let want!: rt.Hasher; + let ranks2!: rt.BTreeMap; + let _473!: rt.Iter<[Rank.Rank, rt.u16]>; + let iter14!: rt.Iter<[Rank.Rank, rt.u16]>; + let _479!: [Rank.Rank, rt.u16] | rt.Done; + let words!: rt.HashMap; + let iterS2!: Uint8Array; + let iterI2!: number; + let _496!: rt.u8 | rt.Done; + let b6!: rt.u8; + let word!: string; + let _502!: rt.usize; + let lens!: rt.BTreeMap; + let iter16!: rt.Iter<[string, rt.ByteVec]>; + let _517!: [string, rt.ByteVec] | rt.Done; + let _524!: string; + let _525!: rt.usize; + let iter17!: rt.Iter<[string, rt.usize]>; + let _529!: [string, rt.usize] | rt.Done; + let clashes!: rt.HashMap; + let iter18!: rt.Iter<[rt.usize, rt.u8]>; + let _555!: [rt.usize, rt.u8] | rt.Done; + let i5!: rt.usize; + let b7!: rt.u8; + let k6!: Clash.Clash; + let _563!: rt.u8; + let kept!: rt.BTreeSet; + let _583!: rt.Iter; + let copy3!: rt.HashMap; + _430 = (n: Nibble.Nibble): rt.u64 => { + let h2!: rt.Hasher; + h2 = rt.hasher(); + Nibble.hash$Hash_DefaultHasher(n, h2); + return rt.hashFinish(h2); + }; + b0: { + _4 = rt.u8Rem(kind, 4); + if (_4 === 0) { + map = rt.hashNew() as rt.HashMap; + iter = rt.iterStepBy(new rt.Range(0, data.length), 2); + while (true) { + _13 = iter.next(); + if (_13 === rt.DONE) { + rt.byteVecPush(out, rt.hashLen(map) & 0xff); + rt.byteVecPush(out, rt.hashLen(map) === 0 ? 1 : 0); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(rt.iterSum(rt.iterMap(rt.hashValues(map), (v5: rt.u16): rt.u16 => { + return rt.u16Rem(v5, 256); + }), rt.u16Add, 0))); + _67 = rt.iterMap(rt.hashIter(map), (_227: [rt.u8, rt.u16]): [rt.u8, rt.u16] => { + return [_227[0], _227[1]] as [rt.u8, rt.u16]; + }); + sorted = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _67, true); + iter2 = rt.btreeIter(sorted); + while (true) { + _73 = iter2.next(); + if (_73 === rt.DONE) { + rt.hashClear(map); + rt.byteVecPush(out, rt.hashLen(map) & 0xff); + break b0; + } else { + rt.byteVecPush(out, _73[0]); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(_73[1])); + } + } + } else { + i = _13; + rt.idx(data, i); + _19 = [rt.u8Rem(data[i], 16), rt.optionUnwrapOr(rt.sliceGet(data, rt.usizeAdd(i, 1)), 0) as rt.u16] as [rt.u8, rt.u16]; + k = _19[0]; + v = _19[1]; + _31 = rt.u16Rem(v, 5); + if (_31 === 0) { + rt.byteVecPush(out, rt.optionMapOr(rt.hashRemove(map, k), 238, (old2: rt.u16): rt.u8 => { + return old2 & 0xff; + })); + } else if (_31 === 1) { + rt.byteVecPush(out, rt.hashContains(map, k) ? 1 : 0); + } else if (_31 === 2) { + rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(map, k), 221, (v4: rt.u16): rt.u8 => { + return v4 & 0xff; + })); + } else { + _48 = rt.u16Mul(v, 3); + rt.byteVecPush(out, rt.optionMapOr(rt.hashInsert(map, k, _48), 204, (old: rt.u16): rt.u8 => { + return old & 0xff; + })); + } + } } - const w = item8[0]; - const bytes2 = item8[1]; - rt.btreeInsert(lens, w, bytes2.length); - } - const iter11 = rt.btreeIter(lens); - while (true) { - const item9 = iter11.next(); - if (item9 === rt.DONE) { - break; + } else if (_4 === 1) { + map2 = rt.hashNew(rt.hashing(rt.hashInt, rt.u64Eq)) as rt.HashMap; + iter3 = rt.iterEnumerate(rt.iterSlice(data)); + while (true) { + _97 = iter3.next(); + if (_97 === rt.DONE) { + _123 = rt.hashKeys(map2); + keys = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _123, true); + iter4 = rt.btreeKeys(keys); + while (true) { + _129 = iter4.next(); + if (_129 === rt.DONE) { + _142 = rt.sliceFirst(data); + if (_142 !== undefined) { + _150 = wide(rt.u8Rem(_142, 13)); + rt.byteVecPush(out, rt.hashIndex(map2, _150)); + } + break b0; + } else { + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(_129)); + rt.byteVecPush(out, rt.hashIndex(map2, _129)); + } + } + } else { + i2 = _97[0]; + b = _97[1]; + k2 = wide(rt.u8Rem(b, 12)); + _105 = rt.u8Rem(rt.u8Div(b, 12), 4); + if (_105 === 0) { + rt.byteVecPush(out, rt.optionUnwrapOr(rt.hashRemove(map2, k2), 238)); + } else if (_105 === 1) { + rt.byteVecPush(out, rt.optionUnwrapOr(rt.hashGet(map2, k2), 221)); + } else { + rt.byteVecPush(out, rt.optionUnwrapOr(rt.hashInsert(map2, k2, i2 & 0xff), 204)); + } + } } - const w2 = item9[0]; - const n3 = item9[1]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(w2)); - rt.byteVecPush(out, n3 & 0xff); - } - const drained = rt.iterSum(rt.iterMap(rt.hashDrain(words), (arg7: [string, rt.ByteVec]): rt.usize => { - const v8 = arg7[1]; - return v8.length; - }), rt.usizeAdd, 0); - rt.byteVecPush(out, drained & 0xff); - rt.byteVecPush(out, rt.hashLen(words) === 0 ? 1 : 0); - let clashes: rt.HashMap = rt.hashNew(rt.hashing(Clash.hash$Hash_DefaultHasher, Clash.eq$PartialEq)) as rt.HashMap; - const iter12 = rt.iterEnumerate(rt.iterSlice(data)); - while (true) { - const item10 = iter12.next(); - if (item10 === rt.DONE) { - break; + } else if (_4 === 2) { + map3 = rt.hashNew(rt.hashing(Nibble.hash$Hash_DefaultHasher, Nibble.eq$PartialEq)) as rt.HashMap; + pairs = rt.hashNew(rt.hashing(Pair.hash$Hash_DefaultHasher, Pair.eq$PartialEq)) as rt.HashMap; + ranks = rt.hashNew(rt.hashing(Rank.hash$Hash_DefaultHasher, Rank.eq$PartialEq)) as rt.HashMap; + tuples = rt.hashNew(rt.hashing(rt.hashTuple([rt.hashInt, rt.hashStr]), rt.eqTuple([rt.same, rt.same]))) as rt.HashMap<[rt.u8, string], rt.u8>; + iterStart = 1; + iterEnd = data.length; + while (true) { + if (!((_161 = iterStart++) < iterEnd)) { + _225 = rt.iterMap(rt.hashIter(map3), (_214: [Nibble.Nibble, rt.u8]): [rt.u8, rt.u8] => { + return [_214[0]._0, _214[1]] as [rt.u8, rt.u8]; + }); + iter6 = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _225, true)); + while (true) { + _230 = iter6.next(); + if (_230 === rt.DONE) { + key = { a: 9, b: 9 }; + local = { n: 7 }; + rt.hashInsert(pairs, key, rt.copy(local)); + local.n = 8; + before = rt.copy(rt.hashIndex(pairs, key)); + _246 = rt.hashGet(pairs, key); + if (_246 !== undefined) { + _246.n = rt.u16Add(_246.n, 2); + } + rt.byteVecPush(out, local.n & 0xff); + rt.byteVecPush(out, before.n & 0xff); + rt.byteVecPush(out, rt.hashIndex(pairs, key).n & 0xff); + _265 = rt.hashIter(pairs); + iter7 = rt.btreeIter(rt.btreeExtend(rt.btreeNew(Pair.cmp$Ord) as rt.BTreeMap, _265, true)); + while (true) { + _269 = iter7.next(); + if (_269 === rt.DONE) { + iterStart2 = 1; + iterEnd2 = data.length; + while (true) { + if (!((_286 = iterStart2++) < iterEnd2)) { + copy = rt.hashClone(ranks, undefined, rt.copy); + _327 = rt.hashGet(copy, { tag: "Low" } as Rank.Rank); + if (_327 !== undefined) { + _327.n = 119; + } + rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(ranks, { tag: "Low" } as Rank.Rank), 255, (t10: Tally.Tally): rt.u8 => { + return t10.n & 0xff; + })); + rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(copy, { tag: "Low" } as Rank.Rank), 255, (t11: Tally.Tally): rt.u8 => { + return t11.n & 0xff; + })); + rt.byteVecPush(out, rt.optionMapOr(rt.hashRemoveEntry(copy, { tag: "Mid", _0: 1 } as Rank.Rank), 255, (_218: [Rank.Rank, Tally.Tally]): rt.u8 => { + let k10!: Rank.Rank; + let t12!: Tally.Tally; + k10 = _218[0]; + t12 = _218[1]; + return rankByte(k10) ^ (t12.n & 0xff); + })); + _348 = rt.iterMap(rt.iterSlice(data), (_223: rt.u8): [rt.u8, Tally.Tally] => { + let b8!: rt.u8; + b8 = _223; + return [rt.u8Rem(b8, 8), { n: b8 as rt.u16 }] as [rt.u8, Tally.Tally]; + }); + bytes = rt.hashExtend(rt.hashNew() as rt.HashMap, _348); + copy2 = rt.hashClone(bytes, undefined, rt.copy); + iter9 = rt.hashValues(copy2); + while (true) { + _356 = iter9.next(); + if (_356 === rt.DONE) { + iterStart3 = 0; + iterEnd3 = 8; + while (true) { + if (!((_364 = iterStart3++) < iterEnd3)) { + iterS = data; + iterI = 0; + while (true) { + _380 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_380 === rt.DONE) { + stamped = rt.hashNew() as rt.HashMap; + stamp(stamped); + stamp(stamped); + rt.byteVecPush(out, rt.hashLen(stamped) & 0xff); + extended = rt.hashNew() as rt.HashMap; + rt.hashExtend(extended, rt.iterMap(rt.hashIter(bytes), rt.copy)); + iter12 = rt.hashValues(extended); + while (true) { + _409 = iter12.next(); + if (_409 === rt.DONE) { + iterStart4 = 0; + iterEnd4 = 8; + while (true) { + if (!((_416 = iterStart4++) < iterEnd4)) { + first = rt.optionUnwrapOr(rt.sliceFirst(data), 0); + rt.byteVecPush(out, rt.u64Eq(_430({ _0: first }), _430({ _0: first ^ 240 })) ? 1 : 0); + _448 = [rt.hasher(), { n: first as rt.u16 }] as [rt.Hasher, Tally.Tally]; + h = _448[0]; + counted = rt.copy(_448[1]); + _453 = countedHasher(h, counted); + _456 = counted.n; + rt.hashInt(_456, _453); + want = rt.hasher(); + rt.hashInt(rt.u16Add(first as rt.u16, 1), want); + rt.byteVecPush(out, rt.u64Eq(rt.hashFinish(h), rt.hashFinish(want)) ? 1 : 0); + rt.hashRetain(ranks, (r2: Rank.Rank, t17: Tally.Tally): boolean => { + if (!(rt.u16Rem(t17.n, 2) === 0)) { + return Rank.eq$PartialEq(r2, { tag: "Low" } as Rank.Rank); + } else { + return true; + } + }); + _473 = rt.iterMap(rt.hashIter(ranks), (_224: [Rank.Rank, Tally.Tally]): [Rank.Rank, rt.u16] => { + return [_224[0], _224[1].n] as [Rank.Rank, rt.u16]; + }); + ranks2 = rt.btreeExtend(rt.btreeNew(Rank.cmp$Ord) as rt.BTreeMap, _473, true); + iter14 = rt.btreeIter(ranks2); + while (true) { + _479 = iter14.next(); + if (_479 === rt.DONE) { + rt.byteVecPush(out, rt.hashLen(tuples) & 0xff); + break b0; + } else { + rt.byteVecPush(out, rankByte(_479[0])); + rt.byteVecPush(out, _479[1] & 0xff); + } + } + } else { + k5 = _416; + rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(bytes, k5), 255, (t15: Tally.Tally): rt.u8 => { + return t15.n & 0xff; + })); + rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(extended, k5), 255, (t16: Tally.Tally): rt.u8 => { + return t16.n & 0xff; + })); + } + } + } else { + _409.n = _409.n ^ 17; + } + } + } else { + b5 = _380; + _387 = rt.u8Rem(b5, 8); + _389 = b5 as rt.u16; + rt.byteVecPush(out, claim(copy2, _387, _389)); + } + } + } else { + k4 = _364; + rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(bytes, k4), 255, (t13: Tally.Tally): rt.u8 => { + return t13.n & 0xff; + })); + rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(copy2, k4), 255, (t14: Tally.Tally): rt.u8 => { + return t14.n & 0xff; + })); + } + } + } else { + _356.n = rt.u16Add(_356.n, 1); + } + } + } else { + i4 = _286; + _294 = rt.usizeSub(i4, 1); + rt.idx(data, _294); + _293 = data[_294]; + rt.idx(data, i4); + _292 = [_293, data[i4]] as [rt.u8, rt.u8]; + a2 = _293; + b4 = _292[1]; + _305 = rank(b4, a2); + t4 = rt.entryOrInsertWith(rt.entryAndModify(rt.entry(ranks, _305), (t9: Tally.Tally): void => { + t9.n = t9.n ^ 3; + }), (): Tally.Tally => { + return { n: b4 as rt.u16 }; + }); + t4.n = rt.u16WrappingAdd(t4.n, t4.n); + rt.idx(data, i4); + _313 = rank(data[i4], 0); + e = rt.entry(ranks, _313); + rt.byteVecPush(out, rankByte(rt.entryKey(e))); + rt.byteVecPush(out, rt.entryOrInsertWith(e, (k9: Rank.Rank): Tally.Tally => { + return { n: rankByte(k9) as rt.u16 }; + }).n & 0xff); + } + } + } else { + p = _269[0]; + t3 = _269[1]; + rt.byteVecPush(out, p.a); + rt.byteVecPush(out, p.b & 0xff); + rt.byteVecPush(out, t3.n & 0xff); + } + } + } else { + k3 = _230[0]; + v2 = _230[1]; + rt.byteVecPush(out, k3); + rt.byteVecPush(out, v2); + } + } + } else { + i3 = _161; + _169 = rt.usizeSub(i3, 1); + rt.idx(data, _169); + _168 = data[_169]; + rt.idx(data, i3); + _167 = [_168, data[i3]] as [rt.u8, rt.u8]; + a = _168; + b3 = _167[1]; + rt.byteVecPush(out, rt.optionUnwrapOr(rt.hashInsert(map3, { _0: a }, b3), 204)); + pair = { a: rt.u8Rem(a, 4), b: rt.u16Rem(b3 as rt.u16, 3) }; + t = rt.entryOrInsertWith(rt.entry(pairs, pair), Tally.default$Default); + t.n = rt.u16Add(t.n, 1); + r = rank(a, b3); + _192 = rt.hashGet(ranks, r); + if (_192 !== undefined) { + _192.n = rt.u16Add(_192.n, 1); + } else { + rt.hashInsert(ranks, r, { n: i3 & 0xffff }); + } + _203 = rt.u8Rem(a, 3); + _207 = rt.usizeRem(b3 as rt.usize, ["", "a", "ab", "b", "é", "", "￿", "𐀀"].length); + if (!(_207 < 8)) { + rt.panic("index out of bounds: the len is " + 8 + " but the index is " + _207); + } + t2 = [_203, ["", "a", "ab", "b", "é", "", "￿", "𐀀"][_207]] as [rt.u8, string]; + rt.byteVecPush(out, rt.optionUnwrapOr(rt.hashRemove(tuples, t2), 187)); + if (rt.u8Rem(a, 2) === 0) { + rt.hashInsert(tuples, t2, a); + } + } } - const i5 = item10[0]; - const b8 = item10[1]; - const k12 = { _0: rt.u8Rem(b8, 8) }; - const value7 = rt.u8Rem(rt.u8Div(b8, 8), 4); - if (value7 === 0) { - rt.byteVecPush(out, rt.optionMapOr(rt.hashRemove(clashes, k12), 0xee, (t20: Tally.Tally): rt.u8 => { - return t20.n & 0xff; - })); - } else if (value7 === 1) { - rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(clashes, k12), 0xdd, (t21: Tally.Tally): rt.u8 => { - return t21.n & 0xff; - })); - } else { - rt.byteVecPush(out, rt.optionMapOr(rt.hashInsert(clashes, rt.copy(k12), { n: i5 & 0xffff }), 0xcc, (t22: Tally.Tally): rt.u8 => { - return t22.n & 0xff; - })); + } else { + words = rt.hashNew() as rt.HashMap; + iterS2 = data; + iterI2 = 0; + while (true) { + _496 = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; + if (_496 === rt.DONE) { + lens = rt.btreeNew(rt.cmpStr) as rt.BTreeMap; + iter16 = rt.hashIter(words); + while (true) { + _517 = iter16.next(); + if (_517 === rt.DONE) { + iter17 = rt.btreeIter(lens); + while (true) { + _529 = iter17.next(); + if (_529 === rt.DONE) { + rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.hashDrain(words), (_2: [string, rt.ByteVec]): rt.usize => { + let v3!: rt.ByteVec; + v3 = _2[1]; + return v3.length; + }), rt.usizeAdd, 0) & 0xff); + rt.byteVecPush(out, rt.hashLen(words) === 0 ? 1 : 0); + clashes = rt.hashNew(rt.hashing(Clash.hash$Hash_DefaultHasher, Clash.eq$PartialEq)) as rt.HashMap; + iter18 = rt.iterEnumerate(rt.iterSlice(data)); + while (true) { + _555 = iter18.next(); + if (_555 === rt.DONE) { + rt.hashRetain(clashes, (k7: Clash.Clash, t8: Tally.Tally): boolean => { + if (!(rt.u8Rem(k7._0, 3) !== 0)) { + return rt.u16Rem(t8.n, 2) === 0; + } else { + return true; + } + }); + _583 = rt.iterMap(rt.hashKeys(clashes), (k8: Clash.Clash): rt.u8 => { + return k8._0; + }); + kept = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _583, true); + rt.iterExtendBytes(out, rt.btreeKeys(kept)); + copy3 = rt.hashClone(clashes, rt.copy, rt.copy); + rt.byteVecPush(out, rt.hashLen(copy3) & 0xff); + rt.byteVecPush(out, rt.hashContains(copy3, { _0: 1 }) ? 1 : 0); + break b0; + } else { + i5 = _555[0]; + b7 = _555[1]; + k6 = { _0: rt.u8Rem(b7, 8) }; + _563 = rt.u8Rem(rt.u8Div(b7, 8), 4); + if (_563 === 0) { + rt.byteVecPush(out, rt.optionMapOr(rt.hashRemove(clashes, k6), 238, (t7: Tally.Tally): rt.u8 => { + return t7.n & 0xff; + })); + } else if (_563 === 1) { + rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(clashes, k6), 221, (t6: Tally.Tally): rt.u8 => { + return t6.n & 0xff; + })); + } else { + rt.byteVecPush(out, rt.optionMapOr(rt.hashInsert(clashes, k6, { n: i5 & 0xffff }), 204, (t5: Tally.Tally): rt.u8 => { + return t5.n & 0xff; + })); + } + } + } + } else { + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_529[0])); + rt.byteVecPush(out, _529[1] & 0xff); + } + } + } else { + _524 = _517[0]; + _525 = _517[1].length; + rt.btreeInsert(lens, _524, _525); + } + } + } else { + b6 = _496; + _502 = rt.usizeRem(b6 as rt.usize, ["", "a", "ab", "b", "é", "", "￿", "𐀀"].length); + if (!(_502 < 8)) { + rt.panic("index out of bounds: the len is " + 8 + " but the index is " + _502); + } + word = ["", "a", "ab", "b", "é", "", "￿", "𐀀"][_502]; + rt.byteVecPush(rt.entryOrInsertWith(rt.entry(words, word), (): rt.ByteVec => { + return new rt.ByteVec(); + }), b6); + } } } - rt.hashRetain(clashes, (k13: Clash.Clash, t23: Tally.Tally): boolean => { - return rt.u8Rem(k13._0, 3) !== 0 || rt.u16Rem(t23.n, 2) === 0; - }); - const kept = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.iterMap(rt.hashKeys(clashes), (k14: Clash.Clash): rt.u8 => { - return k14._0; - }), true); - rt.iterExtendBytes(out, rt.btreeKeys(kept)); - const copy3 = rt.hashClone(clashes, rt.copy, rt.copy); - rt.byteVecPush(out, rt.hashLen(copy3) & 0xff); - rt.byteVecPush(out, rt.hashContains(copy3, { _0: 1 }) ? 1 : 0); } } @@ -409,512 +617,751 @@ export function stamp(map: rt.HashMap): rt.HashMap, k: rt.u8, n: rt.u16): rt.u8 { - const entry = rt.entry(map, k); - arms: { - if (rt.entryOccupied(entry)) { - let e: rt.Entry = entry; - if (rt.u16Rem(rt.entryGet(e).n, 2) === 0) { - const t = rt.entryGet(e); - t.n = rt.u16Add(t.n, n); - return 1; - } - } - if (rt.entryOccupied(entry)) { - const e2 = entry; - return rt.entryRemove(e2).n & 0xff; + let _4!: rt.Entry; + let e!: rt.Entry; + let t!: Tally.Tally; + _4 = rt.entry(map, k); + if (rt.entryOccupied(_4)) { + if (!(rt.u16Rem(rt.entryGet(_4).n, 2) === 0)) { + return rt.entryRemove(_4).n & 0xff; + } else { + e = _4; + t = rt.entryGet(e); + t.n = rt.u16Add(t.n, n); + return 1; } - const e3 = entry; - rt.entryOrInsert(e3, { n }); + } else { + rt.entryOrInsert(_4, { n }); return 0; } } /** `HashSet` and `BTreeSet`, each with the same script. */ export function sets(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const value = rt.u8Rem(kind, 3); - if (value === 0) { - let hashed: rt.HashSet = rt.hashNew() as rt.HashSet; - let sorted: rt.BTreeSet = rt.btreeNew(rt.cmp) as rt.BTreeSet; - for (const item of data) { - const b = item; - const v = rt.u16Rem(b as rt.u16, 24); - const value2 = rt.u8Rem(b, 3); - if (value2 === 0) { - rt.byteVecPush(out, rt.hashDelete(hashed, v) ? 1 : 0); - rt.byteVecPush(out, rt.btreeDelete(sorted, v) ? 1 : 0); - } else if (value2 === 1) { - rt.byteVecPush(out, rt.hashContains(hashed, v) ? 1 : 0); - rt.byteVecPush(out, rt.btreeContains(sorted, v) ? 1 : 0); - } else { - rt.byteVecPush(out, rt.hashAdd(hashed, v) ? 1 : 0); - rt.byteVecPush(out, rt.btreeAdd(sorted, v) ? 1 : 0); - } - } - rt.byteVecPush(out, rt.hashLen(hashed) & 0xff); - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.hashKeys(hashed), (v2: rt.u16): boolean => { - return rt.u16Rem(v2, 2) === 1; - })) & 0xff); - const iter = rt.iterRev(rt.btreeKeys(sorted)); - while (true) { - const v3 = iter.next(); - if (v3 === rt.DONE) { - break; - } - rt.byteVecPush(out, v3 & 0xff); - } - rt.byteVecPush(out, rt.optionUnwrapOr(rt.btreeFirstKey(sorted), 0xff) & 0xff); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.btreeFirstKey(sorted, true), 0xff) & 0xff); - const firsts = rt.iterToArray(rt.btreeRangeKeys(sorted, new rt.Range(4, 12))); - rt.byteVecPush(out, firsts.length & 0xff); - rt.hashRetain(hashed, (v4: rt.u16): boolean => { - return rt.u16Rem(v4, 3) !== 0; - }); - rt.btreeRetain(sorted, (v5: rt.u16): boolean => { - return rt.u16Rem(v5, 3) !== 0; - }); - rt.byteVecPush(out, rt.hashLen(hashed) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.btreeKeys(sorted), (v6: rt.u16): rt.u8 => { - return v6 & 0xff; - })); - } else if (value === 1) { - let nibbles: rt.BTreeSet = rt.btreeNew(Nibble.cmp$Ord) as rt.BTreeSet; - let seen: rt.HashSet = rt.hashNew(rt.hashing(Nibble.hash$Hash_DefaultHasher, Nibble.eq$PartialEq)) as rt.HashSet; - for (const item2 of data) { - const b2 = item2; - rt.byteVecPush(out, rt.btreeAdd(nibbles, { _0: b2 }) ? 1 : 0); - rt.byteVecPush(out, rt.hashAdd(seen, { _0: b2 }) ? 1 : 0); - } - const iter2 = rt.btreeKeys(nibbles); - while (true) { - const n = iter2.next(); - if (n === rt.DONE) { - break; - } - rt.byteVecPush(out, n._0); - } - while (true) { - const popLast = rt.btreePopKey(nibbles, true); - if (popLast !== undefined) { - const n2 = popLast; - rt.byteVecPush(out, n2._0); - if (rt.usizeRem(rt.btreeLen(nibbles), 2) === 0) { - rt.byteVecPush(out, rt.optionMapOr(rt.btreePopKey(nibbles), 0xee, (n3: Nibble.Nibble): rt.u8 => { - return n3._0; - })); + let _4!: rt.u8; + let hashed!: rt.HashSet; + let sorted!: rt.BTreeSet; + let iterS!: Uint8Array; + let iterI!: number; + let _10!: rt.u8 | rt.Done; + let b!: rt.u8; + let v!: rt.u16; + let _17!: rt.u8; + let iter2!: rt.Iter; + let _62!: rt.u16 | rt.Done; + let firsts!: rt.u16[]; + let nibbles!: rt.BTreeSet; + let seen!: rt.HashSet; + let iterS2!: Uint8Array; + let iterI2!: number; + let _106!: rt.u8 | rt.Done; + let b2!: rt.u8; + let iter4!: rt.Iter; + let _123!: Nibble.Nibble | rt.Done; + let _129!: Nibble.Nibble | undefined; + let dirs!: rt.HashSet; + let iterS3!: Uint8Array; + let iterI3!: number; + let _151!: rt.u8 | rt.Done; + let _160!: rt.usize; + let words!: rt.BTreeSet; + let iterS4!: Uint8Array; + let iterI4!: number; + let _175!: rt.u8 | rt.Done; + let _182!: rt.usize; + let iter7!: rt.Iter; + let _192!: string | rt.Done; + let wides!: rt.BTreeSet; + let _200!: rt.Iter; + let iter8!: rt.Iter; + let _207!: rt.u64 | rt.Done; + b0: { + _4 = rt.u8Rem(kind, 3); + if (_4 === 0) { + hashed = rt.hashNew() as rt.HashSet; + sorted = rt.btreeNew(rt.cmp) as rt.BTreeSet; + iterS = data; + iterI = 0; + while (true) { + _10 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_10 === rt.DONE) { + rt.byteVecPush(out, rt.hashLen(hashed) & 0xff); + rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.hashKeys(hashed), (v2: rt.u16): boolean => { + return rt.u16Rem(v2, 2) === 1; + })) & 0xff); + iter2 = rt.iterRev(rt.btreeKeys(sorted)); + while (true) { + _62 = iter2.next(); + if (_62 === rt.DONE) { + rt.byteVecPush(out, rt.optionUnwrapOr(rt.btreeFirstKey(sorted), 255) & 0xff); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.btreeFirstKey(sorted, true), 255) & 0xff); + firsts = rt.iterToArray(rt.btreeRangeKeys(sorted, new rt.Range(4, 12))); + rt.byteVecPush(out, firsts.length & 0xff); + rt.hashRetain(hashed, (v3: rt.u16): boolean => { + return rt.u16Rem(v3, 3) !== 0; + }); + rt.btreeRetain(sorted, (v4: rt.u16): boolean => { + return rt.u16Rem(v4, 3) !== 0; + }); + rt.byteVecPush(out, rt.hashLen(hashed) & 0xff); + rt.iterExtendBytes(out, rt.iterMap(rt.btreeKeys(sorted), (v5: rt.u16): rt.u8 => { + return v5 & 0xff; + })); + break b0; + } else { + rt.byteVecPush(out, _62 & 0xff); + } + } + } else { + b = _10; + v = rt.u16Rem(b as rt.u16, 24); + _17 = rt.u8Rem(b, 3); + if (_17 === 0) { + rt.byteVecPush(out, rt.hashDelete(hashed, v) ? 1 : 0); + rt.byteVecPush(out, rt.btreeDelete(sorted, v) ? 1 : 0); + } else if (_17 === 1) { + rt.byteVecPush(out, rt.hashContains(hashed, v) ? 1 : 0); + rt.byteVecPush(out, rt.btreeContains(sorted, v) ? 1 : 0); + } else { + rt.byteVecPush(out, rt.hashAdd(hashed, v) ? 1 : 0); + rt.byteVecPush(out, rt.btreeAdd(sorted, v) ? 1 : 0); + } } - } else { - break; } - } - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); - let dirs: rt.HashSet = rt.hashNew(rt.hashing(Dir.hash$Hash_DefaultHasher, Dir.eq$PartialEq, true)) as rt.HashSet; - for (const item3 of data) { - const b3 = item3; - const value3 = ["Up" as Dir.Dir, "Top" as Dir.Dir, "Down" as Dir.Dir]; - const dir = rt.at(value3, rt.usizeRem(b3 as rt.usize, 3)); - rt.byteVecPush(out, rt.hashAdd(dirs, dir) ? 1 : 0); - } - rt.byteVecPush(out, rt.hashLen(dirs) & 0xff); - } else { - let words: rt.BTreeSet = rt.btreeNew(rt.cmpStr) as rt.BTreeSet; - for (const item4 of data) { - const b4 = item4; - const arg = words; - const value4 = ["", "a", "ab", "b", "é", "", "￿", "𐀀"]; - rt.btreeAdd(arg, rt.at(value4, rt.usizeRem(b4 as rt.usize, ["", "a", "ab", "b", "é", "", "￿", "𐀀"].length))); - } - const iter3 = rt.btreeKeys(words); - while (true) { - const w = iter3.next(); - if (w === rt.DONE) { - break; + } else if (_4 === 1) { + nibbles = rt.btreeNew(Nibble.cmp$Ord) as rt.BTreeSet; + seen = rt.hashNew(rt.hashing(Nibble.hash$Hash_DefaultHasher, Nibble.eq$PartialEq)) as rt.HashSet; + iterS2 = data; + iterI2 = 0; + while (true) { + _106 = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; + if (_106 === rt.DONE) { + iter4 = rt.btreeKeys(nibbles); + while (true) { + _123 = iter4.next(); + if (_123 === rt.DONE) { + while (true) { + _129 = rt.btreePopKey(nibbles, true); + if (_129 !== undefined) { + rt.byteVecPush(out, _129._0); + if (rt.usizeRem(rt.btreeLen(nibbles), 2) === 0) { + rt.byteVecPush(out, rt.optionMapOr(rt.btreePopKey(nibbles), 238, (n2: Nibble.Nibble): rt.u8 => { + return n2._0; + })); + } + } else { + rt.byteVecPush(out, rt.hashLen(seen) & 0xff); + dirs = rt.hashNew(rt.hashing(Dir.hash$Hash_DefaultHasher, Dir.eq$PartialEq, true)) as rt.HashSet; + iterS3 = data; + iterI3 = 0; + while (true) { + _151 = iterI3 < iterS3.length ? iterS3[iterI3++] : rt.DONE; + if (_151 === rt.DONE) { + rt.byteVecPush(out, rt.hashLen(dirs) & 0xff); + break b0; + } else { + _160 = rt.usizeRem(_151 as rt.usize, 3); + if (!(_160 < 3)) { + rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _160); + } + rt.byteVecPush(out, rt.hashAdd(dirs, ["Up" as Dir.Dir, "Top" as Dir.Dir, "Down" as Dir.Dir][_160]) ? 1 : 0); + } + } + } + } + } else { + rt.byteVecPush(out, _123._0); + } + } + } else { + b2 = _106; + rt.byteVecPush(out, rt.btreeAdd(nibbles, { _0: b2 }) ? 1 : 0); + rt.byteVecPush(out, rt.hashAdd(seen, { _0: b2 }) ? 1 : 0); + } } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(w)); - rt.byteVecPush(out, 0); - } - const wides = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.iterMap(rt.iterSlice(data), (arg2: rt.u8): rt.u64 => { - const b5 = arg2; - return wide(b5); - }), true); - const iter4 = rt.iterRev(rt.btreeKeys(wides)); - while (true) { - const w2 = iter4.next(); - if (w2 === rt.DONE) { - break; + } else { + words = rt.btreeNew(rt.cmpStr) as rt.BTreeSet; + iterS4 = data; + iterI4 = 0; + while (true) { + _175 = iterI4 < iterS4.length ? iterS4[iterI4++] : rt.DONE; + if (_175 === rt.DONE) { + iter7 = rt.btreeKeys(words); + while (true) { + _192 = iter7.next(); + if (_192 === rt.DONE) { + _200 = rt.iterMap(rt.iterSlice(data), (_2: rt.u8): rt.u64 => { + return wide(_2); + }); + wides = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _200, true); + iter8 = rt.iterRev(rt.btreeKeys(wides)); + while (true) { + _207 = iter8.next(); + if (_207 === rt.DONE) { + break b0; + } else { + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(_207)); + } + } + } else { + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_192)); + rt.byteVecPush(out, 0); + } + } + } else { + _182 = rt.usizeRem(_175 as rt.usize, ["", "a", "ab", "b", "é", "", "￿", "𐀀"].length); + if (!(_182 < 8)) { + rt.panic("index out of bounds: the len is " + 8 + " but the index is " + _182); + } + rt.btreeAdd(words, ["", "a", "ab", "b", "é", "", "￿", "𐀀"][_182]); + } } - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(w2)); } } } /** `BTreeMap`: ordered by the key's `Ord`, through inserts, removals, and ranges. */ export function btreeMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const value = rt.u8Rem(kind, 4); - if (value === 0) { - let map: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - const iter = rt.iterStepBy(new rt.Range(0, data.length), 2); - while (true) { - const i = iter.next(); - if (i === rt.DONE) { - break; - } - const [k, v] = [rt.u8Rem(rt.at(data, i), 32), rt.optionUnwrapOr(rt.sliceGet(data, rt.usizeAdd(i, 1)), 0)] as [rt.u8, rt.u8]; - const value2 = rt.u8Rem(v, 6); - if (value2 === 0) { - rt.byteVecPush(out, rt.optionUnwrapOr(rt.btreeRemove(map, k), 0xee)); - } else if (value2 === 1) { - rt.byteVecPush(out, rt.optionMapOr(rt.btreePop(map), 0xdd, (arg: [rt.u8, rt.u8]): rt.u8 => { - const k2 = arg[0]; - const v2 = arg[1]; - return k2 ^ v2; - })); - } else if (value2 === 2) { - rt.byteVecPush(out, rt.optionMapOr(rt.btreePop(map, true), 0xdc, (arg2: [rt.u8, rt.u8]): rt.u8 => { - const k3 = arg2[0]; - const v3 = arg2[1]; - return k3 ^ v3; - })); - } else if (value2 === 3) { - const copied = rt.btreeGet(map, k); - if (copied !== undefined) { - const v4 = copied; - rt.btreeInsert(map, k, rt.u8WrappingAdd(v4, 1)); + let _4!: rt.u8; + let map!: rt.BTreeMap; + let iter!: rt.Iter; + let _13!: rt.usize | rt.Done; + let i!: rt.usize; + let k!: rt.u8; + let v!: rt.u8; + let _19!: [rt.u8, rt.u8]; + let _30!: rt.u8; + let _42!: rt.u8 | undefined; + let _50!: rt.u8; + let iter2!: rt.Iter<[rt.u8, rt.u8]>; + let _73!: [rt.u8, rt.u8] | rt.Done; + let iter3!: rt.Iter<[rt.u8, rt.u8]>; + let _88!: [rt.u8, rt.u8] | rt.Done; + let iter4!: rt.Iter; + let _101!: rt.u8 | rt.Done; + let lo!: rt.u8; + let hi!: rt.u8; + let within!: rt.ByteVec; + let _137!: rt.u8; + let _146!: rt.RangeInclusive; + let ranks!: rt.BTreeMap; + let pairs!: rt.BTreeMap<[rt.u8, rt.u8], rt.u8>; + let wides!: rt.BTreeMap; + let iterStart!: rt.usize; + let iterEnd!: rt.usize; + let _164!: rt.usize; + let i2!: rt.usize; + let a!: rt.u8; + let b!: rt.u8; + let _170!: [rt.u8, rt.u8]; + let _171!: rt.u8; + let _172!: rt.usize; + let t!: Tally.Tally; + let _182!: Rank.Rank; + let _188!: [rt.u8, rt.u8]; + let _196!: rt.u64; + let _197!: Tally.Tally | undefined; + let iterS!: Uint8Array; + let iterI!: number; + let _205!: rt.u8 | rt.Done; + let b2!: rt.u8; + let r!: Rank.Rank; + let _212!: rt.Entry; + let e!: rt.Entry; + let _230!: [Rank.Rank, Tally.Tally]; + let e3!: rt.Entry; + let iter7!: rt.Iter<[Rank.Rank, Tally.Tally]>; + let _240!: [Rank.Rank, Tally.Tally] | rt.Done; + let iter8!: rt.Iter<[[rt.u8, rt.u8], rt.u8]>; + let _255!: [[rt.u8, rt.u8], rt.u8] | rt.Done; + let _269!: { start: rt.u64 }; + let iter9!: rt.Iter<[rt.u64, rt.u8]>; + let _274!: [rt.u64, rt.u8] | rt.Done; + let map2!: rt.BTreeMap; + let _287!: rt.Iter<[Fussy.Fussy, Fussy.Fussy]>; + let copy!: rt.BTreeMap; + let iter10!: rt.Iter<[Fussy.Fussy, Fussy.Fussy]>; + let _294!: [Fussy.Fussy, Fussy.Fussy] | rt.Done; + let nibbles!: rt.BTreeMap; + let words!: rt.BTreeMap; + let iterS2!: Uint8Array; + let iterI2!: number; + let _307!: rt.u8 | rt.Done; + let b3!: rt.u8; + let t2!: Tally.Tally; + let _320!: rt.usize; + let iter12!: rt.Iter<[Nibble.Nibble, rt.u8]>; + let _331!: [Nibble.Nibble, rt.u8] | rt.Done; + let iterStart2!: rt.usize; + let iterEnd2!: rt.usize; + let _344!: rt.usize; + let i3!: rt.usize; + let a2!: Nibble.Nibble; + let b4!: Nibble.Nibble; + let _350!: [Nibble.Nibble, Nibble.Nibble]; + let _351!: Nibble.Nibble; + let _353!: rt.usize; + let x!: rt.u8; + let y!: rt.u8; + let _363!: [rt.u8, rt.u8]; + let _364!: rt.u8; + let _365!: rt.usize; + let o!: rt.Ordering; + let _401!: rt.u8; + let collected!: rt.BTreeMap; + let _409!: rt.Iter<[Nibble.Nibble, rt.u8]>; + let keys!: rt.BTreeSet; + let _412!: rt.Iter; + let _416!: rt.Iter; + let iter14!: rt.Iter<[[Nibble.Nibble, rt.u8], Nibble.Nibble]>; + let _425!: [[Nibble.Nibble, rt.u8], Nibble.Nibble] | rt.Done; + let iter15!: rt.Iter<[string, Tally.Tally]>; + let _442!: [string, Tally.Tally] | rt.Done; + b0: { + _4 = rt.u8Rem(kind, 4); + if (_4 === 0) { + map = rt.btreeNew(rt.cmp) as rt.BTreeMap; + iter = rt.iterStepBy(new rt.Range(0, data.length), 2); + while (true) { + _13 = iter.next(); + if (_13 === rt.DONE) { + rt.byteVecPush(out, rt.optionMapOr(rt.btreeFirst(map), 255, (_223: [rt.u8, rt.u8]): rt.u8 => { + return _223[0]; + })); + rt.byteVecPush(out, rt.optionMapOr(rt.btreeFirst(map, true), 255, (_224: [rt.u8, rt.u8]): rt.u8 => { + return _224[0]; + })); + iter2 = rt.btreeRange(map, new rt.Range(8, 24)); + while (true) { + _73 = iter2.next(); + if (_73 === rt.DONE) { + iter3 = rt.iterRev(rt.btreeRange(map, { start: 10 })); + while (true) { + _88 = iter3.next(); + if (_88 === rt.DONE) { + iter4 = rt.iterMap(rt.btreeRange(map, { end: 6 }), (_229: [rt.u8, rt.u8]): rt.u8 => { + return _229[1]; + }); + while (true) { + _101 = iter4.next(); + if (_101 === rt.DONE) { + rt.iterExtendBytes(out, rt.btreeKeys(map)); + rt.iterExtendBytes(out, rt.btreeValues(map)); + rt.btreeRemove(map, 3); + rt.byteVecPush(out, rt.btreeLen(map) & 0xff); + rt.byteVecPush(out, rt.btreeContains(map, 3) ? 1 : 0); + lo = rt.u8Rem(rt.optionUnwrapOr(rt.sliceFirst(data), 0), 32); + hi = rt.u8Rem(rt.optionUnwrapOr(rt.sliceGet(data, 1), 0), 32); + _137 = rt.u8Rem(lo, 3); + if (_137 === 0) { + within = rt.iterToByteVec(rt.iterMap(rt.btreeRange(map, new rt.Range(lo, hi)), (_238: [rt.u8, rt.u8]): rt.u8 => { + return _238[0]; + })); + } else if (_137 === 1) { + _146 = new rt.RangeInclusive(lo, hi, rt.u8Step); + within = rt.iterToByteVec(rt.iterMap(rt.btreeRange(map, _146), (_235: [rt.u8, rt.u8]): rt.u8 => { + return _235[0]; + })); + } else { + within = rt.iterToByteVec(rt.iterMap(rt.btreeRange(map, { start: lo }), (_231: [rt.u8, rt.u8]): rt.u8 => { + return _231[0]; + })); + } + rt.byteVecExtendFromSlice(out, rt.byteVecView(within)); + rt.iterExtendBytes(out, rt.btreeValues(map)); + break b0; + } else { + rt.byteVecPush(out, _101); + } + } + } else { + rt.byteVecPush(out, _88[0] ^ _88[1]); + } + } + } else { + rt.byteVecPush(out, _73[0]); + rt.byteVecPush(out, _73[1]); + } + } + } else { + i = _13; + rt.idx(data, i); + _19 = [rt.u8Rem(data[i], 32), rt.optionUnwrapOr(rt.sliceGet(data, rt.usizeAdd(i, 1)), 0)] as [rt.u8, rt.u8]; + k = _19[0]; + v = _19[1]; + _30 = rt.u8Rem(v, 6); + if (_30 === 0) { + rt.byteVecPush(out, rt.optionUnwrapOr(rt.btreeRemove(map, k), 238)); + } else if (_30 === 1) { + rt.byteVecPush(out, rt.optionMapOr(rt.btreePop(map), 221, (_219: [rt.u8, rt.u8]): rt.u8 => { + return _219[0] ^ _219[1]; + })); + } else if (_30 === 2) { + rt.byteVecPush(out, rt.optionMapOr(rt.btreePop(map, true), 220, (_216: [rt.u8, rt.u8]): rt.u8 => { + return _216[0] ^ _216[1]; + })); + } else if (_30 === 3) { + _42 = rt.btreeGet(map, k); + if (_42 !== undefined) { + _50 = rt.u8WrappingAdd(_42, 1); + rt.btreeInsert(map, k, _50); + } + rt.byteVecPush(out, rt.optionUnwrapOr(rt.btreeGet(map, k), 219)); + } else { + rt.byteVecPush(out, rt.optionUnwrapOr(rt.btreeInsert(map, k, v), 204)); + } } - rt.byteVecPush(out, rt.optionUnwrapOr(rt.btreeGet(map, k), 0xdb)); - } else { - rt.byteVecPush(out, rt.optionUnwrapOr(rt.btreeInsert(map, k, v), 0xcc)); - } - } - rt.byteVecPush(out, rt.optionMapOr(rt.btreeFirst(map), 0xff, (arg3: [rt.u8, rt.u8]): rt.u8 => { - const k4 = arg3[0]; - return k4; - })); - rt.byteVecPush(out, rt.optionMapOr(rt.btreeFirst(map, true), 0xff, (arg4: [rt.u8, rt.u8]): rt.u8 => { - const k5 = arg4[0]; - return k5; - })); - const iter2 = rt.btreeRange(map, new rt.Range(8, 24)); - while (true) { - const item = iter2.next(); - if (item === rt.DONE) { - break; } - const k6 = item[0]; - const v5 = item[1]; - rt.byteVecPush(out, k6); - rt.byteVecPush(out, v5); - } - const iter3 = rt.iterRev(rt.btreeRange(map, { start: 10 })); - while (true) { - const item2 = iter3.next(); - if (item2 === rt.DONE) { - break; + } else if (_4 === 1) { + ranks = rt.btreeNew(Rank.cmp$Ord) as rt.BTreeMap; + pairs = rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u8, rt.u8], rt.u8>; + wides = rt.btreeNew(rt.cmp) as rt.BTreeMap; + iterStart = 1; + iterEnd = data.length; + while (true) { + if (!((_164 = iterStart++) < iterEnd)) { + _197 = rt.btreeGet(ranks, { tag: "Low" } as Rank.Rank); + if (_197 !== undefined) { + _197.n = _197.n ^ 23130; + } + iterS = data; + iterI = 0; + while (true) { + _205 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_205 === rt.DONE) { + iter7 = rt.btreeIter(ranks); + while (true) { + _240 = iter7.next(); + if (_240 === rt.DONE) { + iter8 = rt.btreeIter(pairs); + while (true) { + _255 = iter8.next(); + if (_255 === rt.DONE) { + _269 = { start: 4503599627370496 }; + iter9 = rt.btreeRange(wides, _269); + while (true) { + _274 = iter9.next(); + if (_274 === rt.DONE) { + break b0; + } else { + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(_274[0])); + rt.byteVecPush(out, _274[1]); + } + } + } else { + rt.byteVecPush(out, rt.u8Shl(_255[0][0], 4) | _255[0][1]); + rt.byteVecPush(out, _255[1]); + } + } + } else { + rt.byteVecPush(out, rankByte(_240[0])); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(_240[1].n)); + } + } + } else { + b2 = _205; + r = rank(b2, rt.u8Div(b2, 3)); + _212 = rt.entry(ranks, r); + if (!rt.entryOccupied(_212)) { + e = _212; + rt.byteVecPush(out, rankByte(rt.entryKey(e))); + rt.entryOrInsert(e, { n: b2 as rt.u16 }); + } else if (!(rt.entryGet(_212).n > 256)) { + e3 = _212; + rt.byteVecPush(out, rt.entryInsert(e3, { n: 512 }).n & 0xff); + } else { + _230 = rt.entryRemoveEntry(_212); + rt.byteVecPush(out, rankByte(_230[0])); + } + } + } + } else { + i2 = _164; + _172 = rt.usizeSub(i2, 1); + rt.idx(data, _172); + _171 = data[_172]; + rt.idx(data, i2); + _170 = [_171, data[i2]] as [rt.u8, rt.u8]; + a = _171; + b = _170[1]; + _182 = rank(a, b); + t = rt.entryOrInsertWith(rt.entry(ranks, _182), Tally.default$Default); + t.n = rt.u16WrappingAdd(t.n, b as rt.u16); + _188 = [rt.u8Rem(a, 4), rt.u8Rem(b, 4)] as [rt.u8, rt.u8]; + rt.btreeInsert(pairs, _188, a); + _196 = wide(a); + rt.entryOrInsert(rt.entry(wides, _196), b); + } } - const k7 = item2[0]; - const v6 = item2[1]; - rt.byteVecPush(out, k7 ^ v6); - } - const iter4 = rt.iterMap(rt.btreeRange(map, { end: 6 }), (arg5: [rt.u8, rt.u8]): rt.u8 => { - const v7 = arg5[1]; - return v7; - }); - while (true) { - const v8 = iter4.next(); - if (v8 === rt.DONE) { - break; + } else if (_4 === 2) { + _287 = rt.iterMap(rt.iterSlice(data), (_215: rt.u8): [Fussy.Fussy, Fussy.Fussy] => { + let b8!: rt.u8; + b8 = _215; + return [{ _0: b8 }, { _0: b8 ^ 90 }] as [Fussy.Fussy, Fussy.Fussy]; + }); + map2 = rt.btreeExtend(rt.btreeNew(Fussy.cmp$Ord) as rt.BTreeMap, _287, true); + copy = rt.btreeClone(map2, Fussy.clone$Clone, Fussy.clone$Clone); + iter10 = rt.btreeIter(copy); + while (true) { + _294 = iter10.next(); + if (_294 === rt.DONE) { + break b0; + } else { + rt.byteVecPush(out, _294[0]._0 ^ _294[1]._0); + } } - rt.byteVecPush(out, v8); - } - rt.iterExtendBytes(out, rt.btreeKeys(map)); - rt.iterExtendBytes(out, rt.btreeValues(map)); - rt.btreeRemove(map, 3); - rt.byteVecPush(out, rt.btreeLen(map) & 0xff); - rt.byteVecPush(out, rt.btreeContains(map, 3) ? 1 : 0); - const lo = rt.u8Rem(rt.optionUnwrapOr(rt.sliceFirst(data), 0), 32); - const hi = rt.u8Rem(rt.optionUnwrapOr(rt.sliceGet(data, 1), 0), 32); - let within: rt.ByteVec; - const value3 = rt.u8Rem(lo, 3); - if (value3 === 0) { - within = rt.iterToByteVec(rt.iterMap(rt.btreeRange(map, new rt.Range(lo, hi)), (arg6: [rt.u8, rt.u8]): rt.u8 => { - const k8 = arg6[0]; - return k8; - })); - } else if (value3 === 1) { - within = rt.iterToByteVec(rt.iterMap(rt.btreeRange(map, new rt.RangeInclusive(lo, hi, rt.u8Step)), (arg7: [rt.u8, rt.u8]): rt.u8 => { - const k9 = arg7[0]; - return k9; - })); } else { - within = rt.iterToByteVec(rt.iterMap(rt.btreeRange(map, { start: lo }), (arg8: [rt.u8, rt.u8]): rt.u8 => { - const k10 = arg8[0]; - return k10; - })); - } - rt.byteVecExtendFromSlice(out, rt.byteVecView(within)); - rt.iterExtendBytes(out, rt.btreeValues(map)); - } else if (value === 1) { - let ranks: rt.BTreeMap = rt.btreeNew(Rank.cmp$Ord) as rt.BTreeMap; - let pairs: rt.BTreeMap<[rt.u8, rt.u8], rt.u8> = rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u8, rt.u8], rt.u8>; - let wides: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - const end = data.length; - for (let i2 = 1; i2 < end; i2++) { - const [a, b] = [rt.at(data, rt.usizeSub(i2, 1)), rt.at(data, i2)] as [rt.u8, rt.u8]; - const t = rt.entryOrInsertWith(rt.entry(ranks, rank(a, b)), Tally.default$Default); - t.n = rt.u16WrappingAdd(t.n, b as rt.u16); - rt.btreeInsert(pairs, [rt.u8Rem(a, 4), rt.u8Rem(b, 4)] as [rt.u8, rt.u8], a); - rt.entryOrInsert(rt.entry(wides, wide(a)), b); - } - const getMut = rt.btreeGet(ranks, { tag: "Low" } as Rank.Rank); - if (getMut !== undefined) { - const t2 = getMut; - t2.n = t2.n ^ 0x5a5a; - } - for (const item3 of data) { - const b2 = item3; - const r = rank(b2, rt.u8Div(b2, 3)); - const entry = rt.entry(ranks, r); - arms: { - if (!rt.entryOccupied(entry)) { - const e = entry; - rt.byteVecPush(out, rankByte(rt.entryKey(e))); - rt.entryOrInsert(e, { n: b2 as rt.u16 }); - break arms; - } - if (rt.entryOccupied(entry)) { - const e2 = entry; - if (rt.entryGet(e2).n > 0x100) { - rt.byteVecPush(out, rankByte(rt.entryRemoveEntry(e2)[0])); - break arms; + nibbles = rt.btreeNew(Nibble.cmp$Ord) as rt.BTreeMap; + words = rt.btreeNew(rt.cmpStr) as rt.BTreeMap; + iterS2 = data; + iterI2 = 0; + while (true) { + _307 = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; + if (_307 === rt.DONE) { + iter12 = rt.btreeIter(nibbles); + while (true) { + _331 = iter12.next(); + if (_331 === rt.DONE) { + iterStart2 = 1; + iterEnd2 = data.length; + while (true) { + if (!((_344 = iterStart2++) < iterEnd2)) { + _409 = rt.iterMap(rt.iterSlice(data), (_2: rt.u8): [Nibble.Nibble, rt.u8] => { + let b5!: rt.u8; + b5 = _2; + return [{ _0: b5 }, b5] as [Nibble.Nibble, rt.u8]; + }); + collected = rt.btreeExtend(rt.btreeNew(Nibble.cmp$Ord) as rt.BTreeMap, _409, true); + _412 = rt.iterMap(rt.iterSlice(data), (_213: rt.u8): Nibble.Nibble => { + return { _0: _213 }; + }); + keys = rt.btreeExtendKeys(rt.btreeNew(Nibble.cmp$Ord) as rt.BTreeSet, _412, true); + _416 = rt.iterMap(rt.iterSlice(data), (_214: rt.u8): Nibble.Nibble => { + return { _0: _214 ^ 48 }; + }); + rt.btreeExtendKeys(keys, _416); + iter14 = rt.iterZip(rt.btreeIter(collected), rt.btreeKeys(keys)); + while (true) { + _425 = iter14.next(); + if (_425 === rt.DONE) { + rt.btreeRetain(words, (w: string, t3: Tally.Tally): boolean => { + if (!(rt.stringLen(w) > 1)) { + return t3.n > 1; + } else { + return true; + } + }); + iter15 = rt.btreeIter(words); + while (true) { + _442 = iter15.next(); + if (_442 === rt.DONE) { + break b0; + } else { + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_442[0])); + rt.byteVecPush(out, _442[1].n & 0xff); + } + } + } else { + rt.byteVecPush(out, _425[0][0]._0); + rt.byteVecPush(out, _425[0][1]); + rt.byteVecPush(out, _425[1]._0); + } + } + } else { + i3 = _344; + _353 = rt.usizeSub(i3, 1); + rt.idx(data, _353); + _351 = { _0: data[_353] }; + rt.idx(data, i3); + _350 = [_351, { _0: data[i3] }] as [Nibble.Nibble, Nibble.Nibble]; + a2 = _351; + b4 = _350[1]; + _365 = rt.usizeSub(i3, 1); + rt.idx(data, _365); + _364 = data[_365]; + rt.idx(data, i3); + _363 = [_364, data[i3]] as [rt.u8, rt.u8]; + x = _364; + y = _363[1]; + o = rt.orderingThen(rt.orderingReverse(Nibble.cmp$Ord(a2, b4)), (): rt.Ordering => { + return rt.cmp(y, x); + }, true); + rt.byteVecPush(out, (o < 0 ? 1 : 0) | (((o >= 0 ? 1 : 0) << 1) & 0xff) | (((rt.orderingThen(Nibble.cmp$Ord(a2, b4), -1) === 0 ? 1 : 0) << 2) & 0xff)); + if (o === -1) { + _401 = 1; + } else if (o === 0) { + _401 = 2; + } else { + _401 = 3; + } + rt.byteVecPush(out, _401); + rt.byteVecPush(out, rt.same(o, 1) ? 1 : 0); + } + } + } else { + rt.byteVecPush(out, _331[0]._0); + rt.byteVecPush(out, _331[1]); + } + } + } else { + b3 = _307; + rt.byteVecPush(out, rt.optionUnwrapOr(rt.btreeInsert(nibbles, { _0: b3 }, b3), 204)); + _320 = rt.usizeRem(b3 as rt.usize, ["", "a", "ab", "b", "é", "", "￿", "𐀀"].length); + if (!(_320 < 8)) { + rt.panic("index out of bounds: the len is " + 8 + " but the index is " + _320); } + t2 = rt.entryOrInsertWith(rt.entry(words, ["", "a", "ab", "b", "é", "", "￿", "𐀀"][_320]), Tally.default$Default); + t2.n = rt.u16Add(t2.n, 1); } - let e3: rt.Entry = entry; - rt.byteVecPush(out, rt.entryInsert(e3, { n: 0x200 }).n & 0xff); - } - } - const iter5 = rt.btreeIter(ranks); - while (true) { - const item4 = iter5.next(); - if (item4 === rt.DONE) { - break; - } - const r2 = item4[0]; - const t3 = item4[1]; - rt.byteVecPush(out, rankByte(r2)); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(t3.n)); - } - const iter6 = rt.btreeIter(pairs); - while (true) { - const item5 = iter6.next(); - if (item5 === rt.DONE) { - break; } - const a2 = item5[0][0]; - const b3 = item5[0][1]; - const v9 = item5[1]; - rt.byteVecPush(out, ((a2 << 4) & 0xff) | b3); - rt.byteVecPush(out, v9); - } - const iter7 = rt.btreeRange(wides, { start: 4503599627370496 }); - while (true) { - const item6 = iter7.next(); - if (item6 === rt.DONE) { - break; - } - const k11 = item6[0]; - const v10 = item6[1]; - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(k11)); - rt.byteVecPush(out, v10); - } - } else if (value === 2) { - const map2 = rt.btreeExtend(rt.btreeNew(Fussy.cmp$Ord) as rt.BTreeMap, rt.iterMap(rt.iterSlice(data), (arg9: rt.u8): [Fussy.Fussy, Fussy.Fussy] => { - const b4 = arg9; - return [{ _0: b4 }, { _0: b4 ^ 0x5a }]; - }), true); - const copy = rt.btreeClone(map2, Fussy.clone$Clone, Fussy.clone$Clone); - const iter8 = rt.btreeIter(copy); - while (true) { - const item7 = iter8.next(); - if (item7 === rt.DONE) { - break; - } - const k12 = item7[0]; - const v11 = item7[1]; - rt.byteVecPush(out, k12._0 ^ v11._0); - } - } else { - let nibbles: rt.BTreeMap = rt.btreeNew(Nibble.cmp$Ord) as rt.BTreeMap; - let words: rt.BTreeMap = rt.btreeNew(rt.cmpStr) as rt.BTreeMap; - for (const item8 of data) { - const b5 = item8; - rt.byteVecPush(out, rt.optionUnwrapOr(rt.btreeInsert(nibbles, { _0: b5 }, b5), 0xcc)); - const arg10 = words; - const value4 = ["", "a", "ab", "b", "é", "", "￿", "𐀀"]; - const t4 = rt.entryOrInsertWith(rt.entry(arg10, rt.at(value4, rt.usizeRem(b5 as rt.usize, ["", "a", "ab", "b", "é", "", "￿", "𐀀"].length))), Tally.default$Default); - t4.n = rt.u16Add(t4.n, 1); - } - const iter9 = rt.btreeIter(nibbles); - while (true) { - const item9 = iter9.next(); - if (item9 === rt.DONE) { - break; - } - const k13 = item9[0]; - const v12 = item9[1]; - rt.byteVecPush(out, k13._0); - rt.byteVecPush(out, v12); - } - const end2 = data.length; - for (let i3 = 1; i3 < end2; i3++) { - const value5 = [{ _0: rt.at(data, rt.usizeSub(i3, 1)) }, { _0: rt.at(data, i3) }] as [Nibble.Nibble, Nibble.Nibble]; - const a3 = value5[0]; - const b6 = value5[1]; - const [x, y] = [rt.at(data, rt.usizeSub(i3, 1)), rt.at(data, i3)] as [rt.u8, rt.u8]; - const o = rt.orderingThen(rt.orderingReverse(Nibble.cmp$Ord(a3, b6)), (): rt.Ordering => { - return rt.cmp(y, x); - }, true); - rt.byteVecPush(out, (o < 0 ? 1 : 0) | (((o >= 0 ? 1 : 0) << 1) & 0xff) | (((rt.orderingThen(Nibble.cmp$Ord(a3, b6), -1) === 0 ? 1 : 0) << 2) & 0xff)); - rt.byteVecPush(out, o === -1 ? 1 : o === 0 ? 2 : 3); - rt.byteVecPush(out, rt.same(o, 1) ? 1 : 0); - } - const collected = rt.btreeExtend(rt.btreeNew(Nibble.cmp$Ord) as rt.BTreeMap, rt.iterMap(rt.iterSlice(data), (arg11: rt.u8): [Nibble.Nibble, rt.u8] => { - const b7 = arg11; - return [{ _0: b7 }, b7]; - }), true); - let keys: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(Nibble.cmp$Ord) as rt.BTreeSet, rt.iterMap(rt.iterSlice(data), (arg12: rt.u8): Nibble.Nibble => { - const b8 = arg12; - return { _0: b8 }; - }), true); - rt.btreeExtendKeys(keys, rt.iterMap(rt.iterSlice(data), (arg13: rt.u8): Nibble.Nibble => { - const b9 = arg13; - return { _0: b9 ^ 0x30 }; - })); - const iter10 = rt.iterZip(rt.btreeIter(collected), rt.btreeKeys(keys)); - while (true) { - const item10 = iter10.next(); - if (item10 === rt.DONE) { - break; - } - const k14 = item10[0][0]; - const v13 = item10[0][1]; - const n = item10[1]; - rt.byteVecPush(out, k14._0); - rt.byteVecPush(out, v13); - rt.byteVecPush(out, n._0); - } - rt.btreeRetain(words, (w: string, t5: Tally.Tally): boolean => { - return rt.stringLen(w) > 1 || t5.n > 1; - }); - const iter11 = rt.btreeIter(words); - while (true) { - const item11 = iter11.next(); - if (item11 === rt.DONE) { - break; - } - const w2 = item11[0]; - const t6 = item11[1]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(w2)); - rt.byteVecPush(out, t6.n & 0xff); } } } /** Pushes an item, and gives back the deque. */ export function touch(q: rt.VecDeque): rt.VecDeque { - rt.dequePushBack(q, 0x42); + rt.dequePushBack(q, 66); return q; } /** `VecDeque`: a ring buffer, pushed and popped at both ends past its capacity. */ export function deques(data: Uint8Array, out: rt.ByteVec): void { - let q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; - let pairs: rt.VecDeque<[rt.u8, rt.u8]> = rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8]>; - for (const item of data) { - const b = item; - const value = rt.u8Rem(b, 7); - if (value === 0) { - rt.byteVecPush(out, rt.optionUnwrapOr(rt.dequePopFront(q), 0xee)); - } else if (value === 1) { - rt.byteVecPush(out, rt.optionUnwrapOr(rt.dequePopBack(q), 0xed)); - } else if (value === 2) { - rt.dequePushFront(q, b); - } else if (value === 3) { - rt.byteVecPush(out, rt.optionUnwrapOr(rt.dequeEnd(q), 0xec)); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.dequeEnd(q, true), 0xeb)); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.dequeGet(q, rt.usizeRem(b as rt.usize, 5)), 0xea)); - } else { - rt.dequePushBack(q, b); - } - rt.dequePushBack(pairs, [b, q.n & 0xff] as [rt.u8, rt.u8]); - if (pairs.n > 3) { - rt.dequePopFront(pairs); - } - } - touch(q); - touch(q); - rt.byteVecPush(out, q.n & 0xff); - rt.iterExtendBytes(out, rt.iterRev(rt.dequeIter(q))); - if (!((q.n === 0))) { - rt.byteVecPush(out, rt.dequeIndex(q, rt.usizeDiv(q.n, 2))); - } - rt.dequeRetain(q, (b2: rt.u8): boolean => { - return rt.u8Rem(b2, 2) === 0; - }); - rt.iterExtendBytes(out, rt.dequeIter(q)); - const iter = rt.dequeIter(pairs); + let q!: rt.VecDeque; + let pairs!: rt.VecDeque<[rt.u8, rt.u8]>; + let iterS!: Uint8Array; + let iterI!: number; + let _7!: rt.u8 | rt.Done; + let b!: rt.u8; + let _12!: rt.u8; + let _36!: rt.usize; + let _42!: [rt.u8, rt.u8]; + let _71!: rt.usize; + let iter2!: rt.Iter<[rt.u8, rt.u8]>; + let _83!: [rt.u8, rt.u8] | rt.Done; + let drained!: rt.ByteVec; + let tallies!: rt.VecDeque; + let _101!: rt.Iter; + let copy!: rt.VecDeque; + let _105!: Tally.Tally | undefined; + let _119!: rt.Iter; + let _121!: Tally.Tally | undefined; + let _135!: rt.Iter; + let _139!: rt.usize; + let a!: rt.usize; + let b2!: rt.usize; + let q2!: rt.VecDeque; + let _171!: rt.Iter; + let drained2!: rt.ByteVec; + let _174!: rt.usize; + let _181!: rt.RangeInclusive; + q = rt.dequeNew() as rt.VecDeque; + pairs = rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8]>; + iterS = data; + iterI = 0; while (true) { - const item2 = iter.next(); - if (item2 === rt.DONE) { - break; + _7 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_7 === rt.DONE) { + touch(q); + touch(q); + rt.byteVecPush(out, q.n & 0xff); + rt.iterExtendBytes(out, rt.iterRev(rt.dequeIter(q))); + if (!((q.n === 0))) { + _71 = rt.usizeDiv(q.n, 2); + rt.byteVecPush(out, rt.dequeIndex(q, _71)); + } + rt.dequeRetain(q, (b3: rt.u8): boolean => { + return rt.u8Rem(b3, 2) === 0; + }); + rt.iterExtendBytes(out, rt.dequeIter(q)); + iter2 = rt.dequeIter(pairs); + while (true) { + _83 = iter2.next(); + if (_83 === rt.DONE) { + drained = rt.iterToByteVec(rt.dequeDrain(q, undefined)); + rt.byteVecExtendFromSlice(out, rt.byteVecView(drained)); + rt.byteVecPush(out, q.n === 0 ? 1 : 0); + _101 = rt.iterMap(rt.iterSlice(data), (_2: rt.u8): Tally.Tally => { + return { n: _2 as rt.u16 }; + }); + tallies = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _101); + copy = rt.dequeClone(tallies, rt.copy); + _105 = rt.dequeEnd(copy); + if (_105 !== undefined) { + _105.n = _105.n ^ 255; + } + rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(tallies), (t: Tally.Tally): rt.u8 => { + return t.n & 0xff; + })); + rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(copy), (t2: Tally.Tally): rt.u8 => { + return t2.n & 0xff; + })); + _119 = rt.dequeIter(tallies); + rt.dequeExtend(copy, rt.iterMap(_119, rt.copy)); + _121 = rt.dequeEnd(copy, true); + if (_121 !== undefined) { + _121.n = _121.n ^ 255; + } + rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(tallies), (t3: Tally.Tally): rt.u8 => { + return t3.n & 0xff; + })); + rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(copy), (t4: Tally.Tally): rt.u8 => { + return t4.n & 0xff; + })); + _135 = rt.iterSlice(data); + rt.dequeExtend(q, _135); + _139 = rt.usizeDiv(q.n, 2); + rt.dequeInsert(q, _139, 66); + rt.byteVecPush(out, rt.optionUnwrapOr(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))); + a = rt.usizeRem(rt.optionUnwrapOr(rt.sliceFirst(data), 0) as rt.usize, 8); + b2 = rt.usizeRem(rt.optionUnwrapOr(rt.sliceGet(data, 1), 0) as rt.usize, 8); + _171 = rt.iterSlice(data); + q2 = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _171); + _174 = rt.usizeRem(a, 4); + if (_174 === 0) { + drained2 = rt.iterToByteVec(rt.dequeDrain(q2, new rt.Range(a, b2))); + } else if (_174 === 1) { + _181 = new rt.RangeInclusive(a, b2, rt.usizeStep); + drained2 = rt.iterToByteVec(rt.dequeDrain(q2, _181)); + } else if (_174 === 2) { + drained2 = rt.iterToByteVec(rt.dequeDrain(q2, { end: b2 })); + } else { + drained2 = rt.iterToByteVec(rt.dequeDrain(q2, { start: a })); + } + rt.byteVecExtendFromSlice(out, rt.byteVecView(drained2)); + rt.iterExtendBytes(out, rt.dequeIter(q2)); + rt.byteVecPush(out, rt.dequeIndex(q2, b2)); + return; + } else { + rt.byteVecPush(out, _83[0] ^ _83[1]); + } + } + } else { + b = _7; + _12 = rt.u8Rem(b, 7); + if (_12 === 0) { + rt.byteVecPush(out, rt.optionUnwrapOr(rt.dequePopFront(q), 238)); + } else if (_12 === 1) { + rt.byteVecPush(out, rt.optionUnwrapOr(rt.dequePopBack(q), 237)); + } else if (_12 === 2) { + rt.dequePushFront(q, b); + } else if (_12 === 3) { + rt.byteVecPush(out, rt.optionUnwrapOr(rt.dequeEnd(q), 236)); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.dequeEnd(q, true), 235)); + _36 = rt.usizeRem(b as rt.usize, 5); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.dequeGet(q, _36), 234)); + } else { + rt.dequePushBack(q, b); + } + _42 = [b, q.n & 0xff] as [rt.u8, rt.u8]; + rt.dequePushBack(pairs, _42); + if (pairs.n > 3) { + rt.dequePopFront(pairs); + } } - const a = item2[0]; - const b3 = item2[1]; - rt.byteVecPush(out, a ^ b3); - } - const drained = rt.iterToByteVec(rt.dequeDrain(q, undefined)); - rt.byteVecExtendFromSlice(out, rt.byteVecView(drained)); - rt.byteVecPush(out, q.n === 0 ? 1 : 0); - const tallies = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterMap(rt.iterSlice(data), (arg: rt.u8): Tally.Tally => { - const b4 = arg; - return { n: b4 as rt.u16 }; - })); - let copy: rt.VecDeque = rt.dequeClone(tallies, rt.copy); - const frontMut = rt.dequeEnd(copy); - if (frontMut !== undefined) { - const t = frontMut; - t.n = t.n ^ 0xff; - } - rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(tallies), (t2: Tally.Tally): rt.u8 => { - return t2.n & 0xff; - })); - rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(copy), (t3: Tally.Tally): rt.u8 => { - return t3.n & 0xff; - })); - rt.dequeExtend(copy, rt.iterMap(rt.dequeIter(tallies), rt.copy)); - const backMut = rt.dequeEnd(copy, true); - if (backMut !== undefined) { - const t4 = backMut; - t4.n = t4.n ^ 0xff; } - rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(tallies), (t5: Tally.Tally): rt.u8 => { - return t5.n & 0xff; - })); - rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(copy), (t6: Tally.Tally): rt.u8 => { - return t6.n & 0xff; - })); - rt.dequeExtend(q, rt.iterSlice(data)); - rt.dequeInsert(q, rt.usizeDiv(q.n, 2), 0x42); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.dequeRemove(q, 1), 0xe9)); - rt.dequeTruncate(q, 5); - rt.byteVecPush(out, rt.dequeContains(q, 0x42, rt.same) ? 1 : 0); - rt.iterExtendBytes(out, rt.iterRev(rt.dequeIter(q))); - const a2 = rt.usizeRem(rt.optionUnwrapOr(rt.sliceFirst(data), 0) as rt.usize, 8); - const b5 = rt.usizeRem(rt.optionUnwrapOr(rt.sliceGet(data, 1), 0) as rt.usize, 8); - let q2: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(data)); - const value2 = rt.usizeRem(a2, 4); - const drained2 = value2 === 0 ? rt.iterToByteVec(rt.dequeDrain(q2, new rt.Range(a2, b5))) : value2 === 1 ? rt.iterToByteVec(rt.dequeDrain(q2, new rt.RangeInclusive(a2, b5, rt.usizeStep))) : value2 === 2 ? rt.iterToByteVec(rt.dequeDrain(q2, { end: b5 })) : rt.iterToByteVec(rt.dequeDrain(q2, { start: a2 })); - rt.byteVecExtendFromSlice(out, rt.byteVecView(drained2)); - rt.iterExtendBytes(out, rt.dequeIter(q2)); - rt.byteVecPush(out, rt.dequeIndex(q2, b5)); } //# sourceMappingURL=collections.ts.map diff --git a/ts/fixtures/lang/expected/fmt.Fails.ts b/ts/fixtures/lang/expected/fmt.Fails.ts index 2f4b136a2..3df147af5 100644 --- a/ts/fixtures/lang/expected/fmt.Fails.ts +++ b/ts/fixtures/lang/expected/fmt.Fails.ts @@ -8,14 +8,20 @@ export interface Fails { } export function fmt$Display(self: Fails, f: rt.Formatter): rt.Result { - if (rt.u8Rem(self._0, 2) === 0) { + let _8!: rt.Result; + let args2!: rt.Fmt[]; + if (!(rt.u8Rem(self._0, 2) === 0)) { + const arg = ([self._0] as [rt.u8])[0]; + args2 = [(f: rt.Formatter) => rt.u8Display(arg, f)]; + _8 = rt.fmtWriteFmt(f, ["half ", args2[0]]); + if (_8.ok) { + return rt.Err(new rt.FmtError()); + } else { + return rt.Err(new rt.FmtError()); + } + } else { return rt.fmtWriteStr(f, "fine"); } - const writeFmt = rt.fmtWriteFmt(f, ["half ", (f: rt.Formatter) => rt.u8Display(self._0, f)]); - if (!writeFmt.ok) { - return rt.Err(writeFmt.error); - } - return rt.Err(new rt.FmtError()); } //# sourceMappingURL=fmt.Fails.ts.map diff --git a/ts/fixtures/lang/expected/fmt.Fault.ts b/ts/fixtures/lang/expected/fmt.Fault.ts index ae83a266c..4baf20303 100644 --- a/ts/fixtures/lang/expected/fmt.Fault.ts +++ b/ts/fixtures/lang/expected/fmt.Fault.ts @@ -4,18 +4,32 @@ import * as rt from "./rt.ts"; import * as Pair from "./fmt.Pair.ts"; export function fmt$Debug(self: Fault, f: rt.Formatter): rt.Result { + let _6!: string; + let _7!: rt.Fmt; + let _11!: string; + let _12!: string; + let _13!: rt.Fmt; + let _14!: string; + let _15!: rt.Fmt; + let _18!: string; + let _19!: rt.Fmt; if (self.tag === "Short") { return rt.fmtWriteStr(f, "Short"); } else if (self.tag === "Code") { - const __self0 = self._0; - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, "Code"), (f: rt.Formatter) => rt.u16Display(__self0, f))); + _6 = "Code"; + _7 = (f: rt.Formatter) => rt.u16Display(self._0, f); + return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _6), _7)); } else if (self.tag === "TooLarge") { - const __self02 = self.size; - const __self1 = self.max; - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "TooLarge"), "size", (f: rt.Formatter) => rt.usizeDisplay(__self02, f)), "max", (f: rt.Formatter) => rt.usizeDisplay(__self1, f))); + _11 = "TooLarge"; + _12 = "size"; + _13 = (f: rt.Formatter) => rt.usizeDisplay(self.size, f); + _14 = "max"; + _15 = (f: rt.Formatter) => rt.usizeDisplay(self.max, f); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _11), _12, _13), _14, _15)); } else { - const __self03 = self._0; - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, "At"), (f: rt.Formatter) => Pair.fmt$Debug(__self03, f))); + _18 = "At"; + _19 = (f: rt.Formatter) => Pair.fmt$Debug(self._0, f); + return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _18), _19)); } } @@ -30,35 +44,45 @@ export type Fault = | { tag: "At"; _0: Pair.Pair }; export function fmt$Display(self: Fault, f: rt.Formatter): rt.Result { + let args2!: rt.Fmt[]; + let args4!: rt.Fmt[]; + let _20!: rt.Fmt; + let args6!: rt.Fmt[]; if (self.tag === "Short") { return rt.fmtPad(f, "short buffer"); } else if (self.tag === "Code") { - const code = self._0; - return rt.fmtWriteFmt(f, ["code=", rt.fmtSpec({ alternate: true, zero: true, width: 6 }, (f: rt.Formatter) => rt.u16LowerHex(code, f))]); + const arg4 = ([self._0] as [rt.u16])[0]; + args2 = [(f: rt.Formatter) => rt.u16LowerHex(arg4, f)]; + return rt.fmtWriteFmt(f, ["code=", rt.fmtSpec({ alternate: true, zero: true, width: 6 }, args2[0])]); } else if (self.tag === "TooLarge") { - const size = self.size; - const max = self.max; - return rt.fmtWriteFmt(f, [(f: rt.Formatter) => rt.usizeDisplay(size, f), " bytes exceeds the ", (f: rt.Formatter) => rt.usizeDisplay(max, f), " byte limit"]); + const arg2 = self.size; + _20 = (f: rt.Formatter) => rt.usizeDisplay(arg2, f); + const arg3 = self.max; + args4 = [_20, (f: rt.Formatter) => rt.usizeDisplay(arg3, f)]; + return rt.fmtWriteFmt(f, [args4[0], " bytes exceeds the ", args4[1], " byte limit"]); } else { - const pair = self._0; - return rt.fmtWriteFmt(f, ["at ", (f: rt.Formatter) => Pair.fmt$Debug(pair, f)]); + const arg = ([self._0] as [Pair.Pair])[0]; + args6 = [(f: rt.Formatter) => Pair.fmt$Debug(arg, f)]; + return rt.fmtWriteFmt(f, ["at ", args6[0]]); } } /** The fault `data` picks. */ function new_(data: Uint8Array): Fault { - const at = (i: rt.usize): rt.u8 => { + let at!: (a0: rt.usize) => rt.u8; + let _3!: rt.u8; + at = (i: rt.usize): rt.u8 => { return rt.optionUnwrapOr(rt.sliceGet(data, i), 0); }; - const value = rt.u8Rem(at(0), 4); - if (value === 0) { - return { tag: "Short" }; - } else if (value === 1) { - return { tag: "Code", _0: (at(1) << 8) | at(2) }; - } else if (value === 2) { - return { tag: "TooLarge", size: (((((at(1) as rt.usize)) << 24) >>> 0) | at(2) as rt.usize) >>> 0, max: at(3) as rt.usize }; + _3 = rt.u8Rem(at(0), 4); + if (_3 === 0) { + return { tag: "Short" } as Fault; + } else if (_3 === 1) { + return { tag: "Code", _0: (at(1) << 8) | at(2) } as Fault; + } else if (_3 === 2) { + return { tag: "TooLarge", size: (((((at(1) as rt.usize)) << 24) >>> 0) | at(2) as rt.usize) >>> 0, max: at(3) as rt.usize } as Fault; } else { - return { tag: "At", _0: { _0: at(1), _1: rt.i64Shl((at(2) << 24) >> 24 as rt.i64, 40) } }; + return { tag: "At", _0: { _0: at(1), _1: rt.i64Shl((at(2) << 24) >> 24 as rt.i64, 40) } } as Fault; } } diff --git a/ts/fixtures/lang/expected/fmt.Hex.ts b/ts/fixtures/lang/expected/fmt.Hex.ts index 611e12b20..9f5d00737 100644 --- a/ts/fixtures/lang/expected/fmt.Hex.ts +++ b/ts/fixtures/lang/expected/fmt.Hex.ts @@ -8,10 +8,16 @@ export interface Hex { } export function fmt$Display(self: Hex, f: rt.Formatter): rt.Result { - if (rt.fmtAlternate(f)) { - return rt.fmtWriteFmt(f, [rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u32LowerHex(self._0, f))]); + let args2!: rt.Fmt[]; + let args4!: rt.Fmt[]; + if (!rt.fmtAlternate(f)) { + const arg2 = ([self._0] as [rt.u32])[0]; + args4 = [(f: rt.Formatter) => rt.u32LowerHex(arg2, f)]; + return rt.fmtWriteFmt(f, [args4[0]]); } else { - return rt.fmtWriteFmt(f, [(f: rt.Formatter) => rt.u32LowerHex(self._0, f)]); + const arg = ([self._0] as [rt.u32])[0]; + args2 = [(f: rt.Formatter) => rt.u32LowerHex(arg, f)]; + return rt.fmtWriteFmt(f, [rt.fmtSpec({ alternate: true }, args2[0])]); } } diff --git a/ts/fixtures/lang/expected/fmt.Kind.ts b/ts/fixtures/lang/expected/fmt.Kind.ts index 6b8106eb8..c278f5d46 100644 --- a/ts/fixtures/lang/expected/fmt.Kind.ts +++ b/ts/fixtures/lang/expected/fmt.Kind.ts @@ -3,6 +3,13 @@ import * as rt from "./rt.ts"; export function fmt$Debug(self: Kind, f: rt.Formatter): rt.Result { + let _8!: string; + let _9!: rt.Fmt; + let _13!: string; + let _14!: string; + let _15!: rt.Fmt; + let _16!: string; + let _17!: rt.Fmt; if (self.tag === "Empty") { return rt.fmtWriteStr(f, "Empty"); } else if (self.tag === "Braced") { @@ -10,12 +17,16 @@ export function fmt$Debug(self: Kind, f: rt.Formatter): rt.Result rt.u8Display(__self0, f))); + _8 = "One"; + _9 = (f: rt.Formatter) => rt.u8Display(self._0, f); + return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _8), _9)); } else { - const __self02 = self.count; - const __self1 = self.items; - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Many"), "count", (f: rt.Formatter) => rt.u32Display(__self02, f)), "items", (f: rt.Formatter) => rt.fmtList(rt.byteVecView(__self1), f, rt.u8Display))); + _13 = "Many"; + _14 = "count"; + _15 = (f: rt.Formatter) => rt.u32Display(self.count, f); + _16 = "items"; + _17 = (f: rt.Formatter) => rt.fmtList(rt.byteVecView(self.items), f, rt.u8Display); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _13), _14, _15), _16, _17)); } } diff --git a/ts/fixtures/lang/expected/fmt.Manual.ts b/ts/fixtures/lang/expected/fmt.Manual.ts index 4f2f5f506..4691ba0a5 100644 --- a/ts/fixtures/lang/expected/fmt.Manual.ts +++ b/ts/fixtures/lang/expected/fmt.Manual.ts @@ -9,7 +9,9 @@ export interface Manual { } export function fmt$Debug(self: Manual, f: rt.Formatter): rt.Result { - return rt.debugStructFinishNonExhaustive(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Manual"), "id", (f: rt.Formatter) => rt.u8Display(self.id, f)), "list", (f: rt.Formatter) => rt.fmtList(self.list, f, rt.u16Display))); + let _6!: rt.DebugStruct; + _6 = rt.fmtDebugStruct(f, "Manual"); + return rt.debugStructFinishNonExhaustive(rt.debugStructField(rt.debugStructField(_6, "id", (f: rt.Formatter) => rt.u8Display(self.id, f)), "list", (f: rt.Formatter) => rt.fmtList(self.list, f, rt.u16Display))); } //# sourceMappingURL=fmt.Manual.ts.map diff --git a/ts/fixtures/lang/expected/fmt.Nested.ts b/ts/fixtures/lang/expected/fmt.Nested.ts index 2ec601e43..fcb48905b 100644 --- a/ts/fixtures/lang/expected/fmt.Nested.ts +++ b/ts/fixtures/lang/expected/fmt.Nested.ts @@ -7,9 +7,13 @@ import * as Point from "./shapes.Point.ts"; import * as Shape from "./shapes.Shape.ts"; export function fmt$Debug(self: Nested, f: rt.Formatter): rt.Result { - const names = ["name", "point", "shape", "tags", "pairs", "maybe", "none", "result", "list", "tuple", "single", "empty", "unit", "boxed"]; - const values = [(f: rt.Formatter) => rt.fmtStr(self.name, f), (f: rt.Formatter) => Point.fmt$Debug(self.point, f), (f: rt.Formatter) => Shape.fmt$Debug(self.shape, f), (f: rt.Formatter) => rt.fmtList(rt.byteVecView(self.tags), f, rt.u8Display), (f: rt.Formatter) => rt.fmtList(self.pairs, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$Debug(value, f)), (f: rt.Formatter) => rt.fmtOption(self.maybe, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$Debug(value, f)), (f: rt.Formatter) => rt.fmtOption(self.none, f, rt.u8Display), (f: rt.Formatter) => rt.fmtResult(self.result, f, rt.u8Display, rt.fmtStr), (f: rt.Formatter) => rt.fmtList(self.list, f, rt.i16Display), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Display(self.tuple[0], f), (f: rt.Formatter) => rt.fmtBool(self.tuple[1], f), (f: rt.Formatter) => rt.fmtStr(self.tuple[2], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Display(self.single[0], f)], f), (f: rt.Formatter) => rt.fmtList(rt.byteVecView(self.empty), f, rt.u8Display), (f: rt.Formatter) => rt.fmtUnit(self.unit, f), (f: rt.Formatter) => Kind.fmt$Debug(self.boxed, f)]; - return rt.fmtDebugStructFields(f, "Nested", names, values); + let names!: string[]; + let values!: rt.Fmt[]; + let _36!: string; + names = ["name", "point", "shape", "tags", "pairs", "maybe", "none", "result", "list", "tuple", "single", "empty", "unit", "boxed"]; + values = [(f: rt.Formatter) => rt.fmtStr(self.name, f), (f: rt.Formatter) => Point.fmt$Debug(self.point, f), (f: rt.Formatter) => Shape.fmt$Debug(self.shape, f), (f: rt.Formatter) => rt.fmtList(rt.byteVecView(self.tags), f, rt.u8Display), (f: rt.Formatter) => rt.fmtList(self.pairs, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$Debug(value, f)), (f: rt.Formatter) => rt.fmtOption(self.maybe, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$Debug(value, f)), (f: rt.Formatter) => rt.fmtOption(self.none, f, rt.u8Display), (f: rt.Formatter) => rt.fmtResult(self.result, f, rt.u8Display, rt.fmtStr), (f: rt.Formatter) => rt.fmtList(self.list, f, rt.i16Display), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Display(self.tuple[0], f), (f: rt.Formatter) => rt.fmtBool(self.tuple[1], f), (f: rt.Formatter) => rt.fmtStr(self.tuple[2], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Display(self.single[0], f)], f), (f: rt.Formatter) => rt.fmtList(rt.byteVecView(self.empty), f, rt.u8Display), (f: rt.Formatter) => rt.fmtUnit(self.unit, f), (f: rt.Formatter) => Kind.fmt$Debug(self.boxed, f)]; + _36 = "Nested"; + return rt.fmtDebugStructFields(f, _36, names, values); } export interface Nested { diff --git a/ts/fixtures/lang/expected/fmt.Padded.ts b/ts/fixtures/lang/expected/fmt.Padded.ts index 3a64bd440..bbc08e6c2 100644 --- a/ts/fixtures/lang/expected/fmt.Padded.ts +++ b/ts/fixtures/lang/expected/fmt.Padded.ts @@ -8,16 +8,14 @@ export interface Padded { } export function fmt$Display(self: Padded, f: rt.Formatter): rt.Result { - const width = rt.fmtWidth(f); - arms: { - if (width !== undefined) { - const width2 = width; - if (width2 > 20) { - return rt.fmtWriteStr(f, "wide"); - } + let _3!: rt.usize | undefined; + _3 = rt.fmtWidth(f); + if (_3 !== undefined) { + if (_3 > 20) { + return rt.fmtWriteStr(f, "wide"); } - return rt.fmtPad(f, self._0); } + return rt.fmtPad(f, self._0); } //# sourceMappingURL=fmt.Padded.ts.map diff --git a/ts/fixtures/lang/expected/fmt.Pair.ts b/ts/fixtures/lang/expected/fmt.Pair.ts index 19d19dbee..3aaea45a2 100644 --- a/ts/fixtures/lang/expected/fmt.Pair.ts +++ b/ts/fixtures/lang/expected/fmt.Pair.ts @@ -3,11 +3,21 @@ import * as rt from "./rt.ts"; export function fmt$Debug(self: Pair, f: rt.Formatter): rt.Result { - return rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(rt.fmtDebugTuple(f, "Pair"), (f: rt.Formatter) => rt.u8Display(self._0, f)), (f: rt.Formatter) => rt.i64Display(self._1, f))); + let _3!: string; + let _4!: rt.Fmt; + let _6!: rt.Fmt; + _3 = "Pair"; + _4 = (f: rt.Formatter) => rt.u8Display(self._0, f); + _6 = (f: rt.Formatter) => rt.i64Display(self._1, f); + return rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4), _6)); } export function eq$PartialEq(self: Pair, other: Pair): boolean { - return self._0 === other._0 && rt.i64Eq(self._1, other._1); + if (!(self._0 === other._0)) { + return false; + } else { + return rt.i64Eq(self._1, other._1); + } } export interface Pair { diff --git a/ts/fixtures/lang/expected/fmt.Seq.ts b/ts/fixtures/lang/expected/fmt.Seq.ts index 44c8a4bf4..4794e2f1e 100644 --- a/ts/fixtures/lang/expected/fmt.Seq.ts +++ b/ts/fixtures/lang/expected/fmt.Seq.ts @@ -8,7 +8,11 @@ export interface Seq { } export function fmt$Debug(self: Seq, f: rt.Formatter): rt.Result { - return rt.debugListFinish(rt.debugListEntries(rt.fmtDebugList(f), self._0, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$Debug(value, f))); + let _5!: rt.DebugList; + let _6!: rt.Iter; + _5 = rt.fmtDebugList(f); + _6 = rt.iterSlice(self._0); + return rt.debugListFinish(rt.debugListEntries(_5, _6, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$Debug(value, f))); } //# sourceMappingURL=fmt.Seq.ts.map diff --git a/ts/fixtures/lang/expected/fmt.Six.ts b/ts/fixtures/lang/expected/fmt.Six.ts index d6aa4afd7..1e0176a98 100644 --- a/ts/fixtures/lang/expected/fmt.Six.ts +++ b/ts/fixtures/lang/expected/fmt.Six.ts @@ -3,8 +3,11 @@ import * as rt from "./rt.ts"; export function fmt$Debug(self: Six, f: rt.Formatter): rt.Result { - const values = [(f: rt.Formatter) => rt.u8Display(self._0, f), (f: rt.Formatter) => rt.u8Display(self._1, f), (f: rt.Formatter) => rt.u8Display(self._2, f), (f: rt.Formatter) => rt.u8Display(self._3, f), (f: rt.Formatter) => rt.u8Display(self._4, f), (f: rt.Formatter) => rt.u8Display(self._5, f)]; - return rt.fmtDebugTupleFields(f, "Six", values); + let values!: rt.Fmt[]; + let _19!: string; + values = [(f: rt.Formatter) => rt.u8Display(self._0, f), (f: rt.Formatter) => rt.u8Display(self._1, f), (f: rt.Formatter) => rt.u8Display(self._2, f), (f: rt.Formatter) => rt.u8Display(self._3, f), (f: rt.Formatter) => rt.u8Display(self._4, f), (f: rt.Formatter) => rt.u8Display(self._5, f)]; + _19 = "Six"; + return rt.fmtDebugTupleFields(f, _19, values); } export interface Six { diff --git a/ts/fixtures/lang/expected/fmt.Tup.ts b/ts/fixtures/lang/expected/fmt.Tup.ts index 22fc090ff..d20eb25d5 100644 --- a/ts/fixtures/lang/expected/fmt.Tup.ts +++ b/ts/fixtures/lang/expected/fmt.Tup.ts @@ -8,10 +8,14 @@ export interface Tup { } export function fmt$Debug(self: Tup, f: rt.Formatter): rt.Result { - if (self._1 !== undefined) { - return rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(rt.fmtDebugTuple(f, "Tup"), (f: rt.Formatter) => rt.u8Display(self._0, f)), (f: rt.Formatter) => rt.fmtOption(self._1, f, rt.u8Display))); + let _7!: rt.DebugTuple; + let _15!: rt.DebugTuple; + if (self._1 === undefined) { + _15 = rt.fmtDebugTuple(f, "Tup"); + return rt.debugTupleFinishNonExhaustive(rt.debugTupleField(_15, (f: rt.Formatter) => rt.u8Display(self._0, f))); } else { - return rt.debugTupleFinishNonExhaustive(rt.debugTupleField(rt.fmtDebugTuple(f, "Tup"), (f: rt.Formatter) => rt.u8Display(self._0, f))); + _7 = rt.fmtDebugTuple(f, "Tup"); + return rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(_7, (f: rt.Formatter) => rt.u8Display(self._0, f)), (f: rt.Formatter) => rt.fmtOption(self._1, f, rt.u8Display))); } } diff --git a/ts/fixtures/lang/expected/fmt.Wide.ts b/ts/fixtures/lang/expected/fmt.Wide.ts index 96a097633..0ef6fcc30 100644 --- a/ts/fixtures/lang/expected/fmt.Wide.ts +++ b/ts/fixtures/lang/expected/fmt.Wide.ts @@ -3,9 +3,13 @@ import * as rt from "./rt.ts"; export function fmt$Debug(self: Wide, f: rt.Formatter): rt.Result { - const names = ["a", "b", "c", "d", "e", "f"]; - const values = [(f: rt.Formatter) => rt.u8Display(self.a, f), (f: rt.Formatter) => rt.u16Display(self.b, f), (f: rt.Formatter) => rt.u32Display(self.c, f), (f: rt.Formatter) => rt.u64Display(self.d, f), (f: rt.Formatter) => rt.i8Display(self.e, f), (f: rt.Formatter) => rt.fmtBool(self.f, f)]; - return rt.fmtDebugStructFields(f, "Wide", names, values); + let names!: string[]; + let values!: rt.Fmt[]; + let _20!: string; + names = ["a", "b", "c", "d", "e", "f"]; + values = [(f: rt.Formatter) => rt.u8Display(self.a, f), (f: rt.Formatter) => rt.u16Display(self.b, f), (f: rt.Formatter) => rt.u32Display(self.c, f), (f: rt.Formatter) => rt.u64Display(self.d, f), (f: rt.Formatter) => rt.i8Display(self.e, f), (f: rt.Formatter) => rt.fmtBool(self.f, f)]; + _20 = "Wide"; + return rt.fmtDebugStructFields(f, _20, names, values); } /** Past five fields, derived `Debug` takes the fields as slices. */ diff --git a/ts/fixtures/lang/expected/fmt.ts b/ts/fixtures/lang/expected/fmt.ts index 654e0f43d..763c591df 100644 --- a/ts/fixtures/lang/expected/fmt.ts +++ b/ts/fixtures/lang/expected/fmt.ts @@ -20,346 +20,748 @@ import type * as Shape from "./shapes.Shape.ts"; export function put(out: rt.ByteVec, s: string): void { rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 0xff); + rt.byteVecPush(out, 255); } /** Integers of every width, with each spec. */ export function ints(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const value = rt.u8Rem(kind, 12); - if (value === 0) { - const data2 = data; - let buf: Uint8Array = rt.bytes(1); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const v = rt.u8FromBeBytes(buf); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.u8Display(v, f), " ", (f: rt.Formatter) => rt.u8Display(v, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.u8Display(v, f)), "|", (f: rt.Formatter) => rt.u8LowerHex(v, f), " ", (f: rt.Formatter) => rt.u8UpperHex(v, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u8LowerHex(v, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u8UpperHex(v, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.u8LowerHex(v, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.u8LowerHex(v, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.u8LowerHex(v, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.u8UpperHex(v, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u8Display(v, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.u8Display(v, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.u8Display(v, f))); - } else if (value === 1) { - const data3 = data; - let buf2: Uint8Array = rt.bytes(2); - const n2 = rt.min(data3.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data3, 0, n2)); - const v2 = rt.u16FromBeBytes(buf2); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.u16Display(v2, f), " ", (f: rt.Formatter) => rt.u16Display(v2, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.u16Display(v2, f)), "|", (f: rt.Formatter) => rt.u16LowerHex(v2, f), " ", (f: rt.Formatter) => rt.u16UpperHex(v2, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u16LowerHex(v2, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u16UpperHex(v2, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.u16LowerHex(v2, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.u16LowerHex(v2, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.u16LowerHex(v2, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.u16UpperHex(v2, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u16Display(v2, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.u16Display(v2, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.u16Display(v2, f))); - } else if (value === 2) { - const data4 = data; - let buf3: Uint8Array = rt.bytes(4); - const n3 = rt.min(data4.length, buf3.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf3, 0, n3), rt.sliceRange(data4, 0, n3)); - const v3 = rt.u32FromBeBytes(buf3); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.u32Display(v3, f), " ", (f: rt.Formatter) => rt.u32Display(v3, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.u32Display(v3, f)), "|", (f: rt.Formatter) => rt.u32LowerHex(v3, f), " ", (f: rt.Formatter) => rt.u32UpperHex(v3, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u32LowerHex(v3, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u32UpperHex(v3, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.u32LowerHex(v3, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.u32LowerHex(v3, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.u32LowerHex(v3, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.u32UpperHex(v3, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u32Display(v3, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.u32Display(v3, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.u32Display(v3, f))); - } else if (value === 3) { - const data5 = data; - let buf4: Uint8Array = rt.bytes(8); - const n4 = rt.min(data5.length, buf4.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf4, 0, n4), rt.sliceRange(data5, 0, n4)); - const v4 = rt.u64FromBeBytes(buf4); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.u64Display(v4, f), " ", (f: rt.Formatter) => rt.u64Display(v4, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.u64Display(v4, f)), "|", (f: rt.Formatter) => rt.u64LowerHex(v4, f), " ", (f: rt.Formatter) => rt.u64UpperHex(v4, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u64LowerHex(v4, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u64UpperHex(v4, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.u64LowerHex(v4, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.u64LowerHex(v4, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.u64LowerHex(v4, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.u64UpperHex(v4, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u64Display(v4, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.u64Display(v4, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.u64Display(v4, f))); - } else if (value === 4) { - const data6 = data; - let buf5: Uint8Array = rt.bytes(16); - const n5 = rt.min(data6.length, buf5.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf5, 0, n5), rt.sliceRange(data6, 0, n5)); - const v5 = rt.u128FromBeBytes(buf5); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.u128Display(v5, f), " ", (f: rt.Formatter) => rt.u128Display(v5, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.u128Display(v5, f)), "|", (f: rt.Formatter) => rt.u128LowerHex(v5, f), " ", (f: rt.Formatter) => rt.u128UpperHex(v5, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u128LowerHex(v5, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u128UpperHex(v5, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.u128LowerHex(v5, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.u128LowerHex(v5, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.u128LowerHex(v5, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.u128UpperHex(v5, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u128Display(v5, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.u128Display(v5, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.u128Display(v5, f))); - } else if (value === 5) { - const data7 = data; - let buf6: Uint8Array = rt.bytes(4); - const n6 = rt.min(data7.length, buf6.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf6, 0, n6), rt.sliceRange(data7, 0, n6)); - const v6 = rt.usizeFromBeBytes(buf6); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.usizeDisplay(v6, f), " ", (f: rt.Formatter) => rt.usizeDisplay(v6, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), "|", (f: rt.Formatter) => rt.usizeLowerHex(v6, f), " ", (f: rt.Formatter) => rt.usizeUpperHex(v6, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.usizeLowerHex(v6, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.usizeUpperHex(v6, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.usizeLowerHex(v6, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.usizeLowerHex(v6, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.usizeLowerHex(v6, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.usizeUpperHex(v6, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.usizeDisplay(v6, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.usizeDisplay(v6, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v6, f))); - } else if (value === 6) { - const data8 = data; - let buf7: Uint8Array = rt.bytes(1); - const n7 = rt.min(data8.length, buf7.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf7, 0, n7), rt.sliceRange(data8, 0, n7)); - const v7 = rt.i8FromBeBytes(buf7); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.i8Display(v7, f), " ", (f: rt.Formatter) => rt.i8Display(v7, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.i8Display(v7, f)), "|", (f: rt.Formatter) => rt.i8LowerHex(v7, f), " ", (f: rt.Formatter) => rt.i8UpperHex(v7, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i8LowerHex(v7, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i8UpperHex(v7, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.i8LowerHex(v7, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.i8LowerHex(v7, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.i8LowerHex(v7, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.i8UpperHex(v7, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i8Display(v7, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.i8Display(v7, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.i8Display(v7, f))); - } else if (value === 7) { - const data9 = data; - let buf8: Uint8Array = rt.bytes(2); - const n8 = rt.min(data9.length, buf8.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf8, 0, n8), rt.sliceRange(data9, 0, n8)); - const v8 = rt.i16FromBeBytes(buf8); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.i16Display(v8, f), " ", (f: rt.Formatter) => rt.i16Display(v8, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.i16Display(v8, f)), "|", (f: rt.Formatter) => rt.i16LowerHex(v8, f), " ", (f: rt.Formatter) => rt.i16UpperHex(v8, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i16LowerHex(v8, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i16UpperHex(v8, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.i16LowerHex(v8, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.i16LowerHex(v8, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.i16LowerHex(v8, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.i16UpperHex(v8, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i16Display(v8, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.i16Display(v8, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.i16Display(v8, f))); - } else if (value === 8) { - const data10 = data; - let buf9: Uint8Array = rt.bytes(4); - const n9 = rt.min(data10.length, buf9.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf9, 0, n9), rt.sliceRange(data10, 0, n9)); - const v9 = rt.i32FromBeBytes(buf9); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.i32Display(v9, f), " ", (f: rt.Formatter) => rt.i32Display(v9, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.i32Display(v9, f)), "|", (f: rt.Formatter) => rt.i32LowerHex(v9, f), " ", (f: rt.Formatter) => rt.i32UpperHex(v9, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i32LowerHex(v9, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i32UpperHex(v9, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.i32LowerHex(v9, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.i32LowerHex(v9, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.i32LowerHex(v9, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.i32UpperHex(v9, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i32Display(v9, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.i32Display(v9, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.i32Display(v9, f))); - } else if (value === 9) { - const data11 = data; - let buf10: Uint8Array = rt.bytes(8); - const n10 = rt.min(data11.length, buf10.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf10, 0, n10), rt.sliceRange(data11, 0, n10)); - const v10 = rt.i64FromBeBytes(buf10); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.i64Display(v10, f), " ", (f: rt.Formatter) => rt.i64Display(v10, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.i64Display(v10, f)), "|", (f: rt.Formatter) => rt.i64LowerHex(v10, f), " ", (f: rt.Formatter) => rt.i64UpperHex(v10, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i64LowerHex(v10, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i64UpperHex(v10, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.i64LowerHex(v10, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.i64LowerHex(v10, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.i64LowerHex(v10, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.i64UpperHex(v10, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i64Display(v10, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.i64Display(v10, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.i64Display(v10, f))); - } else if (value === 10) { - const data12 = data; - let buf11: Uint8Array = rt.bytes(16); - const n11 = rt.min(data12.length, buf11.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf11, 0, n11), rt.sliceRange(data12, 0, n11)); - const v11 = rt.i128FromBeBytes(buf11); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.i128Display(v11, f), " ", (f: rt.Formatter) => rt.i128Display(v11, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.i128Display(v11, f)), "|", (f: rt.Formatter) => rt.i128LowerHex(v11, f), " ", (f: rt.Formatter) => rt.i128UpperHex(v11, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i128LowerHex(v11, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i128UpperHex(v11, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.i128LowerHex(v11, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.i128LowerHex(v11, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.i128LowerHex(v11, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.i128UpperHex(v11, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.i128Display(v11, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.i128Display(v11, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.i128Display(v11, f))); + let _4!: rt.u8; + let v!: rt.u8; + let buf!: Uint8Array; + let n!: rt.usize; + let _23!: string; + let args2!: rt.Fmt[]; + let _38!: string; + let v2!: rt.u16; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _57!: string; + let args4!: rt.Fmt[]; + let _72!: string; + let v3!: rt.u32; + let buf3!: Uint8Array; + let n3!: rt.usize; + let _91!: string; + let args6!: rt.Fmt[]; + let _106!: string; + let v4!: rt.u64; + let buf4!: Uint8Array; + let n4!: rt.usize; + let _125!: string; + let args8!: rt.Fmt[]; + let _140!: string; + let v5!: rt.u128; + let buf5!: Uint8Array; + let n5!: rt.usize; + let _159!: string; + let args10!: rt.Fmt[]; + let _174!: string; + let v6!: rt.usize; + let buf6!: Uint8Array; + let n6!: rt.usize; + let _193!: string; + let args12!: rt.Fmt[]; + let _208!: string; + let v7!: rt.i8; + let buf7!: Uint8Array; + let n7!: rt.usize; + let _227!: string; + let args14!: rt.Fmt[]; + let _242!: string; + let v8!: rt.i16; + let buf8!: Uint8Array; + let n8!: rt.usize; + let _261!: string; + let args16!: rt.Fmt[]; + let _276!: string; + let v9!: rt.i32; + let buf9!: Uint8Array; + let n9!: rt.usize; + let _295!: string; + let args18!: rt.Fmt[]; + let _310!: string; + let v10!: rt.i64; + let buf10!: Uint8Array; + let n10!: rt.usize; + let _329!: string; + let args20!: rt.Fmt[]; + let _344!: string; + let v11!: rt.i128; + let buf11!: Uint8Array; + let n11!: rt.usize; + let _363!: string; + let args22!: rt.Fmt[]; + let _378!: string; + let v12!: rt.isize; + let buf12!: Uint8Array; + let n12!: rt.usize; + let _397!: string; + let args24!: rt.Fmt[]; + let _412!: string; + _4 = rt.u8Rem(kind, 12); + if (_4 === 0) { + buf = Uint8Array.of(0); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + v = rt.u8FromBeBytes(buf); + args2 = [(f: rt.Formatter) => rt.u8Display(v, f), (f: rt.Formatter) => rt.u8Display(v, f), (f: rt.Formatter) => rt.u8LowerHex(v, f), (f: rt.Formatter) => rt.u8UpperHex(v, f)]; + _23 = rt.fmtFormat([args2[0], " ", args2[1], " ", rt.fmtSpec({ width: 5 }, args2[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args2[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args2[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args2[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args2[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args2[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args2[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args2[0]), "|", args2[2], " ", args2[3], " ", rt.fmtSpec({ alternate: true }, args2[2]), " ", rt.fmtSpec({ alternate: true }, args2[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args2[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args2[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args2[3]), "|", rt.fmtSpec({ alternate: true }, args2[1]), " ", rt.fmtSpec({ width: 3 }, args2[1])]); + put(out, _23); + _38 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v, f)); + put(out, _38); + } else if (_4 === 1) { + buf2 = rt.bytes(2); + n2 = rt.min(data.length, buf2.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data, 0, n2)); + v2 = rt.u16FromBeBytes(buf2); + args4 = [(f: rt.Formatter) => rt.u16Display(v2, f), (f: rt.Formatter) => rt.u16Display(v2, f), (f: rt.Formatter) => rt.u16LowerHex(v2, f), (f: rt.Formatter) => rt.u16UpperHex(v2, f)]; + _57 = rt.fmtFormat([args4[0], " ", args4[1], " ", rt.fmtSpec({ width: 5 }, args4[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args4[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args4[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args4[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args4[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args4[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args4[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args4[0]), "|", args4[2], " ", args4[3], " ", rt.fmtSpec({ alternate: true }, args4[2]), " ", rt.fmtSpec({ alternate: true }, args4[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args4[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args4[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args4[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args4[3]), "|", rt.fmtSpec({ alternate: true }, args4[1]), " ", rt.fmtSpec({ width: 3 }, args4[1])]); + put(out, _57); + _72 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v2, f)); + put(out, _72); + } else if (_4 === 2) { + buf3 = rt.bytes(4); + n3 = rt.min(data.length, buf3.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf3, 0, n3), rt.sliceRange(data, 0, n3)); + v3 = rt.u32FromBeBytes(buf3); + args6 = [(f: rt.Formatter) => rt.u32Display(v3, f), (f: rt.Formatter) => rt.u32Display(v3, f), (f: rt.Formatter) => rt.u32LowerHex(v3, f), (f: rt.Formatter) => rt.u32UpperHex(v3, f)]; + _91 = rt.fmtFormat([args6[0], " ", args6[1], " ", rt.fmtSpec({ width: 5 }, args6[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args6[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args6[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args6[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args6[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args6[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args6[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args6[0]), "|", args6[2], " ", args6[3], " ", rt.fmtSpec({ alternate: true }, args6[2]), " ", rt.fmtSpec({ alternate: true }, args6[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args6[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args6[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args6[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args6[3]), "|", rt.fmtSpec({ alternate: true }, args6[1]), " ", rt.fmtSpec({ width: 3 }, args6[1])]); + put(out, _91); + _106 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v3, f)); + put(out, _106); + } else if (_4 === 3) { + buf4 = rt.bytes(8); + n4 = rt.min(data.length, buf4.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf4, 0, n4), rt.sliceRange(data, 0, n4)); + v4 = rt.u64FromBeBytes(buf4); + args8 = [(f: rt.Formatter) => rt.u64Display(v4, f), (f: rt.Formatter) => rt.u64Display(v4, f), (f: rt.Formatter) => rt.u64LowerHex(v4, f), (f: rt.Formatter) => rt.u64UpperHex(v4, f)]; + _125 = rt.fmtFormat([args8[0], " ", args8[1], " ", rt.fmtSpec({ width: 5 }, args8[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args8[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args8[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args8[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args8[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args8[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args8[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args8[0]), "|", args8[2], " ", args8[3], " ", rt.fmtSpec({ alternate: true }, args8[2]), " ", rt.fmtSpec({ alternate: true }, args8[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args8[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args8[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args8[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args8[3]), "|", rt.fmtSpec({ alternate: true }, args8[1]), " ", rt.fmtSpec({ width: 3 }, args8[1])]); + put(out, _125); + _140 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v4, f)); + put(out, _140); + } else if (_4 === 4) { + buf5 = rt.bytes(16); + n5 = rt.min(data.length, buf5.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf5, 0, n5), rt.sliceRange(data, 0, n5)); + v5 = rt.u128FromBeBytes(buf5); + args10 = [(f: rt.Formatter) => rt.u128Display(v5, f), (f: rt.Formatter) => rt.u128Display(v5, f), (f: rt.Formatter) => rt.u128LowerHex(v5, f), (f: rt.Formatter) => rt.u128UpperHex(v5, f)]; + _159 = rt.fmtFormat([args10[0], " ", args10[1], " ", rt.fmtSpec({ width: 5 }, args10[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args10[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args10[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args10[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args10[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args10[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args10[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args10[0]), "|", args10[2], " ", args10[3], " ", rt.fmtSpec({ alternate: true }, args10[2]), " ", rt.fmtSpec({ alternate: true }, args10[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args10[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args10[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args10[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args10[3]), "|", rt.fmtSpec({ alternate: true }, args10[1]), " ", rt.fmtSpec({ width: 3 }, args10[1])]); + put(out, _159); + _174 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v5, f)); + put(out, _174); + } else if (_4 === 5) { + buf6 = rt.bytes(4); + n6 = rt.min(data.length, buf6.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf6, 0, n6), rt.sliceRange(data, 0, n6)); + v6 = rt.usizeFromBeBytes(buf6); + args12 = [(f: rt.Formatter) => rt.usizeDisplay(v6, f), (f: rt.Formatter) => rt.usizeDisplay(v6, f), (f: rt.Formatter) => rt.usizeLowerHex(v6, f), (f: rt.Formatter) => rt.usizeUpperHex(v6, f)]; + _193 = rt.fmtFormat([args12[0], " ", args12[1], " ", rt.fmtSpec({ width: 5 }, args12[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args12[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args12[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args12[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args12[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args12[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args12[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args12[0]), "|", args12[2], " ", args12[3], " ", rt.fmtSpec({ alternate: true }, args12[2]), " ", rt.fmtSpec({ alternate: true }, args12[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args12[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args12[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args12[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args12[3]), "|", rt.fmtSpec({ alternate: true }, args12[1]), " ", rt.fmtSpec({ width: 3 }, args12[1])]); + put(out, _193); + _208 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v6, f)); + put(out, _208); + } else if (_4 === 6) { + buf7 = Uint8Array.of(0); + n7 = rt.min(data.length, buf7.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf7, 0, n7), rt.sliceRange(data, 0, n7)); + v7 = rt.i8FromBeBytes(buf7); + args14 = [(f: rt.Formatter) => rt.i8Display(v7, f), (f: rt.Formatter) => rt.i8Display(v7, f), (f: rt.Formatter) => rt.i8LowerHex(v7, f), (f: rt.Formatter) => rt.i8UpperHex(v7, f)]; + _227 = rt.fmtFormat([args14[0], " ", args14[1], " ", rt.fmtSpec({ width: 5 }, args14[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args14[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args14[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args14[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args14[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args14[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args14[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args14[0]), "|", args14[2], " ", args14[3], " ", rt.fmtSpec({ alternate: true }, args14[2]), " ", rt.fmtSpec({ alternate: true }, args14[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args14[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args14[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args14[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args14[3]), "|", rt.fmtSpec({ alternate: true }, args14[1]), " ", rt.fmtSpec({ width: 3 }, args14[1])]); + put(out, _227); + _242 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v7, f)); + put(out, _242); + } else if (_4 === 7) { + buf8 = rt.bytes(2); + n8 = rt.min(data.length, buf8.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf8, 0, n8), rt.sliceRange(data, 0, n8)); + v8 = rt.i16FromBeBytes(buf8); + args16 = [(f: rt.Formatter) => rt.i16Display(v8, f), (f: rt.Formatter) => rt.i16Display(v8, f), (f: rt.Formatter) => rt.i16LowerHex(v8, f), (f: rt.Formatter) => rt.i16UpperHex(v8, f)]; + _261 = rt.fmtFormat([args16[0], " ", args16[1], " ", rt.fmtSpec({ width: 5 }, args16[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args16[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args16[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args16[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args16[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args16[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args16[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args16[0]), "|", args16[2], " ", args16[3], " ", rt.fmtSpec({ alternate: true }, args16[2]), " ", rt.fmtSpec({ alternate: true }, args16[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args16[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args16[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args16[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args16[3]), "|", rt.fmtSpec({ alternate: true }, args16[1]), " ", rt.fmtSpec({ width: 3 }, args16[1])]); + put(out, _261); + _276 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v8, f)); + put(out, _276); + } else if (_4 === 8) { + buf9 = rt.bytes(4); + n9 = rt.min(data.length, buf9.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf9, 0, n9), rt.sliceRange(data, 0, n9)); + v9 = rt.i32FromBeBytes(buf9); + args18 = [(f: rt.Formatter) => rt.i32Display(v9, f), (f: rt.Formatter) => rt.i32Display(v9, f), (f: rt.Formatter) => rt.i32LowerHex(v9, f), (f: rt.Formatter) => rt.i32UpperHex(v9, f)]; + _295 = rt.fmtFormat([args18[0], " ", args18[1], " ", rt.fmtSpec({ width: 5 }, args18[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args18[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args18[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args18[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args18[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args18[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args18[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args18[0]), "|", args18[2], " ", args18[3], " ", rt.fmtSpec({ alternate: true }, args18[2]), " ", rt.fmtSpec({ alternate: true }, args18[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args18[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args18[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args18[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args18[3]), "|", rt.fmtSpec({ alternate: true }, args18[1]), " ", rt.fmtSpec({ width: 3 }, args18[1])]); + put(out, _295); + _310 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v9, f)); + put(out, _310); + } else if (_4 === 9) { + buf10 = rt.bytes(8); + n10 = rt.min(data.length, buf10.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf10, 0, n10), rt.sliceRange(data, 0, n10)); + v10 = rt.i64FromBeBytes(buf10); + args20 = [(f: rt.Formatter) => rt.i64Display(v10, f), (f: rt.Formatter) => rt.i64Display(v10, f), (f: rt.Formatter) => rt.i64LowerHex(v10, f), (f: rt.Formatter) => rt.i64UpperHex(v10, f)]; + _329 = rt.fmtFormat([args20[0], " ", args20[1], " ", rt.fmtSpec({ width: 5 }, args20[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args20[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args20[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args20[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args20[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args20[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args20[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args20[0]), "|", args20[2], " ", args20[3], " ", rt.fmtSpec({ alternate: true }, args20[2]), " ", rt.fmtSpec({ alternate: true }, args20[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args20[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args20[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args20[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args20[3]), "|", rt.fmtSpec({ alternate: true }, args20[1]), " ", rt.fmtSpec({ width: 3 }, args20[1])]); + put(out, _329); + _344 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v10, f)); + put(out, _344); + } else if (_4 === 10) { + buf11 = rt.bytes(16); + n11 = rt.min(data.length, buf11.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf11, 0, n11), rt.sliceRange(data, 0, n11)); + v11 = rt.i128FromBeBytes(buf11); + args22 = [(f: rt.Formatter) => rt.i128Display(v11, f), (f: rt.Formatter) => rt.i128Display(v11, f), (f: rt.Formatter) => rt.i128LowerHex(v11, f), (f: rt.Formatter) => rt.i128UpperHex(v11, f)]; + _363 = rt.fmtFormat([args22[0], " ", args22[1], " ", rt.fmtSpec({ width: 5 }, args22[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args22[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args22[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args22[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args22[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args22[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args22[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args22[0]), "|", args22[2], " ", args22[3], " ", rt.fmtSpec({ alternate: true }, args22[2]), " ", rt.fmtSpec({ alternate: true }, args22[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args22[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args22[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args22[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args22[3]), "|", rt.fmtSpec({ alternate: true }, args22[1]), " ", rt.fmtSpec({ width: 3 }, args22[1])]); + put(out, _363); + _378 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v11, f)); + put(out, _378); } else { - const data13 = data; - let buf12: Uint8Array = rt.bytes(4); - const n12 = rt.min(data13.length, buf12.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf12, 0, n12), rt.sliceRange(data13, 0, n12)); - const v12 = rt.isizeFromBeBytes(buf12); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.isizeDisplay(v12, f), " ", (f: rt.Formatter) => rt.isizeDisplay(v12, f), " ", rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ align: "<", width: 5 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ align: "^", width: 7 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ zero: true, width: 5 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), "|", (f: rt.Formatter) => rt.isizeLowerHex(v12, f), " ", (f: rt.Formatter) => rt.isizeUpperHex(v12, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.isizeLowerHex(v12, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.isizeUpperHex(v12, f)), " ", rt.fmtSpec({ zero: true, width: 8 }, (f: rt.Formatter) => rt.isizeLowerHex(v12, f)), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, (f: rt.Formatter) => rt.isizeLowerHex(v12, f)), " ", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.isizeLowerHex(v12, f)), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, (f: rt.Formatter) => rt.isizeUpperHex(v12, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.isizeDisplay(v12, f)), " ", rt.fmtSpec({ width: 3 }, (f: rt.Formatter) => rt.isizeDisplay(v12, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v12, f))); + buf12 = rt.bytes(4); + n12 = rt.min(data.length, buf12.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf12, 0, n12), rt.sliceRange(data, 0, n12)); + v12 = rt.isizeFromBeBytes(buf12); + args24 = [(f: rt.Formatter) => rt.isizeDisplay(v12, f), (f: rt.Formatter) => rt.isizeDisplay(v12, f), (f: rt.Formatter) => rt.isizeLowerHex(v12, f), (f: rt.Formatter) => rt.isizeUpperHex(v12, f)]; + _397 = rt.fmtFormat([args24[0], " ", args24[1], " ", rt.fmtSpec({ width: 5 }, args24[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args24[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args24[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args24[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args24[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args24[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args24[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args24[0]), "|", args24[2], " ", args24[3], " ", rt.fmtSpec({ alternate: true }, args24[2]), " ", rt.fmtSpec({ alternate: true }, args24[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args24[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args24[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args24[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args24[3]), "|", rt.fmtSpec({ alternate: true }, args24[1]), " ", rt.fmtSpec({ width: 3 }, args24[1])]); + put(out, _397); + _412 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v12, f)); + put(out, _412); } } /** Strings padded and escaped, and bytes that may not be UTF-8. */ export function strings(data: Uint8Array, out: rt.ByteVec): void { - for (const item of rt.sliceRange(data, 0, rt.min(data.length, 3))) { - const b = item; - const value = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"]; - const s = rt.at(value, rt.usizeRem(b as rt.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"].length)); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.fmtPad(f, s), "|", rt.fmtSpec({ width: 8 }, (f: rt.Formatter) => rt.fmtPad(f, s)), "|", rt.fmtSpec({ align: ">", width: 8 }, (f: rt.Formatter) => rt.fmtPad(f, s)), "|", rt.fmtSpec({ align: "^", width: 8 }, (f: rt.Formatter) => rt.fmtPad(f, s)), "|", rt.fmtSpec({ fill: "-", align: "<", width: 3 }, (f: rt.Formatter) => rt.fmtPad(f, s)), "|", (f: rt.Formatter) => rt.fmtStr(s, f), "|", rt.fmtSpec({ width: 12 }, (f: rt.Formatter) => rt.fmtStr(s, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.fmtStr(s, f)), "|{", (f: rt.Formatter) => rt.fmtPad(f, s), "}"])); - } - const fromUtf8 = rt.stringFromUtf8(rt.sliceToByteVec(data)); - if (fromUtf8.ok) { - const s2 = fromUtf8.value; - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.fmtStr(s2, f), " ", rt.fmtSpec({ align: ">", width: 4 }, (f: rt.Formatter) => rt.fmtPad(f, s2))])); - } else { - const e = fromUtf8.error; - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.fmtFromUtf8ErrorDisplay(e, f), " ", (f: rt.Formatter) => rt.fmtFromUtf8ErrorDebug(e, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.fmtFromUtf8ErrorDebug(e, f)), " ", rt.fmtSpec({ align: ">", width: 80 }, (f: rt.Formatter) => rt.fmtFromUtf8ErrorDisplay(e, f))])); - } - let flag: boolean; - const first = rt.sliceFirst(data); - arms: { - if (first !== undefined) { - const b2 = first; - if (rt.u8Rem(b2, 2) === 0) { - flag = true; - break arms; + let iterS!: Uint8Array; + let iterI!: number; + let _9!: rt.u8 | rt.Done; + let _15!: rt.usize; + let _25!: string; + let args2!: rt.Fmt[]; + let _31!: rt.Fmt; + let _36!: rt.Result; + let s!: string; + let _42!: string; + let args4!: rt.Fmt[]; + let e!: rt.FromUtf8Error; + let _55!: string; + let args6!: rt.Fmt[]; + let flag!: boolean; + let _66!: rt.u8 | undefined; + let _76!: string; + let args8!: rt.Fmt[]; + let _93!: string; + let _94!: boolean; + let _95!: rt.Result; + let _104!: string; + let args10!: rt.Fmt[]; + let _116!: string; + let args12!: rt.Fmt[]; + let _122!: rt.Fmt; + iterS = rt.sliceRange(data, 0, rt.min(data.length, 3)); + iterI = 0; + while (true) { + _9 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_9 === rt.DONE) { + _36 = rt.stringFromUtf8(rt.sliceToByteVec(data)); + if (_36.ok) { + s = _36.value; + args4 = [(f: rt.Formatter) => rt.fmtStr(s, f), (f: rt.Formatter) => rt.fmtPad(f, s)]; + _42 = rt.fmtFormat([args4[0], " ", rt.fmtSpec({ align: ">", width: 4 }, args4[1])]); + put(out, _42); + } else { + e = _36.error; + args6 = [(f: rt.Formatter) => rt.fmtFromUtf8ErrorDisplay(e, f), (f: rt.Formatter) => rt.fmtFromUtf8ErrorDebug(e, f)]; + _55 = rt.fmtFormat([args6[0], " ", args6[1], " ", rt.fmtSpec({ alternate: true }, args6[1]), " ", rt.fmtSpec({ align: ">", width: 80 }, args6[0])]); + put(out, _55); + } + _66 = rt.sliceFirst(data); + b2: { + if (_66 !== undefined) { + if (rt.u8Rem(_66, 2) === 0) { + flag = true; + break b2; + } + } + flag = false; + } + args8 = [(f: rt.Formatter) => rt.fmtBool(flag, f), (f: rt.Formatter) => rt.fmtBool(flag, f), (f: rt.Formatter) => rt.fmtUnit(undefined, f), (f: rt.Formatter) => rt.fmtUnit(undefined, f)]; + _76 = rt.fmtFormat([args8[0], " ", args8[1], " ", rt.fmtSpec({ align: ">", width: 6 }, args8[0]), " ", args8[2], " ", rt.fmtSpec({ alternate: true }, args8[3])]); + put(out, _76); + _94 = flag; + _93 = rt.fmtToString((f: rt.Formatter) => rt.fmtBool(_94, f)); + put(out, _93); + _95 = rt.u8TryFrom(rt.i32Sub(data.length | 0, 3)); + if (_95.ok) { + const arg5 = ([_95.value] as [rt.u8])[0]; + args10 = [(f: rt.Formatter) => rt.u8Display(arg5, f)]; + _104 = rt.fmtFormat([args10[0]]); + put(out, _104); + } else { + const arg3 = _95.error; + _122 = (f: rt.Formatter) => rt.fmtTryFromIntErrorDisplay(arg3, f); + const arg4 = _95.error; + args12 = [_122, (f: rt.Formatter) => rt.fmtTryFromIntErrorDebug(arg4, f)]; + _116 = rt.fmtFormat([args12[0], " ", args12[1], " ", rt.fmtSpec({ align: ">", width: 40 }, args12[0]), "|"]); + put(out, _116); + } + return; + } else { + _15 = rt.usizeRem(_9 as rt.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"].length); + if (!(_15 < 14)) { + rt.panic("index out of bounds: the len is " + 14 + " but the index is " + _15); } + [["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"][_15]] as [string]; + const arg = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"][_15]; + _31 = (f: rt.Formatter) => rt.fmtPad(f, arg); + const arg2 = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"][_15]; + args2 = [_31, (f: rt.Formatter) => rt.fmtStr(arg2, f)]; + _25 = rt.fmtFormat([args2[0], "|", rt.fmtSpec({ width: 8 }, args2[0]), "|", rt.fmtSpec({ align: ">", width: 8 }, args2[0]), "|", rt.fmtSpec({ align: "^", width: 8 }, args2[0]), "|", rt.fmtSpec({ fill: "-", align: "<", width: 3 }, args2[0]), "|", args2[1], "|", rt.fmtSpec({ width: 12 }, args2[1]), "|", rt.fmtSpec({ alternate: true }, args2[1]), "|{", args2[0], "}"]); + put(out, _25); } - flag = false; - } - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.fmtBool(flag, f), " ", (f: rt.Formatter) => rt.fmtBool(flag, f), " ", rt.fmtSpec({ align: ">", width: 6 }, (f: rt.Formatter) => rt.fmtBool(flag, f)), " ", (f: rt.Formatter) => rt.fmtUnit(undefined, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.fmtUnit(undefined, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.fmtBool(flag, f))); - const tryFrom = rt.u8TryFrom(rt.i32Sub(data.length | 0, 3)); - if (tryFrom.ok) { - const v = tryFrom.value; - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.u8Display(v, f)])); - } else { - const e2 = tryFrom.error; - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.fmtTryFromIntErrorDisplay(e2, f), " ", (f: rt.Formatter) => rt.fmtTryFromIntErrorDebug(e2, f), " ", rt.fmtSpec({ align: ">", width: 40 }, (f: rt.Formatter) => rt.fmtTryFromIntErrorDisplay(e2, f)), "|"])); } } export function nested(data: Uint8Array): Nested.Nested { - const at = (i: rt.usize): rt.u8 => { + let at!: (a0: rt.usize) => rt.u8; + let _3!: string; + let _5!: rt.usize; + let _15!: Point.Point; + let _22!: Shape.Shape; + let _23!: rt.u8; + let _35!: rt.ByteVec; + let _40!: Pair.Pair[]; + let _49!: Pair.Pair | undefined; + let _60!: rt.u8 | undefined; + let _61!: rt.Result; + let _73!: rt.i16[]; + let _80!: [rt.u8, boolean, string]; + let _84!: [rt.u8]; + let _88!: rt.ByteVec; + let _90!: Kind.Kind; + let _91!: rt.u8; + at = (i: rt.usize): rt.u8 => { return rt.optionUnwrapOr(rt.sliceGet(data, i), 0); }; - const value = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"]; - const arg = rt.at(value, rt.usizeRem(at(0) as rt.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"].length)); - const arg2 = { x: rt.i32Sub(at(1) as rt.i32, 128), y: -7 }; - const value2 = rt.u8Rem(at(2), 3); - const arg3 = arg; - const arg4 = arg2; - const arg5 = value2 === 0 ? { tag: "Dot" } as Shape.Shape : value2 === 1 ? { tag: "Line", _0: { x: 1, y: 2 }, _1: { x: -3, y: 4 } } as Shape.Shape : { tag: "Rect", corner: { x: 0, y: 0 }, width: at(3) as rt.u16, height: 9 } as Shape.Shape; - const arg6 = rt.sliceToByteVec(rt.sliceRange(data, 0, rt.min(data.length, 4))); - const arg7 = rt.sliceToVec([{ _0: at(4), _1: -1 }, { _0: 2, _1: rt.i64Of(-9223372036854775808n) }]); - const arg8 = rt.u8Rem(at(5), 2) === 0 ? { _0: at(5), _1: 5 } : undefined; - const arg9 = rt.u8Rem(at(6), 2) === 0 ? rt.Ok(at(6)) : rt.Err("no"); - const arg10 = [rt.i16Sub(at(7) as rt.i16, 100), 32767]; - const arg11 = [at(8), true, "t"] as [rt.u8, boolean, string]; - const arg12 = [at(9)] as [rt.u8]; - const arg13 = new rt.ByteVec(); - const value3 = rt.u8Rem(at(10), 3); - return { name: arg3, point: arg4, shape: arg5, tags: arg6, pairs: arg7, maybe: arg8, none: undefined, result: arg9, list: arg10, tuple: arg11, single: arg12, empty: arg13, unit: undefined, boxed: value3 === 0 ? { tag: "Empty" } as Kind.Kind : value3 === 1 ? { tag: "One", _0: at(11) } as Kind.Kind : { tag: "Many", count: 2, items: rt.sliceToByteVec(Uint8Array.of(at(11), at(12))) } as Kind.Kind }; + _5 = rt.usizeRem(at(0) as rt.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"].length); + if (!(_5 < 14)) { + rt.panic("index out of bounds: the len is " + 14 + " but the index is " + _5); + } + _3 = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"][_5]; + _15 = { x: rt.i32Sub(at(1) as rt.i32, 128), y: -7 }; + _23 = rt.u8Rem(at(2), 3); + if (_23 === 0) { + _22 = { tag: "Dot" } as Shape.Shape; + } else if (_23 === 1) { + _22 = { tag: "Line", _0: { x: 1, y: 2 }, _1: { x: -3, y: 4 } } as Shape.Shape; + } else { + _22 = { tag: "Rect", corner: { x: 0, y: 0 }, width: at(3) as rt.u16, height: 9 } as Shape.Shape; + } + _35 = rt.sliceToByteVec(rt.sliceRange(data, 0, rt.min(data.length, 4))); + _40 = rt.sliceToVec([{ _0: at(4), _1: -1 }, { _0: 2, _1: rt.i64Of(-9223372036854775808n) }]); + if (!(rt.u8Rem(at(5), 2) === 0)) { + _49 = undefined; + } else { + _49 = { _0: at(5), _1: 5 }; + } + _60 = undefined; + if (!(rt.u8Rem(at(6), 2) === 0)) { + _61 = rt.Err("no"); + } else { + _61 = rt.Ok(at(6)); + } + _73 = [rt.i16Sub(at(7) as rt.i16, 100), 32767]; + _80 = [at(8), true, "t"] as [rt.u8, boolean, string]; + _84 = [at(9)] as [rt.u8]; + _88 = new rt.ByteVec(); + _91 = rt.u8Rem(at(10), 3); + if (_91 === 0) { + _90 = { tag: "Empty" } as Kind.Kind; + } else if (_91 === 1) { + _90 = { tag: "One", _0: at(11) } as Kind.Kind; + } else { + _90 = { tag: "Many", count: 2, items: rt.sliceToByteVec(Uint8Array.of(at(11), at(12))) } as Kind.Kind; + } + return { name: _3, point: _15, shape: _22, tags: _35, pairs: _40, maybe: _49, none: _60, result: _61, list: _73, tuple: _80, single: _84, empty: _88, unit: undefined, boxed: _90 }; } /** Derived `Debug` of every shape, compact and pretty, with options passed to fields. */ export function derived(data: Uint8Array, out: rt.ByteVec): void { - const at = (i: rt.usize): rt.u8 => { + let at!: (a0: rt.usize) => rt.u8; + let value!: Nested.Nested; + let _8!: string; + let args2!: rt.Fmt[]; + let _20!: string; + let args4!: rt.Fmt[]; + let wide!: Wide.Wide; + let _30!: rt.u8; + let _33!: boolean; + let six!: Six.Six; + let _47!: string; + let args6!: rt.Fmt[]; + let _56!: rt.Fmt; + let _57!: rt.Fmt; + let _58!: rt.Fmt; + let _65!: string; + let args8!: rt.Fmt[]; + let point!: Point.Point; + let _84!: string; + let _89!: Pair.Pair; + let args10!: rt.Fmt[]; + let kinds!: Kind.Kind[]; + let _100!: Kind.Kind; + let _101!: Kind.Kind; + let _105!: Kind.Kind; + let _106!: Kind.Kind; + let _112!: string; + let _118!: Kind.Kind; + let args12!: rt.Fmt[]; + let _130!: string; + let args14!: rt.Fmt[]; + let words!: rt.u16[]; + let _148!: string; + let _153!: rt.u8 | undefined; + let _155!: rt.u8 | undefined; + let args16!: rt.Fmt[]; + let _168!: string; + let args18!: rt.Fmt[]; + let _177!: rt.Fmt; + let _178!: rt.Fmt; + let _179!: rt.Fmt; + at = (i: rt.usize): rt.u8 => { return rt.optionUnwrapOr(rt.sliceGet(data, i), 0); }; - const value = nested(data); - put(out, rt.fmtFormat([(f: rt.Formatter) => Nested.fmt$Debug(value, f)])); - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Nested.fmt$Debug(value, f))])); - const wide = { a: at(0), b: 300, c: 70_000, d: rt.u64Of(18446744073709551615n), e: -1, f: at(1) > 10 }; - const six = { _0: at(0), _1: 1, _2: 2, _3: 3, _4: 4, _5: at(1) }; - const arg3 = out; - const arg = {}; - const arg2 = {}; - put(arg3, rt.fmtFormat([(f: rt.Formatter) => Wide.fmt$Debug(wide, f), " ", (f: rt.Formatter) => Six.fmt$Debug(six, f), " ", (f: rt.Formatter) => Unit.fmt$Debug(arg, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Unit.fmt$Debug(arg2, f))])); - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Wide.fmt$Debug(wide, f)), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Six.fmt$Debug(six, f))])); - const point = { x: at(2) as rt.i32, y: -1 }; - const arg5 = out; - const arg4 = { _0: at(3), _1: -9 }; - put(arg5, rt.fmtFormat([rt.fmtSpec({ width: 5 }, (f: rt.Formatter) => Point.fmt$Debug(point, f)), "|", rt.fmtSpec({ align: "<", width: 4 }, (f: rt.Formatter) => Point.fmt$Debug(point, f)), "|", rt.fmtSpec({ alternate: true, width: 4 }, (f: rt.Formatter) => Point.fmt$Debug(point, f)), "|", rt.fmtSpec({ align: ">", width: 3 }, (f: rt.Formatter) => Pair.fmt$Debug(arg4, f))])); - const kinds = [{ tag: "Empty" } as Kind.Kind, { tag: "One", _0: at(4) } as Kind.Kind, { tag: "Braced" } as Kind.Kind, { tag: "Bare" } as Kind.Kind, { tag: "Many", count: 0, items: new rt.ByteVec() } as Kind.Kind]; - const arg7 = out; - const arg6 = kinds[1]; - put(arg7, rt.fmtFormat([(f: rt.Formatter) => rt.fmtList(kinds, f, (value: Kind.Kind, f: rt.Formatter) => Kind.fmt$Debug(value, f)), " ", (f: rt.Formatter) => Kind.fmt$Debug(arg6, f)])); - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.fmtList(kinds, f, (value: Kind.Kind, f: rt.Formatter) => Kind.fmt$Debug(value, f)))])); - const bytes = data; - const words = [at(5) as rt.u16, 0xffff]; - const arg10 = out; - const arg8 = rt.sliceFirst(data); - const arg9 = rt.sliceGet(data, 100); - put(arg10, rt.fmtFormat([(f: rt.Formatter) => rt.fmtList(bytes, f, rt.u8Display), " ", (f: rt.Formatter) => rt.fmtList(words, f, rt.u16Display), " ", (f: rt.Formatter) => rt.fmtOption(arg8, f, rt.u8Display), " ", (f: rt.Formatter) => rt.fmtOption(arg9, f, rt.u8Display)])); - const arg15 = out; - const arg11 = {}; - const arg12 = {}; - const arg13 = {}; - const arg14 = {}; - put(arg15, rt.fmtFormat([(f: rt.Formatter) => Braced.fmt$Debug(arg11, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Braced.fmt$Debug(arg12, f)), " ", (f: rt.Formatter) => Bare.fmt$Debug(arg13, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Bare.fmt$Debug(arg14, f))])); + value = nested(data); + const arg = ([value] as [Nested.Nested])[0]; + args2 = [(f: rt.Formatter) => Nested.fmt$Debug(arg, f)]; + _8 = rt.fmtFormat([args2[0]]); + put(out, _8); + const arg2 = ([value] as [Nested.Nested])[0]; + args4 = [(f: rt.Formatter) => Nested.fmt$Debug(arg2, f)]; + _20 = rt.fmtFormat([rt.fmtSpec({ alternate: true }, args4[0])]); + put(out, _20); + _30 = at(0); + _33 = at(1) > 10; + wide = { a: _30, b: 300, c: 70000, d: rt.u64Of(18446744073709551615n), e: -1, f: _33 }; + six = { _0: at(0), _1: 1, _2: 2, _3: 3, _4: 4, _5: at(1) }; + _56 = (f: rt.Formatter) => Wide.fmt$Debug(wide, f); + _57 = (f: rt.Formatter) => Six.fmt$Debug(six, f); + const arg3 = {}; + _58 = (f: rt.Formatter) => Unit.fmt$Debug(arg3, f); + const arg4 = {}; + args6 = [_56, _57, _58, (f: rt.Formatter) => Unit.fmt$Debug(arg4, f)]; + _47 = rt.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", rt.fmtSpec({ alternate: true }, args6[3])]); + put(out, _47); + args8 = [(f: rt.Formatter) => Wide.fmt$Debug(wide, f), (f: rt.Formatter) => Six.fmt$Debug(six, f)]; + _65 = rt.fmtFormat([rt.fmtSpec({ alternate: true }, args8[0]), " ", rt.fmtSpec({ alternate: true }, args8[1])]); + put(out, _65); + point = { x: at(2) as rt.i32, y: -1 }; + _89 = { _0: at(3), _1: -9 }; + args10 = [(f: rt.Formatter) => Point.fmt$Debug(point, f), (f: rt.Formatter) => Pair.fmt$Debug(_89, f)]; + _84 = rt.fmtFormat([rt.fmtSpec({ width: 5 }, args10[0]), "|", rt.fmtSpec({ align: "<", width: 4 }, args10[0]), "|", rt.fmtSpec({ alternate: true, width: 4 }, args10[0]), "|", rt.fmtSpec({ align: ">", width: 3 }, args10[1])]); + put(out, _84); + _100 = { tag: "Empty" } as Kind.Kind; + _101 = { tag: "One", _0: at(4) } as Kind.Kind; + _105 = { tag: "Braced" } as Kind.Kind; + _106 = { tag: "Bare" } as Kind.Kind; + kinds = [_100, _101, _105, _106, { tag: "Many", count: 0, items: new rt.ByteVec() } as Kind.Kind]; + _118 = kinds[1]; + args12 = [(f: rt.Formatter) => rt.fmtList(kinds, f, (value: Kind.Kind, f: rt.Formatter) => Kind.fmt$Debug(value, f)), (f: rt.Formatter) => Kind.fmt$Debug(_118, f)]; + _112 = rt.fmtFormat([args12[0], " ", args12[1]]); + put(out, _112); + const arg5 = ([kinds] as [Kind.Kind[]])[0]; + args14 = [(f: rt.Formatter) => rt.fmtList(arg5, f, (value: Kind.Kind, f: rt.Formatter) => Kind.fmt$Debug(value, f))]; + _130 = rt.fmtFormat([rt.fmtSpec({ alternate: true }, args14[0])]); + put(out, _130); + words = [at(5) as rt.u16, 65535]; + _153 = rt.sliceFirst(data); + _155 = rt.sliceGet(data, 100); + args16 = [(f: rt.Formatter) => rt.fmtList(data, f, rt.u8Display), (f: rt.Formatter) => rt.fmtList(words, f, rt.u16Display), (f: rt.Formatter) => rt.fmtOption(_153, f, rt.u8Display), (f: rt.Formatter) => rt.fmtOption(_155, f, rt.u8Display)]; + _148 = rt.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " ", args16[3]]); + put(out, _148); + const arg6 = {}; + _177 = (f: rt.Formatter) => Braced.fmt$Debug(arg6, f); + const arg7 = {}; + _178 = (f: rt.Formatter) => Braced.fmt$Debug(arg7, f); + const arg8 = {}; + _179 = (f: rt.Formatter) => Bare.fmt$Debug(arg8, f); + const arg9 = {}; + args18 = [_177, _178, _179, (f: rt.Formatter) => Bare.fmt$Debug(arg9, f)]; + _168 = rt.fmtFormat([args18[0], " ", rt.fmtSpec({ alternate: true }, args18[1]), " ", args18[2], " ", rt.fmtSpec({ alternate: true }, args18[3])]); + put(out, _168); rt.byteVecExtendFromSlice(out, Uint8Array.of(Braced.eq$PartialEq({}, {}) ? 1 : 0, Bare.eq$PartialEq({}, {}) ? 1 : 0)); } /** Written `Display` and `Debug`, and a `Display` that fails inside `format!`. */ export function written(data: Uint8Array, out: rt.ByteVec): void { - const at = (i: rt.usize): rt.u8 => { + let at!: (a0: rt.usize) => rt.u8; + let hex!: Hex.Hex; + let _14!: string; + let args2!: rt.Fmt[]; + let _27!: string; + let _33!: string; + let args4!: rt.Fmt[]; + let manual!: Manual.Manual; + let empty!: Manual.Manual; + let _59!: string; + let args6!: rt.Fmt[]; + let seq!: Seq.Seq; + let none!: Seq.Seq; + let _85!: string; + let args8!: rt.Fmt[]; + let _97!: rt.u8; + let _100!: rt.u8 | undefined; + let _113!: string; + let args10!: rt.Fmt[]; + let _131!: string; + let args12!: rt.Fmt[]; + let _143!: string; + let args14!: rt.Fmt[]; + let _157!: rt.Fmt; + let _158!: rt.Fmt; + at = (i: rt.usize): rt.u8 => { return rt.optionUnwrapOr(rt.sliceGet(data, i), 0); }; - const hex = { _0: rt.u32Mul(at(0) as rt.u32, 0x1001) }; - put(out, rt.fmtFormat([(f: rt.Formatter) => Hex.fmt$Display(hex, f), "|", rt.fmtSpec({ align: ">", width: 12 }, (f: rt.Formatter) => Hex.fmt$Display(hex, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Hex.fmt$Display(hex, f)), "|", (f: rt.Formatter) => Hex.fmt$Debug(hex, f), "|", rt.fmtSpec({ align: ">", width: 6 }, (f: rt.Formatter) => Hex.fmt$Debug(hex, f)), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Hex.fmt$Debug(hex, f))])); - put(out, rt.fmtToString((f: rt.Formatter) => Hex.fmt$Display(hex, f))); - const padded = { _0: "pad" }; - put(out, rt.fmtFormat([(f: rt.Formatter) => Padded.fmt$Display(padded, f), "|", rt.fmtSpec({ align: ">", width: 6 }, (f: rt.Formatter) => Padded.fmt$Display(padded, f)), "|", rt.fmtSpec({ fill: "_", align: "^", width: 9 }, (f: rt.Formatter) => Padded.fmt$Display(padded, f)), "|", rt.fmtSpec({ width: 30 }, (f: rt.Formatter) => Padded.fmt$Display(padded, f)), "|"])); - const manual = { id: at(1), list: rt.sliceToVec([1, at(2) as rt.u16]) }; - const empty = { id: 0, list: [] }; - put(out, rt.fmtFormat([(f: rt.Formatter) => Manual.fmt$Debug(manual, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Manual.fmt$Debug(manual, f)), " ", (f: rt.Formatter) => Manual.fmt$Debug(empty, f)])); - const seq = { _0: rt.sliceToVec([{ _0: at(3), _1: 0 }, { _0: 1, _1: -1 }]) }; - const none = { _0: [] }; - put(out, rt.fmtFormat([(f: rt.Formatter) => Seq.fmt$Debug(seq, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Seq.fmt$Debug(seq, f)), " ", (f: rt.Formatter) => Seq.fmt$Debug(none, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Seq.fmt$Debug(none, f))])); - const tup = { _0: at(4), _1: rt.u8Rem(at(5), 2) === 0 ? at(5) : undefined }; - put(out, rt.fmtFormat([(f: rt.Formatter) => Tup.fmt$Debug(tup, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Tup.fmt$Debug(tup, f))])); - const fine = { _0: at(6) & (~1 & 0xff) }; - put(out, rt.fmtFormat([(f: rt.Formatter) => Fails.fmt$Display(fine, f), " ", rt.fmtSpec({ align: ">", width: 9 }, (f: rt.Formatter) => Fails.fmt$Display(fine, f))])); - const arg3 = out; - const arg = at(7); - const arg2 = at(8); - put(arg3, rt.fmtFormat([(f: rt.Formatter) => rt.u8Display(arg2, f), " ", (f: rt.Formatter) => rt.u8Display(arg, f), " ", (f: rt.Formatter) => rt.u8Display(arg, f), " named ", rt.fmtSpec({ align: ">", width: 5 }, (f: rt.Formatter) => rt.fmtPad(f, "named"))])); + hex = { _0: rt.u32Mul(at(0) as rt.u32, 4097) }; + args2 = [(f: rt.Formatter) => Hex.fmt$Display(hex, f), (f: rt.Formatter) => Hex.fmt$Debug(hex, f)]; + _14 = rt.fmtFormat([args2[0], "|", rt.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", rt.fmtSpec({ alternate: true }, args2[0]), "|", args2[1], "|", rt.fmtSpec({ align: ">", width: 6 }, args2[1]), "|", rt.fmtSpec({ alternate: true }, args2[1])]); + put(out, _14); + _27 = rt.fmtToString((f: rt.Formatter) => Hex.fmt$Display(hex, f)); + put(out, _27); + const arg = ([{ _0: "pad" }] as [Padded.Padded])[0]; + args4 = [(f: rt.Formatter) => Padded.fmt$Display(arg, f)]; + _33 = rt.fmtFormat([args4[0], "|", rt.fmtSpec({ align: ">", width: 6 }, args4[0]), "|", rt.fmtSpec({ fill: "_", align: "^", width: 9 }, args4[0]), "|", rt.fmtSpec({ width: 30 }, args4[0]), "|"]); + put(out, _33); + manual = { id: at(1), list: rt.sliceToVec([1, at(2) as rt.u16]) }; + empty = { id: 0, list: [] }; + args6 = [(f: rt.Formatter) => Manual.fmt$Debug(manual, f), (f: rt.Formatter) => Manual.fmt$Debug(empty, f)]; + _59 = rt.fmtFormat([args6[0], " ", rt.fmtSpec({ alternate: true }, args6[0]), " ", args6[1]]); + put(out, _59); + seq = { _0: rt.sliceToVec([{ _0: at(3), _1: 0 }, { _0: 1, _1: -1 }]) }; + none = { _0: [] }; + args8 = [(f: rt.Formatter) => Seq.fmt$Debug(seq, f), (f: rt.Formatter) => Seq.fmt$Debug(none, f)]; + _85 = rt.fmtFormat([args8[0], " ", rt.fmtSpec({ alternate: true }, args8[0]), " ", args8[1], " ", rt.fmtSpec({ alternate: true }, args8[1])]); + put(out, _85); + _97 = at(4); + if (!(rt.u8Rem(at(5), 2) === 0)) { + _100 = undefined; + } else { + _100 = at(5); + } + const arg2 = ([{ _0: _97, _1: _100 }] as [Tup.Tup])[0]; + args10 = [(f: rt.Formatter) => Tup.fmt$Debug(arg2, f)]; + _113 = rt.fmtFormat([args10[0], " ", rt.fmtSpec({ alternate: true }, args10[0])]); + put(out, _113); + const arg3 = ([{ _0: at(6) & (~1 & 0xff) }] as [Fails.Fails])[0]; + args12 = [(f: rt.Formatter) => Fails.fmt$Display(arg3, f)]; + _131 = rt.fmtFormat([args12[0], " ", rt.fmtSpec({ align: ">", width: 9 }, args12[0])]); + put(out, _131); + [at(7), at(8), "named"] as [rt.u8, rt.u8, string]; + const arg4 = at(8); + _157 = (f: rt.Formatter) => rt.u8Display(arg4, f); + const arg5 = at(7); + _158 = (f: rt.Formatter) => rt.u8Display(arg5, f); + const arg6 = at(7); + args14 = [_157, _158, (f: rt.Formatter) => rt.u8Display(arg6, f), (f: rt.Formatter) => rt.fmtPad(f, "named")]; + _143 = rt.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " named ", rt.fmtSpec({ align: ">", width: 5 }, args14[3])]); + put(out, _143); } /** Panics, each with the message native Rust formats. */ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { - const n = rt.optionUnwrapOr(rt.sliceFirst(rest), 0); - const value = rt.u8Rem(kind, 19); - if (value === 0) { - rt.panicFmt(["bad ", (f: rt.Formatter) => rt.u8Display(n, f), ": ", (f: rt.Formatter) => rt.fmtList(rest, f, rt.u8Display)]); - } else if (value === 1) { - const arg = { _0: n as rt.u32 }; - rt.panicFmt(["internal error: entered unreachable code: never ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u8LowerHex(n, f)), " ", (f: rt.Formatter) => Hex.fmt$Display(arg, f)]); - } else if (value === 2) { + let n!: rt.u8; + let _7!: rt.u8; + let args2!: rt.Fmt[]; + let args4!: rt.Fmt[]; + let _27!: rt.Fmt; + let args6!: rt.Fmt[]; + let _39!: rt.Fmt; + let kind3!: string; + let _66!: rt.Arguments | undefined; + let args8!: rt.Fmt[]; + let r!: rt.Result; + let _98!: string; + let _100!: rt.u8; + let r2!: rt.Result; + let _108!: string; + let _110!: rt.u8; + let _119!: string; + let _121!: rt.u8; + let missing!: rt.u8 | undefined; + let _127!: string; + let _129!: rt.u8; + let _132!: string; + let args10!: rt.Fmt[]; + let _143!: string; + let args12!: rt.Fmt[]; + let _155!: string; + let _157!: Fails.Fails; + let args14!: rt.Fmt[]; + let _167!: rt.Fmt; + let start!: rt.usize; + let end!: rt.usize; + let _173!: [rt.usize, rt.usize]; + let _183!: string; + let _189!: Uint8Array; + let args16!: rt.Fmt[]; + let _196!: rt.Fmt; + let buf!: Uint8Array; + let _202!: Uint8Array; + let _211!: string; + let args18!: rt.Fmt[]; + let r4!: rt.Result; + let _221!: rt.Result; + let s!: string; + let _225!: rt.u8; + let e!: rt.FromUtf8Error; + let _232!: string; + let _234!: rt.u8; + let buf2!: Uint8Array; + let dest!: rt.usize; + let _244!: Uint8Array; + let _258!: string; + let args20!: rt.Fmt[]; + let _269!: string; + let _271!: rt.usize; + let r5!: rt.Result; + let _283!: string; + let args22!: rt.Fmt[]; + n = rt.optionUnwrapOr(rt.sliceFirst(rest), 0); + _7 = rt.u8Rem(kind, 20); + if (_7 === 0) { + args2 = [(f: rt.Formatter) => rt.u8Display(n, f), (f: rt.Formatter) => rt.fmtList(rest, f, rt.u8Display)]; + rt.panicFmt(["bad ", args2[0], ": ", args2[1]]); + } else if (_7 === 1) { + _27 = (f: rt.Formatter) => rt.u8LowerHex(n, f); + const arg14 = { _0: n as rt.u32 }; + args4 = [_27, (f: rt.Formatter) => Hex.fmt$Display(arg14, f)]; + rt.panicFmt(["internal error: entered unreachable code: never ", rt.fmtSpec({ alternate: true }, args4[0]), " ", args4[1]]); + } else if (_7 === 2) { if (!(n > 200)) { - const arg2 = { _0: n, _1: 0 }; - rt.panicFmt(["small ", (f: rt.Formatter) => rt.u8Display(n, f), " ", (f: rt.Formatter) => Pair.fmt$Debug(arg2, f)]); + _39 = (f: rt.Formatter) => rt.u8Display(n, f); + const arg13 = { _0: n, _1: 0 }; + args6 = [_39, (f: rt.Formatter) => Pair.fmt$Debug(arg13, f)]; + rt.panicFmt(["small ", args6[0], " ", args6[1]]); } - } else if (value === 3) { + } else if (_7 === 3) { if (!(n > 200)) { rt.panic("assertion failed: n > 200"); } - } else if (value === 4) { - const value2 = [n, 7] as [rt.u8, rt.u8]; - const leftVal = value2[0]; - const rightVal = value2[1]; - if (leftVal !== rightVal) { - const kind2 = "=="; - rt.assertFailed(kind2, (f: rt.Formatter) => rt.u8Display(leftVal, f), (f: rt.Formatter) => rt.u8Display(rightVal, f)); + } else if (_7 === 4) { + if (!(n === 7)) { + rt.assertFailed("==", (f: rt.Formatter) => rt.u8Display(n, f), (f: rt.Formatter) => rt.u8Display(7, f), undefined); } - } else if (value === 5) { - const value3 = [{ _0: n, _1: 1 }, { _0: n, _1: 1 }] as [Pair.Pair, Pair.Pair]; - const leftVal2 = value3[0]; - const rightVal2 = value3[1]; - if (Pair.eq$PartialEq(leftVal2, rightVal2)) { - const kind3 = "!="; - rt.assertFailed(kind3, (f: rt.Formatter) => Pair.fmt$Debug(leftVal2, f), (f: rt.Formatter) => Pair.fmt$Debug(rightVal2, f), ["same ", (f: rt.Formatter) => rt.u8Display(n, f)]); + } else if (_7 === 5) { + if (Pair.eq$PartialEq({ _0: n, _1: 1 }, { _0: n, _1: 1 })) { + const arg10 = ([n] as [rt.u8])[0]; + kind3 = "!="; + args8 = [(f: rt.Formatter) => rt.u8Display(arg10, f)]; + _66 = ["same ", args8[0]]; + const arg11 = { _0: n, _1: 1 }; + const arg12 = { _0: n, _1: 1 }; + rt.assertFailed(kind3, (f: rt.Formatter) => Pair.fmt$Debug(arg11, f), (f: rt.Formatter) => Pair.fmt$Debug(arg12, f), _66); } - } else if (value === 6) { - const value4 = [n, 9] as [rt.u8, rt.u8]; - const leftVal3 = value4[0]; - const rightVal3 = value4[1]; - if (leftVal3 !== rightVal3) { - const kind4 = "=="; - rt.assertFailed(kind4, (f: rt.Formatter) => rt.u8Display(leftVal3, f), (f: rt.Formatter) => rt.u8Display(rightVal3, f), ["with context"]); + } else if (_7 === 6) { + if (!(n === 9)) { + rt.assertFailed("==", (f: rt.Formatter) => rt.u8Display(n, f), (f: rt.Formatter) => rt.u8Display(9, f), ["with context"]); } - } else if (value === 7) { - const r = rt.u8Rem(n, 2) === 0 ? rt.Err({ tag: "One", _0: n } as Kind.Kind) : rt.Err({ tag: "Many", count: 1, items: rt.sliceToByteVec(Uint8Array.of(n)) } as Kind.Kind); - const arg4 = out; - const arg3 = rt.resultUnwrap(r, (value: Kind.Kind, f: rt.Formatter) => Kind.fmt$Debug(value, f)); - put(arg4, rt.fmtToString((f: rt.Formatter) => rt.u8Display(arg3, f))); - } else if (value === 8) { - const r2 = n > 128 ? rt.Ok(n) : rt.Err({ _0: n, _1: -2 }); - const arg6 = out; - const arg5 = rt.resultExpect(rt.copy(r2), "expected a byte", (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$Debug(value, f)); - put(arg6, rt.fmtToString((f: rt.Formatter) => rt.u8Display(arg5, f))); - } else if (value === 9) { - const r3 = rt.Ok({ x: n as rt.i32, y: 0 }); - const arg8 = out; - const arg7 = rt.resultUnwrapErr(rt.copy(r3), (value: Point.Point, f: rt.Formatter) => Point.fmt$Debug(value, f)); - put(arg8, rt.fmtToString((f: rt.Formatter) => rt.u8Display(arg7, f))); - } else if (value === 10) { - const missing = rt.sliceGet(rest, 200); - const arg10 = out; - const arg9 = rt.optionExpect(missing, rt.fmtFormat(["missing ", (f: rt.Formatter) => rt.u8Display(n, f)])); - put(arg10, rt.fmtToString((f: rt.Formatter) => rt.u8Display(arg9, f))); - } else if (value === 11) { - const arg12 = out; - const arg11 = { _0: n }; - put(arg12, rt.fmtFormat([(f: rt.Formatter) => Fails.fmt$Display(arg11, f)])); - } else if (value === 12) { - const arg14 = out; - const arg13 = { _0: n }; - put(arg14, rt.fmtToString((f: rt.Formatter) => Fails.fmt$Display(arg13, f))); - } else if (value === 13) { - const arg15 = { _0: n as rt.u32 }; - const arg16 = { _0: n }; - rt.panicFmt([(f: rt.Formatter) => Hex.fmt$Display(arg15, f), " then ", (f: rt.Formatter) => Fails.fmt$Display(arg16, f)]); - } else if (value === 14) { - const [start, end] = [rt.u8Rem(n, 8) as rt.usize, rt.u8Div(n, 32) as rt.usize] as [rt.usize, rt.usize]; - const arg19 = out; - const arg17 = rt.sliceRange(rest, start); - const arg18 = rt.sliceRange(rest, start, end); - put(arg19, rt.fmtFormat([(f: rt.Formatter) => rt.fmtList(arg17, f, rt.u8Display), " ", (f: rt.Formatter) => rt.fmtList(arg18, f, rt.u8Display)])); - } else if (value === 15) { - let buf: Uint8Array = rt.bytes(3); - rt.sliceCopyFromSlice(buf, rt.sliceRange(rest, 0, rt.min(rest.length, 4))); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.fmtList(buf, f, rt.u8Display)])); - } else if (value === 16) { - let r4: rt.Result; - const fromUtf8 = rt.stringFromUtf8(rt.sliceToByteVec(rest)); - if (fromUtf8.ok) { - const s = fromUtf8.value; - r4 = rt.Ok(rt.stringLen(s) & 0xff); + } else if (_7 === 7) { + if (rt.u8Rem(n, 2) === 0) { + r = rt.Err({ tag: "One", _0: n } as Kind.Kind); } else { - const e = fromUtf8.error; + r = rt.Err({ tag: "Many", count: 1, items: rt.sliceToByteVec(Uint8Array.of(n)) } as Kind.Kind); + } + _100 = rt.resultUnwrap(r, (value: Kind.Kind, f: rt.Formatter) => Kind.fmt$Debug(value, f)); + _98 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(_100, f)); + put(out, _98); + } else if (_7 === 8) { + if (!(n > 128)) { + r2 = rt.Err({ _0: n, _1: -2 }); + } else { + r2 = rt.Ok(n); + } + _110 = rt.resultExpect(r2, "expected a byte", (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$Debug(value, f)); + _108 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(_110, f)); + put(out, _108); + } else if (_7 === 9) { + _121 = rt.resultUnwrapErr(rt.Ok({ x: n as rt.i32, y: 0 }), (value: Point.Point, f: rt.Formatter) => Point.fmt$Debug(value, f)); + _119 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(_121, f)); + put(out, _119); + } else if (_7 === 10) { + missing = rt.sliceGet(rest, 200); + const arg9 = ([n] as [rt.u8])[0]; + args10 = [(f: rt.Formatter) => rt.u8Display(arg9, f)]; + _132 = rt.fmtFormat(["missing ", args10[0]]); + _129 = rt.optionExpect(missing, _132); + _127 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(_129, f)); + put(out, _127); + } else if (_7 === 11) { + const arg8 = ([{ _0: n }] as [Fails.Fails])[0]; + args12 = [(f: rt.Formatter) => Fails.fmt$Display(arg8, f)]; + _143 = rt.fmtFormat([args12[0]]); + put(out, _143); + } else if (_7 === 12) { + _157 = { _0: n }; + _155 = rt.fmtToString((f: rt.Formatter) => Fails.fmt$Display(_157, f)); + put(out, _155); + } else if (_7 === 13) { + const arg6 = { _0: n as rt.u32 }; + _167 = (f: rt.Formatter) => Hex.fmt$Display(arg6, f); + const arg7 = { _0: n }; + args14 = [_167, (f: rt.Formatter) => Fails.fmt$Display(arg7, f)]; + rt.panicFmt([args14[0], " then ", args14[1]]); + } else if (_7 === 14) { + _173 = [rt.u8Rem(n, 8) as rt.usize, rt.u8Div(n, 32) as rt.usize] as [rt.usize, rt.usize]; + start = _173[0]; + end = _173[1]; + _189 = rt.sliceRange(rest, start); + [_189, rt.sliceRange(rest, start, end)] as [Uint8Array, Uint8Array]; + _196 = (f: rt.Formatter) => rt.fmtList(_189, f, rt.u8Display); + const arg5 = rt.sliceRange(rest, start, end); + args16 = [_196, (f: rt.Formatter) => rt.fmtList(arg5, f, rt.u8Display)]; + _183 = rt.fmtFormat([args16[0], " ", args16[1]]); + put(out, _183); + } else if (_7 === 15) { + buf = rt.bytes(3); + _202 = buf; + const part3 = rt.min(rest.length, 4); + rt.sliceCopyFromSlice(_202, rt.sliceRange(rest, 0, part3)); + const arg4 = ([buf] as [Uint8Array])[0]; + args18 = [(f: rt.Formatter) => rt.fmtList(arg4, f, rt.u8Display)]; + _211 = rt.fmtFormat([args18[0]]); + put(out, _211); + } else if (_7 === 16) { + _221 = rt.stringFromUtf8(rt.sliceToByteVec(rest)); + if (_221.ok) { + s = _221.value; + _225 = rt.stringLen(s) & 0xff; + r4 = rt.Ok(_225); + } else { + e = _221.error; r4 = rt.Err(e); } - const arg21 = out; - const arg20 = rt.resultUnwrap(r4, rt.fmtFromUtf8ErrorDebug); - put(arg21, rt.fmtToString((f: rt.Formatter) => rt.u8Display(arg20, f))); - } else if (value === 17) { - let buf2: Uint8Array = Uint8Array.of(1, 2, 3, 4); - const dest = rt.usizeRem(rt.optionUnwrapOr(rt.sliceGet(rest, 1), 0) as rt.usize, 4); - rt.sliceCopyWithin(buf2, rt.u8Rem(n, 6) as rt.usize, rt.u8Rem(rt.u8Div(n, 6), 6) as rt.usize, dest); - put(out, rt.fmtFormat([(f: rt.Formatter) => rt.fmtList(buf2, f, rt.u8Display)])); + _234 = rt.resultUnwrap(r4, rt.fmtFromUtf8ErrorDebug); + _232 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(_234, f)); + put(out, _232); + } else if (_7 === 17) { + buf2 = Uint8Array.of(1, 2, 3, 4); + const part = rt.u8Rem(n, 6) as rt.usize; + const part2 = rt.u8Rem(rt.u8Div(n, 6), 6) as rt.usize; + dest = rt.usizeRem(rt.optionUnwrapOr(rt.sliceGet(rest, 1), 0) as rt.usize, 4); + _244 = buf2; + rt.sliceCopyWithin(_244, part, part2, dest); + const arg3 = ([buf2] as [Uint8Array])[0]; + args20 = [(f: rt.Formatter) => rt.fmtList(arg3, f, rt.u8Display)]; + _258 = rt.fmtFormat([args20[0]]); + put(out, _258); + } else if (_7 === 18) { + _271 = rt.u8Rem(n, 8) as rt.usize; + rt.idx(rest, _271); + const arg2 = rest[_271]; + _269 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(arg2, f)); + put(out, _269); } else { - const r5 = rt.u8Rem(n, 2) === 0 ? rt.Err(n) : rt.Ok(n); - const arg23 = out; - const arg22 = rt.resultUnwrapErr(r5, rt.u8Display); - put(arg23, rt.fmtFormat([(f: rt.Formatter) => rt.u8Display(arg22, f)])); + if (!(rt.u8Rem(n, 2) === 0)) { + r5 = rt.Ok(n); + } else { + r5 = rt.Err(n); + } + const arg = ([rt.resultUnwrapErr(r5, rt.u8Display)] as [rt.u8])[0]; + args22 = [(f: rt.Formatter) => rt.u8Display(arg, f)]; + _283 = rt.fmtFormat([args22[0]]); + put(out, _283); } } diff --git a/ts/fixtures/lang/expected/generics.Either.ts b/ts/fixtures/lang/expected/generics.Either.ts index 9f8804208..d2315f509 100644 --- a/ts/fixtures/lang/expected/generics.Either.ts +++ b/ts/fixtures/lang/expected/generics.Either.ts @@ -4,36 +4,60 @@ import * as rt from "./rt.ts"; import * as Point from "./shapes.Point.ts"; export function fmt$Debug_Point_u8(self: Either, f: rt.Formatter): rt.Result { + let _5!: string; + let _6!: rt.Fmt; + let _9!: string; + let _10!: string; + let _11!: rt.Fmt; if (self.tag === "Left") { - const __self0 = self._0; - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, "Left"), (f: rt.Formatter) => Point.fmt$Debug(__self0, f))); + _5 = "Left"; + _6 = (f: rt.Formatter) => Point.fmt$Debug(self._0, f); + return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _5), _6)); } else if (self.tag === "Right") { - const __self02 = self.value; - return rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, "Right"), "value", (f: rt.Formatter) => rt.u8Display(__self02, f))); + _9 = "Right"; + _10 = "value"; + _11 = (f: rt.Formatter) => rt.u8Display(self.value, f); + return rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, _9), _10, _11)); } else { return rt.fmtWriteStr(f, "Neither"); } } export function fmt$Debug_u8_Point(self: Either, f: rt.Formatter): rt.Result { + let _5!: string; + let _6!: rt.Fmt; + let _9!: string; + let _10!: string; + let _11!: rt.Fmt; if (self.tag === "Left") { - const __self0 = self._0; - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, "Left"), (f: rt.Formatter) => rt.u8Display(__self0, f))); + _5 = "Left"; + _6 = (f: rt.Formatter) => rt.u8Display(self._0, f); + return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _5), _6)); } else if (self.tag === "Right") { - const __self02 = self.value; - return rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, "Right"), "value", (f: rt.Formatter) => Point.fmt$Debug(__self02, f))); + _9 = "Right"; + _10 = "value"; + _11 = (f: rt.Formatter) => Point.fmt$Debug(self.value, f); + return rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, _9), _10, _11)); } else { return rt.fmtWriteStr(f, "Neither"); } } export function fmt$Debug_u8_u16(self: Either, f: rt.Formatter): rt.Result { + let _5!: string; + let _6!: rt.Fmt; + let _9!: string; + let _10!: string; + let _11!: rt.Fmt; if (self.tag === "Left") { - const __self0 = self._0; - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, "Left"), (f: rt.Formatter) => rt.u8Display(__self0, f))); + _5 = "Left"; + _6 = (f: rt.Formatter) => rt.u8Display(self._0, f); + return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _5), _6)); } else if (self.tag === "Right") { - const __self02 = self.value; - return rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, "Right"), "value", (f: rt.Formatter) => rt.u16Display(__self02, f))); + _9 = "Right"; + _10 = "value"; + _11 = (f: rt.Formatter) => rt.u16Display(self.value, f); + return rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, _9), _10, _11)); } else { return rt.fmtWriteStr(f, "Neither"); } @@ -44,8 +68,7 @@ export type Either = { tag: "Left"; _0: L } | { tag: "Right"; value: R } | export function left$Point_u8(self: Either): Point.Point | undefined { if (self.tag === "Left") { - const l = rt.copy(self._0); - return rt.copy(l); + return rt.copy(self._0); } else { return undefined; } @@ -53,8 +76,7 @@ export function left$Point_u8(self: Either): Point.Point | u export function left$u8_Point(self: Either): rt.u8 | undefined { if (self.tag === "Left") { - const l = self._0; - return l; + return self._0; } else { return undefined; } @@ -62,8 +84,7 @@ export function left$u8_Point(self: Either): rt.u8 | undefin export function left$u8_u16(self: Either): rt.u8 | undefined { if (self.tag === "Left") { - const l = self._0; - return l; + return self._0; } else { return undefined; } @@ -71,13 +92,11 @@ export function left$u8_u16(self: Either): rt.u8 | undefined { export function flip$u8_Point(self: Either): Either { if (self.tag === "Left") { - const l = self._0; - return { tag: "Right", value: l }; + return { tag: "Right", value: self._0 } as Either; } else if (self.tag === "Right") { - const value = rt.copy(self.value); - return { tag: "Left", _0: rt.copy(value) }; + return { tag: "Left", _0: self.value } as Either; } else { - return { tag: "Neither" }; + return { tag: "Neither" } as Either; } } diff --git a/ts/fixtures/lang/expected/generics.Tagged.ts b/ts/fixtures/lang/expected/generics.Tagged.ts index 10a8f9f21..eb3cf6c88 100644 --- a/ts/fixtures/lang/expected/generics.Tagged.ts +++ b/ts/fixtures/lang/expected/generics.Tagged.ts @@ -5,7 +5,21 @@ import * as Either from "./generics.Either.ts"; import * as Wrap from "./generics.Wrap.ts"; export function fmt$Debug_Either_u8_u16_i16(self: Tagged, rt.i16>, f: rt.Formatter): rt.Result { - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Tagged"), "key", (f: rt.Formatter) => Either.fmt$Debug_u8_u16(self.key, f)), "inner", (f: rt.Formatter) => Wrap.fmt$Debug_i16(self.inner, f)), "all", (f: rt.Formatter) => rt.fmtList(self.all, f, (value: Wrap.Wrap, f: rt.Formatter) => Wrap.fmt$Debug_i16(value, f)))); + let _3!: string; + let _4!: string; + let _5!: rt.Fmt; + let _7!: string; + let _8!: rt.Fmt; + let _10!: string; + let _11!: rt.Fmt; + _3 = "Tagged"; + _4 = "key"; + _5 = (f: rt.Formatter) => Either.fmt$Debug_u8_u16(self.key, f); + _7 = "inner"; + _8 = (f: rt.Formatter) => Wrap.fmt$Debug_i16(self.inner, f); + _10 = "all"; + _11 = (f: rt.Formatter) => rt.fmtList(self.all, f, (value: Wrap.Wrap, f: rt.Formatter) => Wrap.fmt$Debug_i16(value, f)); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8), _10, _11)); } /** Two parameters, one nested in another generic type. */ diff --git a/ts/fixtures/lang/expected/generics.Wrap.ts b/ts/fixtures/lang/expected/generics.Wrap.ts index 97bc4b801..bcaf4ed0d 100644 --- a/ts/fixtures/lang/expected/generics.Wrap.ts +++ b/ts/fixtures/lang/expected/generics.Wrap.ts @@ -7,43 +7,137 @@ import * as Point from "./shapes.Point.ts"; import * as Shape from "./shapes.Shape.ts"; export function fmt$Debug_Option_u8(self: Wrap, f: rt.Formatter): rt.Result { - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Wrap"), "value", (f: rt.Formatter) => rt.fmtOption(self.value, f, rt.u8Display)), "count", (f: rt.Formatter) => rt.u8Display(self.count, f))); + let _3!: string; + let _4!: string; + let _5!: rt.Fmt; + let _7!: string; + let _8!: rt.Fmt; + _3 = "Wrap"; + _4 = "value"; + _5 = (f: rt.Formatter) => rt.fmtOption(self.value, f, rt.u8Display); + _7 = "count"; + _8 = (f: rt.Formatter) => rt.u8Display(self.count, f); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function fmt$Debug_Pair(self: Wrap, f: rt.Formatter): rt.Result { - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Wrap"), "value", (f: rt.Formatter) => Pair.fmt$Debug(self.value, f)), "count", (f: rt.Formatter) => rt.u8Display(self.count, f))); + let _3!: string; + let _4!: string; + let _5!: rt.Fmt; + let _7!: string; + let _8!: rt.Fmt; + _3 = "Wrap"; + _4 = "value"; + _5 = (f: rt.Formatter) => Pair.fmt$Debug(self.value, f); + _7 = "count"; + _8 = (f: rt.Formatter) => rt.u8Display(self.count, f); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function fmt$Debug_Point(self: Wrap, f: rt.Formatter): rt.Result { - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Wrap"), "value", (f: rt.Formatter) => Point.fmt$Debug(self.value, f)), "count", (f: rt.Formatter) => rt.u8Display(self.count, f))); + let _3!: string; + let _4!: string; + let _5!: rt.Fmt; + let _7!: string; + let _8!: rt.Fmt; + _3 = "Wrap"; + _4 = "value"; + _5 = (f: rt.Formatter) => Point.fmt$Debug(self.value, f); + _7 = "count"; + _8 = (f: rt.Formatter) => rt.u8Display(self.count, f); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function fmt$Debug_Result_u8_Shape(self: Wrap>, f: rt.Formatter): rt.Result { - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Wrap"), "value", (f: rt.Formatter) => rt.fmtResult(self.value, f, rt.u8Display, (value: Shape.Shape, f: rt.Formatter) => Shape.fmt$Debug(value, f))), "count", (f: rt.Formatter) => rt.u8Display(self.count, f))); + let _3!: string; + let _4!: string; + let _5!: rt.Fmt; + let _7!: string; + let _8!: rt.Fmt; + _3 = "Wrap"; + _4 = "value"; + _5 = (f: rt.Formatter) => rt.fmtResult(self.value, f, rt.u8Display, (value: Shape.Shape, f: rt.Formatter) => Shape.fmt$Debug(value, f)); + _7 = "count"; + _8 = (f: rt.Formatter) => rt.u8Display(self.count, f); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function fmt$Debug_Shape(self: Wrap, f: rt.Formatter): rt.Result { - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Wrap"), "value", (f: rt.Formatter) => Shape.fmt$Debug(self.value, f)), "count", (f: rt.Formatter) => rt.u8Display(self.count, f))); + let _3!: string; + let _4!: string; + let _5!: rt.Fmt; + let _7!: string; + let _8!: rt.Fmt; + _3 = "Wrap"; + _4 = "value"; + _5 = (f: rt.Formatter) => Shape.fmt$Debug(self.value, f); + _7 = "count"; + _8 = (f: rt.Formatter) => rt.u8Display(self.count, f); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function fmt$Debug_Vec_u16(self: Wrap, f: rt.Formatter): rt.Result { - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Wrap"), "value", (f: rt.Formatter) => rt.fmtList(self.value, f, rt.u16Display)), "count", (f: rt.Formatter) => rt.u8Display(self.count, f))); + let _3!: string; + let _4!: string; + let _5!: rt.Fmt; + let _7!: string; + let _8!: rt.Fmt; + _3 = "Wrap"; + _4 = "value"; + _5 = (f: rt.Formatter) => rt.fmtList(self.value, f, rt.u16Display); + _7 = "count"; + _8 = (f: rt.Formatter) => rt.u8Display(self.count, f); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function fmt$Debug_Wrap_Pair(self: Wrap>, f: rt.Formatter): rt.Result { - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Wrap"), "value", (f: rt.Formatter) => fmt$Debug_Pair(self.value, f)), "count", (f: rt.Formatter) => rt.u8Display(self.count, f))); + let _3!: string; + let _4!: string; + let _5!: rt.Fmt; + let _7!: string; + let _8!: rt.Fmt; + _3 = "Wrap"; + _4 = "value"; + _5 = (f: rt.Formatter) => fmt$Debug_Pair(self.value, f); + _7 = "count"; + _8 = (f: rt.Formatter) => rt.u8Display(self.count, f); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function fmt$Debug_i16(self: Wrap, f: rt.Formatter): rt.Result { - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Wrap"), "value", (f: rt.Formatter) => rt.i16Display(self.value, f)), "count", (f: rt.Formatter) => rt.u8Display(self.count, f))); + let _3!: string; + let _4!: string; + let _5!: rt.Fmt; + let _7!: string; + let _8!: rt.Fmt; + _3 = "Wrap"; + _4 = "value"; + _5 = (f: rt.Formatter) => rt.i16Display(self.value, f); + _7 = "count"; + _8 = (f: rt.Formatter) => rt.u8Display(self.count, f); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function fmt$Debug_u8(self: Wrap, f: rt.Formatter): rt.Result { - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Wrap"), "value", (f: rt.Formatter) => rt.u8Display(self.value, f)), "count", (f: rt.Formatter) => rt.u8Display(self.count, f))); + let _3!: string; + let _4!: string; + let _5!: rt.Fmt; + let _7!: string; + let _8!: rt.Fmt; + _3 = "Wrap"; + _4 = "value"; + _5 = (f: rt.Formatter) => rt.u8Display(self.value, f); + _7 = "count"; + _8 = (f: rt.Formatter) => rt.u8Display(self.count, f); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function eq$PartialEq_Pair(self: Wrap, other: Wrap): boolean { - return self.count === other.count && Pair.eq$PartialEq(self.value, other.value); + if (!(self.count === other.count)) { + return false; + } else { + return Pair.eq$PartialEq(self.value, other.value); + } } /** A generic struct, with methods on every instance, on some, and on one. */ @@ -62,11 +156,11 @@ export function new$Option_u8(value: rt.u8 | undefined): Wrap } export function new$Pair(value: Pair.Pair): Wrap { - return new Wrap({ value: rt.copy(value), count: 0 }); + return new Wrap({ value, count: 0 }); } export function new$Point(value: Point.Point): Wrap { - return new Wrap({ value: rt.copy(value), count: 0 }); + return new Wrap({ value, count: 0 }); } export function new$Shape(value: Shape.Shape): Wrap { @@ -74,7 +168,7 @@ export function new$Shape(value: Shape.Shape): Wrap { } export function new$Wrap_Pair(value: Wrap): Wrap> { - return new Wrap({ value: rt.copy(value), count: 0 }); + return new Wrap({ value, count: 0 }); } export function new$i16(value: rt.i16): Wrap { @@ -117,7 +211,7 @@ export function bump$u8(self: Wrap): rt.u8 { } export function intoInner$Point(self: Wrap): Point.Point { - return rt.copy(self.value); + return self.value; } /** A method with its own type parameter. */ diff --git a/ts/fixtures/lang/expected/generics.ts b/ts/fixtures/lang/expected/generics.ts index 3dbb9be39..05ae75ddb 100644 --- a/ts/fixtures/lang/expected/generics.ts +++ b/ts/fixtures/lang/expected/generics.ts @@ -6,24 +6,66 @@ import type * as Pair from "./fmt.Pair.ts"; import * as Either from "./generics.Either.ts"; import * as Tagged from "./generics.Tagged.ts"; import * as Wrap from "./generics.Wrap.ts"; +import type * as Meters from "./shapes.Meters.ts"; import * as Point from "./shapes.Point.ts"; import type * as Shape from "./shapes.Shape.ts"; /** Each method once per instance: `Wrap` of a struct, an enum, a number, and itself. */ export function methods(data: Uint8Array, out: rt.ByteVec): void { - const at = (i: rt.usize): rt.u8 => { + let at!: (a0: rt.usize) => rt.u8; + let point!: Wrap.Wrap; + let byte!: Wrap.Wrap; + let nested!: Wrap.Wrap>; + let meters!: Wrap.Wrap; + let shape!: Wrap.Wrap; + let _46!: string; + let args2!: rt.Fmt[]; + let _64!: string; + let args4!: rt.Fmt[]; + let mapped!: Wrap.Wrap; + let _111!: string; + let _119!: Wrap.Wrap; + let args6!: rt.Fmt[]; + let _126!: rt.Fmt; + let iter!: rt.Iter>; + let _140!: Either.Either | rt.Done; + let either!: Either.Either; + let flipped!: Either.Either; + let _148!: string; + let args8!: rt.Fmt[]; + let _161!: rt.Fmt; + let _162!: rt.Fmt; + let _163!: rt.Fmt; + let list!: Wrap.Wrap; + let _171!: rt.u16; + let none!: Wrap.Wrap; + let some!: Wrap.Wrap; + let err!: Wrap.Wrap>; + let _188!: string; + let _193!: rt.u8; + let args10!: rt.Fmt[]; + let tagged!: Tagged.Tagged, rt.i16>; + let _232!: string; + let args12!: rt.Fmt[]; + let _241!: rt.Fmt; + at = (i: rt.usize): rt.u8 => { return rt.optionUnwrapOr(rt.sliceGet(data, i), 0); }; - let point: Wrap.Wrap = Wrap.new$Point({ x: at(0) as rt.i32, y: -2 }); + point = rt.copy(Wrap.new$Point({ x: at(0) as rt.i32, y: -2 })); Wrap.bump$Point(point); - let byte: Wrap.Wrap = Wrap.new$u8(at(1)); + byte = rt.copy(Wrap.new$u8(at(1))); Wrap.bump$u8(byte); Wrap.bump$u8(byte); - const nested = Wrap.new$Wrap_Pair(Wrap.new$Pair({ _0: at(2), _1: -3 })); - const meters = new Wrap.Wrap({ value: { _0: at(3) as rt.u64 }, count: at(4) }); - const shape = Wrap.new$Shape({ tag: "Rect", corner: Wrap.intoInner$Point(rt.copy(point)), width: at(5) as rt.u16, height: 3 }); - put(out, rt.fmtFormat([(f: rt.Formatter) => Wrap.fmt$Debug_Point(point, f), " ", (f: rt.Formatter) => Wrap.fmt$Debug_u8(byte, f), " ", (f: rt.Formatter) => Wrap.fmt$Debug_Wrap_Pair(nested, f), " ", (f: rt.Formatter) => Wrap.fmt$Debug_Shape(shape, f)])); - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Wrap.fmt$Debug_Wrap_Pair(nested, f))])); + nested = Wrap.new$Wrap_Pair(Wrap.new$Pair({ _0: at(2), _1: -3 })); + meters = new Wrap.Wrap({ value: { _0: at(3) as rt.u64 }, count: at(4) }); + shape = Wrap.new$Shape({ tag: "Rect", corner: Wrap.intoInner$Point(point), width: at(5) as rt.u16, height: 3 } as Shape.Shape); + args2 = [(f: rt.Formatter) => Wrap.fmt$Debug_Point(point, f), (f: rt.Formatter) => Wrap.fmt$Debug_u8(byte, f), (f: rt.Formatter) => Wrap.fmt$Debug_Wrap_Pair(nested, f), (f: rt.Formatter) => Wrap.fmt$Debug_Shape(shape, f)]; + _46 = rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3]]); + put(out, _46); + const arg = ([nested] as [Wrap.Wrap>])[0]; + args4 = [(f: rt.Formatter) => Wrap.fmt$Debug_Wrap_Pair(arg, f)]; + _64 = rt.fmtFormat([rt.fmtSpec({ alternate: true }, args4[0])]); + put(out, _64); rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(Wrap.double$u8(byte))); rt.byteVecPush(out, Wrap.get$u8(byte)); rt.byteVecPush(out, Wrap.get$Pair(Wrap.get$Wrap_Pair(nested))._0); @@ -31,35 +73,55 @@ export function methods(data: Uint8Array, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(Wrap.scaled$Shape(shape))); Wrap.describe$Area_Meters(meters, out); Wrap.describe$Area_Shape(shape, out); - const mapped = Wrap.map$u8_Pair_methods_closure1(rt.copy(byte), (b: rt.u8): Pair.Pair => { + mapped = Wrap.map$u8_Pair_methods_closure1(byte, (b: rt.u8): Pair.Pair => { return { _0: b, _1: at(6) as rt.i64 }; }); - const arg2 = out; - const arg = Wrap.eq$PartialEq_Pair(mapped, Wrap.new$Pair({ _0: at(1), _1: 0 })); - put(arg2, rt.fmtFormat([(f: rt.Formatter) => Wrap.fmt$Debug_Pair(mapped, f), " ", (f: rt.Formatter) => rt.fmtBool(arg, f)])); - const eithers = [{ tag: "Left", _0: at(7) } as Either.Either, { tag: "Right", value: Point.new(1, -1) } as Either.Either, { tag: "Neither" } as Either.Either]; - for (const either of rt.copy(eithers)) { - const flipped = Either.flip$u8_Point(either); - const arg5 = out; - const arg3 = Either.left$u8_Point(either); - const arg4 = Either.left$Point_u8(flipped); - put(arg5, rt.fmtFormat([(f: rt.Formatter) => Either.fmt$Debug_u8_Point(either, f), " ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Either.fmt$Debug_Point_u8(flipped, f)), " ", (f: rt.Formatter) => rt.fmtOption(arg3, f, rt.u8Display), " ", (f: rt.Formatter) => rt.fmtOption(arg4, f, (value: Point.Point, f: rt.Formatter) => Point.fmt$Debug(value, f))])); + _119 = Wrap.new$Pair({ _0: at(1), _1: 0 }); + [Wrap.eq$PartialEq_Pair(mapped, _119), mapped] as [boolean, Wrap.Wrap]; + _126 = (f: rt.Formatter) => Wrap.fmt$Debug_Pair(mapped, f); + const arg2 = Wrap.eq$PartialEq_Pair(mapped, _119); + args6 = [_126, (f: rt.Formatter) => rt.fmtBool(arg2, f)]; + _111 = rt.fmtFormat([args6[0], " ", args6[1]]); + put(out, _111); + iter = rt.iterSlice([{ tag: "Left", _0: at(7) } as Either.Either, { tag: "Right", value: Point.new(1, -1) } as Either.Either, { tag: "Neither" } as Either.Either]); + while (true) { + _140 = iter.next(); + if (_140 === rt.DONE) { + list = new Wrap.Wrap({ value: [], count: 1 }); + _171 = at(10) as rt.u16; + list.value.push(_171); + Wrap.bump$Vec_u16(list); + none = new Wrap.Wrap({ value: undefined, count: 0 }); + some = Wrap.new$Option_u8(rt.sliceGet(data, 11)); + err = new Wrap.Wrap({ value: rt.Err({ tag: "Dot" } as Shape.Shape), count: 2 }); + _193 = rt.optionUnwrapOr(Wrap.get$Option_u8(none), some.count); + args10 = [(f: rt.Formatter) => Wrap.fmt$Debug_Vec_u16(list, f), (f: rt.Formatter) => Wrap.fmt$Debug_Option_u8(none, f), (f: rt.Formatter) => Wrap.fmt$Debug_Option_u8(some, f), (f: rt.Formatter) => Wrap.fmt$Debug_Result_u8_Shape(err, f), (f: rt.Formatter) => rt.u8Display(_193, f)]; + _188 = rt.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " ", args10[3], " ", args10[4]]); + put(out, _188); + tagged = new Tagged.Tagged({ key: { tag: "Right", value: 500 } as Either.Either, inner: Wrap.new$i16(rt.i16Sub(at(8) as rt.i16, 100)), all: rt.sliceToVec([Wrap.new$i16(-1), Wrap.new$i16(at(9) as rt.i16)]) }); + [Tagged.first$Either_u8_u16_i16(tagged), tagged] as [Wrap.Wrap | undefined, Tagged.Tagged, rt.i16>]; + _241 = (f: rt.Formatter) => Tagged.fmt$Debug_Either_u8_u16_i16(tagged, f); + const arg5 = Tagged.first$Either_u8_u16_i16(tagged); + args12 = [_241, (f: rt.Formatter) => rt.fmtOption(arg5, f, (value: Wrap.Wrap, f: rt.Formatter) => Wrap.fmt$Debug_i16(value, f))]; + _232 = rt.fmtFormat([args12[0], " ", args12[1]]); + put(out, _232); + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(tagged.inner.value)); + rt.byteVecPush(out, rt.optionUnwrapOr(Either.left$u8_u16(tagged.key), 0)); + return; + } else { + either = _140; + flipped = Either.flip$u8_Point(either); + [Either.left$u8_Point(either), Either.left$Point_u8(flipped), either, flipped] as [rt.u8 | undefined, Point.Point | undefined, Either.Either, Either.Either]; + _161 = (f: rt.Formatter) => Either.fmt$Debug_u8_Point(either, f); + _162 = (f: rt.Formatter) => Either.fmt$Debug_Point_u8(flipped, f); + const arg3 = Either.left$u8_Point(either); + _163 = (f: rt.Formatter) => rt.fmtOption(arg3, f, rt.u8Display); + const arg4 = Either.left$Point_u8(flipped); + args8 = [_161, _162, _163, (f: rt.Formatter) => rt.fmtOption(arg4, f, (value: Point.Point, f: rt.Formatter) => Point.fmt$Debug(value, f))]; + _148 = rt.fmtFormat([args8[0], " ", rt.fmtSpec({ alternate: true }, args8[1]), " ", args8[2], " ", args8[3]]); + put(out, _148); + } } - let list: Wrap.Wrap = new Wrap.Wrap({ value: [], count: 1 }); - list.value.push(at(10) as rt.u16); - Wrap.bump$Vec_u16(list); - const none = new Wrap.Wrap({ value: undefined, count: 0 }); - const some = Wrap.new$Option_u8(rt.sliceGet(data, 11)); - const err = new Wrap.Wrap({ value: rt.Err({ tag: "Dot" } as Shape.Shape), count: 2 }); - const arg7 = out; - const arg6 = rt.optionUnwrapOr(Wrap.get$Option_u8(none), some.count); - put(arg7, rt.fmtFormat([(f: rt.Formatter) => Wrap.fmt$Debug_Vec_u16(list, f), " ", (f: rt.Formatter) => Wrap.fmt$Debug_Option_u8(none, f), " ", (f: rt.Formatter) => Wrap.fmt$Debug_Option_u8(some, f), " ", (f: rt.Formatter) => Wrap.fmt$Debug_Result_u8_Shape(err, f), " ", (f: rt.Formatter) => rt.u8Display(arg6, f)])); - const tagged = new Tagged.Tagged({ key: { tag: "Right", value: 500 } as Either.Either, inner: Wrap.new$i16(rt.i16Sub(at(8) as rt.i16, 100)), all: rt.sliceToVec([Wrap.new$i16(-1), Wrap.new$i16(at(9) as rt.i16)]) }); - const arg9 = out; - const arg8 = Tagged.first$Either_u8_u16_i16(tagged); - put(arg9, rt.fmtFormat([(f: rt.Formatter) => Tagged.fmt$Debug_Either_u8_u16_i16(tagged, f), " ", (f: rt.Formatter) => rt.fmtOption(arg8, f, (value: Wrap.Wrap, f: rt.Formatter) => Wrap.fmt$Debug_i16(value, f))])); - rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(tagged.inner.value)); - rt.byteVecPush(out, rt.optionUnwrapOr(Either.left$u8_u16(tagged.key), 0)); } //# sourceMappingURL=generics.ts.map diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 708b43691..14f96c4f4 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -10,113 +10,118 @@ import { copies, order, discriminants, loops, patterns, closures, library } from /** Run one case. */ export function run(input: Uint8Array): rt.ByteVec { - let out: rt.ByteVec = new rt.ByteVec(); + let out!: rt.ByteVec; + let op!: rt.u8; + let kind!: rt.u8; + let _10!: [rt.u8, rt.u8]; + let _14!: rt.u8; + let _28!: rt.u8; + let _36!: [rt.u8, Uint8Array] | undefined; + out = new rt.ByteVec(); if (!(input.length >= 2)) { return out; - } - const op = input[0]; - const kind = input[1]; - const data = input.subarray(2, input.length - 0); - const [op2, kind2] = [op, kind] as [rt.u8, rt.u8]; - const value = rt.u8Rem(op2, 38); - if (value === 0) { - u8Op(kind2, data, out); - } else if (value === 1) { - u16Op(kind2, data, out); - } else if (value === 2) { - u32Op(kind2, data, out); - } else if (value === 3) { - u64Op(kind2, data, out); - } else if (value === 4) { - u128Op(kind2, data, out); - } else if (value === 5) { - usizeOp(kind2, data, out); - } else if (value === 6) { - i8Op(kind2, data, out); - } else if (value === 7) { - i16Op(kind2, data, out); - } else if (value === 8) { - i32Op(kind2, data, out); - } else if (value === 9) { - i64Op(kind2, data, out); - } else if (value === 10) { - i128Op(kind2, data, out); - } else if (value === 11) { - isizeOp(kind2, data, out); - } else if (value === 12) { - const value2 = rt.u8Rem(kind2, 6); - if (value2 === 0) { - i8Neg(data, out); - } else if (value2 === 1) { - i16Neg(data, out); - } else if (value2 === 2) { - i32Neg(data, out); - } else if (value2 === 3) { - i64Neg(data, out); - } else if (value2 === 4) { - i128Neg(data, out); - } else { - isizeNeg(data, out); - } - } else if (value === 13) { - const splitFirst = rt.sliceSplitFirst(data); - if (splitFirst !== undefined) { - const to = splitFirst[0]; - const data2 = splitFirst[1]; - cast(kind2, to, data2, out); + } else { + _10 = [input[0], input[1]] as [rt.u8, rt.u8]; + op = _10[0]; + kind = _10[1]; + _14 = rt.u8Rem(op, 38); + if (_14 === 0) { + u8Op(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 1) { + u16Op(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 2) { + u32Op(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 3) { + u64Op(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 4) { + u128Op(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 5) { + usizeOp(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 6) { + i8Op(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 7) { + i16Op(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 8) { + i32Op(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 9) { + i64Op(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 10) { + i128Op(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 11) { + isizeOp(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 12) { + _28 = rt.u8Rem(kind, 6); + if (_28 === 0) { + i8Neg(input.subarray(2, input.length - 0), out); + } else if (_28 === 1) { + i16Neg(input.subarray(2, input.length - 0), out); + } else if (_28 === 2) { + i32Neg(input.subarray(2, input.length - 0), out); + } else if (_28 === 3) { + i64Neg(input.subarray(2, input.length - 0), out); + } else if (_28 === 4) { + i128Neg(input.subarray(2, input.length - 0), out); + } else { + isizeNeg(input.subarray(2, input.length - 0), out); + } + } else if (_14 === 13) { + _36 = rt.sliceSplitFirst(input.subarray(2, input.length - 0)); + if (_36 === undefined) { + cast(kind, rt.u8Div(kind, 12), input.subarray(2, input.length - 0), out); + } else { + cast(kind, _36[0], _36[1], out); + } + } else if (_14 === 14) { + convert(input.subarray(2, input.length - 0), out); + } else if (_14 === 15) { + copies(input.subarray(2, input.length - 0), out); + } else if (_14 === 16) { + loops(input.subarray(2, input.length - 0), out); + } else if (_14 === 17) { + patterns(input.subarray(2, input.length - 0), out); + } else if (_14 === 18) { + closures(input.subarray(2, input.length - 0), out); + } else if (_14 === 19) { + discriminants(input.subarray(2, input.length - 0), out); + } else if (_14 === 20) { + library(input.subarray(2, input.length - 0), out); + } else if (_14 === 21) { + ints(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 22) { + strings(input.subarray(2, input.length - 0), out); + } else if (_14 === 23) { + derived(input.subarray(2, input.length - 0), out); + } else if (_14 === 24) { + written(input.subarray(2, input.length - 0), out); + } else if (_14 === 25) { + panics(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 26) { + methods(input.subarray(2, input.length - 0), out); + } else if (_14 === 27) { + adaptors(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 28) { + consumers(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 29) { + ranges(input.subarray(2, input.length - 0), out); + } else if (_14 === 30) { + options(input.subarray(2, input.length - 0), out); + } else if (_14 === 31) { + own(input.subarray(2, input.length - 0), out); + } else if (_14 === 32) { + values(input.subarray(2, input.length - 0), out); + } else if (_14 === 33) { + order(input.subarray(2, input.length - 0), out); + } else if (_14 === 34) { + hashMaps(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 35) { + sets(kind, input.subarray(2, input.length - 0), out); + } else if (_14 === 36) { + btreeMaps(kind, input.subarray(2, input.length - 0), out); } else { - cast(kind2, rt.u8Div(kind2, 12), data, out); + deques(input.subarray(2, input.length - 0), out); } - } else if (value === 14) { - convert(data, out); - } else if (value === 15) { - copies(data, out); - } else if (value === 16) { - loops(data, out); - } else if (value === 17) { - patterns(data, out); - } else if (value === 18) { - closures(data, out); - } else if (value === 19) { - discriminants(data, out); - } else if (value === 20) { - library(data, out); - } else if (value === 21) { - ints(kind2, data, out); - } else if (value === 22) { - strings(data, out); - } else if (value === 23) { - derived(data, out); - } else if (value === 24) { - written(data, out); - } else if (value === 25) { - panics(kind2, data, out); - } else if (value === 26) { - methods(data, out); - } else if (value === 27) { - adaptors(kind2, data, out); - } else if (value === 28) { - consumers(kind2, data, out); - } else if (value === 29) { - ranges(data, out); - } else if (value === 30) { - options(data, out); - } else if (value === 31) { - own(data, out); - } else if (value === 32) { - values(data, out); - } else if (value === 33) { - order(data, out); - } else if (value === 34) { - hashMaps(kind2, data, out); - } else if (value === 35) { - sets(kind2, data, out); - } else if (value === 36) { - btreeMaps(kind2, data, out); - } else { - deques(data, out); + return out; } - return out; } //# sourceMappingURL=harness.ts.map diff --git a/ts/fixtures/lang/expected/ints.ts b/ts/fixtures/lang/expected/ints.ts index a25866351..3f08d93d0 100644 --- a/ts/fixtures/lang/expected/ints.ts +++ b/ts/fixtures/lang/expected/ints.ts @@ -4,1918 +4,2886 @@ import * as rt from "./rt.ts"; /** Apply operation `op` to operands taken from `data`. */ export function u8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(1); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, data3] = [rt.u8FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.u8, Uint8Array]; - const data4 = data3; - let buf2: Uint8Array = rt.bytes(1); - const n2 = rt.min(data4.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data4, 0, n2)); - const [b, data5] = [rt.u8FromBeBytes(buf2), rt.sliceRange(data4, n2)] as [rt.u8, Uint8Array]; - const shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(data5), 0) as rt.u32, rt.u32Mul(2, 8)); - const put = (out2: rt.ByteVec, v: rt.u8): void => { + let a!: rt.u8; + let _6!: [rt.u8, Uint8Array]; + let buf!: Uint8Array; + let n!: rt.usize; + let b!: rt.u8; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _33!: Uint8Array; + let _38!: rt.u8; + let shift!: rt.u32; + let _50!: (a0: rt.ByteVec, a1: rt.u8) => void; + let _51!: (a0: rt.ByteVec, a1: rt.u8 | undefined) => void; + let _52!: rt.u8; + let x!: rt.u8; + let x2!: rt.u8; + _50 = (out2: rt.ByteVec, v: rt.u8): void => { rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(v as rt.u128)); rt.byteVecPush(out2, rt.u8FromBeBytes(rt.u8ToBeBytes(v)) === v ? 1 : 0); }; - const putOpt = (out3: rt.ByteVec, v2: rt.u8 | undefined): void => { - if (v2 !== undefined) { - const v3 = v2; + _51 = (out3: rt.ByteVec, v2: rt.u8 | undefined): void => { + let v3!: rt.u8; + if (v2 === undefined) { + rt.byteVecPush(out3, 0); + } else { + v3 = v2; rt.byteVecPush(out3, 1); rt.byteVecExtendFromSlice(out3, rt.u128ToBeBytes(v3 as rt.u128)); - } else { - rt.byteVecPush(out3, 0); } }; - const value = rt.u8Rem(op, 24); - if (value === 0) { - put(out, rt.u8Add(a, b)); - } else if (value === 1) { - put(out, rt.u8Sub(a, b)); - } else if (value === 2) { - put(out, rt.u8Mul(a, b)); - } else if (value === 3) { - put(out, rt.u8Div(a, b)); - } else if (value === 4) { - put(out, rt.u8Rem(a, b)); - } else if (value === 5) { - put(out, a & b); - } else if (value === 6) { - put(out, a | b); - } else if (value === 7) { - put(out, a ^ b); - } else if (value === 8) { - put(out, rt.u8Shl(a, shift)); - } else if (value === 9) { - put(out, rt.u8Shr(a, shift)); - } else if (value === 10) { - put(out, ~a & 0xff); - } else if (value === 11) { - putOpt(out, rt.u8CheckedAdd(a, b)); - } else if (value === 12) { - putOpt(out, rt.u8CheckedSub(a, b)); - } else if (value === 13) { - putOpt(out, rt.u8CheckedMul(a, b)); - } else if (value === 14) { - put(out, rt.u8SaturatingAdd(a, b)); - } else if (value === 15) { - put(out, rt.u8SaturatingSub(a, b)); - } else if (value === 16) { - put(out, rt.u8WrappingAdd(a, b)); - } else if (value === 17) { - put(out, rt.u8WrappingSub(a, b)); - } else if (value === 18) { + buf = Uint8Array.of(0); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + _6 = [rt.u8FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.u8, Uint8Array]; + a = _6[0]; + buf2 = Uint8Array.of(0); + n2 = rt.min(rt.sliceRange(data, n).length, buf2.length); + _33 = rt.sliceRange(buf2, 0, n2); + const slice = rt.sliceRange(data, n); + rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + _38 = rt.u8FromBeBytes(buf2); + const slice2 = rt.sliceRange(data, n); + [_38, rt.sliceRange(slice2, n2)] as [rt.u8, Uint8Array]; + b = _38; + shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 8)); + _52 = rt.u8Rem(op, 25); + if (_52 === 0) { + const part16 = rt.u8Add(a, b); + _50(out, part16); + } else if (_52 === 1) { + const part15 = rt.u8Sub(a, b); + _50(out, part15); + } else if (_52 === 2) { + const part14 = rt.u8Mul(a, b); + _50(out, part14); + } else if (_52 === 3) { + const part13 = rt.u8Div(a, b); + _50(out, part13); + } else if (_52 === 4) { + const part12 = rt.u8Rem(a, b); + _50(out, part12); + } else if (_52 === 5) { + _50(out, a & b); + } else if (_52 === 6) { + _50(out, a | b); + } else if (_52 === 7) { + _50(out, a ^ b); + } else if (_52 === 8) { + const part11 = rt.u8Shl(a, shift); + _50(out, part11); + } else if (_52 === 9) { + const part10 = rt.u8Shr(a, shift); + _50(out, part10); + } else if (_52 === 10) { + _50(out, ~a & 0xff); + } else if (_52 === 11) { + const part9 = rt.u8CheckedAdd(a, b); + _51(out, part9); + } else if (_52 === 12) { + const part8 = rt.u8CheckedSub(a, b); + _51(out, part8); + } else if (_52 === 13) { + const part7 = rt.u8CheckedMul(a, b); + _51(out, part7); + } else if (_52 === 14) { + const part6 = rt.u8SaturatingAdd(a, b); + _50(out, part6); + } else if (_52 === 15) { + const part5 = rt.u8SaturatingSub(a, b); + _50(out, part5); + } else if (_52 === 16) { + const part4 = rt.u8WrappingAdd(a, b); + _50(out, part4); + } else if (_52 === 17) { + const part3 = rt.u8WrappingSub(a, b); + _50(out, part3); + } else if (_52 === 18) { rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u8LeadingOnes(a))); - } else if (value === 19) { + } else if (_52 === 19) { rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u8LeadingZeros(a))); - } else if (value === 20) { - put(out, rt.max(a, b)); - } else if (value === 21) { - put(out, rt.min(a, b)); - } else if (value === 22) { + } else if (_52 === 20) { + const part2 = rt.max(a, b); + _50(out, part2); + } else if (_52 === 21) { + const part = rt.min(a, b); + _50(out, part); + } else if (_52 === 22) { rt.byteVecPush(out, a === b ? 1 : 0); rt.byteVecPush(out, a < b ? 1 : 0); rt.byteVecPush(out, a >= b ? 1 : 0); rt.byteVecPush(out, rt.u8WrappingSub(a, b) === 0 ? 1 : 0); + } else if (_52 === 23) { + x = rt.u8Add(a, b); + rt.u8Mul(x, b); + rt.u8Mul(rt.u8Sub(x, b), a); + rt.byteVecPush(out, 1); } else { - let x: rt.u8 = a; - x = rt.u8Add(x, b); - x = rt.u8Sub(x, 1); - x = rt.u8Mul(x, 2); - x = rt.u8Shr(x, 1); - x = rt.u8Shl(x, 1); - const value2 = 1 << 3; - x = x | value2; - x = x ^ b; - const value3 = ~(1 << 2) & 0xff; - x = x & value3; - put(out, x); + x2 = a; + x2 = rt.u8Add(x2, b); + x2 = rt.u8Sub(x2, 1); + x2 = rt.u8Mul(x2, 2); + x2 = x2 >> 1; + x2 = (x2 << 1) & 0xff; + x2 = x2 | (1 << 3); + x2 = x2 ^ b; + x2 = x2 & (~(1 << 2) & 0xff); + x2 = rt.u8Rem(x2, 7); + x2 = rt.u8Div(x2, 3); + _50(out, x2); } } /** Apply operation `op` to operands taken from `data`. */ export function u16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(2); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, data3] = [rt.u16FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.u16, Uint8Array]; - const data4 = data3; - let buf2: Uint8Array = rt.bytes(2); - const n2 = rt.min(data4.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data4, 0, n2)); - const [b, data5] = [rt.u16FromBeBytes(buf2), rt.sliceRange(data4, n2)] as [rt.u16, Uint8Array]; - const shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(data5), 0) as rt.u32, rt.u32Mul(2, 16)); - const put = (out2: rt.ByteVec, v: rt.u16): void => { + let a!: rt.u16; + let _6!: [rt.u16, Uint8Array]; + let buf!: Uint8Array; + let n!: rt.usize; + let b!: rt.u16; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _33!: Uint8Array; + let _38!: rt.u16; + let shift!: rt.u32; + let _50!: (a0: rt.ByteVec, a1: rt.u16) => void; + let _51!: (a0: rt.ByteVec, a1: rt.u16 | undefined) => void; + let _52!: rt.u8; + let x!: rt.u16; + let x2!: rt.u16; + _50 = (out2: rt.ByteVec, v: rt.u16): void => { rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(v as rt.u128)); rt.byteVecPush(out2, rt.u16FromBeBytes(rt.u16ToBeBytes(v)) === v ? 1 : 0); }; - const putOpt = (out3: rt.ByteVec, v2: rt.u16 | undefined): void => { - if (v2 !== undefined) { - const v3 = v2; + _51 = (out3: rt.ByteVec, v2: rt.u16 | undefined): void => { + let v3!: rt.u16; + if (v2 === undefined) { + rt.byteVecPush(out3, 0); + } else { + v3 = v2; rt.byteVecPush(out3, 1); rt.byteVecExtendFromSlice(out3, rt.u128ToBeBytes(v3 as rt.u128)); - } else { - rt.byteVecPush(out3, 0); } }; - const value = rt.u8Rem(op, 24); - if (value === 0) { - put(out, rt.u16Add(a, b)); - } else if (value === 1) { - put(out, rt.u16Sub(a, b)); - } else if (value === 2) { - put(out, rt.u16Mul(a, b)); - } else if (value === 3) { - put(out, rt.u16Div(a, b)); - } else if (value === 4) { - put(out, rt.u16Rem(a, b)); - } else if (value === 5) { - put(out, a & b); - } else if (value === 6) { - put(out, a | b); - } else if (value === 7) { - put(out, a ^ b); - } else if (value === 8) { - put(out, rt.u16Shl(a, shift)); - } else if (value === 9) { - put(out, rt.u16Shr(a, shift)); - } else if (value === 10) { - put(out, ~a & 0xffff); - } else if (value === 11) { - putOpt(out, rt.u16CheckedAdd(a, b)); - } else if (value === 12) { - putOpt(out, rt.u16CheckedSub(a, b)); - } else if (value === 13) { - putOpt(out, rt.u16CheckedMul(a, b)); - } else if (value === 14) { - put(out, rt.u16SaturatingAdd(a, b)); - } else if (value === 15) { - put(out, rt.u16SaturatingSub(a, b)); - } else if (value === 16) { - put(out, rt.u16WrappingAdd(a, b)); - } else if (value === 17) { - put(out, rt.u16WrappingSub(a, b)); - } else if (value === 18) { + buf = rt.bytes(2); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + _6 = [rt.u16FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.u16, Uint8Array]; + a = _6[0]; + buf2 = rt.bytes(2); + n2 = rt.min(rt.sliceRange(data, n).length, buf2.length); + _33 = rt.sliceRange(buf2, 0, n2); + const slice = rt.sliceRange(data, n); + rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + _38 = rt.u16FromBeBytes(buf2); + const slice2 = rt.sliceRange(data, n); + [_38, rt.sliceRange(slice2, n2)] as [rt.u16, Uint8Array]; + b = _38; + shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 16)); + _52 = rt.u8Rem(op, 25); + if (_52 === 0) { + const part16 = rt.u16Add(a, b); + _50(out, part16); + } else if (_52 === 1) { + const part15 = rt.u16Sub(a, b); + _50(out, part15); + } else if (_52 === 2) { + const part14 = rt.u16Mul(a, b); + _50(out, part14); + } else if (_52 === 3) { + const part13 = rt.u16Div(a, b); + _50(out, part13); + } else if (_52 === 4) { + const part12 = rt.u16Rem(a, b); + _50(out, part12); + } else if (_52 === 5) { + _50(out, a & b); + } else if (_52 === 6) { + _50(out, a | b); + } else if (_52 === 7) { + _50(out, a ^ b); + } else if (_52 === 8) { + const part11 = rt.u16Shl(a, shift); + _50(out, part11); + } else if (_52 === 9) { + const part10 = rt.u16Shr(a, shift); + _50(out, part10); + } else if (_52 === 10) { + _50(out, ~a & 0xffff); + } else if (_52 === 11) { + const part9 = rt.u16CheckedAdd(a, b); + _51(out, part9); + } else if (_52 === 12) { + const part8 = rt.u16CheckedSub(a, b); + _51(out, part8); + } else if (_52 === 13) { + const part7 = rt.u16CheckedMul(a, b); + _51(out, part7); + } else if (_52 === 14) { + const part6 = rt.u16SaturatingAdd(a, b); + _50(out, part6); + } else if (_52 === 15) { + const part5 = rt.u16SaturatingSub(a, b); + _50(out, part5); + } else if (_52 === 16) { + const part4 = rt.u16WrappingAdd(a, b); + _50(out, part4); + } else if (_52 === 17) { + const part3 = rt.u16WrappingSub(a, b); + _50(out, part3); + } else if (_52 === 18) { rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u16LeadingOnes(a))); - } else if (value === 19) { + } else if (_52 === 19) { rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u16LeadingZeros(a))); - } else if (value === 20) { - put(out, rt.max(a, b)); - } else if (value === 21) { - put(out, rt.min(a, b)); - } else if (value === 22) { + } else if (_52 === 20) { + const part2 = rt.max(a, b); + _50(out, part2); + } else if (_52 === 21) { + const part = rt.min(a, b); + _50(out, part); + } else if (_52 === 22) { rt.byteVecPush(out, a === b ? 1 : 0); rt.byteVecPush(out, a < b ? 1 : 0); rt.byteVecPush(out, a >= b ? 1 : 0); rt.byteVecPush(out, rt.u16WrappingSub(a, b) === 0 ? 1 : 0); + } else if (_52 === 23) { + x = rt.u16Add(a, b); + rt.u16Mul(x, b); + rt.u16Mul(rt.u16Sub(x, b), a); + rt.byteVecPush(out, 1); } else { - let x: rt.u16 = a; - x = rt.u16Add(x, b); - x = rt.u16Sub(x, 1); - x = rt.u16Mul(x, 2); - x = rt.u16Shr(x, 1); - x = rt.u16Shl(x, 1); - const value2 = 1 << 3; - x = x | value2; - x = x ^ b; - const value3 = ~(1 << 2) & 0xffff; - x = x & value3; - put(out, x); + x2 = a; + x2 = rt.u16Add(x2, b); + x2 = rt.u16Sub(x2, 1); + x2 = rt.u16Mul(x2, 2); + x2 = x2 >> 1; + x2 = (x2 << 1) & 0xffff; + x2 = x2 | (1 << 3); + x2 = x2 ^ b; + x2 = x2 & (~(1 << 2) & 0xffff); + x2 = rt.u16Rem(x2, 7); + x2 = rt.u16Div(x2, 3); + _50(out, x2); } } /** Apply operation `op` to operands taken from `data`. */ export function u32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(4); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, data3] = [rt.u32FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.u32, Uint8Array]; - const data4 = data3; - let buf2: Uint8Array = rt.bytes(4); - const n2 = rt.min(data4.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data4, 0, n2)); - const [b, data5] = [rt.u32FromBeBytes(buf2), rt.sliceRange(data4, n2)] as [rt.u32, Uint8Array]; - const shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(data5), 0) as rt.u32, rt.u32Mul(2, 32)); - const put = (out2: rt.ByteVec, v: rt.u32): void => { + let a!: rt.u32; + let _6!: [rt.u32, Uint8Array]; + let buf!: Uint8Array; + let n!: rt.usize; + let b!: rt.u32; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _33!: Uint8Array; + let _38!: rt.u32; + let shift!: rt.u32; + let _50!: (a0: rt.ByteVec, a1: rt.u32) => void; + let _51!: (a0: rt.ByteVec, a1: rt.u32 | undefined) => void; + let _52!: rt.u8; + let x!: rt.u32; + let x2!: rt.u32; + _50 = (out2: rt.ByteVec, v: rt.u32): void => { rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(v as rt.u128)); rt.byteVecPush(out2, rt.u32FromBeBytes(rt.u32ToBeBytes(v)) === v ? 1 : 0); }; - const putOpt = (out3: rt.ByteVec, v2: rt.u32 | undefined): void => { - if (v2 !== undefined) { - const v3 = v2; + _51 = (out3: rt.ByteVec, v2: rt.u32 | undefined): void => { + let v3!: rt.u32; + if (v2 === undefined) { + rt.byteVecPush(out3, 0); + } else { + v3 = v2; rt.byteVecPush(out3, 1); rt.byteVecExtendFromSlice(out3, rt.u128ToBeBytes(v3 as rt.u128)); - } else { - rt.byteVecPush(out3, 0); } }; - const value = rt.u8Rem(op, 24); - if (value === 0) { - put(out, rt.u32Add(a, b)); - } else if (value === 1) { - put(out, rt.u32Sub(a, b)); - } else if (value === 2) { - put(out, rt.u32Mul(a, b)); - } else if (value === 3) { - put(out, rt.u32Div(a, b)); - } else if (value === 4) { - put(out, rt.u32Rem(a, b)); - } else if (value === 5) { - put(out, (a & b) >>> 0); - } else if (value === 6) { - put(out, (a | b) >>> 0); - } else if (value === 7) { - put(out, (a ^ b) >>> 0); - } else if (value === 8) { - put(out, rt.u32Shl(a, shift)); - } else if (value === 9) { - put(out, rt.u32Shr(a, shift)); - } else if (value === 10) { - put(out, ~a >>> 0); - } else if (value === 11) { - putOpt(out, rt.u32CheckedAdd(a, b)); - } else if (value === 12) { - putOpt(out, rt.u32CheckedSub(a, b)); - } else if (value === 13) { - putOpt(out, rt.u32CheckedMul(a, b)); - } else if (value === 14) { - put(out, rt.u32SaturatingAdd(a, b)); - } else if (value === 15) { - put(out, rt.u32SaturatingSub(a, b)); - } else if (value === 16) { - put(out, rt.u32WrappingAdd(a, b)); - } else if (value === 17) { - put(out, rt.u32WrappingSub(a, b)); - } else if (value === 18) { + buf = rt.bytes(4); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + _6 = [rt.u32FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.u32, Uint8Array]; + a = _6[0]; + buf2 = rt.bytes(4); + n2 = rt.min(rt.sliceRange(data, n).length, buf2.length); + _33 = rt.sliceRange(buf2, 0, n2); + const slice = rt.sliceRange(data, n); + rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + _38 = rt.u32FromBeBytes(buf2); + const slice2 = rt.sliceRange(data, n); + [_38, rt.sliceRange(slice2, n2)] as [rt.u32, Uint8Array]; + b = _38; + shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 32)); + _52 = rt.u8Rem(op, 25); + if (_52 === 0) { + const part16 = rt.u32Add(a, b); + _50(out, part16); + } else if (_52 === 1) { + const part15 = rt.u32Sub(a, b); + _50(out, part15); + } else if (_52 === 2) { + const part14 = rt.u32Mul(a, b); + _50(out, part14); + } else if (_52 === 3) { + const part13 = rt.u32Div(a, b); + _50(out, part13); + } else if (_52 === 4) { + const part12 = rt.u32Rem(a, b); + _50(out, part12); + } else if (_52 === 5) { + _50(out, (a & b) >>> 0); + } else if (_52 === 6) { + _50(out, (a | b) >>> 0); + } else if (_52 === 7) { + _50(out, (a ^ b) >>> 0); + } else if (_52 === 8) { + const part11 = rt.u32Shl(a, shift); + _50(out, part11); + } else if (_52 === 9) { + const part10 = rt.u32Shr(a, shift); + _50(out, part10); + } else if (_52 === 10) { + _50(out, ~a >>> 0); + } else if (_52 === 11) { + const part9 = rt.u32CheckedAdd(a, b); + _51(out, part9); + } else if (_52 === 12) { + const part8 = rt.u32CheckedSub(a, b); + _51(out, part8); + } else if (_52 === 13) { + const part7 = rt.u32CheckedMul(a, b); + _51(out, part7); + } else if (_52 === 14) { + const part6 = rt.u32SaturatingAdd(a, b); + _50(out, part6); + } else if (_52 === 15) { + const part5 = rt.u32SaturatingSub(a, b); + _50(out, part5); + } else if (_52 === 16) { + const part4 = rt.u32WrappingAdd(a, b); + _50(out, part4); + } else if (_52 === 17) { + const part3 = rt.u32WrappingSub(a, b); + _50(out, part3); + } else if (_52 === 18) { rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32LeadingOnes(a))); - } else if (value === 19) { + } else if (_52 === 19) { rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32LeadingZeros(a))); - } else if (value === 20) { - put(out, rt.max(a, b)); - } else if (value === 21) { - put(out, rt.min(a, b)); - } else if (value === 22) { + } else if (_52 === 20) { + const part2 = rt.max(a, b); + _50(out, part2); + } else if (_52 === 21) { + const part = rt.min(a, b); + _50(out, part); + } else if (_52 === 22) { rt.byteVecPush(out, a === b ? 1 : 0); rt.byteVecPush(out, a < b ? 1 : 0); rt.byteVecPush(out, a >= b ? 1 : 0); rt.byteVecPush(out, rt.u32WrappingSub(a, b) === 0 ? 1 : 0); + } else if (_52 === 23) { + x = rt.u32Add(a, b); + rt.u32Mul(x, b); + rt.u32Mul(rt.u32Sub(x, b), a); + rt.byteVecPush(out, 1); } else { - let x: rt.u32 = a; - x = rt.u32Add(x, b); - x = rt.u32Sub(x, 1); - x = rt.u32Mul(x, 2); - x = rt.u32Shr(x, 1); - x = rt.u32Shl(x, 1); - const value2 = 1 << 3; - x = (x | value2) >>> 0; - x = (x ^ b) >>> 0; - const value3 = ~(1 << 2) >>> 0; - x = (x & value3) >>> 0; - put(out, x); + x2 = a; + x2 = rt.u32Add(x2, b); + x2 = rt.u32Sub(x2, 1); + x2 = rt.u32Mul(x2, 2); + x2 = x2 >>> 1; + x2 = (x2 << 1) >>> 0; + x2 = (x2 | (1 << 3)) >>> 0; + x2 = (x2 ^ b) >>> 0; + x2 = (x2 & (~(1 << 2) >>> 0)) >>> 0; + x2 = rt.u32Rem(x2, 7); + x2 = rt.u32Div(x2, 3); + _50(out, x2); } } /** Apply operation `op` to operands taken from `data`. */ export function u64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(8); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, data3] = [rt.u64FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.u64, Uint8Array]; - const data4 = data3; - let buf2: Uint8Array = rt.bytes(8); - const n2 = rt.min(data4.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data4, 0, n2)); - const [b, data5] = [rt.u64FromBeBytes(buf2), rt.sliceRange(data4, n2)] as [rt.u64, Uint8Array]; - const shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(data5), 0) as rt.u32, rt.u32Mul(2, 64)); - const put = (out2: rt.ByteVec, v: rt.u64): void => { + let a!: rt.u64; + let _6!: [rt.u64, Uint8Array]; + let buf!: Uint8Array; + let n!: rt.usize; + let b!: rt.u64; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _33!: Uint8Array; + let _38!: rt.u64; + let shift!: rt.u32; + let _50!: (a0: rt.ByteVec, a1: rt.u64) => void; + let _51!: (a0: rt.ByteVec, a1: rt.u64 | undefined) => void; + let _52!: rt.u8; + let x!: rt.u64; + let x2!: rt.u64; + _50 = (out2: rt.ByteVec, v: rt.u64): void => { rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(rt.u128Cast(v))); rt.byteVecPush(out2, rt.u64Eq(rt.u64FromBeBytes(rt.u64ToBeBytes(v)), v) ? 1 : 0); }; - const putOpt = (out3: rt.ByteVec, v2: rt.u64 | undefined): void => { - if (v2 !== undefined) { - const v3 = v2; + _51 = (out3: rt.ByteVec, v2: rt.u64 | undefined): void => { + let v3!: rt.u64; + if (v2 === undefined) { + rt.byteVecPush(out3, 0); + } else { + v3 = v2; rt.byteVecPush(out3, 1); rt.byteVecExtendFromSlice(out3, rt.u128ToBeBytes(rt.u128Cast(v3))); - } else { - rt.byteVecPush(out3, 0); } }; - const value = rt.u8Rem(op, 24); - if (value === 0) { - put(out, rt.u64Add(a, b)); - } else if (value === 1) { - put(out, rt.u64Sub(a, b)); - } else if (value === 2) { - put(out, rt.u64Mul(a, b)); - } else if (value === 3) { - put(out, rt.u64Div(a, b)); - } else if (value === 4) { - put(out, rt.u64Rem(a, b)); - } else if (value === 5) { - put(out, rt.u64And(a, b)); - } else if (value === 6) { - put(out, rt.u64Or(a, b)); - } else if (value === 7) { - put(out, rt.u64Xor(a, b)); - } else if (value === 8) { - put(out, rt.u64Shl(a, shift)); - } else if (value === 9) { - put(out, rt.u64Shr(a, shift)); - } else if (value === 10) { - put(out, rt.u64Not(a)); - } else if (value === 11) { - putOpt(out, rt.u64CheckedAdd(a, b)); - } else if (value === 12) { - putOpt(out, rt.u64CheckedSub(a, b)); - } else if (value === 13) { - putOpt(out, rt.u64CheckedMul(a, b)); - } else if (value === 14) { - put(out, rt.u64SaturatingAdd(a, b)); - } else if (value === 15) { - put(out, rt.u64SaturatingSub(a, b)); - } else if (value === 16) { - put(out, rt.u64WrappingAdd(a, b)); - } else if (value === 17) { - put(out, rt.u64WrappingSub(a, b)); - } else if (value === 18) { + buf = rt.bytes(8); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + _6 = [rt.u64FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.u64, Uint8Array]; + a = _6[0]; + buf2 = rt.bytes(8); + n2 = rt.min(rt.sliceRange(data, n).length, buf2.length); + _33 = rt.sliceRange(buf2, 0, n2); + const slice = rt.sliceRange(data, n); + rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + _38 = rt.u64FromBeBytes(buf2); + const slice2 = rt.sliceRange(data, n); + [_38, rt.sliceRange(slice2, n2)] as [rt.u64, Uint8Array]; + b = _38; + shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 64)); + _52 = rt.u8Rem(op, 25); + if (_52 === 0) { + const part16 = rt.u64Add(a, b); + _50(out, part16); + } else if (_52 === 1) { + const part15 = rt.u64Sub(a, b); + _50(out, part15); + } else if (_52 === 2) { + const part14 = rt.u64Mul(a, b); + _50(out, part14); + } else if (_52 === 3) { + const part13 = rt.u64Div(a, b); + _50(out, part13); + } else if (_52 === 4) { + const part12 = rt.u64Rem(a, b); + _50(out, part12); + } else if (_52 === 5) { + _50(out, rt.u64And(a, b)); + } else if (_52 === 6) { + _50(out, rt.u64Or(a, b)); + } else if (_52 === 7) { + _50(out, rt.u64Xor(a, b)); + } else if (_52 === 8) { + const part11 = rt.u64Shl(a, shift); + _50(out, part11); + } else if (_52 === 9) { + const part10 = rt.u64Shr(a, shift); + _50(out, part10); + } else if (_52 === 10) { + _50(out, rt.u64Not(a)); + } else if (_52 === 11) { + const part9 = rt.u64CheckedAdd(a, b); + _51(out, part9); + } else if (_52 === 12) { + const part8 = rt.u64CheckedSub(a, b); + _51(out, part8); + } else if (_52 === 13) { + const part7 = rt.u64CheckedMul(a, b); + _51(out, part7); + } else if (_52 === 14) { + const part6 = rt.u64SaturatingAdd(a, b); + _50(out, part6); + } else if (_52 === 15) { + const part5 = rt.u64SaturatingSub(a, b); + _50(out, part5); + } else if (_52 === 16) { + const part4 = rt.u64WrappingAdd(a, b); + _50(out, part4); + } else if (_52 === 17) { + const part3 = rt.u64WrappingSub(a, b); + _50(out, part3); + } else if (_52 === 18) { rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u64LeadingOnes(a))); - } else if (value === 19) { + } else if (_52 === 19) { rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u64LeadingZeros(a))); - } else if (value === 20) { - put(out, rt.u64Max(a, b)); - } else if (value === 21) { - put(out, rt.u64Min(a, b)); - } else if (value === 22) { + } else if (_52 === 20) { + const part2 = rt.u64Max(a, b); + _50(out, part2); + } else if (_52 === 21) { + const part = rt.u64Min(a, b); + _50(out, part); + } else if (_52 === 22) { rt.byteVecPush(out, rt.u64Eq(a, b) ? 1 : 0); rt.byteVecPush(out, rt.u64Lt(a, b) ? 1 : 0); rt.byteVecPush(out, rt.u64Ge(a, b) ? 1 : 0); rt.byteVecPush(out, rt.u64WrappingSub(a, b) === 0 ? 1 : 0); + } else if (_52 === 23) { + x = rt.u64Add(a, b); + rt.u64Mul(x, b); + rt.u64Mul(rt.u64Sub(x, b), a); + rt.byteVecPush(out, 1); } else { - let x: rt.u64 = a; - x = rt.u64Add(x, b); - x = rt.u64Sub(x, 1); - x = rt.u64Mul(x, 2); - x = rt.u64Shr(x, 1); - x = rt.u64Shl(x, 1); - x = rt.u64Or(x, 8); - x = rt.u64Xor(x, b); - const value2 = rt.u64Not(4); - x = rt.u64And(x, value2); - put(out, x); + x2 = a; + x2 = rt.u64Add(x2, b); + x2 = rt.u64Sub(x2, 1); + x2 = rt.u64Mul(x2, 2); + x2 = rt.u64Shr(x2, 1); + x2 = rt.u64Shl(x2, 1); + x2 = rt.u64Or(x2, 8); + x2 = rt.u64Xor(x2, b); + x2 = rt.u64And(x2, rt.u64Not(4)); + x2 = rt.u64Rem(x2, 7); + x2 = rt.u64Div(x2, 3); + _50(out, x2); } } /** Apply operation `op` to operands taken from `data`. */ export function u128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(16); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, data3] = [rt.u128FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.u128, Uint8Array]; - const data4 = data3; - let buf2: Uint8Array = rt.bytes(16); - const n2 = rt.min(data4.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data4, 0, n2)); - const [b, data5] = [rt.u128FromBeBytes(buf2), rt.sliceRange(data4, n2)] as [rt.u128, Uint8Array]; - const shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(data5), 0) as rt.u32, rt.u32Mul(2, 128)); - const put = (out2: rt.ByteVec, v: rt.u128): void => { + let a!: rt.u128; + let _6!: [rt.u128, Uint8Array]; + let buf!: Uint8Array; + let n!: rt.usize; + let b!: rt.u128; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _33!: Uint8Array; + let _38!: rt.u128; + let shift!: rt.u32; + let _50!: (a0: rt.ByteVec, a1: rt.u128) => void; + let _51!: (a0: rt.ByteVec, a1: rt.u128 | undefined) => void; + let _52!: rt.u8; + let x!: rt.u128; + let x2!: rt.u128; + _50 = (out2: rt.ByteVec, v: rt.u128): void => { rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(v)); rt.byteVecPush(out2, rt.u128Eq(rt.u128FromBeBytes(rt.u128ToBeBytes(v)), v) ? 1 : 0); }; - const putOpt = (out3: rt.ByteVec, v2: rt.u128 | undefined): void => { - if (v2 !== undefined) { - const v3 = v2; + _51 = (out3: rt.ByteVec, v2: rt.u128 | undefined): void => { + let v3!: rt.u128; + if (v2 === undefined) { + rt.byteVecPush(out3, 0); + } else { + v3 = v2; rt.byteVecPush(out3, 1); rt.byteVecExtendFromSlice(out3, rt.u128ToBeBytes(v3)); - } else { - rt.byteVecPush(out3, 0); } }; - const value = rt.u8Rem(op, 24); - if (value === 0) { - put(out, rt.u128Add(a, b)); - } else if (value === 1) { - put(out, rt.u128Sub(a, b)); - } else if (value === 2) { - put(out, rt.u128Mul(a, b)); - } else if (value === 3) { - put(out, rt.u128Div(a, b)); - } else if (value === 4) { - put(out, rt.u128Rem(a, b)); - } else if (value === 5) { - put(out, rt.u128And(a, b)); - } else if (value === 6) { - put(out, rt.u128Or(a, b)); - } else if (value === 7) { - put(out, rt.u128Xor(a, b)); - } else if (value === 8) { - put(out, rt.u128Shl(a, shift)); - } else if (value === 9) { - put(out, rt.u128Shr(a, shift)); - } else if (value === 10) { - put(out, rt.u128Not(a)); - } else if (value === 11) { - putOpt(out, rt.u128CheckedAdd(a, b)); - } else if (value === 12) { - putOpt(out, rt.u128CheckedSub(a, b)); - } else if (value === 13) { - putOpt(out, rt.u128CheckedMul(a, b)); - } else if (value === 14) { - put(out, rt.u128SaturatingAdd(a, b)); - } else if (value === 15) { - put(out, rt.u128SaturatingSub(a, b)); - } else if (value === 16) { - put(out, rt.u128WrappingAdd(a, b)); - } else if (value === 17) { - put(out, rt.u128WrappingSub(a, b)); - } else if (value === 18) { + buf = rt.bytes(16); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + _6 = [rt.u128FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.u128, Uint8Array]; + a = _6[0]; + buf2 = rt.bytes(16); + n2 = rt.min(rt.sliceRange(data, n).length, buf2.length); + _33 = rt.sliceRange(buf2, 0, n2); + const slice = rt.sliceRange(data, n); + rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + _38 = rt.u128FromBeBytes(buf2); + const slice2 = rt.sliceRange(data, n); + [_38, rt.sliceRange(slice2, n2)] as [rt.u128, Uint8Array]; + b = _38; + shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 128)); + _52 = rt.u8Rem(op, 25); + if (_52 === 0) { + const part16 = rt.u128Add(a, b); + _50(out, part16); + } else if (_52 === 1) { + const part15 = rt.u128Sub(a, b); + _50(out, part15); + } else if (_52 === 2) { + const part14 = rt.u128Mul(a, b); + _50(out, part14); + } else if (_52 === 3) { + const part13 = rt.u128Div(a, b); + _50(out, part13); + } else if (_52 === 4) { + const part12 = rt.u128Rem(a, b); + _50(out, part12); + } else if (_52 === 5) { + _50(out, rt.u128And(a, b)); + } else if (_52 === 6) { + _50(out, rt.u128Or(a, b)); + } else if (_52 === 7) { + _50(out, rt.u128Xor(a, b)); + } else if (_52 === 8) { + const part11 = rt.u128Shl(a, shift); + _50(out, part11); + } else if (_52 === 9) { + const part10 = rt.u128Shr(a, shift); + _50(out, part10); + } else if (_52 === 10) { + _50(out, rt.u128Not(a)); + } else if (_52 === 11) { + const part9 = rt.u128CheckedAdd(a, b); + _51(out, part9); + } else if (_52 === 12) { + const part8 = rt.u128CheckedSub(a, b); + _51(out, part8); + } else if (_52 === 13) { + const part7 = rt.u128CheckedMul(a, b); + _51(out, part7); + } else if (_52 === 14) { + const part6 = rt.u128SaturatingAdd(a, b); + _50(out, part6); + } else if (_52 === 15) { + const part5 = rt.u128SaturatingSub(a, b); + _50(out, part5); + } else if (_52 === 16) { + const part4 = rt.u128WrappingAdd(a, b); + _50(out, part4); + } else if (_52 === 17) { + const part3 = rt.u128WrappingSub(a, b); + _50(out, part3); + } else if (_52 === 18) { rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u128LeadingOnes(a))); - } else if (value === 19) { + } else if (_52 === 19) { rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u128LeadingZeros(a))); - } else if (value === 20) { - put(out, rt.u128Max(a, b)); - } else if (value === 21) { - put(out, rt.u128Min(a, b)); - } else if (value === 22) { + } else if (_52 === 20) { + const part2 = rt.u128Max(a, b); + _50(out, part2); + } else if (_52 === 21) { + const part = rt.u128Min(a, b); + _50(out, part); + } else if (_52 === 22) { rt.byteVecPush(out, rt.u128Eq(a, b) ? 1 : 0); rt.byteVecPush(out, rt.u128Lt(a, b) ? 1 : 0); rt.byteVecPush(out, rt.u128Ge(a, b) ? 1 : 0); rt.byteVecPush(out, rt.u128WrappingSub(a, b) === 0 ? 1 : 0); + } else if (_52 === 23) { + x = rt.u128Add(a, b); + rt.u128Mul(x, b); + rt.u128Mul(rt.u128Sub(x, b), a); + rt.byteVecPush(out, 1); } else { - let x: rt.u128 = a; - x = rt.u128Add(x, b); - x = rt.u128Sub(x, 1); - x = rt.u128Mul(x, 2); - x = rt.u128Shr(x, 1); - x = rt.u128Shl(x, 1); - const value2 = rt.u128Shl(1, 3); - x = rt.u128Or(x, value2); - x = rt.u128Xor(x, b); - const value3 = rt.u128Not(rt.u128Shl(1, 2)); - x = rt.u128And(x, value3); - put(out, x); + x2 = a; + x2 = rt.u128Add(x2, b); + x2 = rt.u128Sub(x2, 1); + x2 = rt.u128Mul(x2, 2); + x2 = rt.u128Shr(x2, 1); + x2 = rt.u128Shl(x2, 1); + x2 = rt.u128Or(x2, rt.u128Shl(1, 3)); + x2 = rt.u128Xor(x2, b); + x2 = rt.u128And(x2, rt.u128Not(rt.u128Shl(1, 2))); + x2 = rt.u128Rem(x2, 7); + x2 = rt.u128Div(x2, 3); + _50(out, x2); } } /** Apply operation `op` to operands taken from `data`. */ export function usizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(4); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, data3] = [rt.usizeFromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.usize, Uint8Array]; - const data4 = data3; - let buf2: Uint8Array = rt.bytes(4); - const n2 = rt.min(data4.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data4, 0, n2)); - const [b, data5] = [rt.usizeFromBeBytes(buf2), rt.sliceRange(data4, n2)] as [rt.usize, Uint8Array]; - const shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(data5), 0) as rt.u32, rt.u32Mul(2, 32)); - const put = (out2: rt.ByteVec, v: rt.usize): void => { + let a!: rt.usize; + let _6!: [rt.usize, Uint8Array]; + let buf!: Uint8Array; + let n!: rt.usize; + let b!: rt.usize; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _33!: Uint8Array; + let _38!: rt.usize; + let shift!: rt.u32; + let _50!: (a0: rt.ByteVec, a1: rt.usize) => void; + let _51!: (a0: rt.ByteVec, a1: rt.usize | undefined) => void; + let _52!: rt.u8; + let x!: rt.usize; + let x2!: rt.usize; + _50 = (out2: rt.ByteVec, v: rt.usize): void => { rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(v as rt.u128)); rt.byteVecPush(out2, rt.usizeFromBeBytes(rt.usizeToBeBytes(v)) === v ? 1 : 0); }; - const putOpt = (out3: rt.ByteVec, v2: rt.usize | undefined): void => { - if (v2 !== undefined) { - const v3 = v2; + _51 = (out3: rt.ByteVec, v2: rt.usize | undefined): void => { + let v3!: rt.usize; + if (v2 === undefined) { + rt.byteVecPush(out3, 0); + } else { + v3 = v2; rt.byteVecPush(out3, 1); rt.byteVecExtendFromSlice(out3, rt.u128ToBeBytes(v3 as rt.u128)); - } else { - rt.byteVecPush(out3, 0); } }; - const value = rt.u8Rem(op, 24); - if (value === 0) { - put(out, rt.usizeAdd(a, b)); - } else if (value === 1) { - put(out, rt.usizeSub(a, b)); - } else if (value === 2) { - put(out, rt.usizeMul(a, b)); - } else if (value === 3) { - put(out, rt.usizeDiv(a, b)); - } else if (value === 4) { - put(out, rt.usizeRem(a, b)); - } else if (value === 5) { - put(out, (a & b) >>> 0); - } else if (value === 6) { - put(out, (a | b) >>> 0); - } else if (value === 7) { - put(out, (a ^ b) >>> 0); - } else if (value === 8) { - put(out, rt.usizeShl(a, shift)); - } else if (value === 9) { - put(out, rt.usizeShr(a, shift)); - } else if (value === 10) { - put(out, ~a >>> 0); - } else if (value === 11) { - putOpt(out, rt.usizeCheckedAdd(a, b)); - } else if (value === 12) { - putOpt(out, rt.usizeCheckedSub(a, b)); - } else if (value === 13) { - putOpt(out, rt.usizeCheckedMul(a, b)); - } else if (value === 14) { - put(out, rt.usizeSaturatingAdd(a, b)); - } else if (value === 15) { - put(out, rt.usizeSaturatingSub(a, b)); - } else if (value === 16) { - put(out, rt.usizeWrappingAdd(a, b)); - } else if (value === 17) { - put(out, rt.usizeWrappingSub(a, b)); - } else if (value === 18) { + buf = rt.bytes(4); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + _6 = [rt.usizeFromBeBytes(buf), rt.sliceRange(data, n)] as [rt.usize, Uint8Array]; + a = _6[0]; + buf2 = rt.bytes(4); + n2 = rt.min(rt.sliceRange(data, n).length, buf2.length); + _33 = rt.sliceRange(buf2, 0, n2); + const slice = rt.sliceRange(data, n); + rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + _38 = rt.usizeFromBeBytes(buf2); + const slice2 = rt.sliceRange(data, n); + [_38, rt.sliceRange(slice2, n2)] as [rt.usize, Uint8Array]; + b = _38; + shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 32)); + _52 = rt.u8Rem(op, 25); + if (_52 === 0) { + const part16 = rt.usizeAdd(a, b); + _50(out, part16); + } else if (_52 === 1) { + const part15 = rt.usizeSub(a, b); + _50(out, part15); + } else if (_52 === 2) { + const part14 = rt.usizeMul(a, b); + _50(out, part14); + } else if (_52 === 3) { + const part13 = rt.usizeDiv(a, b); + _50(out, part13); + } else if (_52 === 4) { + const part12 = rt.usizeRem(a, b); + _50(out, part12); + } else if (_52 === 5) { + _50(out, (a & b) >>> 0); + } else if (_52 === 6) { + _50(out, (a | b) >>> 0); + } else if (_52 === 7) { + _50(out, (a ^ b) >>> 0); + } else if (_52 === 8) { + const part11 = rt.usizeShl(a, shift); + _50(out, part11); + } else if (_52 === 9) { + const part10 = rt.usizeShr(a, shift); + _50(out, part10); + } else if (_52 === 10) { + _50(out, ~a >>> 0); + } else if (_52 === 11) { + const part9 = rt.usizeCheckedAdd(a, b); + _51(out, part9); + } else if (_52 === 12) { + const part8 = rt.usizeCheckedSub(a, b); + _51(out, part8); + } else if (_52 === 13) { + const part7 = rt.usizeCheckedMul(a, b); + _51(out, part7); + } else if (_52 === 14) { + const part6 = rt.usizeSaturatingAdd(a, b); + _50(out, part6); + } else if (_52 === 15) { + const part5 = rt.usizeSaturatingSub(a, b); + _50(out, part5); + } else if (_52 === 16) { + const part4 = rt.usizeWrappingAdd(a, b); + _50(out, part4); + } else if (_52 === 17) { + const part3 = rt.usizeWrappingSub(a, b); + _50(out, part3); + } else if (_52 === 18) { rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.usizeLeadingOnes(a))); - } else if (value === 19) { + } else if (_52 === 19) { rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.usizeLeadingZeros(a))); - } else if (value === 20) { - put(out, rt.max(a, b)); - } else if (value === 21) { - put(out, rt.min(a, b)); - } else if (value === 22) { + } else if (_52 === 20) { + const part2 = rt.max(a, b); + _50(out, part2); + } else if (_52 === 21) { + const part = rt.min(a, b); + _50(out, part); + } else if (_52 === 22) { rt.byteVecPush(out, a === b ? 1 : 0); rt.byteVecPush(out, a < b ? 1 : 0); rt.byteVecPush(out, a >= b ? 1 : 0); rt.byteVecPush(out, rt.usizeWrappingSub(a, b) === 0 ? 1 : 0); + } else if (_52 === 23) { + x = rt.usizeAdd(a, b); + rt.usizeMul(x, b); + rt.usizeMul(rt.usizeSub(x, b), a); + rt.byteVecPush(out, 1); } else { - let x: rt.usize = a; - x = rt.usizeAdd(x, b); - x = rt.usizeSub(x, 1); - x = rt.usizeMul(x, 2); - x = rt.usizeShr(x, 1); - x = rt.usizeShl(x, 1); - const value2 = 1 << 3; - x = (x | value2) >>> 0; - x = (x ^ b) >>> 0; - const value3 = ~(1 << 2) >>> 0; - x = (x & value3) >>> 0; - put(out, x); + x2 = a; + x2 = rt.usizeAdd(x2, b); + x2 = rt.usizeSub(x2, 1); + x2 = rt.usizeMul(x2, 2); + x2 = x2 >>> 1; + x2 = (x2 << 1) >>> 0; + x2 = (x2 | (1 << 3)) >>> 0; + x2 = (x2 ^ b) >>> 0; + x2 = (x2 & (~(1 << 2) >>> 0)) >>> 0; + x2 = rt.usizeRem(x2, 7); + x2 = rt.usizeDiv(x2, 3); + _50(out, x2); } } /** Apply operation `op` to operands taken from `data`. */ export function i8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(1); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, data3] = [rt.i8FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.i8, Uint8Array]; - const data4 = data3; - let buf2: Uint8Array = rt.bytes(1); - const n2 = rt.min(data4.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data4, 0, n2)); - const [b, data5] = [rt.i8FromBeBytes(buf2), rt.sliceRange(data4, n2)] as [rt.i8, Uint8Array]; - const shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(data5), 0) as rt.u32, rt.u32Mul(2, 8)); - const put = (out2: rt.ByteVec, v: rt.i8): void => { + let a!: rt.i8; + let _6!: [rt.i8, Uint8Array]; + let buf!: Uint8Array; + let n!: rt.usize; + let b!: rt.i8; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _33!: Uint8Array; + let _38!: rt.i8; + let shift!: rt.u32; + let _50!: (a0: rt.ByteVec, a1: rt.i8) => void; + let _51!: (a0: rt.ByteVec, a1: rt.i8 | undefined) => void; + let _52!: rt.u8; + let x!: rt.i8; + let x2!: rt.i8; + _50 = (out2: rt.ByteVec, v: rt.i8): void => { rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(v as rt.i128)); rt.byteVecPush(out2, rt.i8FromBeBytes(rt.i8ToBeBytes(v)) === v ? 1 : 0); }; - const putOpt = (out3: rt.ByteVec, v2: rt.i8 | undefined): void => { - if (v2 !== undefined) { - const v3 = v2; + _51 = (out3: rt.ByteVec, v2: rt.i8 | undefined): void => { + let v3!: rt.i8; + if (v2 === undefined) { + rt.byteVecPush(out3, 0); + } else { + v3 = v2; rt.byteVecPush(out3, 1); rt.byteVecExtendFromSlice(out3, rt.i128ToBeBytes(v3 as rt.i128)); - } else { - rt.byteVecPush(out3, 0); } }; - const value = rt.u8Rem(op, 24); - if (value === 0) { - put(out, rt.i8Add(a, b)); - } else if (value === 1) { - put(out, rt.i8Sub(a, b)); - } else if (value === 2) { - put(out, rt.i8Mul(a, b)); - } else if (value === 3) { - put(out, rt.i8Div(a, b)); - } else if (value === 4) { - put(out, rt.i8Rem(a, b)); - } else if (value === 5) { - put(out, a & b); - } else if (value === 6) { - put(out, a | b); - } else if (value === 7) { - put(out, a ^ b); - } else if (value === 8) { - put(out, rt.i8Shl(a, shift)); - } else if (value === 9) { - put(out, rt.i8Shr(a, shift)); - } else if (value === 10) { - put(out, ~a); - } else if (value === 11) { - putOpt(out, rt.i8CheckedAdd(a, b)); - } else if (value === 12) { - putOpt(out, rt.i8CheckedSub(a, b)); - } else if (value === 13) { - putOpt(out, rt.i8CheckedMul(a, b)); - } else if (value === 14) { - put(out, rt.i8SaturatingAdd(a, b)); - } else if (value === 15) { - put(out, rt.i8SaturatingSub(a, b)); - } else if (value === 16) { - put(out, rt.i8WrappingAdd(a, b)); - } else if (value === 17) { - put(out, rt.i8WrappingSub(a, b)); - } else if (value === 18) { + buf = Uint8Array.of(0); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + _6 = [rt.i8FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i8, Uint8Array]; + a = _6[0]; + buf2 = Uint8Array.of(0); + n2 = rt.min(rt.sliceRange(data, n).length, buf2.length); + _33 = rt.sliceRange(buf2, 0, n2); + const slice = rt.sliceRange(data, n); + rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + _38 = rt.i8FromBeBytes(buf2); + const slice2 = rt.sliceRange(data, n); + [_38, rt.sliceRange(slice2, n2)] as [rt.i8, Uint8Array]; + b = _38; + shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 8)); + _52 = rt.u8Rem(op, 25); + if (_52 === 0) { + const part16 = rt.i8Add(a, b); + _50(out, part16); + } else if (_52 === 1) { + const part15 = rt.i8Sub(a, b); + _50(out, part15); + } else if (_52 === 2) { + const part14 = rt.i8Mul(a, b); + _50(out, part14); + } else if (_52 === 3) { + const part13 = rt.i8Div(a, b); + _50(out, part13); + } else if (_52 === 4) { + const part12 = rt.i8Rem(a, b); + _50(out, part12); + } else if (_52 === 5) { + _50(out, a & b); + } else if (_52 === 6) { + _50(out, a | b); + } else if (_52 === 7) { + _50(out, a ^ b); + } else if (_52 === 8) { + const part11 = rt.i8Shl(a, shift); + _50(out, part11); + } else if (_52 === 9) { + const part10 = rt.i8Shr(a, shift); + _50(out, part10); + } else if (_52 === 10) { + _50(out, ~a); + } else if (_52 === 11) { + const part9 = rt.i8CheckedAdd(a, b); + _51(out, part9); + } else if (_52 === 12) { + const part8 = rt.i8CheckedSub(a, b); + _51(out, part8); + } else if (_52 === 13) { + const part7 = rt.i8CheckedMul(a, b); + _51(out, part7); + } else if (_52 === 14) { + const part6 = rt.i8SaturatingAdd(a, b); + _50(out, part6); + } else if (_52 === 15) { + const part5 = rt.i8SaturatingSub(a, b); + _50(out, part5); + } else if (_52 === 16) { + const part4 = rt.i8WrappingAdd(a, b); + _50(out, part4); + } else if (_52 === 17) { + const part3 = rt.i8WrappingSub(a, b); + _50(out, part3); + } else if (_52 === 18) { rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i8LeadingOnes(a))); - } else if (value === 19) { + } else if (_52 === 19) { rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i8LeadingZeros(a))); - } else if (value === 20) { - put(out, rt.max(a, b)); - } else if (value === 21) { - put(out, rt.min(a, b)); - } else if (value === 22) { + } else if (_52 === 20) { + const part2 = rt.max(a, b); + _50(out, part2); + } else if (_52 === 21) { + const part = rt.min(a, b); + _50(out, part); + } else if (_52 === 22) { rt.byteVecPush(out, a === b ? 1 : 0); rt.byteVecPush(out, a < b ? 1 : 0); rt.byteVecPush(out, a >= b ? 1 : 0); rt.byteVecPush(out, rt.i8WrappingSub(a, b) === 0 ? 1 : 0); + } else if (_52 === 23) { + x = rt.i8Add(a, b); + rt.i8Mul(x, b); + rt.i8Mul(rt.i8Sub(x, b), a); + rt.byteVecPush(out, 1); } else { - let x: rt.i8 = a; - x = rt.i8Add(x, b); - x = rt.i8Sub(x, 1); - x = rt.i8Mul(x, 2); - x = rt.i8Shr(x, 1); - x = rt.i8Shl(x, 1); - const value2 = 1 << 3; - x = x | value2; - x = x ^ b; - const value3 = ~(1 << 2); - x = x & value3; - put(out, x); + x2 = a; + x2 = rt.i8Add(x2, b); + x2 = rt.i8Sub(x2, 1); + x2 = rt.i8Mul(x2, 2); + x2 = x2 >> 1; + x2 = (x2 << 1 << 24) >> 24; + x2 = x2 | (1 << 3); + x2 = x2 ^ b; + x2 = x2 & ~(1 << 2); + x2 = rt.i8Rem(x2, 7); + x2 = rt.i8Div(x2, 3); + _50(out, x2); } } /** Apply operation `op` to operands taken from `data`. */ export function i16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(2); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, data3] = [rt.i16FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.i16, Uint8Array]; - const data4 = data3; - let buf2: Uint8Array = rt.bytes(2); - const n2 = rt.min(data4.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data4, 0, n2)); - const [b, data5] = [rt.i16FromBeBytes(buf2), rt.sliceRange(data4, n2)] as [rt.i16, Uint8Array]; - const shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(data5), 0) as rt.u32, rt.u32Mul(2, 16)); - const put = (out2: rt.ByteVec, v: rt.i16): void => { + let a!: rt.i16; + let _6!: [rt.i16, Uint8Array]; + let buf!: Uint8Array; + let n!: rt.usize; + let b!: rt.i16; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _33!: Uint8Array; + let _38!: rt.i16; + let shift!: rt.u32; + let _50!: (a0: rt.ByteVec, a1: rt.i16) => void; + let _51!: (a0: rt.ByteVec, a1: rt.i16 | undefined) => void; + let _52!: rt.u8; + let x!: rt.i16; + let x2!: rt.i16; + _50 = (out2: rt.ByteVec, v: rt.i16): void => { rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(v as rt.i128)); rt.byteVecPush(out2, rt.i16FromBeBytes(rt.i16ToBeBytes(v)) === v ? 1 : 0); }; - const putOpt = (out3: rt.ByteVec, v2: rt.i16 | undefined): void => { - if (v2 !== undefined) { - const v3 = v2; + _51 = (out3: rt.ByteVec, v2: rt.i16 | undefined): void => { + let v3!: rt.i16; + if (v2 === undefined) { + rt.byteVecPush(out3, 0); + } else { + v3 = v2; rt.byteVecPush(out3, 1); rt.byteVecExtendFromSlice(out3, rt.i128ToBeBytes(v3 as rt.i128)); - } else { - rt.byteVecPush(out3, 0); } }; - const value = rt.u8Rem(op, 24); - if (value === 0) { - put(out, rt.i16Add(a, b)); - } else if (value === 1) { - put(out, rt.i16Sub(a, b)); - } else if (value === 2) { - put(out, rt.i16Mul(a, b)); - } else if (value === 3) { - put(out, rt.i16Div(a, b)); - } else if (value === 4) { - put(out, rt.i16Rem(a, b)); - } else if (value === 5) { - put(out, a & b); - } else if (value === 6) { - put(out, a | b); - } else if (value === 7) { - put(out, a ^ b); - } else if (value === 8) { - put(out, rt.i16Shl(a, shift)); - } else if (value === 9) { - put(out, rt.i16Shr(a, shift)); - } else if (value === 10) { - put(out, ~a); - } else if (value === 11) { - putOpt(out, rt.i16CheckedAdd(a, b)); - } else if (value === 12) { - putOpt(out, rt.i16CheckedSub(a, b)); - } else if (value === 13) { - putOpt(out, rt.i16CheckedMul(a, b)); - } else if (value === 14) { - put(out, rt.i16SaturatingAdd(a, b)); - } else if (value === 15) { - put(out, rt.i16SaturatingSub(a, b)); - } else if (value === 16) { - put(out, rt.i16WrappingAdd(a, b)); - } else if (value === 17) { - put(out, rt.i16WrappingSub(a, b)); - } else if (value === 18) { + buf = rt.bytes(2); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + _6 = [rt.i16FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i16, Uint8Array]; + a = _6[0]; + buf2 = rt.bytes(2); + n2 = rt.min(rt.sliceRange(data, n).length, buf2.length); + _33 = rt.sliceRange(buf2, 0, n2); + const slice = rt.sliceRange(data, n); + rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + _38 = rt.i16FromBeBytes(buf2); + const slice2 = rt.sliceRange(data, n); + [_38, rt.sliceRange(slice2, n2)] as [rt.i16, Uint8Array]; + b = _38; + shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 16)); + _52 = rt.u8Rem(op, 25); + if (_52 === 0) { + const part16 = rt.i16Add(a, b); + _50(out, part16); + } else if (_52 === 1) { + const part15 = rt.i16Sub(a, b); + _50(out, part15); + } else if (_52 === 2) { + const part14 = rt.i16Mul(a, b); + _50(out, part14); + } else if (_52 === 3) { + const part13 = rt.i16Div(a, b); + _50(out, part13); + } else if (_52 === 4) { + const part12 = rt.i16Rem(a, b); + _50(out, part12); + } else if (_52 === 5) { + _50(out, a & b); + } else if (_52 === 6) { + _50(out, a | b); + } else if (_52 === 7) { + _50(out, a ^ b); + } else if (_52 === 8) { + const part11 = rt.i16Shl(a, shift); + _50(out, part11); + } else if (_52 === 9) { + const part10 = rt.i16Shr(a, shift); + _50(out, part10); + } else if (_52 === 10) { + _50(out, ~a); + } else if (_52 === 11) { + const part9 = rt.i16CheckedAdd(a, b); + _51(out, part9); + } else if (_52 === 12) { + const part8 = rt.i16CheckedSub(a, b); + _51(out, part8); + } else if (_52 === 13) { + const part7 = rt.i16CheckedMul(a, b); + _51(out, part7); + } else if (_52 === 14) { + const part6 = rt.i16SaturatingAdd(a, b); + _50(out, part6); + } else if (_52 === 15) { + const part5 = rt.i16SaturatingSub(a, b); + _50(out, part5); + } else if (_52 === 16) { + const part4 = rt.i16WrappingAdd(a, b); + _50(out, part4); + } else if (_52 === 17) { + const part3 = rt.i16WrappingSub(a, b); + _50(out, part3); + } else if (_52 === 18) { rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i16LeadingOnes(a))); - } else if (value === 19) { + } else if (_52 === 19) { rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i16LeadingZeros(a))); - } else if (value === 20) { - put(out, rt.max(a, b)); - } else if (value === 21) { - put(out, rt.min(a, b)); - } else if (value === 22) { + } else if (_52 === 20) { + const part2 = rt.max(a, b); + _50(out, part2); + } else if (_52 === 21) { + const part = rt.min(a, b); + _50(out, part); + } else if (_52 === 22) { rt.byteVecPush(out, a === b ? 1 : 0); rt.byteVecPush(out, a < b ? 1 : 0); rt.byteVecPush(out, a >= b ? 1 : 0); rt.byteVecPush(out, rt.i16WrappingSub(a, b) === 0 ? 1 : 0); + } else if (_52 === 23) { + x = rt.i16Add(a, b); + rt.i16Mul(x, b); + rt.i16Mul(rt.i16Sub(x, b), a); + rt.byteVecPush(out, 1); } else { - let x: rt.i16 = a; - x = rt.i16Add(x, b); - x = rt.i16Sub(x, 1); - x = rt.i16Mul(x, 2); - x = rt.i16Shr(x, 1); - x = rt.i16Shl(x, 1); - const value2 = 1 << 3; - x = x | value2; - x = x ^ b; - const value3 = ~(1 << 2); - x = x & value3; - put(out, x); + x2 = a; + x2 = rt.i16Add(x2, b); + x2 = rt.i16Sub(x2, 1); + x2 = rt.i16Mul(x2, 2); + x2 = x2 >> 1; + x2 = (x2 << 1 << 16) >> 16; + x2 = x2 | (1 << 3); + x2 = x2 ^ b; + x2 = x2 & ~(1 << 2); + x2 = rt.i16Rem(x2, 7); + x2 = rt.i16Div(x2, 3); + _50(out, x2); } } /** Apply operation `op` to operands taken from `data`. */ export function i32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(4); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, data3] = [rt.i32FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.i32, Uint8Array]; - const data4 = data3; - let buf2: Uint8Array = rt.bytes(4); - const n2 = rt.min(data4.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data4, 0, n2)); - const [b, data5] = [rt.i32FromBeBytes(buf2), rt.sliceRange(data4, n2)] as [rt.i32, Uint8Array]; - const shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(data5), 0) as rt.u32, rt.u32Mul(2, 32)); - const put = (out2: rt.ByteVec, v: rt.i32): void => { + let a!: rt.i32; + let _6!: [rt.i32, Uint8Array]; + let buf!: Uint8Array; + let n!: rt.usize; + let b!: rt.i32; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _33!: Uint8Array; + let _38!: rt.i32; + let shift!: rt.u32; + let _50!: (a0: rt.ByteVec, a1: rt.i32) => void; + let _51!: (a0: rt.ByteVec, a1: rt.i32 | undefined) => void; + let _52!: rt.u8; + let x!: rt.i32; + let x2!: rt.i32; + _50 = (out2: rt.ByteVec, v: rt.i32): void => { rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(v as rt.i128)); rt.byteVecPush(out2, rt.i32FromBeBytes(rt.i32ToBeBytes(v)) === v ? 1 : 0); }; - const putOpt = (out3: rt.ByteVec, v2: rt.i32 | undefined): void => { - if (v2 !== undefined) { - const v3 = v2; + _51 = (out3: rt.ByteVec, v2: rt.i32 | undefined): void => { + let v3!: rt.i32; + if (v2 === undefined) { + rt.byteVecPush(out3, 0); + } else { + v3 = v2; rt.byteVecPush(out3, 1); rt.byteVecExtendFromSlice(out3, rt.i128ToBeBytes(v3 as rt.i128)); - } else { - rt.byteVecPush(out3, 0); } }; - const value = rt.u8Rem(op, 24); - if (value === 0) { - put(out, rt.i32Add(a, b)); - } else if (value === 1) { - put(out, rt.i32Sub(a, b)); - } else if (value === 2) { - put(out, rt.i32Mul(a, b)); - } else if (value === 3) { - put(out, rt.i32Div(a, b)); - } else if (value === 4) { - put(out, rt.i32Rem(a, b)); - } else if (value === 5) { - put(out, a & b); - } else if (value === 6) { - put(out, a | b); - } else if (value === 7) { - put(out, a ^ b); - } else if (value === 8) { - put(out, rt.i32Shl(a, shift)); - } else if (value === 9) { - put(out, rt.i32Shr(a, shift)); - } else if (value === 10) { - put(out, ~a); - } else if (value === 11) { - putOpt(out, rt.i32CheckedAdd(a, b)); - } else if (value === 12) { - putOpt(out, rt.i32CheckedSub(a, b)); - } else if (value === 13) { - putOpt(out, rt.i32CheckedMul(a, b)); - } else if (value === 14) { - put(out, rt.i32SaturatingAdd(a, b)); - } else if (value === 15) { - put(out, rt.i32SaturatingSub(a, b)); - } else if (value === 16) { - put(out, rt.i32WrappingAdd(a, b)); - } else if (value === 17) { - put(out, rt.i32WrappingSub(a, b)); - } else if (value === 18) { + buf = rt.bytes(4); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + _6 = [rt.i32FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i32, Uint8Array]; + a = _6[0]; + buf2 = rt.bytes(4); + n2 = rt.min(rt.sliceRange(data, n).length, buf2.length); + _33 = rt.sliceRange(buf2, 0, n2); + const slice = rt.sliceRange(data, n); + rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + _38 = rt.i32FromBeBytes(buf2); + const slice2 = rt.sliceRange(data, n); + [_38, rt.sliceRange(slice2, n2)] as [rt.i32, Uint8Array]; + b = _38; + shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 32)); + _52 = rt.u8Rem(op, 25); + if (_52 === 0) { + const part16 = rt.i32Add(a, b); + _50(out, part16); + } else if (_52 === 1) { + const part15 = rt.i32Sub(a, b); + _50(out, part15); + } else if (_52 === 2) { + const part14 = rt.i32Mul(a, b); + _50(out, part14); + } else if (_52 === 3) { + const part13 = rt.i32Div(a, b); + _50(out, part13); + } else if (_52 === 4) { + const part12 = rt.i32Rem(a, b); + _50(out, part12); + } else if (_52 === 5) { + _50(out, a & b); + } else if (_52 === 6) { + _50(out, a | b); + } else if (_52 === 7) { + _50(out, a ^ b); + } else if (_52 === 8) { + const part11 = rt.i32Shl(a, shift); + _50(out, part11); + } else if (_52 === 9) { + const part10 = rt.i32Shr(a, shift); + _50(out, part10); + } else if (_52 === 10) { + _50(out, ~a); + } else if (_52 === 11) { + const part9 = rt.i32CheckedAdd(a, b); + _51(out, part9); + } else if (_52 === 12) { + const part8 = rt.i32CheckedSub(a, b); + _51(out, part8); + } else if (_52 === 13) { + const part7 = rt.i32CheckedMul(a, b); + _51(out, part7); + } else if (_52 === 14) { + const part6 = rt.i32SaturatingAdd(a, b); + _50(out, part6); + } else if (_52 === 15) { + const part5 = rt.i32SaturatingSub(a, b); + _50(out, part5); + } else if (_52 === 16) { + const part4 = rt.i32WrappingAdd(a, b); + _50(out, part4); + } else if (_52 === 17) { + const part3 = rt.i32WrappingSub(a, b); + _50(out, part3); + } else if (_52 === 18) { rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i32LeadingOnes(a))); - } else if (value === 19) { + } else if (_52 === 19) { rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i32LeadingZeros(a))); - } else if (value === 20) { - put(out, rt.max(a, b)); - } else if (value === 21) { - put(out, rt.min(a, b)); - } else if (value === 22) { + } else if (_52 === 20) { + const part2 = rt.max(a, b); + _50(out, part2); + } else if (_52 === 21) { + const part = rt.min(a, b); + _50(out, part); + } else if (_52 === 22) { rt.byteVecPush(out, a === b ? 1 : 0); rt.byteVecPush(out, a < b ? 1 : 0); rt.byteVecPush(out, a >= b ? 1 : 0); rt.byteVecPush(out, rt.i32WrappingSub(a, b) === 0 ? 1 : 0); + } else if (_52 === 23) { + x = rt.i32Add(a, b); + rt.i32Mul(x, b); + rt.i32Mul(rt.i32Sub(x, b), a); + rt.byteVecPush(out, 1); } else { - let x: rt.i32 = a; - x = rt.i32Add(x, b); - x = rt.i32Sub(x, 1); - x = rt.i32Mul(x, 2); - x = rt.i32Shr(x, 1); - x = rt.i32Shl(x, 1); - const value2 = 1 << 3; - x = x | value2; - x = x ^ b; - const value3 = ~(1 << 2); - x = x & value3; - put(out, x); + x2 = a; + x2 = rt.i32Add(x2, b); + x2 = rt.i32Sub(x2, 1); + x2 = rt.i32Mul(x2, 2); + x2 = x2 >> 1; + x2 = (x2 << 1) | 0; + x2 = x2 | (1 << 3); + x2 = x2 ^ b; + x2 = x2 & ~(1 << 2); + x2 = rt.i32Rem(x2, 7); + x2 = rt.i32Div(x2, 3); + _50(out, x2); } } /** Apply operation `op` to operands taken from `data`. */ export function i64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(8); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, data3] = [rt.i64FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.i64, Uint8Array]; - const data4 = data3; - let buf2: Uint8Array = rt.bytes(8); - const n2 = rt.min(data4.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data4, 0, n2)); - const [b, data5] = [rt.i64FromBeBytes(buf2), rt.sliceRange(data4, n2)] as [rt.i64, Uint8Array]; - const shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(data5), 0) as rt.u32, rt.u32Mul(2, 64)); - const put = (out2: rt.ByteVec, v: rt.i64): void => { + let a!: rt.i64; + let _6!: [rt.i64, Uint8Array]; + let buf!: Uint8Array; + let n!: rt.usize; + let b!: rt.i64; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _33!: Uint8Array; + let _38!: rt.i64; + let shift!: rt.u32; + let _50!: (a0: rt.ByteVec, a1: rt.i64) => void; + let _51!: (a0: rt.ByteVec, a1: rt.i64 | undefined) => void; + let _52!: rt.u8; + let x!: rt.i64; + let x2!: rt.i64; + _50 = (out2: rt.ByteVec, v: rt.i64): void => { rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(rt.i128Cast(v))); rt.byteVecPush(out2, rt.i64Eq(rt.i64FromBeBytes(rt.i64ToBeBytes(v)), v) ? 1 : 0); }; - const putOpt = (out3: rt.ByteVec, v2: rt.i64 | undefined): void => { - if (v2 !== undefined) { - const v3 = v2; + _51 = (out3: rt.ByteVec, v2: rt.i64 | undefined): void => { + let v3!: rt.i64; + if (v2 === undefined) { + rt.byteVecPush(out3, 0); + } else { + v3 = v2; rt.byteVecPush(out3, 1); rt.byteVecExtendFromSlice(out3, rt.i128ToBeBytes(rt.i128Cast(v3))); - } else { - rt.byteVecPush(out3, 0); } }; - const value = rt.u8Rem(op, 24); - if (value === 0) { - put(out, rt.i64Add(a, b)); - } else if (value === 1) { - put(out, rt.i64Sub(a, b)); - } else if (value === 2) { - put(out, rt.i64Mul(a, b)); - } else if (value === 3) { - put(out, rt.i64Div(a, b)); - } else if (value === 4) { - put(out, rt.i64Rem(a, b)); - } else if (value === 5) { - put(out, rt.i64And(a, b)); - } else if (value === 6) { - put(out, rt.i64Or(a, b)); - } else if (value === 7) { - put(out, rt.i64Xor(a, b)); - } else if (value === 8) { - put(out, rt.i64Shl(a, shift)); - } else if (value === 9) { - put(out, rt.i64Shr(a, shift)); - } else if (value === 10) { - put(out, rt.i64Not(a)); - } else if (value === 11) { - putOpt(out, rt.i64CheckedAdd(a, b)); - } else if (value === 12) { - putOpt(out, rt.i64CheckedSub(a, b)); - } else if (value === 13) { - putOpt(out, rt.i64CheckedMul(a, b)); - } else if (value === 14) { - put(out, rt.i64SaturatingAdd(a, b)); - } else if (value === 15) { - put(out, rt.i64SaturatingSub(a, b)); - } else if (value === 16) { - put(out, rt.i64WrappingAdd(a, b)); - } else if (value === 17) { - put(out, rt.i64WrappingSub(a, b)); - } else if (value === 18) { + buf = rt.bytes(8); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + _6 = [rt.i64FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i64, Uint8Array]; + a = _6[0]; + buf2 = rt.bytes(8); + n2 = rt.min(rt.sliceRange(data, n).length, buf2.length); + _33 = rt.sliceRange(buf2, 0, n2); + const slice = rt.sliceRange(data, n); + rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + _38 = rt.i64FromBeBytes(buf2); + const slice2 = rt.sliceRange(data, n); + [_38, rt.sliceRange(slice2, n2)] as [rt.i64, Uint8Array]; + b = _38; + shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 64)); + _52 = rt.u8Rem(op, 25); + if (_52 === 0) { + const part16 = rt.i64Add(a, b); + _50(out, part16); + } else if (_52 === 1) { + const part15 = rt.i64Sub(a, b); + _50(out, part15); + } else if (_52 === 2) { + const part14 = rt.i64Mul(a, b); + _50(out, part14); + } else if (_52 === 3) { + const part13 = rt.i64Div(a, b); + _50(out, part13); + } else if (_52 === 4) { + const part12 = rt.i64Rem(a, b); + _50(out, part12); + } else if (_52 === 5) { + _50(out, rt.i64And(a, b)); + } else if (_52 === 6) { + _50(out, rt.i64Or(a, b)); + } else if (_52 === 7) { + _50(out, rt.i64Xor(a, b)); + } else if (_52 === 8) { + const part11 = rt.i64Shl(a, shift); + _50(out, part11); + } else if (_52 === 9) { + const part10 = rt.i64Shr(a, shift); + _50(out, part10); + } else if (_52 === 10) { + _50(out, rt.i64Not(a)); + } else if (_52 === 11) { + const part9 = rt.i64CheckedAdd(a, b); + _51(out, part9); + } else if (_52 === 12) { + const part8 = rt.i64CheckedSub(a, b); + _51(out, part8); + } else if (_52 === 13) { + const part7 = rt.i64CheckedMul(a, b); + _51(out, part7); + } else if (_52 === 14) { + const part6 = rt.i64SaturatingAdd(a, b); + _50(out, part6); + } else if (_52 === 15) { + const part5 = rt.i64SaturatingSub(a, b); + _50(out, part5); + } else if (_52 === 16) { + const part4 = rt.i64WrappingAdd(a, b); + _50(out, part4); + } else if (_52 === 17) { + const part3 = rt.i64WrappingSub(a, b); + _50(out, part3); + } else if (_52 === 18) { rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i64LeadingOnes(a))); - } else if (value === 19) { + } else if (_52 === 19) { rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i64LeadingZeros(a))); - } else if (value === 20) { - put(out, rt.i64Max(a, b)); - } else if (value === 21) { - put(out, rt.i64Min(a, b)); - } else if (value === 22) { + } else if (_52 === 20) { + const part2 = rt.i64Max(a, b); + _50(out, part2); + } else if (_52 === 21) { + const part = rt.i64Min(a, b); + _50(out, part); + } else if (_52 === 22) { rt.byteVecPush(out, rt.i64Eq(a, b) ? 1 : 0); rt.byteVecPush(out, rt.i64Lt(a, b) ? 1 : 0); rt.byteVecPush(out, rt.i64Ge(a, b) ? 1 : 0); rt.byteVecPush(out, rt.i64WrappingSub(a, b) === 0 ? 1 : 0); + } else if (_52 === 23) { + x = rt.i64Add(a, b); + rt.i64Mul(x, b); + rt.i64Mul(rt.i64Sub(x, b), a); + rt.byteVecPush(out, 1); } else { - let x: rt.i64 = a; - x = rt.i64Add(x, b); - x = rt.i64Sub(x, 1); - x = rt.i64Mul(x, 2); - x = rt.i64Shr(x, 1); - x = rt.i64Shl(x, 1); - x = rt.i64Or(x, 8); - x = rt.i64Xor(x, b); - const value2 = rt.i64Not(4); - x = rt.i64And(x, value2); - put(out, x); + x2 = a; + x2 = rt.i64Add(x2, b); + x2 = rt.i64Sub(x2, 1); + x2 = rt.i64Mul(x2, 2); + x2 = rt.i64Shr(x2, 1); + x2 = rt.i64Shl(x2, 1); + x2 = rt.i64Or(x2, 8); + x2 = rt.i64Xor(x2, b); + x2 = rt.i64And(x2, rt.i64Not(4)); + x2 = rt.i64Rem(x2, 7); + x2 = rt.i64Div(x2, 3); + _50(out, x2); } } /** Apply operation `op` to operands taken from `data`. */ export function i128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(16); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, data3] = [rt.i128FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.i128, Uint8Array]; - const data4 = data3; - let buf2: Uint8Array = rt.bytes(16); - const n2 = rt.min(data4.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data4, 0, n2)); - const [b, data5] = [rt.i128FromBeBytes(buf2), rt.sliceRange(data4, n2)] as [rt.i128, Uint8Array]; - const shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(data5), 0) as rt.u32, rt.u32Mul(2, 128)); - const put = (out2: rt.ByteVec, v: rt.i128): void => { + let a!: rt.i128; + let _6!: [rt.i128, Uint8Array]; + let buf!: Uint8Array; + let n!: rt.usize; + let b!: rt.i128; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _33!: Uint8Array; + let _38!: rt.i128; + let shift!: rt.u32; + let _50!: (a0: rt.ByteVec, a1: rt.i128) => void; + let _51!: (a0: rt.ByteVec, a1: rt.i128 | undefined) => void; + let _52!: rt.u8; + let x!: rt.i128; + let x2!: rt.i128; + _50 = (out2: rt.ByteVec, v: rt.i128): void => { rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(v)); rt.byteVecPush(out2, rt.i128Eq(rt.i128FromBeBytes(rt.i128ToBeBytes(v)), v) ? 1 : 0); }; - const putOpt = (out3: rt.ByteVec, v2: rt.i128 | undefined): void => { - if (v2 !== undefined) { - const v3 = v2; + _51 = (out3: rt.ByteVec, v2: rt.i128 | undefined): void => { + let v3!: rt.i128; + if (v2 === undefined) { + rt.byteVecPush(out3, 0); + } else { + v3 = v2; rt.byteVecPush(out3, 1); rt.byteVecExtendFromSlice(out3, rt.i128ToBeBytes(v3)); - } else { - rt.byteVecPush(out3, 0); } }; - const value = rt.u8Rem(op, 24); - if (value === 0) { - put(out, rt.i128Add(a, b)); - } else if (value === 1) { - put(out, rt.i128Sub(a, b)); - } else if (value === 2) { - put(out, rt.i128Mul(a, b)); - } else if (value === 3) { - put(out, rt.i128Div(a, b)); - } else if (value === 4) { - put(out, rt.i128Rem(a, b)); - } else if (value === 5) { - put(out, rt.i128And(a, b)); - } else if (value === 6) { - put(out, rt.i128Or(a, b)); - } else if (value === 7) { - put(out, rt.i128Xor(a, b)); - } else if (value === 8) { - put(out, rt.i128Shl(a, shift)); - } else if (value === 9) { - put(out, rt.i128Shr(a, shift)); - } else if (value === 10) { - put(out, rt.i128Not(a)); - } else if (value === 11) { - putOpt(out, rt.i128CheckedAdd(a, b)); - } else if (value === 12) { - putOpt(out, rt.i128CheckedSub(a, b)); - } else if (value === 13) { - putOpt(out, rt.i128CheckedMul(a, b)); - } else if (value === 14) { - put(out, rt.i128SaturatingAdd(a, b)); - } else if (value === 15) { - put(out, rt.i128SaturatingSub(a, b)); - } else if (value === 16) { - put(out, rt.i128WrappingAdd(a, b)); - } else if (value === 17) { - put(out, rt.i128WrappingSub(a, b)); - } else if (value === 18) { + buf = rt.bytes(16); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + _6 = [rt.i128FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i128, Uint8Array]; + a = _6[0]; + buf2 = rt.bytes(16); + n2 = rt.min(rt.sliceRange(data, n).length, buf2.length); + _33 = rt.sliceRange(buf2, 0, n2); + const slice = rt.sliceRange(data, n); + rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + _38 = rt.i128FromBeBytes(buf2); + const slice2 = rt.sliceRange(data, n); + [_38, rt.sliceRange(slice2, n2)] as [rt.i128, Uint8Array]; + b = _38; + shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 128)); + _52 = rt.u8Rem(op, 25); + if (_52 === 0) { + const part16 = rt.i128Add(a, b); + _50(out, part16); + } else if (_52 === 1) { + const part15 = rt.i128Sub(a, b); + _50(out, part15); + } else if (_52 === 2) { + const part14 = rt.i128Mul(a, b); + _50(out, part14); + } else if (_52 === 3) { + const part13 = rt.i128Div(a, b); + _50(out, part13); + } else if (_52 === 4) { + const part12 = rt.i128Rem(a, b); + _50(out, part12); + } else if (_52 === 5) { + _50(out, rt.i128And(a, b)); + } else if (_52 === 6) { + _50(out, rt.i128Or(a, b)); + } else if (_52 === 7) { + _50(out, rt.i128Xor(a, b)); + } else if (_52 === 8) { + const part11 = rt.i128Shl(a, shift); + _50(out, part11); + } else if (_52 === 9) { + const part10 = rt.i128Shr(a, shift); + _50(out, part10); + } else if (_52 === 10) { + _50(out, rt.i128Not(a)); + } else if (_52 === 11) { + const part9 = rt.i128CheckedAdd(a, b); + _51(out, part9); + } else if (_52 === 12) { + const part8 = rt.i128CheckedSub(a, b); + _51(out, part8); + } else if (_52 === 13) { + const part7 = rt.i128CheckedMul(a, b); + _51(out, part7); + } else if (_52 === 14) { + const part6 = rt.i128SaturatingAdd(a, b); + _50(out, part6); + } else if (_52 === 15) { + const part5 = rt.i128SaturatingSub(a, b); + _50(out, part5); + } else if (_52 === 16) { + const part4 = rt.i128WrappingAdd(a, b); + _50(out, part4); + } else if (_52 === 17) { + const part3 = rt.i128WrappingSub(a, b); + _50(out, part3); + } else if (_52 === 18) { rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i128LeadingOnes(a))); - } else if (value === 19) { + } else if (_52 === 19) { rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i128LeadingZeros(a))); - } else if (value === 20) { - put(out, rt.i128Max(a, b)); - } else if (value === 21) { - put(out, rt.i128Min(a, b)); - } else if (value === 22) { + } else if (_52 === 20) { + const part2 = rt.i128Max(a, b); + _50(out, part2); + } else if (_52 === 21) { + const part = rt.i128Min(a, b); + _50(out, part); + } else if (_52 === 22) { rt.byteVecPush(out, rt.i128Eq(a, b) ? 1 : 0); rt.byteVecPush(out, rt.i128Lt(a, b) ? 1 : 0); rt.byteVecPush(out, rt.i128Ge(a, b) ? 1 : 0); rt.byteVecPush(out, rt.i128WrappingSub(a, b) === 0 ? 1 : 0); + } else if (_52 === 23) { + x = rt.i128Add(a, b); + rt.i128Mul(x, b); + rt.i128Mul(rt.i128Sub(x, b), a); + rt.byteVecPush(out, 1); } else { - let x: rt.i128 = a; - x = rt.i128Add(x, b); - x = rt.i128Sub(x, 1); - x = rt.i128Mul(x, 2); - x = rt.i128Shr(x, 1); - x = rt.i128Shl(x, 1); - const value2 = rt.i128Shl(1, 3); - x = rt.i128Or(x, value2); - x = rt.i128Xor(x, b); - const value3 = rt.i128Not(rt.i128Shl(1, 2)); - x = rt.i128And(x, value3); - put(out, x); + x2 = a; + x2 = rt.i128Add(x2, b); + x2 = rt.i128Sub(x2, 1); + x2 = rt.i128Mul(x2, 2); + x2 = rt.i128Shr(x2, 1); + x2 = rt.i128Shl(x2, 1); + x2 = rt.i128Or(x2, rt.i128Shl(1, 3)); + x2 = rt.i128Xor(x2, b); + x2 = rt.i128And(x2, rt.i128Not(rt.i128Shl(1, 2))); + x2 = rt.i128Rem(x2, 7); + x2 = rt.i128Div(x2, 3); + _50(out, x2); } } /** Apply operation `op` to operands taken from `data`. */ export function isizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(4); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, data3] = [rt.isizeFromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.isize, Uint8Array]; - const data4 = data3; - let buf2: Uint8Array = rt.bytes(4); - const n2 = rt.min(data4.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data4, 0, n2)); - const [b, data5] = [rt.isizeFromBeBytes(buf2), rt.sliceRange(data4, n2)] as [rt.isize, Uint8Array]; - const shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(data5), 0) as rt.u32, rt.u32Mul(2, 32)); - const put = (out2: rt.ByteVec, v: rt.isize): void => { + let a!: rt.isize; + let _6!: [rt.isize, Uint8Array]; + let buf!: Uint8Array; + let n!: rt.usize; + let b!: rt.isize; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _33!: Uint8Array; + let _38!: rt.isize; + let shift!: rt.u32; + let _50!: (a0: rt.ByteVec, a1: rt.isize) => void; + let _51!: (a0: rt.ByteVec, a1: rt.isize | undefined) => void; + let _52!: rt.u8; + let x!: rt.isize; + let x2!: rt.isize; + _50 = (out2: rt.ByteVec, v: rt.isize): void => { rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(v as rt.i128)); rt.byteVecPush(out2, rt.isizeFromBeBytes(rt.isizeToBeBytes(v)) === v ? 1 : 0); }; - const putOpt = (out3: rt.ByteVec, v2: rt.isize | undefined): void => { - if (v2 !== undefined) { - const v3 = v2; + _51 = (out3: rt.ByteVec, v2: rt.isize | undefined): void => { + let v3!: rt.isize; + if (v2 === undefined) { + rt.byteVecPush(out3, 0); + } else { + v3 = v2; rt.byteVecPush(out3, 1); rt.byteVecExtendFromSlice(out3, rt.i128ToBeBytes(v3 as rt.i128)); - } else { - rt.byteVecPush(out3, 0); } }; - const value = rt.u8Rem(op, 24); - if (value === 0) { - put(out, rt.isizeAdd(a, b)); - } else if (value === 1) { - put(out, rt.isizeSub(a, b)); - } else if (value === 2) { - put(out, rt.isizeMul(a, b)); - } else if (value === 3) { - put(out, rt.isizeDiv(a, b)); - } else if (value === 4) { - put(out, rt.isizeRem(a, b)); - } else if (value === 5) { - put(out, a & b); - } else if (value === 6) { - put(out, a | b); - } else if (value === 7) { - put(out, a ^ b); - } else if (value === 8) { - put(out, rt.isizeShl(a, shift)); - } else if (value === 9) { - put(out, rt.isizeShr(a, shift)); - } else if (value === 10) { - put(out, ~a); - } else if (value === 11) { - putOpt(out, rt.isizeCheckedAdd(a, b)); - } else if (value === 12) { - putOpt(out, rt.isizeCheckedSub(a, b)); - } else if (value === 13) { - putOpt(out, rt.isizeCheckedMul(a, b)); - } else if (value === 14) { - put(out, rt.isizeSaturatingAdd(a, b)); - } else if (value === 15) { - put(out, rt.isizeSaturatingSub(a, b)); - } else if (value === 16) { - put(out, rt.isizeWrappingAdd(a, b)); - } else if (value === 17) { - put(out, rt.isizeWrappingSub(a, b)); - } else if (value === 18) { + buf = rt.bytes(4); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + _6 = [rt.isizeFromBeBytes(buf), rt.sliceRange(data, n)] as [rt.isize, Uint8Array]; + a = _6[0]; + buf2 = rt.bytes(4); + n2 = rt.min(rt.sliceRange(data, n).length, buf2.length); + _33 = rt.sliceRange(buf2, 0, n2); + const slice = rt.sliceRange(data, n); + rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + _38 = rt.isizeFromBeBytes(buf2); + const slice2 = rt.sliceRange(data, n); + [_38, rt.sliceRange(slice2, n2)] as [rt.isize, Uint8Array]; + b = _38; + shift = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, rt.u32Mul(2, 32)); + _52 = rt.u8Rem(op, 25); + if (_52 === 0) { + const part16 = rt.isizeAdd(a, b); + _50(out, part16); + } else if (_52 === 1) { + const part15 = rt.isizeSub(a, b); + _50(out, part15); + } else if (_52 === 2) { + const part14 = rt.isizeMul(a, b); + _50(out, part14); + } else if (_52 === 3) { + const part13 = rt.isizeDiv(a, b); + _50(out, part13); + } else if (_52 === 4) { + const part12 = rt.isizeRem(a, b); + _50(out, part12); + } else if (_52 === 5) { + _50(out, a & b); + } else if (_52 === 6) { + _50(out, a | b); + } else if (_52 === 7) { + _50(out, a ^ b); + } else if (_52 === 8) { + const part11 = rt.isizeShl(a, shift); + _50(out, part11); + } else if (_52 === 9) { + const part10 = rt.isizeShr(a, shift); + _50(out, part10); + } else if (_52 === 10) { + _50(out, ~a); + } else if (_52 === 11) { + const part9 = rt.isizeCheckedAdd(a, b); + _51(out, part9); + } else if (_52 === 12) { + const part8 = rt.isizeCheckedSub(a, b); + _51(out, part8); + } else if (_52 === 13) { + const part7 = rt.isizeCheckedMul(a, b); + _51(out, part7); + } else if (_52 === 14) { + const part6 = rt.isizeSaturatingAdd(a, b); + _50(out, part6); + } else if (_52 === 15) { + const part5 = rt.isizeSaturatingSub(a, b); + _50(out, part5); + } else if (_52 === 16) { + const part4 = rt.isizeWrappingAdd(a, b); + _50(out, part4); + } else if (_52 === 17) { + const part3 = rt.isizeWrappingSub(a, b); + _50(out, part3); + } else if (_52 === 18) { rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.isizeLeadingOnes(a))); - } else if (value === 19) { + } else if (_52 === 19) { rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.isizeLeadingZeros(a))); - } else if (value === 20) { - put(out, rt.max(a, b)); - } else if (value === 21) { - put(out, rt.min(a, b)); - } else if (value === 22) { + } else if (_52 === 20) { + const part2 = rt.max(a, b); + _50(out, part2); + } else if (_52 === 21) { + const part = rt.min(a, b); + _50(out, part); + } else if (_52 === 22) { rt.byteVecPush(out, a === b ? 1 : 0); rt.byteVecPush(out, a < b ? 1 : 0); rt.byteVecPush(out, a >= b ? 1 : 0); rt.byteVecPush(out, rt.isizeWrappingSub(a, b) === 0 ? 1 : 0); + } else if (_52 === 23) { + x = rt.isizeAdd(a, b); + rt.isizeMul(x, b); + rt.isizeMul(rt.isizeSub(x, b), a); + rt.byteVecPush(out, 1); } else { - let x: rt.isize = a; - x = rt.isizeAdd(x, b); - x = rt.isizeSub(x, 1); - x = rt.isizeMul(x, 2); - x = rt.isizeShr(x, 1); - x = rt.isizeShl(x, 1); - const value2 = 1 << 3; - x = x | value2; - x = x ^ b; - const value3 = ~(1 << 2); - x = x & value3; - put(out, x); + x2 = a; + x2 = rt.isizeAdd(x2, b); + x2 = rt.isizeSub(x2, 1); + x2 = rt.isizeMul(x2, 2); + x2 = x2 >> 1; + x2 = (x2 << 1) | 0; + x2 = x2 | (1 << 3); + x2 = x2 ^ b; + x2 = x2 & ~(1 << 2); + x2 = rt.isizeRem(x2, 7); + x2 = rt.isizeDiv(x2, 3); + _50(out, x2); } } /** Negate, which overflows at the minimum. */ export function i8Neg(data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(1); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, ] = [rt.i8FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.i8, Uint8Array]; - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i8Neg(a) as rt.i128)); + let buf!: Uint8Array; + let n!: rt.usize; + buf = Uint8Array.of(0); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i8Neg(([rt.i8FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i8, Uint8Array])[0]) as rt.i128)); } /** Negate, which overflows at the minimum. */ export function i16Neg(data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(2); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, ] = [rt.i16FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.i16, Uint8Array]; - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i16Neg(a) as rt.i128)); + let buf!: Uint8Array; + let n!: rt.usize; + buf = rt.bytes(2); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i16Neg(([rt.i16FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i16, Uint8Array])[0]) as rt.i128)); } /** Negate, which overflows at the minimum. */ export function i32Neg(data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(4); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, ] = [rt.i32FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.i32, Uint8Array]; - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i32Neg(a) as rt.i128)); + let buf!: Uint8Array; + let n!: rt.usize; + buf = rt.bytes(4); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i32Neg(([rt.i32FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i32, Uint8Array])[0]) as rt.i128)); } /** Negate, which overflows at the minimum. */ export function i64Neg(data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(8); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, ] = [rt.i64FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.i64, Uint8Array]; - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i128Cast(rt.i64Neg(a)))); + let buf!: Uint8Array; + let n!: rt.usize; + buf = rt.bytes(8); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i128Cast(rt.i64Neg(([rt.i64FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i64, Uint8Array])[0])))); } /** Negate, which overflows at the minimum. */ export function i128Neg(data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(16); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, ] = [rt.i128FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.i128, Uint8Array]; - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i128Neg(a))); + let buf!: Uint8Array; + let n!: rt.usize; + buf = rt.bytes(16); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i128Neg(([rt.i128FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i128, Uint8Array])[0]))); } /** Negate, which overflows at the minimum. */ export function isizeNeg(data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(4); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [a, ] = [rt.isizeFromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.isize, Uint8Array]; - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.isizeNeg(a) as rt.i128)); + let buf!: Uint8Array; + let n!: rt.usize; + buf = rt.bytes(4); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.isizeNeg(([rt.isizeFromBeBytes(buf), rt.sliceRange(data, n)] as [rt.isize, Uint8Array])[0]) as rt.i128)); } /** Cast a value of type `from` to type `to`, both indexes into the twelve types. */ export function cast(from: rt.u8, to: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const value = rt.u8Rem(from, 12); - if (value === 0) { - const data2 = data; - let buf: Uint8Array = rt.bytes(1); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const v = ([rt.u8FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.u8, Uint8Array])[0]; - const out2 = out; - const value2 = rt.u8Rem(to, 12); - if (value2 === 0) { - const v2 = v; - rt.byteVecExtendFromSlice(out2, rt.u8ToBeBytes(v2)); - rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v2, f)))); - } else if (value2 === 1) { - const v3 = v as rt.u16; - rt.byteVecExtendFromSlice(out2, rt.u16ToBeBytes(v3)); - rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v3, f)))); - } else if (value2 === 2) { - const v4 = v as rt.u32; - rt.byteVecExtendFromSlice(out2, rt.u32ToBeBytes(v4)); - rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v4, f)))); - } else if (value2 === 3) { - const v5 = v as rt.u64; - rt.byteVecExtendFromSlice(out2, rt.u64ToBeBytes(v5)); - rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v5, f)))); - } else if (value2 === 4) { - const v6 = v as rt.u128; - rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(v6)); - rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v6, f)))); - } else if (value2 === 5) { - const v7 = v as rt.usize; - rt.byteVecExtendFromSlice(out2, rt.usizeToBeBytes(v7)); - rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v7, f)))); - } else if (value2 === 6) { - const v8 = (v << 24) >> 24; - rt.byteVecExtendFromSlice(out2, rt.i8ToBeBytes(v8)); - rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v8, f)))); - } else if (value2 === 7) { - const v9 = v as rt.i16; - rt.byteVecExtendFromSlice(out2, rt.i16ToBeBytes(v9)); - rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v9, f)))); - } else if (value2 === 8) { - const v10 = v as rt.i32; - rt.byteVecExtendFromSlice(out2, rt.i32ToBeBytes(v10)); - rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v10, f)))); - } else if (value2 === 9) { - const v11 = v as rt.i64; - rt.byteVecExtendFromSlice(out2, rt.i64ToBeBytes(v11)); - rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v11, f)))); - } else if (value2 === 10) { - const v12 = v as rt.i128; - rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(v12)); - rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v12, f)))); + let _5!: rt.u8; + let v!: rt.u8; + let buf!: Uint8Array; + let n!: rt.usize; + let _25!: rt.u8; + let v2!: rt.u8; + let _35!: string; + let v3!: rt.u16; + let _45!: string; + let v4!: rt.u32; + let _55!: string; + let v5!: rt.u64; + let _65!: string; + let v6!: rt.u128; + let _75!: string; + let v7!: rt.usize; + let _85!: string; + let v8!: rt.i8; + let _95!: string; + let v9!: rt.i16; + let _105!: string; + let v10!: rt.i32; + let _115!: string; + let v11!: rt.i64; + let _125!: string; + let v12!: rt.i128; + let _135!: string; + let v13!: rt.isize; + let _145!: string; + let v14!: rt.u16; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _165!: rt.u8; + let v15!: rt.u8; + let _175!: string; + let v16!: rt.u16; + let _185!: string; + let v17!: rt.u32; + let _195!: string; + let v18!: rt.u64; + let _205!: string; + let v19!: rt.u128; + let _215!: string; + let v20!: rt.usize; + let _225!: string; + let v21!: rt.i8; + let _235!: string; + let v22!: rt.i16; + let _245!: string; + let v23!: rt.i32; + let _255!: string; + let v24!: rt.i64; + let _265!: string; + let v25!: rt.i128; + let _275!: string; + let v26!: rt.isize; + let _285!: string; + let v27!: rt.u32; + let buf3!: Uint8Array; + let n3!: rt.usize; + let _305!: rt.u8; + let v28!: rt.u8; + let _315!: string; + let v29!: rt.u16; + let _325!: string; + let v30!: rt.u32; + let _335!: string; + let v31!: rt.u64; + let _345!: string; + let v32!: rt.u128; + let _355!: string; + let v33!: rt.usize; + let _365!: string; + let v34!: rt.i8; + let _375!: string; + let v35!: rt.i16; + let _385!: string; + let v36!: rt.i32; + let _395!: string; + let v37!: rt.i64; + let _405!: string; + let v38!: rt.i128; + let _415!: string; + let v39!: rt.isize; + let _425!: string; + let v40!: rt.u64; + let buf4!: Uint8Array; + let n4!: rt.usize; + let _445!: rt.u8; + let v41!: rt.u8; + let _455!: string; + let v42!: rt.u16; + let _465!: string; + let v43!: rt.u32; + let _475!: string; + let v44!: rt.u64; + let _485!: string; + let v45!: rt.u128; + let _495!: string; + let v46!: rt.usize; + let _505!: string; + let v47!: rt.i8; + let _515!: string; + let v48!: rt.i16; + let _525!: string; + let v49!: rt.i32; + let _535!: string; + let v50!: rt.i64; + let _545!: string; + let v51!: rt.i128; + let _555!: string; + let v52!: rt.isize; + let _565!: string; + let v53!: rt.u128; + let buf5!: Uint8Array; + let n5!: rt.usize; + let _585!: rt.u8; + let v54!: rt.u8; + let _595!: string; + let v55!: rt.u16; + let _605!: string; + let v56!: rt.u32; + let _615!: string; + let v57!: rt.u64; + let _625!: string; + let v58!: rt.u128; + let _635!: string; + let v59!: rt.usize; + let _645!: string; + let v60!: rt.i8; + let _655!: string; + let v61!: rt.i16; + let _665!: string; + let v62!: rt.i32; + let _675!: string; + let v63!: rt.i64; + let _685!: string; + let v64!: rt.i128; + let _695!: string; + let v65!: rt.isize; + let _705!: string; + let v66!: rt.usize; + let buf6!: Uint8Array; + let n6!: rt.usize; + let _725!: rt.u8; + let v67!: rt.u8; + let _735!: string; + let v68!: rt.u16; + let _745!: string; + let v69!: rt.u32; + let _755!: string; + let v70!: rt.u64; + let _765!: string; + let v71!: rt.u128; + let _775!: string; + let v72!: rt.usize; + let _785!: string; + let v73!: rt.i8; + let _795!: string; + let v74!: rt.i16; + let _805!: string; + let v75!: rt.i32; + let _815!: string; + let v76!: rt.i64; + let _825!: string; + let v77!: rt.i128; + let _835!: string; + let v78!: rt.isize; + let _845!: string; + let v79!: rt.i8; + let buf7!: Uint8Array; + let n7!: rt.usize; + let _865!: rt.u8; + let v80!: rt.u8; + let _875!: string; + let v81!: rt.u16; + let _885!: string; + let v82!: rt.u32; + let _895!: string; + let v83!: rt.u64; + let _905!: string; + let v84!: rt.u128; + let _915!: string; + let v85!: rt.usize; + let _925!: string; + let v86!: rt.i8; + let _935!: string; + let v87!: rt.i16; + let _945!: string; + let v88!: rt.i32; + let _955!: string; + let v89!: rt.i64; + let _965!: string; + let v90!: rt.i128; + let _975!: string; + let v91!: rt.isize; + let _985!: string; + let v92!: rt.i16; + let buf8!: Uint8Array; + let n8!: rt.usize; + let _1005!: rt.u8; + let v93!: rt.u8; + let _1015!: string; + let v94!: rt.u16; + let _1025!: string; + let v95!: rt.u32; + let _1035!: string; + let v96!: rt.u64; + let _1045!: string; + let v97!: rt.u128; + let _1055!: string; + let v98!: rt.usize; + let _1065!: string; + let v99!: rt.i8; + let _1075!: string; + let v100!: rt.i16; + let _1085!: string; + let v101!: rt.i32; + let _1095!: string; + let v102!: rt.i64; + let _1105!: string; + let v103!: rt.i128; + let _1115!: string; + let v104!: rt.isize; + let _1125!: string; + let v105!: rt.i32; + let buf9!: Uint8Array; + let n9!: rt.usize; + let _1145!: rt.u8; + let v106!: rt.u8; + let _1155!: string; + let v107!: rt.u16; + let _1165!: string; + let v108!: rt.u32; + let _1175!: string; + let v109!: rt.u64; + let _1185!: string; + let v110!: rt.u128; + let _1195!: string; + let v111!: rt.usize; + let _1205!: string; + let v112!: rt.i8; + let _1215!: string; + let v113!: rt.i16; + let _1225!: string; + let v114!: rt.i32; + let _1235!: string; + let v115!: rt.i64; + let _1245!: string; + let v116!: rt.i128; + let _1255!: string; + let v117!: rt.isize; + let _1265!: string; + let v118!: rt.i64; + let buf10!: Uint8Array; + let n10!: rt.usize; + let _1285!: rt.u8; + let v119!: rt.u8; + let _1295!: string; + let v120!: rt.u16; + let _1305!: string; + let v121!: rt.u32; + let _1315!: string; + let v122!: rt.u64; + let _1325!: string; + let v123!: rt.u128; + let _1335!: string; + let v124!: rt.usize; + let _1345!: string; + let v125!: rt.i8; + let _1355!: string; + let v126!: rt.i16; + let _1365!: string; + let v127!: rt.i32; + let _1375!: string; + let v128!: rt.i64; + let _1385!: string; + let v129!: rt.i128; + let _1395!: string; + let v130!: rt.isize; + let _1405!: string; + let v131!: rt.i128; + let buf11!: Uint8Array; + let n11!: rt.usize; + let _1425!: rt.u8; + let v132!: rt.u8; + let _1435!: string; + let v133!: rt.u16; + let _1445!: string; + let v134!: rt.u32; + let _1455!: string; + let v135!: rt.u64; + let _1465!: string; + let v136!: rt.u128; + let _1475!: string; + let v137!: rt.usize; + let _1485!: string; + let v138!: rt.i8; + let _1495!: string; + let v139!: rt.i16; + let _1505!: string; + let v140!: rt.i32; + let _1515!: string; + let v141!: rt.i64; + let _1525!: string; + let v142!: rt.i128; + let _1535!: string; + let v143!: rt.isize; + let _1545!: string; + let v144!: rt.isize; + let buf12!: Uint8Array; + let n12!: rt.usize; + let _1565!: rt.u8; + let v145!: rt.u8; + let _1575!: string; + let v146!: rt.u16; + let _1585!: string; + let v147!: rt.u32; + let _1595!: string; + let v148!: rt.u64; + let _1605!: string; + let v149!: rt.u128; + let _1615!: string; + let v150!: rt.usize; + let _1625!: string; + let v151!: rt.i8; + let _1635!: string; + let v152!: rt.i16; + let _1645!: string; + let v153!: rt.i32; + let _1655!: string; + let v154!: rt.i64; + let _1665!: string; + let v155!: rt.i128; + let _1675!: string; + let v156!: rt.isize; + let _1685!: string; + _5 = rt.u8Rem(from, 12); + if (_5 === 0) { + buf = Uint8Array.of(0); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + v = ([rt.u8FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.u8, Uint8Array])[0]; + _25 = rt.u8Rem(to, 12); + if (_25 === 0) { + v2 = v; + rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v2)); + _35 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v2, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_35)); + } else if (_25 === 1) { + v3 = v as rt.u16; + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v3)); + _45 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v3, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_45)); + } else if (_25 === 2) { + v4 = v as rt.u32; + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v4)); + _55 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v4, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_55)); + } else if (_25 === 3) { + v5 = v as rt.u64; + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v5)); + _65 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v5, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_65)); + } else if (_25 === 4) { + v6 = v as rt.u128; + rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v6)); + _75 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v6, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_75)); + } else if (_25 === 5) { + v7 = v as rt.usize; + rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v7)); + _85 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v7, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_85)); + } else if (_25 === 6) { + v8 = (v << 24) >> 24; + rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v8)); + _95 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v8, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_95)); + } else if (_25 === 7) { + v9 = v as rt.i16; + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v9)); + _105 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v9, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_105)); + } else if (_25 === 8) { + v10 = v as rt.i32; + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v10)); + _115 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v10, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_115)); + } else if (_25 === 9) { + v11 = v as rt.i64; + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v11)); + _125 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v11, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_125)); + } else if (_25 === 10) { + v12 = v as rt.i128; + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v12)); + _135 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v12, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_135)); } else { - const v13 = v as rt.isize; - rt.byteVecExtendFromSlice(out2, rt.isizeToBeBytes(v13)); - rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v13, f)))); + v13 = v as rt.isize; + rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v13)); + _145 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v13, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_145)); } - } else if (value === 1) { - const data3 = data; - let buf2: Uint8Array = rt.bytes(2); - const n2 = rt.min(data3.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data3, 0, n2)); - const v14 = ([rt.u16FromBeBytes(buf2), rt.sliceRange(data3, n2)] as [rt.u16, Uint8Array])[0]; - const out3 = out; - const value3 = rt.u8Rem(to, 12); - if (value3 === 0) { - const v15 = v14 & 0xff; - rt.byteVecExtendFromSlice(out3, rt.u8ToBeBytes(v15)); - rt.byteVecExtendFromSlice(out3, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v15, f)))); - } else if (value3 === 1) { - const v16 = v14; - rt.byteVecExtendFromSlice(out3, rt.u16ToBeBytes(v16)); - rt.byteVecExtendFromSlice(out3, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v16, f)))); - } else if (value3 === 2) { - const v17 = v14 as rt.u32; - rt.byteVecExtendFromSlice(out3, rt.u32ToBeBytes(v17)); - rt.byteVecExtendFromSlice(out3, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v17, f)))); - } else if (value3 === 3) { - const v18 = v14 as rt.u64; - rt.byteVecExtendFromSlice(out3, rt.u64ToBeBytes(v18)); - rt.byteVecExtendFromSlice(out3, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v18, f)))); - } else if (value3 === 4) { - const v19 = v14 as rt.u128; - rt.byteVecExtendFromSlice(out3, rt.u128ToBeBytes(v19)); - rt.byteVecExtendFromSlice(out3, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v19, f)))); - } else if (value3 === 5) { - const v20 = v14 as rt.usize; - rt.byteVecExtendFromSlice(out3, rt.usizeToBeBytes(v20)); - rt.byteVecExtendFromSlice(out3, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v20, f)))); - } else if (value3 === 6) { - const v21 = (v14 << 24) >> 24; - rt.byteVecExtendFromSlice(out3, rt.i8ToBeBytes(v21)); - rt.byteVecExtendFromSlice(out3, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v21, f)))); - } else if (value3 === 7) { - const v22 = (v14 << 16) >> 16; - rt.byteVecExtendFromSlice(out3, rt.i16ToBeBytes(v22)); - rt.byteVecExtendFromSlice(out3, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v22, f)))); - } else if (value3 === 8) { - const v23 = v14 as rt.i32; - rt.byteVecExtendFromSlice(out3, rt.i32ToBeBytes(v23)); - rt.byteVecExtendFromSlice(out3, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v23, f)))); - } else if (value3 === 9) { - const v24 = v14 as rt.i64; - rt.byteVecExtendFromSlice(out3, rt.i64ToBeBytes(v24)); - rt.byteVecExtendFromSlice(out3, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v24, f)))); - } else if (value3 === 10) { - const v25 = v14 as rt.i128; - rt.byteVecExtendFromSlice(out3, rt.i128ToBeBytes(v25)); - rt.byteVecExtendFromSlice(out3, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v25, f)))); + } else if (_5 === 1) { + buf2 = rt.bytes(2); + n2 = rt.min(data.length, buf2.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data, 0, n2)); + v14 = ([rt.u16FromBeBytes(buf2), rt.sliceRange(data, n2)] as [rt.u16, Uint8Array])[0]; + _165 = rt.u8Rem(to, 12); + if (_165 === 0) { + v15 = v14 & 0xff; + rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v15)); + _175 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v15, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_175)); + } else if (_165 === 1) { + v16 = v14; + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v16)); + _185 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v16, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_185)); + } else if (_165 === 2) { + v17 = v14 as rt.u32; + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v17)); + _195 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v17, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_195)); + } else if (_165 === 3) { + v18 = v14 as rt.u64; + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v18)); + _205 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v18, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_205)); + } else if (_165 === 4) { + v19 = v14 as rt.u128; + rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v19)); + _215 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v19, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_215)); + } else if (_165 === 5) { + v20 = v14 as rt.usize; + rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v20)); + _225 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v20, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_225)); + } else if (_165 === 6) { + v21 = (v14 << 24) >> 24; + rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v21)); + _235 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v21, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_235)); + } else if (_165 === 7) { + v22 = (v14 << 16) >> 16; + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v22)); + _245 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v22, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_245)); + } else if (_165 === 8) { + v23 = v14 as rt.i32; + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v23)); + _255 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v23, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_255)); + } else if (_165 === 9) { + v24 = v14 as rt.i64; + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v24)); + _265 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v24, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_265)); + } else if (_165 === 10) { + v25 = v14 as rt.i128; + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v25)); + _275 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v25, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_275)); } else { - const v26 = v14 as rt.isize; - rt.byteVecExtendFromSlice(out3, rt.isizeToBeBytes(v26)); - rt.byteVecExtendFromSlice(out3, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v26, f)))); + v26 = v14 as rt.isize; + rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v26)); + _285 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v26, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_285)); } - } else if (value === 2) { - const data4 = data; - let buf3: Uint8Array = rt.bytes(4); - const n3 = rt.min(data4.length, buf3.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf3, 0, n3), rt.sliceRange(data4, 0, n3)); - const v27 = ([rt.u32FromBeBytes(buf3), rt.sliceRange(data4, n3)] as [rt.u32, Uint8Array])[0]; - const out4 = out; - const value4 = rt.u8Rem(to, 12); - if (value4 === 0) { - const v28 = v27 & 0xff; - rt.byteVecExtendFromSlice(out4, rt.u8ToBeBytes(v28)); - rt.byteVecExtendFromSlice(out4, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v28, f)))); - } else if (value4 === 1) { - const v29 = v27 & 0xffff; - rt.byteVecExtendFromSlice(out4, rt.u16ToBeBytes(v29)); - rt.byteVecExtendFromSlice(out4, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v29, f)))); - } else if (value4 === 2) { - const v30 = v27; - rt.byteVecExtendFromSlice(out4, rt.u32ToBeBytes(v30)); - rt.byteVecExtendFromSlice(out4, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v30, f)))); - } else if (value4 === 3) { - const v31 = v27 as rt.u64; - rt.byteVecExtendFromSlice(out4, rt.u64ToBeBytes(v31)); - rt.byteVecExtendFromSlice(out4, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v31, f)))); - } else if (value4 === 4) { - const v32 = v27 as rt.u128; - rt.byteVecExtendFromSlice(out4, rt.u128ToBeBytes(v32)); - rt.byteVecExtendFromSlice(out4, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v32, f)))); - } else if (value4 === 5) { - const v33 = v27 as rt.usize; - rt.byteVecExtendFromSlice(out4, rt.usizeToBeBytes(v33)); - rt.byteVecExtendFromSlice(out4, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v33, f)))); - } else if (value4 === 6) { - const v34 = (v27 << 24) >> 24; - rt.byteVecExtendFromSlice(out4, rt.i8ToBeBytes(v34)); - rt.byteVecExtendFromSlice(out4, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v34, f)))); - } else if (value4 === 7) { - const v35 = (v27 << 16) >> 16; - rt.byteVecExtendFromSlice(out4, rt.i16ToBeBytes(v35)); - rt.byteVecExtendFromSlice(out4, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v35, f)))); - } else if (value4 === 8) { - const v36 = v27 | 0; - rt.byteVecExtendFromSlice(out4, rt.i32ToBeBytes(v36)); - rt.byteVecExtendFromSlice(out4, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v36, f)))); - } else if (value4 === 9) { - const v37 = v27 as rt.i64; - rt.byteVecExtendFromSlice(out4, rt.i64ToBeBytes(v37)); - rt.byteVecExtendFromSlice(out4, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v37, f)))); - } else if (value4 === 10) { - const v38 = v27 as rt.i128; - rt.byteVecExtendFromSlice(out4, rt.i128ToBeBytes(v38)); - rt.byteVecExtendFromSlice(out4, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v38, f)))); + } else if (_5 === 2) { + buf3 = rt.bytes(4); + n3 = rt.min(data.length, buf3.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf3, 0, n3), rt.sliceRange(data, 0, n3)); + v27 = ([rt.u32FromBeBytes(buf3), rt.sliceRange(data, n3)] as [rt.u32, Uint8Array])[0]; + _305 = rt.u8Rem(to, 12); + if (_305 === 0) { + v28 = v27 & 0xff; + rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v28)); + _315 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v28, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_315)); + } else if (_305 === 1) { + v29 = v27 & 0xffff; + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v29)); + _325 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v29, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_325)); + } else if (_305 === 2) { + v30 = v27; + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v30)); + _335 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v30, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_335)); + } else if (_305 === 3) { + v31 = v27 as rt.u64; + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v31)); + _345 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v31, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_345)); + } else if (_305 === 4) { + v32 = v27 as rt.u128; + rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v32)); + _355 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v32, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_355)); + } else if (_305 === 5) { + v33 = v27 as rt.usize; + rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v33)); + _365 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v33, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_365)); + } else if (_305 === 6) { + v34 = (v27 << 24) >> 24; + rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v34)); + _375 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v34, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_375)); + } else if (_305 === 7) { + v35 = (v27 << 16) >> 16; + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v35)); + _385 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v35, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_385)); + } else if (_305 === 8) { + v36 = v27 | 0; + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v36)); + _395 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v36, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_395)); + } else if (_305 === 9) { + v37 = v27 as rt.i64; + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v37)); + _405 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v37, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_405)); + } else if (_305 === 10) { + v38 = v27 as rt.i128; + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v38)); + _415 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v38, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_415)); } else { - const v39 = v27 | 0; - rt.byteVecExtendFromSlice(out4, rt.isizeToBeBytes(v39)); - rt.byteVecExtendFromSlice(out4, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v39, f)))); + v39 = v27 | 0; + rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v39)); + _425 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v39, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_425)); } - } else if (value === 3) { - const data5 = data; - let buf4: Uint8Array = rt.bytes(8); - const n4 = rt.min(data5.length, buf4.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf4, 0, n4), rt.sliceRange(data5, 0, n4)); - const v40 = ([rt.u64FromBeBytes(buf4), rt.sliceRange(data5, n4)] as [rt.u64, Uint8Array])[0]; - const out5 = out; - const value5 = rt.u8Rem(to, 12); - if (value5 === 0) { - const v41 = rt.u64Low(v40) & 0xff; - rt.byteVecExtendFromSlice(out5, rt.u8ToBeBytes(v41)); - rt.byteVecExtendFromSlice(out5, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v41, f)))); - } else if (value5 === 1) { - const v42 = rt.u64Low(v40) & 0xffff; - rt.byteVecExtendFromSlice(out5, rt.u16ToBeBytes(v42)); - rt.byteVecExtendFromSlice(out5, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v42, f)))); - } else if (value5 === 2) { - const v43 = rt.u64Low(v40); - rt.byteVecExtendFromSlice(out5, rt.u32ToBeBytes(v43)); - rt.byteVecExtendFromSlice(out5, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v43, f)))); - } else if (value5 === 3) { - const v44 = v40; - rt.byteVecExtendFromSlice(out5, rt.u64ToBeBytes(v44)); - rt.byteVecExtendFromSlice(out5, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v44, f)))); - } else if (value5 === 4) { - const v45 = rt.u128Cast(v40); - rt.byteVecExtendFromSlice(out5, rt.u128ToBeBytes(v45)); - rt.byteVecExtendFromSlice(out5, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v45, f)))); - } else if (value5 === 5) { - const v46 = rt.u64Low(v40); - rt.byteVecExtendFromSlice(out5, rt.usizeToBeBytes(v46)); - rt.byteVecExtendFromSlice(out5, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v46, f)))); - } else if (value5 === 6) { - const v47 = (rt.u64Low(v40) << 24) >> 24; - rt.byteVecExtendFromSlice(out5, rt.i8ToBeBytes(v47)); - rt.byteVecExtendFromSlice(out5, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v47, f)))); - } else if (value5 === 7) { - const v48 = (rt.u64Low(v40) << 16) >> 16; - rt.byteVecExtendFromSlice(out5, rt.i16ToBeBytes(v48)); - rt.byteVecExtendFromSlice(out5, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v48, f)))); - } else if (value5 === 8) { - const v49 = rt.u64Low(v40) | 0; - rt.byteVecExtendFromSlice(out5, rt.i32ToBeBytes(v49)); - rt.byteVecExtendFromSlice(out5, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v49, f)))); - } else if (value5 === 9) { - const v50 = rt.i64Cast(v40); - rt.byteVecExtendFromSlice(out5, rt.i64ToBeBytes(v50)); - rt.byteVecExtendFromSlice(out5, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v50, f)))); - } else if (value5 === 10) { - const v51 = rt.i128Cast(v40); - rt.byteVecExtendFromSlice(out5, rt.i128ToBeBytes(v51)); - rt.byteVecExtendFromSlice(out5, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v51, f)))); + } else if (_5 === 3) { + buf4 = rt.bytes(8); + n4 = rt.min(data.length, buf4.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf4, 0, n4), rt.sliceRange(data, 0, n4)); + v40 = ([rt.u64FromBeBytes(buf4), rt.sliceRange(data, n4)] as [rt.u64, Uint8Array])[0]; + _445 = rt.u8Rem(to, 12); + if (_445 === 0) { + v41 = rt.u64Low(v40) & 0xff; + rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v41)); + _455 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v41, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_455)); + } else if (_445 === 1) { + v42 = rt.u64Low(v40) & 0xffff; + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v42)); + _465 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v42, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_465)); + } else if (_445 === 2) { + v43 = rt.u64Low(v40); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v43)); + _475 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v43, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_475)); + } else if (_445 === 3) { + v44 = v40; + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v44)); + _485 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v44, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_485)); + } else if (_445 === 4) { + v45 = rt.u128Cast(v40); + rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v45)); + _495 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v45, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_495)); + } else if (_445 === 5) { + v46 = rt.u64Low(v40); + rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v46)); + _505 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v46, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_505)); + } else if (_445 === 6) { + v47 = (rt.u64Low(v40) << 24) >> 24; + rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v47)); + _515 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v47, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_515)); + } else if (_445 === 7) { + v48 = (rt.u64Low(v40) << 16) >> 16; + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v48)); + _525 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v48, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_525)); + } else if (_445 === 8) { + v49 = rt.u64Low(v40) | 0; + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v49)); + _535 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v49, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_535)); + } else if (_445 === 9) { + v50 = rt.i64Cast(v40); + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v50)); + _545 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v50, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_545)); + } else if (_445 === 10) { + v51 = rt.i128Cast(v40); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v51)); + _555 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v51, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_555)); } else { - const v52 = rt.u64Low(v40) | 0; - rt.byteVecExtendFromSlice(out5, rt.isizeToBeBytes(v52)); - rt.byteVecExtendFromSlice(out5, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v52, f)))); + v52 = rt.u64Low(v40) | 0; + rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v52)); + _565 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v52, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_565)); } - } else if (value === 4) { - const data6 = data; - let buf5: Uint8Array = rt.bytes(16); - const n5 = rt.min(data6.length, buf5.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf5, 0, n5), rt.sliceRange(data6, 0, n5)); - const v53 = ([rt.u128FromBeBytes(buf5), rt.sliceRange(data6, n5)] as [rt.u128, Uint8Array])[0]; - const out6 = out; - const value6 = rt.u8Rem(to, 12); - if (value6 === 0) { - const v54 = rt.u128Low(v53) & 0xff; - rt.byteVecExtendFromSlice(out6, rt.u8ToBeBytes(v54)); - rt.byteVecExtendFromSlice(out6, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v54, f)))); - } else if (value6 === 1) { - const v55 = rt.u128Low(v53) & 0xffff; - rt.byteVecExtendFromSlice(out6, rt.u16ToBeBytes(v55)); - rt.byteVecExtendFromSlice(out6, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v55, f)))); - } else if (value6 === 2) { - const v56 = rt.u128Low(v53); - rt.byteVecExtendFromSlice(out6, rt.u32ToBeBytes(v56)); - rt.byteVecExtendFromSlice(out6, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v56, f)))); - } else if (value6 === 3) { - const v57 = rt.u64Cast(v53); - rt.byteVecExtendFromSlice(out6, rt.u64ToBeBytes(v57)); - rt.byteVecExtendFromSlice(out6, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v57, f)))); - } else if (value6 === 4) { - const v58 = v53; - rt.byteVecExtendFromSlice(out6, rt.u128ToBeBytes(v58)); - rt.byteVecExtendFromSlice(out6, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v58, f)))); - } else if (value6 === 5) { - const v59 = rt.u128Low(v53); - rt.byteVecExtendFromSlice(out6, rt.usizeToBeBytes(v59)); - rt.byteVecExtendFromSlice(out6, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v59, f)))); - } else if (value6 === 6) { - const v60 = (rt.u128Low(v53) << 24) >> 24; - rt.byteVecExtendFromSlice(out6, rt.i8ToBeBytes(v60)); - rt.byteVecExtendFromSlice(out6, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v60, f)))); - } else if (value6 === 7) { - const v61 = (rt.u128Low(v53) << 16) >> 16; - rt.byteVecExtendFromSlice(out6, rt.i16ToBeBytes(v61)); - rt.byteVecExtendFromSlice(out6, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v61, f)))); - } else if (value6 === 8) { - const v62 = rt.u128Low(v53) | 0; - rt.byteVecExtendFromSlice(out6, rt.i32ToBeBytes(v62)); - rt.byteVecExtendFromSlice(out6, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v62, f)))); - } else if (value6 === 9) { - const v63 = rt.i64Cast(v53); - rt.byteVecExtendFromSlice(out6, rt.i64ToBeBytes(v63)); - rt.byteVecExtendFromSlice(out6, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v63, f)))); - } else if (value6 === 10) { - const v64 = rt.i128Cast(v53); - rt.byteVecExtendFromSlice(out6, rt.i128ToBeBytes(v64)); - rt.byteVecExtendFromSlice(out6, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v64, f)))); + } else if (_5 === 4) { + buf5 = rt.bytes(16); + n5 = rt.min(data.length, buf5.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf5, 0, n5), rt.sliceRange(data, 0, n5)); + v53 = ([rt.u128FromBeBytes(buf5), rt.sliceRange(data, n5)] as [rt.u128, Uint8Array])[0]; + _585 = rt.u8Rem(to, 12); + if (_585 === 0) { + v54 = rt.u128Low(v53) & 0xff; + rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v54)); + _595 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v54, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_595)); + } else if (_585 === 1) { + v55 = rt.u128Low(v53) & 0xffff; + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v55)); + _605 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v55, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_605)); + } else if (_585 === 2) { + v56 = rt.u128Low(v53); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v56)); + _615 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v56, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_615)); + } else if (_585 === 3) { + v57 = rt.u64Cast(v53); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v57)); + _625 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v57, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_625)); + } else if (_585 === 4) { + v58 = v53; + rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v58)); + _635 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v58, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_635)); + } else if (_585 === 5) { + v59 = rt.u128Low(v53); + rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v59)); + _645 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v59, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_645)); + } else if (_585 === 6) { + v60 = (rt.u128Low(v53) << 24) >> 24; + rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v60)); + _655 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v60, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_655)); + } else if (_585 === 7) { + v61 = (rt.u128Low(v53) << 16) >> 16; + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v61)); + _665 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v61, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_665)); + } else if (_585 === 8) { + v62 = rt.u128Low(v53) | 0; + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v62)); + _675 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v62, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_675)); + } else if (_585 === 9) { + v63 = rt.i64Cast(v53); + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v63)); + _685 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v63, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_685)); + } else if (_585 === 10) { + v64 = rt.i128Cast(v53); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v64)); + _695 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v64, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_695)); } else { - const v65 = rt.u128Low(v53) | 0; - rt.byteVecExtendFromSlice(out6, rt.isizeToBeBytes(v65)); - rt.byteVecExtendFromSlice(out6, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v65, f)))); + v65 = rt.u128Low(v53) | 0; + rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v65)); + _705 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v65, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_705)); } - } else if (value === 5) { - const data7 = data; - let buf6: Uint8Array = rt.bytes(4); - const n6 = rt.min(data7.length, buf6.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf6, 0, n6), rt.sliceRange(data7, 0, n6)); - const v66 = ([rt.usizeFromBeBytes(buf6), rt.sliceRange(data7, n6)] as [rt.usize, Uint8Array])[0]; - const out7 = out; - const value7 = rt.u8Rem(to, 12); - if (value7 === 0) { - const v67 = v66 & 0xff; - rt.byteVecExtendFromSlice(out7, rt.u8ToBeBytes(v67)); - rt.byteVecExtendFromSlice(out7, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v67, f)))); - } else if (value7 === 1) { - const v68 = v66 & 0xffff; - rt.byteVecExtendFromSlice(out7, rt.u16ToBeBytes(v68)); - rt.byteVecExtendFromSlice(out7, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v68, f)))); - } else if (value7 === 2) { - const v69 = v66 as rt.u32; - rt.byteVecExtendFromSlice(out7, rt.u32ToBeBytes(v69)); - rt.byteVecExtendFromSlice(out7, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v69, f)))); - } else if (value7 === 3) { - const v70 = v66 as rt.u64; - rt.byteVecExtendFromSlice(out7, rt.u64ToBeBytes(v70)); - rt.byteVecExtendFromSlice(out7, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v70, f)))); - } else if (value7 === 4) { - const v71 = v66 as rt.u128; - rt.byteVecExtendFromSlice(out7, rt.u128ToBeBytes(v71)); - rt.byteVecExtendFromSlice(out7, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v71, f)))); - } else if (value7 === 5) { - const v72 = v66; - rt.byteVecExtendFromSlice(out7, rt.usizeToBeBytes(v72)); - rt.byteVecExtendFromSlice(out7, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v72, f)))); - } else if (value7 === 6) { - const v73 = (v66 << 24) >> 24; - rt.byteVecExtendFromSlice(out7, rt.i8ToBeBytes(v73)); - rt.byteVecExtendFromSlice(out7, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v73, f)))); - } else if (value7 === 7) { - const v74 = (v66 << 16) >> 16; - rt.byteVecExtendFromSlice(out7, rt.i16ToBeBytes(v74)); - rt.byteVecExtendFromSlice(out7, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v74, f)))); - } else if (value7 === 8) { - const v75 = v66 | 0; - rt.byteVecExtendFromSlice(out7, rt.i32ToBeBytes(v75)); - rt.byteVecExtendFromSlice(out7, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v75, f)))); - } else if (value7 === 9) { - const v76 = v66 as rt.i64; - rt.byteVecExtendFromSlice(out7, rt.i64ToBeBytes(v76)); - rt.byteVecExtendFromSlice(out7, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v76, f)))); - } else if (value7 === 10) { - const v77 = v66 as rt.i128; - rt.byteVecExtendFromSlice(out7, rt.i128ToBeBytes(v77)); - rt.byteVecExtendFromSlice(out7, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v77, f)))); + } else if (_5 === 5) { + buf6 = rt.bytes(4); + n6 = rt.min(data.length, buf6.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf6, 0, n6), rt.sliceRange(data, 0, n6)); + v66 = ([rt.usizeFromBeBytes(buf6), rt.sliceRange(data, n6)] as [rt.usize, Uint8Array])[0]; + _725 = rt.u8Rem(to, 12); + if (_725 === 0) { + v67 = v66 & 0xff; + rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v67)); + _735 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v67, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_735)); + } else if (_725 === 1) { + v68 = v66 & 0xffff; + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v68)); + _745 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v68, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_745)); + } else if (_725 === 2) { + v69 = v66 as rt.u32; + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v69)); + _755 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v69, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_755)); + } else if (_725 === 3) { + v70 = v66 as rt.u64; + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v70)); + _765 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v70, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_765)); + } else if (_725 === 4) { + v71 = v66 as rt.u128; + rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v71)); + _775 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v71, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_775)); + } else if (_725 === 5) { + v72 = v66; + rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v72)); + _785 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v72, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_785)); + } else if (_725 === 6) { + v73 = (v66 << 24) >> 24; + rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v73)); + _795 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v73, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_795)); + } else if (_725 === 7) { + v74 = (v66 << 16) >> 16; + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v74)); + _805 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v74, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_805)); + } else if (_725 === 8) { + v75 = v66 | 0; + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v75)); + _815 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v75, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_815)); + } else if (_725 === 9) { + v76 = v66 as rt.i64; + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v76)); + _825 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v76, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_825)); + } else if (_725 === 10) { + v77 = v66 as rt.i128; + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v77)); + _835 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v77, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_835)); } else { - const v78 = v66 | 0; - rt.byteVecExtendFromSlice(out7, rt.isizeToBeBytes(v78)); - rt.byteVecExtendFromSlice(out7, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v78, f)))); + v78 = v66 | 0; + rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v78)); + _845 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v78, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_845)); } - } else if (value === 6) { - const data8 = data; - let buf7: Uint8Array = rt.bytes(1); - const n7 = rt.min(data8.length, buf7.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf7, 0, n7), rt.sliceRange(data8, 0, n7)); - const v79 = ([rt.i8FromBeBytes(buf7), rt.sliceRange(data8, n7)] as [rt.i8, Uint8Array])[0]; - const out8 = out; - const value8 = rt.u8Rem(to, 12); - if (value8 === 0) { - const v80 = v79 & 0xff; - rt.byteVecExtendFromSlice(out8, rt.u8ToBeBytes(v80)); - rt.byteVecExtendFromSlice(out8, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v80, f)))); - } else if (value8 === 1) { - const v81 = v79 & 0xffff; - rt.byteVecExtendFromSlice(out8, rt.u16ToBeBytes(v81)); - rt.byteVecExtendFromSlice(out8, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v81, f)))); - } else if (value8 === 2) { - const v82 = v79 >>> 0; - rt.byteVecExtendFromSlice(out8, rt.u32ToBeBytes(v82)); - rt.byteVecExtendFromSlice(out8, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v82, f)))); - } else if (value8 === 3) { - const v83 = rt.u64Cast(v79); - rt.byteVecExtendFromSlice(out8, rt.u64ToBeBytes(v83)); - rt.byteVecExtendFromSlice(out8, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v83, f)))); - } else if (value8 === 4) { - const v84 = rt.u128Cast(v79); - rt.byteVecExtendFromSlice(out8, rt.u128ToBeBytes(v84)); - rt.byteVecExtendFromSlice(out8, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v84, f)))); - } else if (value8 === 5) { - const v85 = v79 >>> 0; - rt.byteVecExtendFromSlice(out8, rt.usizeToBeBytes(v85)); - rt.byteVecExtendFromSlice(out8, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v85, f)))); - } else if (value8 === 6) { - const v86 = v79; - rt.byteVecExtendFromSlice(out8, rt.i8ToBeBytes(v86)); - rt.byteVecExtendFromSlice(out8, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v86, f)))); - } else if (value8 === 7) { - const v87 = v79 as rt.i16; - rt.byteVecExtendFromSlice(out8, rt.i16ToBeBytes(v87)); - rt.byteVecExtendFromSlice(out8, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v87, f)))); - } else if (value8 === 8) { - const v88 = v79 as rt.i32; - rt.byteVecExtendFromSlice(out8, rt.i32ToBeBytes(v88)); - rt.byteVecExtendFromSlice(out8, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v88, f)))); - } else if (value8 === 9) { - const v89 = v79 as rt.i64; - rt.byteVecExtendFromSlice(out8, rt.i64ToBeBytes(v89)); - rt.byteVecExtendFromSlice(out8, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v89, f)))); - } else if (value8 === 10) { - const v90 = v79 as rt.i128; - rt.byteVecExtendFromSlice(out8, rt.i128ToBeBytes(v90)); - rt.byteVecExtendFromSlice(out8, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v90, f)))); + } else if (_5 === 6) { + buf7 = Uint8Array.of(0); + n7 = rt.min(data.length, buf7.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf7, 0, n7), rt.sliceRange(data, 0, n7)); + v79 = ([rt.i8FromBeBytes(buf7), rt.sliceRange(data, n7)] as [rt.i8, Uint8Array])[0]; + _865 = rt.u8Rem(to, 12); + if (_865 === 0) { + v80 = v79 & 0xff; + rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v80)); + _875 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v80, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_875)); + } else if (_865 === 1) { + v81 = v79 & 0xffff; + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v81)); + _885 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v81, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_885)); + } else if (_865 === 2) { + v82 = v79 >>> 0; + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v82)); + _895 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v82, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_895)); + } else if (_865 === 3) { + v83 = rt.u64Cast(v79); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v83)); + _905 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v83, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_905)); + } else if (_865 === 4) { + v84 = rt.u128Cast(v79); + rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v84)); + _915 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v84, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_915)); + } else if (_865 === 5) { + v85 = v79 >>> 0; + rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v85)); + _925 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v85, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_925)); + } else if (_865 === 6) { + v86 = v79; + rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v86)); + _935 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v86, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_935)); + } else if (_865 === 7) { + v87 = v79 as rt.i16; + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v87)); + _945 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v87, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_945)); + } else if (_865 === 8) { + v88 = v79 as rt.i32; + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v88)); + _955 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v88, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_955)); + } else if (_865 === 9) { + v89 = v79 as rt.i64; + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v89)); + _965 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v89, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_965)); + } else if (_865 === 10) { + v90 = v79 as rt.i128; + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v90)); + _975 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v90, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_975)); } else { - const v91 = v79 as rt.isize; - rt.byteVecExtendFromSlice(out8, rt.isizeToBeBytes(v91)); - rt.byteVecExtendFromSlice(out8, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v91, f)))); + v91 = v79 as rt.isize; + rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v91)); + _985 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v91, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_985)); } - } else if (value === 7) { - const data9 = data; - let buf8: Uint8Array = rt.bytes(2); - const n8 = rt.min(data9.length, buf8.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf8, 0, n8), rt.sliceRange(data9, 0, n8)); - const v92 = ([rt.i16FromBeBytes(buf8), rt.sliceRange(data9, n8)] as [rt.i16, Uint8Array])[0]; - const out9 = out; - const value9 = rt.u8Rem(to, 12); - if (value9 === 0) { - const v93 = v92 & 0xff; - rt.byteVecExtendFromSlice(out9, rt.u8ToBeBytes(v93)); - rt.byteVecExtendFromSlice(out9, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v93, f)))); - } else if (value9 === 1) { - const v94 = v92 & 0xffff; - rt.byteVecExtendFromSlice(out9, rt.u16ToBeBytes(v94)); - rt.byteVecExtendFromSlice(out9, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v94, f)))); - } else if (value9 === 2) { - const v95 = v92 >>> 0; - rt.byteVecExtendFromSlice(out9, rt.u32ToBeBytes(v95)); - rt.byteVecExtendFromSlice(out9, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v95, f)))); - } else if (value9 === 3) { - const v96 = rt.u64Cast(v92); - rt.byteVecExtendFromSlice(out9, rt.u64ToBeBytes(v96)); - rt.byteVecExtendFromSlice(out9, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v96, f)))); - } else if (value9 === 4) { - const v97 = rt.u128Cast(v92); - rt.byteVecExtendFromSlice(out9, rt.u128ToBeBytes(v97)); - rt.byteVecExtendFromSlice(out9, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v97, f)))); - } else if (value9 === 5) { - const v98 = v92 >>> 0; - rt.byteVecExtendFromSlice(out9, rt.usizeToBeBytes(v98)); - rt.byteVecExtendFromSlice(out9, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v98, f)))); - } else if (value9 === 6) { - const v99 = (v92 << 24) >> 24; - rt.byteVecExtendFromSlice(out9, rt.i8ToBeBytes(v99)); - rt.byteVecExtendFromSlice(out9, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v99, f)))); - } else if (value9 === 7) { - const v100 = v92; - rt.byteVecExtendFromSlice(out9, rt.i16ToBeBytes(v100)); - rt.byteVecExtendFromSlice(out9, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v100, f)))); - } else if (value9 === 8) { - const v101 = v92 as rt.i32; - rt.byteVecExtendFromSlice(out9, rt.i32ToBeBytes(v101)); - rt.byteVecExtendFromSlice(out9, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v101, f)))); - } else if (value9 === 9) { - const v102 = v92 as rt.i64; - rt.byteVecExtendFromSlice(out9, rt.i64ToBeBytes(v102)); - rt.byteVecExtendFromSlice(out9, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v102, f)))); - } else if (value9 === 10) { - const v103 = v92 as rt.i128; - rt.byteVecExtendFromSlice(out9, rt.i128ToBeBytes(v103)); - rt.byteVecExtendFromSlice(out9, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v103, f)))); + } else if (_5 === 7) { + buf8 = rt.bytes(2); + n8 = rt.min(data.length, buf8.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf8, 0, n8), rt.sliceRange(data, 0, n8)); + v92 = ([rt.i16FromBeBytes(buf8), rt.sliceRange(data, n8)] as [rt.i16, Uint8Array])[0]; + _1005 = rt.u8Rem(to, 12); + if (_1005 === 0) { + v93 = v92 & 0xff; + rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v93)); + _1015 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v93, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1015)); + } else if (_1005 === 1) { + v94 = v92 & 0xffff; + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v94)); + _1025 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v94, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1025)); + } else if (_1005 === 2) { + v95 = v92 >>> 0; + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v95)); + _1035 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v95, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1035)); + } else if (_1005 === 3) { + v96 = rt.u64Cast(v92); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v96)); + _1045 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v96, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1045)); + } else if (_1005 === 4) { + v97 = rt.u128Cast(v92); + rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v97)); + _1055 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v97, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1055)); + } else if (_1005 === 5) { + v98 = v92 >>> 0; + rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v98)); + _1065 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v98, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1065)); + } else if (_1005 === 6) { + v99 = (v92 << 24) >> 24; + rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v99)); + _1075 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v99, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1075)); + } else if (_1005 === 7) { + v100 = v92; + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v100)); + _1085 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v100, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1085)); + } else if (_1005 === 8) { + v101 = v92 as rt.i32; + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v101)); + _1095 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v101, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1095)); + } else if (_1005 === 9) { + v102 = v92 as rt.i64; + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v102)); + _1105 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v102, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1105)); + } else if (_1005 === 10) { + v103 = v92 as rt.i128; + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v103)); + _1115 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v103, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1115)); } else { - const v104 = v92 as rt.isize; - rt.byteVecExtendFromSlice(out9, rt.isizeToBeBytes(v104)); - rt.byteVecExtendFromSlice(out9, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v104, f)))); + v104 = v92 as rt.isize; + rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v104)); + _1125 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v104, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1125)); } - } else if (value === 8) { - const data10 = data; - let buf9: Uint8Array = rt.bytes(4); - const n9 = rt.min(data10.length, buf9.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf9, 0, n9), rt.sliceRange(data10, 0, n9)); - const v105 = ([rt.i32FromBeBytes(buf9), rt.sliceRange(data10, n9)] as [rt.i32, Uint8Array])[0]; - const out10 = out; - const value10 = rt.u8Rem(to, 12); - if (value10 === 0) { - const v106 = v105 & 0xff; - rt.byteVecExtendFromSlice(out10, rt.u8ToBeBytes(v106)); - rt.byteVecExtendFromSlice(out10, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v106, f)))); - } else if (value10 === 1) { - const v107 = v105 & 0xffff; - rt.byteVecExtendFromSlice(out10, rt.u16ToBeBytes(v107)); - rt.byteVecExtendFromSlice(out10, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v107, f)))); - } else if (value10 === 2) { - const v108 = v105 >>> 0; - rt.byteVecExtendFromSlice(out10, rt.u32ToBeBytes(v108)); - rt.byteVecExtendFromSlice(out10, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v108, f)))); - } else if (value10 === 3) { - const v109 = rt.u64Cast(v105); - rt.byteVecExtendFromSlice(out10, rt.u64ToBeBytes(v109)); - rt.byteVecExtendFromSlice(out10, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v109, f)))); - } else if (value10 === 4) { - const v110 = rt.u128Cast(v105); - rt.byteVecExtendFromSlice(out10, rt.u128ToBeBytes(v110)); - rt.byteVecExtendFromSlice(out10, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v110, f)))); - } else if (value10 === 5) { - const v111 = v105 >>> 0; - rt.byteVecExtendFromSlice(out10, rt.usizeToBeBytes(v111)); - rt.byteVecExtendFromSlice(out10, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v111, f)))); - } else if (value10 === 6) { - const v112 = (v105 << 24) >> 24; - rt.byteVecExtendFromSlice(out10, rt.i8ToBeBytes(v112)); - rt.byteVecExtendFromSlice(out10, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v112, f)))); - } else if (value10 === 7) { - const v113 = (v105 << 16) >> 16; - rt.byteVecExtendFromSlice(out10, rt.i16ToBeBytes(v113)); - rt.byteVecExtendFromSlice(out10, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v113, f)))); - } else if (value10 === 8) { - const v114 = v105; - rt.byteVecExtendFromSlice(out10, rt.i32ToBeBytes(v114)); - rt.byteVecExtendFromSlice(out10, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v114, f)))); - } else if (value10 === 9) { - const v115 = v105 as rt.i64; - rt.byteVecExtendFromSlice(out10, rt.i64ToBeBytes(v115)); - rt.byteVecExtendFromSlice(out10, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v115, f)))); - } else if (value10 === 10) { - const v116 = v105 as rt.i128; - rt.byteVecExtendFromSlice(out10, rt.i128ToBeBytes(v116)); - rt.byteVecExtendFromSlice(out10, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v116, f)))); + } else if (_5 === 8) { + buf9 = rt.bytes(4); + n9 = rt.min(data.length, buf9.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf9, 0, n9), rt.sliceRange(data, 0, n9)); + v105 = ([rt.i32FromBeBytes(buf9), rt.sliceRange(data, n9)] as [rt.i32, Uint8Array])[0]; + _1145 = rt.u8Rem(to, 12); + if (_1145 === 0) { + v106 = v105 & 0xff; + rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v106)); + _1155 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v106, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1155)); + } else if (_1145 === 1) { + v107 = v105 & 0xffff; + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v107)); + _1165 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v107, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1165)); + } else if (_1145 === 2) { + v108 = v105 >>> 0; + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v108)); + _1175 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v108, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1175)); + } else if (_1145 === 3) { + v109 = rt.u64Cast(v105); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v109)); + _1185 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v109, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1185)); + } else if (_1145 === 4) { + v110 = rt.u128Cast(v105); + rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v110)); + _1195 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v110, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1195)); + } else if (_1145 === 5) { + v111 = v105 >>> 0; + rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v111)); + _1205 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v111, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1205)); + } else if (_1145 === 6) { + v112 = (v105 << 24) >> 24; + rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v112)); + _1215 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v112, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1215)); + } else if (_1145 === 7) { + v113 = (v105 << 16) >> 16; + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v113)); + _1225 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v113, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1225)); + } else if (_1145 === 8) { + v114 = v105; + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v114)); + _1235 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v114, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1235)); + } else if (_1145 === 9) { + v115 = v105 as rt.i64; + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v115)); + _1245 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v115, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1245)); + } else if (_1145 === 10) { + v116 = v105 as rt.i128; + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v116)); + _1255 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v116, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1255)); } else { - const v117 = v105 as rt.isize; - rt.byteVecExtendFromSlice(out10, rt.isizeToBeBytes(v117)); - rt.byteVecExtendFromSlice(out10, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v117, f)))); + v117 = v105 as rt.isize; + rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v117)); + _1265 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v117, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1265)); } - } else if (value === 9) { - const data11 = data; - let buf10: Uint8Array = rt.bytes(8); - const n10 = rt.min(data11.length, buf10.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf10, 0, n10), rt.sliceRange(data11, 0, n10)); - const v118 = ([rt.i64FromBeBytes(buf10), rt.sliceRange(data11, n10)] as [rt.i64, Uint8Array])[0]; - const out11 = out; - const value11 = rt.u8Rem(to, 12); - if (value11 === 0) { - const v119 = rt.i64Low(v118) & 0xff; - rt.byteVecExtendFromSlice(out11, rt.u8ToBeBytes(v119)); - rt.byteVecExtendFromSlice(out11, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v119, f)))); - } else if (value11 === 1) { - const v120 = rt.i64Low(v118) & 0xffff; - rt.byteVecExtendFromSlice(out11, rt.u16ToBeBytes(v120)); - rt.byteVecExtendFromSlice(out11, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v120, f)))); - } else if (value11 === 2) { - const v121 = rt.i64Low(v118); - rt.byteVecExtendFromSlice(out11, rt.u32ToBeBytes(v121)); - rt.byteVecExtendFromSlice(out11, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v121, f)))); - } else if (value11 === 3) { - const v122 = rt.u64Cast(v118); - rt.byteVecExtendFromSlice(out11, rt.u64ToBeBytes(v122)); - rt.byteVecExtendFromSlice(out11, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v122, f)))); - } else if (value11 === 4) { - const v123 = rt.u128Cast(v118); - rt.byteVecExtendFromSlice(out11, rt.u128ToBeBytes(v123)); - rt.byteVecExtendFromSlice(out11, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v123, f)))); - } else if (value11 === 5) { - const v124 = rt.i64Low(v118); - rt.byteVecExtendFromSlice(out11, rt.usizeToBeBytes(v124)); - rt.byteVecExtendFromSlice(out11, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v124, f)))); - } else if (value11 === 6) { - const v125 = (rt.i64Low(v118) << 24) >> 24; - rt.byteVecExtendFromSlice(out11, rt.i8ToBeBytes(v125)); - rt.byteVecExtendFromSlice(out11, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v125, f)))); - } else if (value11 === 7) { - const v126 = (rt.i64Low(v118) << 16) >> 16; - rt.byteVecExtendFromSlice(out11, rt.i16ToBeBytes(v126)); - rt.byteVecExtendFromSlice(out11, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v126, f)))); - } else if (value11 === 8) { - const v127 = rt.i64Low(v118) | 0; - rt.byteVecExtendFromSlice(out11, rt.i32ToBeBytes(v127)); - rt.byteVecExtendFromSlice(out11, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v127, f)))); - } else if (value11 === 9) { - const v128 = v118; - rt.byteVecExtendFromSlice(out11, rt.i64ToBeBytes(v128)); - rt.byteVecExtendFromSlice(out11, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v128, f)))); - } else if (value11 === 10) { - const v129 = rt.i128Cast(v118); - rt.byteVecExtendFromSlice(out11, rt.i128ToBeBytes(v129)); - rt.byteVecExtendFromSlice(out11, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v129, f)))); + } else if (_5 === 9) { + buf10 = rt.bytes(8); + n10 = rt.min(data.length, buf10.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf10, 0, n10), rt.sliceRange(data, 0, n10)); + v118 = ([rt.i64FromBeBytes(buf10), rt.sliceRange(data, n10)] as [rt.i64, Uint8Array])[0]; + _1285 = rt.u8Rem(to, 12); + if (_1285 === 0) { + v119 = rt.i64Low(v118) & 0xff; + rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v119)); + _1295 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v119, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1295)); + } else if (_1285 === 1) { + v120 = rt.i64Low(v118) & 0xffff; + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v120)); + _1305 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v120, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1305)); + } else if (_1285 === 2) { + v121 = rt.i64Low(v118); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v121)); + _1315 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v121, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1315)); + } else if (_1285 === 3) { + v122 = rt.u64Cast(v118); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v122)); + _1325 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v122, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1325)); + } else if (_1285 === 4) { + v123 = rt.u128Cast(v118); + rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v123)); + _1335 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v123, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1335)); + } else if (_1285 === 5) { + v124 = rt.i64Low(v118); + rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v124)); + _1345 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v124, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1345)); + } else if (_1285 === 6) { + v125 = (rt.i64Low(v118) << 24) >> 24; + rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v125)); + _1355 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v125, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1355)); + } else if (_1285 === 7) { + v126 = (rt.i64Low(v118) << 16) >> 16; + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v126)); + _1365 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v126, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1365)); + } else if (_1285 === 8) { + v127 = rt.i64Low(v118) | 0; + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v127)); + _1375 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v127, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1375)); + } else if (_1285 === 9) { + v128 = v118; + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v128)); + _1385 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v128, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1385)); + } else if (_1285 === 10) { + v129 = rt.i128Cast(v118); + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v129)); + _1395 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v129, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1395)); } else { - const v130 = rt.i64Low(v118) | 0; - rt.byteVecExtendFromSlice(out11, rt.isizeToBeBytes(v130)); - rt.byteVecExtendFromSlice(out11, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v130, f)))); + v130 = rt.i64Low(v118) | 0; + rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v130)); + _1405 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v130, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1405)); } - } else if (value === 10) { - const data12 = data; - let buf11: Uint8Array = rt.bytes(16); - const n11 = rt.min(data12.length, buf11.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf11, 0, n11), rt.sliceRange(data12, 0, n11)); - const v131 = ([rt.i128FromBeBytes(buf11), rt.sliceRange(data12, n11)] as [rt.i128, Uint8Array])[0]; - const out12 = out; - const value12 = rt.u8Rem(to, 12); - if (value12 === 0) { - const v132 = rt.i128Low(v131) & 0xff; - rt.byteVecExtendFromSlice(out12, rt.u8ToBeBytes(v132)); - rt.byteVecExtendFromSlice(out12, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v132, f)))); - } else if (value12 === 1) { - const v133 = rt.i128Low(v131) & 0xffff; - rt.byteVecExtendFromSlice(out12, rt.u16ToBeBytes(v133)); - rt.byteVecExtendFromSlice(out12, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v133, f)))); - } else if (value12 === 2) { - const v134 = rt.i128Low(v131); - rt.byteVecExtendFromSlice(out12, rt.u32ToBeBytes(v134)); - rt.byteVecExtendFromSlice(out12, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v134, f)))); - } else if (value12 === 3) { - const v135 = rt.u64Cast(v131); - rt.byteVecExtendFromSlice(out12, rt.u64ToBeBytes(v135)); - rt.byteVecExtendFromSlice(out12, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v135, f)))); - } else if (value12 === 4) { - const v136 = rt.u128Cast(v131); - rt.byteVecExtendFromSlice(out12, rt.u128ToBeBytes(v136)); - rt.byteVecExtendFromSlice(out12, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v136, f)))); - } else if (value12 === 5) { - const v137 = rt.i128Low(v131); - rt.byteVecExtendFromSlice(out12, rt.usizeToBeBytes(v137)); - rt.byteVecExtendFromSlice(out12, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v137, f)))); - } else if (value12 === 6) { - const v138 = (rt.i128Low(v131) << 24) >> 24; - rt.byteVecExtendFromSlice(out12, rt.i8ToBeBytes(v138)); - rt.byteVecExtendFromSlice(out12, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v138, f)))); - } else if (value12 === 7) { - const v139 = (rt.i128Low(v131) << 16) >> 16; - rt.byteVecExtendFromSlice(out12, rt.i16ToBeBytes(v139)); - rt.byteVecExtendFromSlice(out12, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v139, f)))); - } else if (value12 === 8) { - const v140 = rt.i128Low(v131) | 0; - rt.byteVecExtendFromSlice(out12, rt.i32ToBeBytes(v140)); - rt.byteVecExtendFromSlice(out12, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v140, f)))); - } else if (value12 === 9) { - const v141 = rt.i64Cast(v131); - rt.byteVecExtendFromSlice(out12, rt.i64ToBeBytes(v141)); - rt.byteVecExtendFromSlice(out12, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v141, f)))); - } else if (value12 === 10) { - const v142 = v131; - rt.byteVecExtendFromSlice(out12, rt.i128ToBeBytes(v142)); - rt.byteVecExtendFromSlice(out12, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v142, f)))); + } else if (_5 === 10) { + buf11 = rt.bytes(16); + n11 = rt.min(data.length, buf11.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf11, 0, n11), rt.sliceRange(data, 0, n11)); + v131 = ([rt.i128FromBeBytes(buf11), rt.sliceRange(data, n11)] as [rt.i128, Uint8Array])[0]; + _1425 = rt.u8Rem(to, 12); + if (_1425 === 0) { + v132 = rt.i128Low(v131) & 0xff; + rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v132)); + _1435 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v132, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1435)); + } else if (_1425 === 1) { + v133 = rt.i128Low(v131) & 0xffff; + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v133)); + _1445 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v133, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1445)); + } else if (_1425 === 2) { + v134 = rt.i128Low(v131); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v134)); + _1455 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v134, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1455)); + } else if (_1425 === 3) { + v135 = rt.u64Cast(v131); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v135)); + _1465 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v135, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1465)); + } else if (_1425 === 4) { + v136 = rt.u128Cast(v131); + rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v136)); + _1475 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v136, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1475)); + } else if (_1425 === 5) { + v137 = rt.i128Low(v131); + rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v137)); + _1485 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v137, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1485)); + } else if (_1425 === 6) { + v138 = (rt.i128Low(v131) << 24) >> 24; + rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v138)); + _1495 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v138, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1495)); + } else if (_1425 === 7) { + v139 = (rt.i128Low(v131) << 16) >> 16; + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v139)); + _1505 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v139, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1505)); + } else if (_1425 === 8) { + v140 = rt.i128Low(v131) | 0; + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v140)); + _1515 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v140, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1515)); + } else if (_1425 === 9) { + v141 = rt.i64Cast(v131); + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v141)); + _1525 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v141, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1525)); + } else if (_1425 === 10) { + v142 = v131; + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v142)); + _1535 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v142, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1535)); } else { - const v143 = rt.i128Low(v131) | 0; - rt.byteVecExtendFromSlice(out12, rt.isizeToBeBytes(v143)); - rt.byteVecExtendFromSlice(out12, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v143, f)))); + v143 = rt.i128Low(v131) | 0; + rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v143)); + _1545 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v143, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1545)); } } else { - const data13 = data; - let buf12: Uint8Array = rt.bytes(4); - const n12 = rt.min(data13.length, buf12.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf12, 0, n12), rt.sliceRange(data13, 0, n12)); - const v144 = ([rt.isizeFromBeBytes(buf12), rt.sliceRange(data13, n12)] as [rt.isize, Uint8Array])[0]; - const out13 = out; - const value13 = rt.u8Rem(to, 12); - if (value13 === 0) { - const v145 = v144 & 0xff; - rt.byteVecExtendFromSlice(out13, rt.u8ToBeBytes(v145)); - rt.byteVecExtendFromSlice(out13, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v145, f)))); - } else if (value13 === 1) { - const v146 = v144 & 0xffff; - rt.byteVecExtendFromSlice(out13, rt.u16ToBeBytes(v146)); - rt.byteVecExtendFromSlice(out13, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v146, f)))); - } else if (value13 === 2) { - const v147 = v144 >>> 0; - rt.byteVecExtendFromSlice(out13, rt.u32ToBeBytes(v147)); - rt.byteVecExtendFromSlice(out13, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v147, f)))); - } else if (value13 === 3) { - const v148 = rt.u64Cast(v144); - rt.byteVecExtendFromSlice(out13, rt.u64ToBeBytes(v148)); - rt.byteVecExtendFromSlice(out13, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v148, f)))); - } else if (value13 === 4) { - const v149 = rt.u128Cast(v144); - rt.byteVecExtendFromSlice(out13, rt.u128ToBeBytes(v149)); - rt.byteVecExtendFromSlice(out13, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v149, f)))); - } else if (value13 === 5) { - const v150 = v144 >>> 0; - rt.byteVecExtendFromSlice(out13, rt.usizeToBeBytes(v150)); - rt.byteVecExtendFromSlice(out13, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v150, f)))); - } else if (value13 === 6) { - const v151 = (v144 << 24) >> 24; - rt.byteVecExtendFromSlice(out13, rt.i8ToBeBytes(v151)); - rt.byteVecExtendFromSlice(out13, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v151, f)))); - } else if (value13 === 7) { - const v152 = (v144 << 16) >> 16; - rt.byteVecExtendFromSlice(out13, rt.i16ToBeBytes(v152)); - rt.byteVecExtendFromSlice(out13, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v152, f)))); - } else if (value13 === 8) { - const v153 = v144 as rt.i32; - rt.byteVecExtendFromSlice(out13, rt.i32ToBeBytes(v153)); - rt.byteVecExtendFromSlice(out13, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v153, f)))); - } else if (value13 === 9) { - const v154 = v144 as rt.i64; - rt.byteVecExtendFromSlice(out13, rt.i64ToBeBytes(v154)); - rt.byteVecExtendFromSlice(out13, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v154, f)))); - } else if (value13 === 10) { - const v155 = v144 as rt.i128; - rt.byteVecExtendFromSlice(out13, rt.i128ToBeBytes(v155)); - rt.byteVecExtendFromSlice(out13, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v155, f)))); + buf12 = rt.bytes(4); + n12 = rt.min(data.length, buf12.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf12, 0, n12), rt.sliceRange(data, 0, n12)); + v144 = ([rt.isizeFromBeBytes(buf12), rt.sliceRange(data, n12)] as [rt.isize, Uint8Array])[0]; + _1565 = rt.u8Rem(to, 12); + if (_1565 === 0) { + v145 = v144 & 0xff; + rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v145)); + _1575 = rt.fmtToString((f: rt.Formatter) => rt.u8Display(v145, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1575)); + } else if (_1565 === 1) { + v146 = v144 & 0xffff; + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v146)); + _1585 = rt.fmtToString((f: rt.Formatter) => rt.u16Display(v146, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1585)); + } else if (_1565 === 2) { + v147 = v144 >>> 0; + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v147)); + _1595 = rt.fmtToString((f: rt.Formatter) => rt.u32Display(v147, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1595)); + } else if (_1565 === 3) { + v148 = rt.u64Cast(v144); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v148)); + _1605 = rt.fmtToString((f: rt.Formatter) => rt.u64Display(v148, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1605)); + } else if (_1565 === 4) { + v149 = rt.u128Cast(v144); + rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v149)); + _1615 = rt.fmtToString((f: rt.Formatter) => rt.u128Display(v149, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1615)); + } else if (_1565 === 5) { + v150 = v144 >>> 0; + rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v150)); + _1625 = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v150, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1625)); + } else if (_1565 === 6) { + v151 = (v144 << 24) >> 24; + rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v151)); + _1635 = rt.fmtToString((f: rt.Formatter) => rt.i8Display(v151, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1635)); + } else if (_1565 === 7) { + v152 = (v144 << 16) >> 16; + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v152)); + _1645 = rt.fmtToString((f: rt.Formatter) => rt.i16Display(v152, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1645)); + } else if (_1565 === 8) { + v153 = v144 as rt.i32; + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v153)); + _1655 = rt.fmtToString((f: rt.Formatter) => rt.i32Display(v153, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1655)); + } else if (_1565 === 9) { + v154 = v144 as rt.i64; + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v154)); + _1665 = rt.fmtToString((f: rt.Formatter) => rt.i64Display(v154, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1665)); + } else if (_1565 === 10) { + v155 = v144 as rt.i128; + rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v155)); + _1675 = rt.fmtToString((f: rt.Formatter) => rt.i128Display(v155, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1675)); } else { - const v156 = v144; - rt.byteVecExtendFromSlice(out13, rt.isizeToBeBytes(v156)); - rt.byteVecExtendFromSlice(out13, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v156, f)))); + v156 = v144; + rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v156)); + _1685 = rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v156, f)); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_1685)); } } } /** Conversions that check, and ones that cannot fail. */ export function convert(data: Uint8Array, out: rt.ByteVec): void { - const data2 = data; - let buf: Uint8Array = rt.bytes(8); - const n = rt.min(data2.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data2, 0, n)); - const [wide, data3] = [rt.u64FromBeBytes(buf), rt.sliceRange(data2, n)] as [rt.u64, Uint8Array]; - const data4 = data3; - let buf2: Uint8Array = rt.bytes(4); - const n2 = rt.min(data4.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data4, 0, n2)); - const [signed, ] = [rt.i32FromBeBytes(buf2), rt.sliceRange(data4, n2)] as [rt.i32, Uint8Array]; + let wide!: rt.u64; + let _5!: [rt.u64, Uint8Array]; + let buf!: Uint8Array; + let n!: rt.usize; + let signed!: rt.i32; + let buf2!: Uint8Array; + let n2!: rt.usize; + let _31!: Uint8Array; + let _36!: rt.i32; + let _46!: rt.Result; + let _53!: rt.Result; + let _60!: rt.Result; + let widened!: rt.u64; + let into!: rt.i64; + let a!: rt.u8; + let b!: rt.u8; + let c!: rt.u8; + let d!: rt.u8; + let _86!: Uint8Array; + buf = rt.bytes(8); + n = rt.min(data.length, buf.length); + rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + _5 = [rt.u64FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.u64, Uint8Array]; + wide = _5[0]; + buf2 = rt.bytes(4); + n2 = rt.min(rt.sliceRange(data, n).length, buf2.length); + _31 = rt.sliceRange(buf2, 0, n2); + const slice = rt.sliceRange(data, n); + rt.sliceCopyFromSlice(_31, rt.sliceRange(slice, 0, n2)); + _36 = rt.i32FromBeBytes(buf2); + const slice2 = rt.sliceRange(data, n); + signed = ([_36, rt.sliceRange(slice2, n2)] as [rt.i32, Uint8Array])[0]; rt.byteVecPush(out, rt.u8TryFrom(wide).ok ? 1 : 0); - const tryFrom = rt.u32TryFrom(wide); - if (tryFrom.ok) { - const v = tryFrom.value; - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v)); + _46 = rt.u32TryFrom(wide); + if (_46.ok) { + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(_46.value)); } else { - rt.byteVecPush(out, 0xff); + rt.byteVecPush(out, 255); } - const tryFrom2 = rt.usizeTryFrom(signed); - if (tryFrom2.ok) { - const v2 = tryFrom2.value; - rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v2)); + _53 = rt.usizeTryFrom(signed); + if (_53.ok) { + rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(_53.value)); } else { - rt.byteVecPush(out, 0xfe); + rt.byteVecPush(out, 254); } - const tryFrom3 = rt.i8TryFrom(signed); - if (tryFrom3.ok) { - const v3 = tryFrom3.value; - rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v3)); + _60 = rt.i8TryFrom(signed); + if (_60.ok) { + rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(_60.value)); } else { - rt.byteVecPush(out, 0xfd); + rt.byteVecPush(out, 253); } - const widened = (rt.u64Low(wide) & 0xffff) as rt.u64; - const into = signed as rt.i64; + widened = (rt.u64Low(wide) & 0xffff) as rt.u64; + into = signed as rt.i64; rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(widened)); rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(into)); rt.byteVecPush(out, rt.u8Add(true ? 1 : 0, false ? 1 : 0)); - const toBeBytes = rt.u32ToBeBytes(signed >>> 0); - const a = toBeBytes[0]; - const b = toBeBytes[1]; - const c = toBeBytes[2]; - const d = toBeBytes[3]; + _86 = rt.u32ToBeBytes(signed >>> 0); + a = _86[0]; + b = _86[1]; + c = _86[2]; + d = _86[3]; rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes((a << 24) >> 24)); rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes((a << 8) | b)); rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes((((a << 8) | b) << 16) >> 16)); rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(((a << 24) | (b << 16) | (c << 8) | d) >>> 0)); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(((b & 0x3f) << 16) | (c << 8) | d)); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(((b & 63) << 16) | (c << 8) | d)); rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes((a << 24) | (c << 8) | d)); rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(0)); rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.u64FromBeBytes(Uint8Array.of(d, c, b, a, a, b, c, d)))); - const bytes = Uint8Array.of(d, c, b, a); - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(rt.i32FromBeBytes(bytes))); + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(rt.i32FromBeBytes(Uint8Array.of(d, c, b, a)))); rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(fromHalves(rt.u64Low(rt.u64Shr(wide, 32)), rt.u64Low(wide)))); - const narrow = rt.u64Or(rt.u64Shl((rt.u64Low(rt.u64Shr(wide, 40)) & 0xff) as rt.u64, 32), (rt.u64Low(wide) & 0xffff) as rt.u64); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(narrow)); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.u64FromHalves((rt.u64Low(rt.u64Shr(wide, 40)) & 0xff) as rt.u32, (rt.u64Low(wide) & 0xffff) as rt.u32))); } /** A `u64` from its high and low 32 bits, as moq-net's varints join them. */ export function fromHalves(hi: rt.u32, lo: rt.u32): rt.u64 { - return rt.u64Or(rt.u64Shl(hi as rt.u64, 32), lo as rt.u64); + return rt.u64FromHalves(hi, lo); } //# sourceMappingURL=ints.ts.map diff --git a/ts/fixtures/lang/expected/iters.Countdown.ts b/ts/fixtures/lang/expected/iters.Countdown.ts index 97dee3dfd..0783a2862 100644 --- a/ts/fixtures/lang/expected/iters.Countdown.ts +++ b/ts/fixtures/lang/expected/iters.Countdown.ts @@ -9,10 +9,11 @@ export interface Countdown { } export function next$Iterator(self: Countdown): rt.u8 | rt.Done { + let left!: rt.u8; if (self.left === 0) { return rt.DONE; } else { - const left = self.left; + left = self.left; self.left = rt.u8SaturatingSub(left, self.step); return left; } diff --git a/ts/fixtures/lang/expected/iters.Doubled.ts b/ts/fixtures/lang/expected/iters.Doubled.ts index 67fb2e11b..10eb2be27 100644 --- a/ts/fixtures/lang/expected/iters.Doubled.ts +++ b/ts/fixtures/lang/expected/iters.Doubled.ts @@ -8,10 +8,13 @@ export interface Doubled { } export function fmt$Debug(self: Doubled, f: rt.Formatter): rt.Result { - return rt.debugListFinish(rt.debugListEntries(rt.fmtDebugList(f), rt.iterMap(rt.iterSlice(self._0), (arg: rt.u8): rt.u16 => { - const b = arg; - return rt.u16Mul(b as rt.u16, 2); - }), rt.u16Display)); + let _5!: rt.DebugList; + let _6!: rt.Iter; + _5 = rt.fmtDebugList(f); + _6 = rt.iterMap(rt.iterSlice(self._0), (_2: rt.u8): rt.u16 => { + return rt.u16Mul(_2 as rt.u16, 2); + }); + return rt.debugListFinish(rt.debugListEntries(_5, _6, rt.u16Display)); } //# sourceMappingURL=iters.Doubled.ts.map diff --git a/ts/fixtures/lang/expected/iters.Evens.ts b/ts/fixtures/lang/expected/iters.Evens.ts index b9f888ef1..636ae85e4 100644 --- a/ts/fixtures/lang/expected/iters.Evens.ts +++ b/ts/fixtures/lang/expected/iters.Evens.ts @@ -8,15 +8,20 @@ export interface Evens { } export function next$Iterator(self: Evens): rt.u8 | rt.Done { - while (true) { - const next = self.inner.next(); - if (next === rt.DONE) { + let _2!: rt.u8 | rt.Done; + let b!: rt.u8; + l0: while (true) { + _2 = self.inner.next(); + if (_2 !== rt.DONE) { + b = _2; + if (!(rt.u8Rem(b, 2) === 0)) { + continue l0; + } else { + return b; + } + } else { return rt.DONE; } - const b = next; - if (rt.u8Rem(b, 2) === 0) { - return b; - } } } diff --git a/ts/fixtures/lang/expected/iters.Gaps.ts b/ts/fixtures/lang/expected/iters.Gaps.ts index f914498cb..995965c89 100644 --- a/ts/fixtures/lang/expected/iters.Gaps.ts +++ b/ts/fixtures/lang/expected/iters.Gaps.ts @@ -9,16 +9,20 @@ export interface Gaps { } export function next$Iterator(self: Gaps): rt.u8 | undefined | rt.Done { - const get = rt.sliceGet(self.data, self.at); - if (get === undefined) { + let b!: rt.u8; + let _3!: rt.u8 | undefined; + _3 = rt.sliceGet(self.data, self.at); + if (_3 !== undefined) { + b = _3; + self.at = rt.usizeAdd(self.at, 1); + if (!(b === 0)) { + return b; + } else { + return undefined; + } + } else { return rt.DONE; } - const b = get; - self.at = rt.usizeAdd(self.at, 1); - if (b === 0) { - return undefined; - } - return b; } //# sourceMappingURL=iters.Gaps.ts.map diff --git a/ts/fixtures/lang/expected/iters.Halving.ts b/ts/fixtures/lang/expected/iters.Halving.ts index 56d40c387..95fce4e88 100644 --- a/ts/fixtures/lang/expected/iters.Halving.ts +++ b/ts/fixtures/lang/expected/iters.Halving.ts @@ -12,16 +12,18 @@ export class Halving { } export function next$Iterator_u8(self: Halving): rt.u8 | rt.Done { - const value = self.value; + let value!: rt.u8; + value = self.value; self.value = rt.u8Div(self.value, 2); return rt.iterFromOption(rt.thenSome(value !== 0, value)); } export function next$Iterator_u64(self: Halving): rt.u64 | rt.Done { + let value!: rt.u64; if (self.value === 0) { return rt.DONE; } else { - const value = self.value; + value = self.value; self.value = rt.u64Shr(value, 1); return value; } diff --git a/ts/fixtures/lang/expected/iters.Held.ts b/ts/fixtures/lang/expected/iters.Held.ts index 643f634f2..9847eedb8 100644 --- a/ts/fixtures/lang/expected/iters.Held.ts +++ b/ts/fixtures/lang/expected/iters.Held.ts @@ -8,8 +8,8 @@ export interface Held { } export function skipOne(self: Held): rt.u8 { - rt.iterToOption(self.it.next()); - return rt.optionUnwrapOr(rt.iterToOption(self.it.next()), 0xbb); + self.it.next(); + return rt.optionUnwrapOr(rt.iterToOption(self.it.next()), 187); } //# sourceMappingURL=iters.Held.ts.map diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index 4a8175c49..8b17e10ec 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -13,336 +13,395 @@ import * as Wrapper from "./iters.Wrapper.ts"; /** Adaptor chains over the input bytes, each consumed one way. */ export function adaptors(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - const value = rt.u8Rem(kind, 8); - if (value === 0) { - const doubled = rt.iterToByteVec(rt.iterFilter(rt.iterMap(rt.iterSlice(data), (arg: rt.u8): rt.u8 => { - const b = arg; - return rt.u8Div(b, 2); - }), (b2: rt.u8): boolean => { - return rt.u8Rem(b2, 3) !== 0; - })); - rt.byteVecExtendFromSlice(out, rt.byteVecView(doubled)); - const small = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(data), (arg2: rt.u8): rt.u16 | undefined => { - const b3 = arg2; - return rt.thenSome(b3 < 100, rt.u16Mul(b3 as rt.u16, 200)); - })); - for (const v of small) { - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v)); - } - } else if (value === 1) { - const iter = rt.iterStepBy(rt.iterSkip(rt.iterEnumerate(rt.iterSlice(data)), 1), 2); - while (true) { - const item = iter.next(); - if (item === rt.DONE) { - break; - } - const i = item[0]; - const b4 = item[1]; - rt.byteVecPush(out, i & 0xff); - rt.byteVecPush(out, b4); - } - const iter2 = rt.iterTake(rt.iterEnumerate(rt.iterRev(rt.iterSlice(data))), 3); - while (true) { - const item2 = iter2.next(); - if (item2 === rt.DONE) { - break; + let _4!: rt.u8; + let doubled!: rt.ByteVec; + let iterS!: rt.u16[]; + let iterI!: number; + let _18!: rt.u16 | rt.Done; + let iter2!: rt.Iter<[rt.usize, rt.u8]>; + let _32!: [rt.usize, rt.u8] | rt.Done; + let i!: rt.usize; + let b!: rt.u8; + let iter3!: rt.Iter<[rt.usize, rt.u8]>; + let _46!: [rt.usize, rt.u8] | rt.Done; + let _56!: [Uint8Array, Uint8Array]; + let zipped!: rt.ByteVec; + let chained!: rt.ByteVec; + let taken!: rt.ByteVec; + let skipped!: rt.ByteVec; + let mapped!: rt.ByteVec; + let words!: rt.ByteVec[]; + let flat!: rt.ByteVec; + let it!: rt.Peekable; + let _118!: rt.u8 | rt.Done; + let b2!: rt.u8; + let run!: rt.u8; + let _133!: rt.u8 | undefined; + let it2!: rt.Iter; + let firsts!: rt.ByteVec; + let _152!: rt.u8 | undefined; + let rest!: rt.ByteVec; + let pairs!: Uint8Array[]; + let copies!: Uint8Array[]; + let iter4!: rt.Iter; + let _187!: Uint8Array | rt.Done; + let v2!: rt.u16[]; + let _196!: rt.Iter; + b0: { + _4 = rt.u8Rem(kind, 8); + if (_4 === 0) { + doubled = rt.iterToByteVec(rt.iterFilter(rt.iterMap(rt.iterSlice(data), (_216: rt.u8): rt.u8 => { + return rt.u8Div(_216, 2); + }), (b11: rt.u8): boolean => { + return rt.u8Rem(b11, 3) !== 0; + })); + rt.byteVecExtendFromSlice(out, rt.byteVecView(doubled)); + iterS = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(data), (_217: rt.u8): rt.u16 | undefined => { + let b12!: rt.u8; + b12 = _217; + return rt.thenSome(b12 < 100, rt.u16Mul(b12 as rt.u16, 200)); + })); + iterI = 0; + while (true) { + _18 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_18 === rt.DONE) { + break b0; + } else { + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(_18)); + } } - const i2 = item2[0]; - const b5 = item2[1]; - rt.byteVecPush(out, (i2 & 0xff) ^ b5); - } - } else if (value === 2) { - const [front, back] = rt.sliceSplitAt(data, rt.usizeDiv(data.length, 2)); - const zipped = rt.iterToByteVec(rt.iterMap(rt.iterZip(rt.iterSlice(front), rt.iterRev(rt.iterSlice(back))), (arg3: [rt.u8, rt.u8]): rt.u8 => { - const a = arg3[0]; - const b6 = arg3[1]; - return a ^ b6; - })); - rt.byteVecExtendFromSlice(out, rt.byteVecView(zipped)); - const chained = rt.iterToByteVec(rt.iterRev(rt.iterChain(rt.iterSlice(front), rt.iterSlice(back)))); - rt.byteVecExtendFromSlice(out, rt.byteVecView(chained)); - } else if (value === 3) { - const taken = rt.iterToByteVec(rt.iterTakeWhile(rt.iterSlice(data), (arg4: rt.u8): boolean => { - const b7 = arg4; - return b7 !== 0; - })); - const skipped = rt.iterToByteVec(rt.iterSkipWhile(rt.iterSlice(data), (arg5: rt.u8): boolean => { - const b8 = arg5; - return b8 < 0x80; - })); - const mapped = rt.iterToByteVec(rt.iterMapWhile(rt.iterSlice(data), (arg6: rt.u8): rt.u8 | undefined => { - const b9 = arg6; - return rt.u8CheckedAdd(b9, 0x40); - })); - rt.byteVecPush(out, taken.length & 0xff); - rt.byteVecPush(out, skipped.length & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteVecView(mapped)); - } else if (value === 4) { - const words = chunksByZero$ChunksByZero_u8s(data); - const flat = rt.iterToByteVec(rt.iterFlatMap(rt.iterSlice(words), (w: rt.ByteVec): rt.Iter => { - return rt.iterRev(rt.iterSlice(rt.byteVecView(w))); - })); - rt.byteVecExtendFromSlice(out, rt.byteVecView(flat)); - const nested = rt.iterFlatten(rt.iterMap(rt.iterSlice(words), (w2: rt.ByteVec): rt.Iter => { - return rt.iterMap(rt.iterSlice(rt.byteVecView(w2)), (arg7: rt.u8): rt.u8 => { - const b10 = arg7; - return rt.u8WrappingAdd(b10, 3); - }); - })); - rt.iterExtendBytes(out, rt.iterRev(nested)); - } else if (value === 5) { - let it: rt.Peekable = rt.iterPeekable(rt.iterSlice(data)); - while (true) { - const next = rt.iterToOption(it.next()); - if (next !== undefined) { - const b11 = next; - let run: rt.u8 = 1; - while (rt.peekableNextIf(it, (arg8: rt.u8): boolean => { - const next2 = arg8; - return next2 === b11; - }) !== undefined) { - run = rt.u8Add(run, 1); + } else if (_4 === 1) { + iter2 = rt.iterStepBy(rt.iterSkip(rt.iterEnumerate(rt.iterSlice(data)), 1), 2); + while (true) { + _32 = iter2.next(); + if (_32 === rt.DONE) { + iter3 = rt.iterTake(rt.iterEnumerate(rt.iterRev(rt.iterSlice(data))), 3); + while (true) { + _46 = iter3.next(); + if (_46 === rt.DONE) { + break b0; + } else { + rt.byteVecPush(out, (_46[0] & 0xff) ^ _46[1]); + } + } + } else { + i = _32[0]; + b = _32[1]; + rt.byteVecPush(out, i & 0xff); + rt.byteVecPush(out, b); } - rt.byteVecPush(out, b11); - rt.byteVecPush(out, run); - const peek = rt.peekablePeek(it); - if (peek !== undefined) { - const next3 = peek; - rt.byteVecPush(out, next3); + } + } else if (_4 === 2) { + _56 = rt.sliceSplitAt(data, rt.usizeDiv(data.length, 2)); + zipped = rt.iterToByteVec(rt.iterMap(rt.iterZip(rt.iterSlice(_56[0]), rt.iterRev(rt.iterSlice(_56[1]))), (_215: [rt.u8, rt.u8]): rt.u8 => { + return _215[0] ^ _215[1]; + })); + rt.byteVecExtendFromSlice(out, rt.byteVecView(zipped)); + chained = rt.iterToByteVec(rt.iterRev(rt.iterChain(rt.iterSlice(_56[0]), rt.iterSlice(_56[1])))); + rt.byteVecExtendFromSlice(out, rt.byteVecView(chained)); + } else if (_4 === 3) { + taken = rt.iterToByteVec(rt.iterTakeWhile(rt.iterSlice(data), (_212: rt.u8): boolean => { + return _212 !== 0; + })); + skipped = rt.iterToByteVec(rt.iterSkipWhile(rt.iterSlice(data), (_213: rt.u8): boolean => { + return _213 < 128; + })); + mapped = rt.iterToByteVec(rt.iterMapWhile(rt.iterSlice(data), (_214: rt.u8): rt.u8 | undefined => { + return rt.u8CheckedAdd(_214, 64); + })); + rt.byteVecPush(out, taken.length & 0xff); + rt.byteVecPush(out, skipped.length & 0xff); + rt.byteVecExtendFromSlice(out, rt.byteVecView(mapped)); + } else if (_4 === 4) { + words = chunksByZero$ChunksByZero_u8s(data); + flat = rt.iterToByteVec(rt.iterFlatMap(rt.iterSlice(words), (w: rt.ByteVec): rt.Iter => { + return rt.iterRev(rt.iterSlice(rt.byteVecView(w))); + })); + rt.byteVecExtendFromSlice(out, rt.byteVecView(flat)); + rt.iterExtendBytes(out, rt.iterRev(rt.iterFlatten(rt.iterMap(rt.iterSlice(words), (w2: rt.ByteVec): rt.Iter => { + return rt.iterMap(rt.iterSlice(rt.byteVecView(w2)), (_211: rt.u8): rt.u8 => { + return rt.u8WrappingAdd(_211, 3); + }); + })))); + } else if (_4 === 5) { + it = rt.iterPeekable(rt.iterSlice(data)); + l4: while (true) { + _118 = it.next(); + if (_118 !== rt.DONE) { + b2 = _118; + run = 1; + while (true) { + if (!((rt.peekableNextIf(it, (_210: rt.u8): boolean => { + return _210 === b2; + }) !== undefined))) { + rt.byteVecPush(out, b2); + rt.byteVecPush(out, run); + _133 = rt.peekablePeek(it); + if (_133 !== undefined) { + rt.byteVecPush(out, _133); + continue l4; + } else { + continue l4; + } + } else { + run = rt.u8Add(run, 1); + } + } + } else { + break b0; } + } + } else if (_4 === 6) { + it2 = rt.iterSlice(data); + firsts = rt.iterToByteVec(rt.iterTake(it2, 2)); + rt.byteVecExtendFromSlice(out, rt.byteVecView(firsts)); + rt.byteVecPush(out, it2.len() & 0xff); + _152 = rt.iterToOption(it2.nextBack()); + if (_152 === undefined) { + rt.byteVecPush(out, 238); } else { - break; + rt.byteVecPush(out, _152); } - } - } else if (value === 6) { - let it2: rt.Iter = rt.iterSlice(data); - const firsts = rt.iterToByteVec(rt.iterTake(it2, 2)); - rt.byteVecExtendFromSlice(out, rt.byteVecView(firsts)); - rt.byteVecPush(out, it2.len() & 0xff); - const nextBack = rt.iterToOption(it2.nextBack()); - if (nextBack !== undefined) { - const last = nextBack; - rt.byteVecPush(out, last); + rest = rt.iterToByteVec(rt.iterStepBy(rt.iterRev(it2), 3)); + rt.byteVecExtendFromSlice(out, rt.byteVecView(rest)); } else { - rt.byteVecPush(out, 0xee); - } - const rest = rt.iterToByteVec(rt.iterStepBy(rt.iterRev(it2), 3)); - rt.byteVecExtendFromSlice(out, rt.byteVecView(rest)); - } else { - const pairs = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (arg9: rt.u8): Uint8Array => { - const b12 = arg9; - return Uint8Array.of(b12, ~b12 & 0xff); - })); - let copies: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.iterSlice(pairs), rt.copy)); - if (!((copies.length === 0))) { - const value2 = copies[rt.idx(copies, 0)]; - value2[0] = 0x55; - } - const iter3 = rt.iterChain(rt.iterSlice(pairs), rt.iterSlice(copies)); - while (true) { - const pair = iter3.next(); - if (pair === rt.DONE) { - break; + pairs = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (_2: rt.u8): Uint8Array => { + let b3!: rt.u8; + b3 = _2; + return Uint8Array.of(b3, ~b3 & 0xff); + })); + copies = rt.iterToArray(rt.iterMap(rt.iterSlice(pairs), rt.copy)); + if (!((copies.length === 0))) { + const at = rt.idx(copies, 0); + copies[at][0] = 85; + } + iter4 = rt.iterChain(rt.iterSlice(pairs), rt.iterSlice(copies)); + while (true) { + _187 = iter4.next(); + if (_187 === rt.DONE) { + v2 = []; + _196 = rt.iterMap(rt.iterSlice(data), (_22: rt.u8): rt.u16 => { + return rt.u16Add(_22 as rt.u16, 1); + }); + rt.iterExtend(v2, _196); + rt.byteVecPush(out, v2.length & 0xff); + rt.iterExtendBytes(out, rt.iterFilter(rt.iterSlice(data), (_24: rt.u8): boolean => { + return _24 > 128; + })); + break b0; + } else { + rt.byteVecExtendFromSlice(out, _187); + } } - rt.byteVecExtendFromSlice(out, pair); } - let v2: rt.u16[] = []; - rt.iterExtend(v2, rt.iterMap(rt.iterSlice(data), (arg10: rt.u8): rt.u16 => { - const b13 = arg10; - return rt.u16Add(b13 as rt.u16, 1); - })); - rt.byteVecPush(out, v2.length & 0xff); - rt.iterExtendBytes(out, rt.iterFilter(rt.iterSlice(data), (arg11: rt.u8): boolean => { - const b14 = arg11; - return b14 > 0x80; - })); } } /** The runs between zero bytes. */ export function chunksByZero$ChunksByZero_u8s(self: Uint8Array): rt.ByteVec[] { - let words: rt.ByteVec[] = []; - let word: rt.ByteVec = new rt.ByteVec(); - for (const item of self) { - const b = item; - if (b === 0) { - const arg = words; - const taken = word; - word = new rt.ByteVec(); - arg.push(taken); + let words!: rt.ByteVec[]; + let word!: rt.ByteVec; + let iterS!: Uint8Array; + let iterI!: number; + let _6!: rt.u8 | rt.Done; + let b!: rt.u8; + let _13!: rt.ByteVec; + words = []; + word = new rt.ByteVec(); + iterS = self; + iterI = 0; + while (true) { + _6 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_6 === rt.DONE) { + words.push(word); + return words; } else { - rt.byteVecPush(word, b); + b = _6; + if (!(b === 0)) { + rt.byteVecPush(word, b); + } else { + const taken = word; + word = new rt.ByteVec(); + _13 = taken; + words.push(_13); + } } } - words.push(word); - return words; } /** Consumers, and how far each reads: `log` records every item a closure sees. */ export function consumers(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - let log: rt.ByteVec = new rt.ByteVec(); - const value = rt.u8Rem(kind, 6); - if (value === 0) { - const any = rt.iterAny(rt.iterInspect(rt.iterSlice(data), (arg: rt.u8): void => { - const b = arg; - rt.byteVecPush(log, b); - }), (arg2: rt.u8): boolean => { - const b2 = arg2; - return b2 > 0xf0; - }); - rt.byteVecPush(out, any ? 1 : 0); - const all = rt.iterAll(rt.iterSlice(data), (arg3: rt.u8): boolean => { - const b3 = arg3; - return b3 !== 0; - }); - rt.byteVecPush(out, all ? 1 : 0); - rt.byteVecPush(out, rt.iterCount(rt.iterSlice(data)) & 0xff); - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterSlice(data), (arg4: rt.u8): boolean => { - const b4 = arg4; - return rt.u8Rem(b4, 2) === 0; - })) & 0xff); - } else if (value === 1) { - const found = rt.iterFind(rt.iterInspect(rt.iterSlice(data), (arg5: rt.u8): void => { - const b5 = arg5; - rt.byteVecPush(log, b5); - }), (arg6: rt.u8): boolean => { - const b6 = arg6; - return rt.u8Rem(b6, 7) === 3; - }); - rt.byteVecPush(out, rt.optionUnwrapOr(found, 0xff)); - const mapped = rt.iterFindMap(rt.iterSlice(data), (arg7: rt.u8): rt.u8 | undefined => { - const b7 = arg7; - if (b7 > 0x50) { - return rt.u8CheckedMul(b7, 3); - } else { - return undefined; - } - }); - rt.byteVecPush(out, rt.optionUnwrapOr(mapped, 0)); - const position = rt.iterPosition(rt.iterSlice(data), (arg8: rt.u8): boolean => { - const b8 = arg8; - return b8 === 0x40; - }); - rt.byteVecPush(out, rt.optionMapOr(position, 0xff, (p: rt.usize): rt.u8 => { - return p & 0xff; - })); - const short = rt.sliceRange(data, rt.usizeDiv(data.length, 2)); - const logged = (b9: rt.u8): rt.u8 => { - return b9; - }; - const pairs = rt.iterCount(rt.iterZip(rt.iterMap(rt.iterSlice(data), (arg9: rt.u8): rt.u8 => { - const b10 = arg9; - rt.byteVecPush(log, b10); - return b10; - }), rt.iterSlice(short), true)); - rt.byteVecPush(out, pairs & 0xff); - const walked = rt.iterMap(rt.iterSlice(data), (arg10: rt.u8): rt.u8 => { - const b11 = arg10; - rt.byteVecPush(log, ~b11 & 0xff); - return b11; - }); - const iter = rt.iterZip(walked, rt.iterSlice(short), true); - while (true) { - const item = iter.next(); - if (item === rt.DONE) { - break; - } - const a = item[0]; - const b12 = item[1]; - rt.byteVecPush(out, a ^ b12); - } - const iter2 = rt.iterZip(rt.iterMap(rt.iterInspect(rt.iterSlice(data), (arg11: rt.u8): void => { - const b13 = arg11; - rt.byteVecPush(log, b13); - }), logged), rt.iterSlice(short)); - while (true) { - const item2 = iter2.next(); - if (item2 === rt.DONE) { - break; + let log!: rt.ByteVec; + let _5!: rt.u8; + let _9!: rt.Iter; + let _17!: rt.Iter; + let _31!: rt.Iter; + let _40!: rt.Iter; + let _45!: rt.Iter; + let short!: Uint8Array; + let iter!: rt.Iter<[rt.u8, rt.u8]>; + let _69!: [rt.u8, rt.u8] | rt.Done; + let iter2!: rt.Iter<[rt.u8, rt.u8]>; + let _85!: [rt.u8, rt.u8] | rt.Done; + let back!: rt.Iter<[rt.u8, rt.u8]>; + let _97!: [rt.u8, rt.u8] | undefined; + let a3!: rt.u8; + let b2!: rt.u8; + let _140!: rt.Iter; + let it!: rt.Iter; + let _147!: rt.Iter; + let _162!: rt.Iter; + let parsed!: rt.Result; + let v!: rt.ByteVec; + log = new rt.ByteVec(); + b0: { + _5 = rt.u8Rem(kind, 6); + if (_5 === 0) { + _9 = rt.iterInspect(rt.iterSlice(data), (_228: rt.u8): void => { + rt.byteVecPush(log, _228); + }); + rt.byteVecPush(out, rt.iterAny(_9, (_229: rt.u8): boolean => { + return _229 > 240; + }) ? 1 : 0); + _17 = rt.iterSlice(data); + rt.byteVecPush(out, rt.iterAll(_17, (_230: rt.u8): boolean => { + return _230 !== 0; + }) ? 1 : 0); + rt.byteVecPush(out, rt.iterCount(rt.iterSlice(data)) & 0xff); + rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterSlice(data), (_231: rt.u8): boolean => { + return rt.u8Rem(_231, 2) === 0; + })) & 0xff); + } else if (_5 === 1) { + _31 = rt.iterInspect(rt.iterSlice(data), (_220: rt.u8): void => { + rt.byteVecPush(log, _220); + }); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterFind(_31, (_221: rt.u8): boolean => { + return rt.u8Rem(_221, 7) === 3; + }), 255)); + _40 = rt.iterSlice(data); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterFindMap(_40, (_222: rt.u8): rt.u8 | undefined => { + let b14!: rt.u8; + b14 = _222; + if (!(b14 > 80)) { + return undefined; + } else { + return rt.u8CheckedMul(b14, 3); + } + }), 0)); + _45 = rt.iterSlice(data); + rt.byteVecPush(out, rt.optionMapOr(rt.iterPosition(_45, (_223: rt.u8): boolean => { + return _223 === 64; + }), 255, (p: rt.usize): rt.u8 => { + return p & 0xff; + })); + short = rt.sliceRange(data, rt.usizeDiv(data.length, 2)); + rt.byteVecPush(out, rt.iterCount(rt.iterZip(rt.iterMap(rt.iterSlice(data), (_224: rt.u8): rt.u8 => { + let b16!: rt.u8; + b16 = _224; + rt.byteVecPush(log, b16); + return b16; + }), rt.iterSlice(short), true)) & 0xff); + iter = rt.iterZip(rt.iterMap(rt.iterSlice(data), (_225: rt.u8): rt.u8 => { + let b17!: rt.u8; + b17 = _225; + rt.byteVecPush(log, ~b17 & 0xff); + return b17; + }), rt.iterSlice(short), true); + while (true) { + _69 = iter.next(); + if (_69 === rt.DONE) { + iter2 = rt.iterZip(rt.iterMap(rt.iterInspect(rt.iterSlice(data), (_226: rt.u8): void => { + rt.byteVecPush(log, _226); + }), (b19: rt.u8): rt.u8 => { + return b19; + }), rt.iterSlice(short)); + while (true) { + _85 = iter2.next(); + if (_85 === rt.DONE) { + back = rt.iterZip(rt.iterMap(rt.iterSlice(data), (_227: rt.u8): rt.u8 => { + return rotateFree$RotateFree_u8(_227); + }), rt.iterSlice(short), true); + _97 = rt.iterToOption(back.nextBack()); + if (_97 !== undefined) { + a3 = _97[0]; + b2 = _97[1]; + rt.byteVecPush(out, a3); + rt.byteVecPush(out, b2); + } + rt.byteVecPush(out, back.len() & 0xff); + break b0; + } else { + rt.byteVecPush(out, _85[0] ^ _85[1]); + } + } + } else { + rt.byteVecPush(out, _69[0] ^ _69[1]); + } } - const a2 = item2[0]; - const b14 = item2[1]; - rt.byteVecPush(out, a2 ^ b14); - } - let back: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSlice(data), (arg12: rt.u8): rt.u8 => { - const b15 = arg12; - return rotateFree$RotateFree_u8(b15); - }), rt.iterSlice(short), true); - const nextBack = rt.iterToOption(back.nextBack()); - if (nextBack !== undefined) { - const a3 = nextBack[0]; - const b16 = nextBack[1]; - rt.byteVecPush(out, a3); - rt.byteVecPush(out, b16); - } - rt.byteVecPush(out, back.len() & 0xff); - } else if (value === 2) { - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMax(rt.iterSlice(data)), 0)); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMin(rt.iterSlice(data)), 0xff)); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMaxByKey(rt.iterSlice(data), (arg13: rt.u8): rt.u8 => { - const b17 = arg13; - return rt.u8Rem(b17, 16); - }), 0xee)); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMinByKey(rt.iterSlice(data), (arg14: rt.u8): rt.u8 => { - const b18 = arg14; - return rt.u8Div(b18, 16); - }), 0xee)); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterLast(rt.iterSlice(data)), 0xdd)); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(rt.iterSlice(data), 3), 0xcc)); - let it: rt.Iter = rt.iterSlice(data); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterToOption(rt.iterTake(it, rt.usizeRem(data.length, 3)).nthBackItem(1)), 0xbb)); - rt.byteVecPush(out, it.len() & 0xff); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(rt.iterTake(it, rt.usizeRem(data.length, 5)), 2), 0xbb)); - rt.byteVecPush(out, it.len() & 0xff); - } else if (value === 3) { - const wide = rt.iterSum(rt.iterMap(rt.iterSlice(data), (arg15: rt.u8): rt.u64 => { - const b19 = arg15; - return rt.u64Mul(b19 as rt.u64, 0x0101_0101_0101); - }), rt.u64Add, 0); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(wide)); - const folded = rt.iterFold(rt.iterSlice(data), 0, (acc: rt.u32, arg16: rt.u8): rt.u32 => { - const b20 = arg16; - return rt.u32WrappingAdd((acc << 3) >>> 0, (b20 as rt.u32 ^ acc) >>> 0); - }); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(folded)); - rt.iterForEach(rt.iterSlice(data), (arg17: rt.u8): void => { - const b21 = arg17; - rt.byteVecPush(log, rotateFree$RotateFree_u8(b21)); - }); - } else if (value === 4) { - const total = rt.iterSum(rt.iterSlice(data), rt.u8Add, 0); - rt.byteVecPush(out, total); - const product = rt.iterProduct(rt.iterMap(rt.iterSlice(data), (arg18: rt.u8): rt.u16 => { - const b22 = arg18; - return rt.u16Add(rt.u16Rem(b22 as rt.u16, 4), 1); - }), rt.u16Mul, 1); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(product)); - } else { - const parsed = rt.iterCollectResult(rt.iterMap(rt.iterSlice(data), (arg19: rt.u8): rt.Result => { - const b23 = arg19; - if (b23 < 0xf0) { - return rt.Ok(b23); + } else if (_5 === 2) { + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMax(rt.iterSlice(data)), 0)); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMin(rt.iterSlice(data)), 255)); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMaxByKey(rt.iterSlice(data), (_218: rt.u8): rt.u8 => { + return rt.u8Rem(_218, 16); + }), 238)); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMinByKey(rt.iterSlice(data), (_219: rt.u8): rt.u8 => { + return rt.u8Div(_219, 16); + }), 238)); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterLast(rt.iterSlice(data)), 221)); + _140 = rt.iterSlice(data); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(_140, 3), 204)); + it = rt.iterSlice(data); + _147 = rt.iterTake(it, rt.usizeRem(data.length, 3)); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterToOption(_147.nthBackItem(1)), 187)); + rt.byteVecPush(out, it.len() & 0xff); + _162 = rt.iterTake(it, rt.usizeRem(data.length, 5)); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(_162, 2), 187)); + rt.byteVecPush(out, it.len() & 0xff); + } else if (_5 === 3) { + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.iterSum(rt.iterMap(rt.iterSlice(data), (_214: rt.u8): rt.u64 => { + return rt.u64Mul(_214 as rt.u64, 1103823438081); + }), rt.u64Add, 0))); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.iterFold(rt.iterSlice(data), 0, (acc: rt.u32, _34: rt.u8): rt.u32 => { + let b8!: rt.u8; + let _510!: rt.u32; + b8 = _34; + _510 = (acc << 3) >>> 0; + return rt.u32WrappingAdd(_510, (b8 as rt.u32 ^ acc) >>> 0); + }))); + rt.iterForEach(rt.iterSlice(data), (_216: rt.u8): void => { + rt.byteVecPush(log, rotateFree$RotateFree_u8(_216)); + }); + } else if (_5 === 4) { + rt.byteVecPush(out, rt.iterSum(rt.iterSlice(data), rt.u8Add, 0)); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(rt.iterProduct(rt.iterMap(rt.iterSlice(data), (_213: rt.u8): rt.u16 => { + return rt.u16Add(rt.u16Rem(_213 as rt.u16, 4), 1); + }), rt.u16Mul, 1))); + } else { + parsed = rt.iterCollectResult(rt.iterMap(rt.iterSlice(data), (_2: rt.u8): rt.Result => { + let b3!: rt.u8; + b3 = _2; + if (!(b3 < 240)) { + return rt.Err(b3); + } else { + return rt.Ok(b3); + } + }), (values__: rt.Iter) => rt.iterToByteVec(values__)); + if (parsed.ok) { + v = parsed.value; + rt.byteVecExtendFromSlice(out, rt.byteVecView(v)); } else { - return rt.Err(b23); + rt.byteVecPush(out, parsed.error); } - }), (values__: rt.Iter) => rt.iterToByteVec(values__)); - if (parsed.ok) { - const v = parsed.value; - rt.byteVecExtendFromSlice(out, rt.byteVecView(v)); - } else { - const e = parsed.error; - rt.byteVecPush(out, e); + rt.byteVecPush(out, rt.optionMapOr(rt.iterCollectOption(rt.iterMap(rt.iterInspect(rt.iterSlice(data), (_24: rt.u8): void => { + rt.byteVecPush(log, _24); + }), (_29: rt.u8): rt.u16 | undefined => { + let b5!: rt.u8; + b5 = _29; + return rt.thenSome(b5 !== 32, b5 as rt.u16); + }), (values__: rt.Iter) => rt.iterToArray(values__)), 255, (v2: rt.u16[]): rt.u8 => { + return v2.length & 0xff; + })); } - const some = rt.iterCollectOption(rt.iterMap(rt.iterInspect(rt.iterSlice(data), (arg20: rt.u8): void => { - const b24 = arg20; - rt.byteVecPush(log, b24); - }), (arg21: rt.u8): rt.u16 | undefined => { - const b25 = arg21; - return rt.thenSome(b25 !== 0x20, b25 as rt.u16); - }), (values__: rt.Iter) => rt.iterToArray(values__)); - rt.byteVecPush(out, rt.optionMapOr(some, 0xff, (v2: rt.u16[]): rt.u8 => { - return v2.length & 0xff; - })); } rt.byteVecExtendFromSlice(out, rt.byteVecView(log)); } @@ -353,99 +412,142 @@ export function rotateFree$RotateFree_u8(self: rt.u8): rt.u8 { /** Ranges as values and as iterators. */ export function ranges(data: Uint8Array, out: rt.ByteVec): void { - const a = rt.optionUnwrapOr(rt.sliceFirst(data), 0); - const b = rt.optionUnwrapOr(rt.sliceGet(data, 1), 0); - const range = new rt.Range(a, b); - rt.byteVecPush(out, range.start); - rt.byteVecPush(out, range.end); + let a!: rt.u8; + let b!: rt.u8; + let range!: rt.Range; + let copy!: rt.Range; + let iter!: rt.Iter; + let _37!: rt.u8 | rt.Done; + let iter2!: rt.Iter; + let _47!: rt.u8 | rt.Done; + let _56!: rt.Range; + let top!: rt.ByteVec; + let inclusive!: rt.RangeInclusive; + let near!: rt.RangeInclusive; + let low!: rt.RangeInclusive; + let _113!: rt.usize; + let _125!: rt.u8; + let reversed!: rt.RangeInclusive; + let _132!: rt.Iter; + let counted!: rt.Iter<[rt.usize, rt.u8]>; + let i3!: rt.usize; + let n!: rt.u8; + let _149!: [rt.usize, rt.u8]; + let _152!: rt.usize; + let stepped!: rt.RangeInclusive; + let wide!: rt.Range; + let edge!: rt.u64; + let past!: rt.Range; + let _223!: rt.usize; + let _240!: rt.RangeInclusive; + let _243!: rt.usize; + let _250!: rt.u64; + let iterS!: rt.u32[]; + let iterI!: number; + let _295!: rt.u32 | rt.Done; + a = rt.optionUnwrapOr(rt.sliceFirst(data), 0); + b = rt.optionUnwrapOr(rt.sliceGet(data, 1), 0); + range = new rt.Range(a, b); + rt.byteVecPush(out, a); + rt.byteVecPush(out, b); rt.byteVecPush(out, rt.rangeIsEmpty(range) ? 1 : 0); - rt.byteVecPush(out, rt.rangeContains(range, 0x40) ? 1 : 0); - let copy: rt.Range = rt.rangeClone(range); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterToOption(copy.next()), 0xff)); + rt.byteVecPush(out, rt.rangeContains(range, 64) ? 1 : 0); + copy = rt.rangeClone(range); + rt.byteVecPush(out, rt.optionUnwrapOr(copy.start < copy.end ? copy.start++ : undefined, 255)); rt.byteVecPush(out, range.len() & 0xff); - const iter = rt.iterStepBy(rt.iterRev(range), 3); - while (true) { - const i = iter.next(); - if (i === rt.DONE) { - break; - } - rt.byteVecPush(out, i); - } - const iter2 = rt.iterStepBy(rt.iterSkip(new rt.Range(a, b), 1), 4); + iter = rt.iterStepBy(rt.iterRev(range), 3); while (true) { - const i2 = iter2.next(); - if (i2 === rt.DONE) { - break; + _37 = iter.next(); + if (_37 === rt.DONE) { + iter2 = rt.iterStepBy(rt.iterSkip(new rt.Range(a, b), 1), 4); + while (true) { + _47 = iter2.next(); + if (_47 === rt.DONE) { + _56 = new rt.Range(a, b); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(_56, 5), 238)); + top = rt.iterToByteVec(new rt.RangeInclusive(rt.max(a, 250), 255, rt.u8Step)); + rt.byteVecExtendFromSlice(out, rt.byteVecView(top)); + inclusive = new rt.RangeInclusive(a, b, rt.u8Step); + rt.byteVecPush(out, rt.rangeInclusiveStart(inclusive)); + rt.byteVecPush(out, rt.rangeInclusiveEnd(inclusive)); + rt.byteVecPush(out, rt.rangeInclusiveContains(inclusive, b) ? 1 : 0); + rt.byteVecPush(out, rt.rangeInclusiveContains(new rt.RangeInclusive(32, 127, rt.u64Step), a as rt.u64) ? 1 : 0); + near = new rt.RangeInclusive(rt.max(a, 200), 255, rt.u8Step); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(near, b as rt.usize), 238)); + rt.byteVecPush(out, rt.rangeInclusiveStart(near)); + rt.byteVecPush(out, rt.rangeInclusiveIsEmpty(near) ? 1 : 0); + rt.byteVecPush(out, rt.rangeInclusiveContains(near, 255) ? 1 : 0); + rt.byteVecPush(out, rt.rangeInclusiveContains(near, 100) ? 1 : 0); + low = new rt.RangeInclusive(0, b, rt.u8Step); + _113 = rt.usizeRem(a as rt.usize, 16); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterToOption(low.nthBackItem(_113)), 238)); + rt.byteVecPush(out, rt.rangeInclusiveEnd(low)); + _125 = rt.u8Div(b, 2); + rt.byteVecPush(out, rt.rangeInclusiveContains(low, _125) ? 1 : 0); + reversed = new rt.RangeInclusive(a, b, rt.u8Step); + _132 = rt.iterRev(reversed); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(_132, a as rt.usize), 238)); + rt.byteVecPush(out, rt.rangeInclusiveEnd(reversed)); + rt.byteVecPush(out, rt.rangeInclusiveContains(reversed, a) ? 1 : 0); + counted = rt.iterEnumerate(new rt.RangeInclusive(a, b, rt.u8Step)); + _152 = rt.usizeDiv(b as rt.usize, 4); + _149 = rt.optionUnwrapOr(rt.iterNth(counted, _152), [221, 221] as [rt.usize, rt.u8]); + i3 = _149[0]; + n = _149[1]; + rt.byteVecPush(out, i3 & 0xff); + rt.byteVecPush(out, n); + rt.byteVecPush(out, rt.optionMapOr(rt.iterToOption(counted.next()), 204, (_2: [rt.usize, rt.u8]): rt.u8 => { + return _2[0] & 0xff; + })); + stepped = new rt.RangeInclusive(a, b, rt.u8Step); + rt.byteVecPush(out, rt.iterCount(rt.iterStepBy(stepped, 3)) & 0xff); + rt.byteVecPush(out, rt.rangeInclusiveStart(stepped)); + rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(new rt.RangeInclusive((a << 24) >> 24, (b << 24) >> 24, rt.i8Step)), (i5: rt.i8): rt.u8 => { + return i5 & 0xff; + })); + wide = new rt.Range(a as rt.u64, rt.u64Mul(b as rt.u64, 3), rt.u64Step); + rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterMap(wide, (n2: rt.u64): rt.u64 => { + return rt.u64Rem(n2, 5); + }), (_23: rt.u64): boolean => { + return _23 === 0; + })) & 0xff); + rt.byteVecPush(out, rt.rangeIsEmpty(wide) ? 1 : 0); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.iterSum(new rt.Range(0, a as rt.u64, rt.u64Step), rt.u64Add, 0))); + edge = rt.u64Add(rt.u64Sub(rt.u64Of(9007199254740992n), 2), rt.u64Rem(a as rt.u64, 4)); + past = new rt.Range(edge, rt.u64Add(edge, 4), rt.u64Step); + _223 = rt.usizeRem(b as rt.usize, 3); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterNth(past, _223), 0))); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterToOption(past.nextBack()), 0))); + _240 = new rt.RangeInclusive(edge, rt.u64Add(edge, 3), rt.u64Step); + _243 = rt.usizeRem(b as rt.usize, 5); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterNth(_240, _243), 0))); + _250 = rt.u64Rem(a as rt.u64, 3); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.iterSum(rt.iterMap(new rt.RangeInclusive(rt.u64Sub(rt.u64Of(18446744073709551615n), _250), rt.u64Of(18446744073709551615n), rt.u64Step), (n4: rt.u64): rt.u64 => { + return rt.u64Rem(n4, 7); + }), rt.u64Add, 0))); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterMaxByKey(rt.iterRev(new rt.RangeInclusive(edge, rt.u64Add(edge, 2), rt.u64Step)), (_24: rt.u64): rt.u64 => { + return _24; + }), 0))); + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(rt.optionUnwrapOr(rt.iterMin(new rt.Range(rt.i64Sub(rt.i64Neg(rt.i64Of(9007199254740992n)), 1), rt.i64Add(rt.i64Neg(rt.i64Of(9007199254740992n)), 1), rt.i64Step)), 0))); + iterS = rt.iterToArray(rt.iterRev(rt.iterStepBy(new rt.Range(0, 48), 8))); + iterI = 0; + while (true) { + _295 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_295 === rt.DONE) { + updates(a, b, data, out); + return; + } else { + rt.byteVecPush(out, _295 & 0xff); + } + } + } else { + rt.byteVecPush(out, _47); + } + } + } else { + rt.byteVecPush(out, _37); } - rt.byteVecPush(out, i2); - } - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(new rt.Range(a, b), 5), 0xee)); - const top = rt.iterToByteVec(new rt.RangeInclusive(rt.max(a, 250), 255, rt.u8Step)); - rt.byteVecExtendFromSlice(out, rt.byteVecView(top)); - const inclusive = new rt.RangeInclusive(a, b, rt.u8Step); - rt.byteVecPush(out, rt.rangeInclusiveStart(inclusive)); - rt.byteVecPush(out, rt.rangeInclusiveEnd(inclusive)); - rt.byteVecPush(out, rt.rangeInclusiveContains(inclusive, b) ? 1 : 0); - let near: rt.RangeInclusive = new rt.RangeInclusive(rt.max(a, 200), 255, rt.u8Step); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(near, b as rt.usize), 0xee)); - rt.byteVecPush(out, rt.rangeInclusiveStart(near)); - rt.byteVecPush(out, rt.rangeInclusiveIsEmpty(near) ? 1 : 0); - rt.byteVecPush(out, rt.rangeInclusiveContains(near, 255) ? 1 : 0); - rt.byteVecPush(out, rt.rangeInclusiveContains(near, 100) ? 1 : 0); - let low: rt.RangeInclusive = new rt.RangeInclusive(0, b, rt.u8Step); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterToOption(low.nthBackItem(rt.usizeRem(a as rt.usize, 16))), 0xee)); - rt.byteVecPush(out, rt.rangeInclusiveEnd(low)); - rt.byteVecPush(out, rt.rangeInclusiveContains(low, rt.u8Div(b, 2)) ? 1 : 0); - let reversed: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u8Step); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(rt.iterRev(reversed), a as rt.usize), 0xee)); - rt.byteVecPush(out, rt.rangeInclusiveEnd(reversed)); - rt.byteVecPush(out, rt.rangeInclusiveContains(reversed, a) ? 1 : 0); - let counted: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(new rt.RangeInclusive(a, b, rt.u8Step)); - const [i3, n] = rt.optionUnwrapOr(rt.iterNth(counted, rt.usizeDiv(b as rt.usize, 4)), [0xdd, 0xdd] as [rt.usize, rt.u8]); - rt.byteVecPush(out, i3 & 0xff); - rt.byteVecPush(out, n); - rt.byteVecPush(out, rt.optionMapOr(rt.iterToOption(counted.next()), 0xcc, (arg: [rt.usize, rt.u8]): rt.u8 => { - const i4 = arg[0]; - return i4 & 0xff; - })); - let stepped: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u8Step); - rt.byteVecPush(out, rt.iterCount(rt.iterStepBy(stepped, 3)) & 0xff); - rt.byteVecPush(out, rt.rangeInclusiveStart(stepped)); - const signed = new rt.RangeInclusive((a << 24) >> 24, (b << 24) >> 24, rt.i8Step); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(signed), (i5: rt.i8): rt.u8 => { - return i5 & 0xff; - })); - let wide: rt.Range = new rt.Range(a as rt.u64, rt.u64Mul(b as rt.u64, 3), rt.u64Step); - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterMap(wide, (n2: rt.u64): rt.u64 => { - return rt.u64Rem(n2, 5); - }), (arg2: rt.u64): boolean => { - const n3 = arg2; - return n3 === 0; - })) & 0xff); - rt.byteVecPush(out, rt.rangeIsEmpty(wide) ? 1 : 0); - const total = rt.iterSum(new rt.Range(0, a as rt.u64, rt.u64Step), rt.u64Add, 0); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(total)); - const edge = rt.u64Add(9007199254740990, rt.u64Rem(a as rt.u64, 4)); - let past: rt.Range = new rt.Range(edge, rt.u64Add(edge, 4), rt.u64Step); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterNth(past, rt.usizeRem(b as rt.usize, 3)), 0))); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterToOption(past.nextBack()), 0))); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterNth(new rt.RangeInclusive(edge, rt.u64Add(edge, 3), rt.u64Step), rt.usizeRem(b as rt.usize, 5)), 0))); - const top2 = rt.iterSum(rt.iterMap(new rt.RangeInclusive(rt.u64Sub(rt.u64Of(18446744073709551615n), rt.u64Rem(a as rt.u64, 3)), rt.u64Of(18446744073709551615n), rt.u64Step), (n4: rt.u64): rt.u64 => { - return rt.u64Rem(n4, 7); - }), rt.u64Add, 0); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(top2)); - const most = rt.optionUnwrapOr(rt.iterMaxByKey(rt.iterRev(new rt.RangeInclusive(edge, rt.u64Add(edge, 2), rt.u64Step)), (arg3: rt.u64): rt.u64 => { - const n5 = arg3; - return n5; - }), 0); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(most)); - const least = rt.optionUnwrapOr(rt.iterMin(new rt.Range(rt.i64Sub(rt.i64Neg(rt.i64Of(9007199254740992n)), 1), rt.i64Add(rt.i64Neg(rt.i64Of(9007199254740992n)), 1), rt.i64Step)), 0); - rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(least)); - const steps = rt.iterToArray(rt.iterRev(rt.iterStepBy(new rt.Range(0, 48), 8))); - for (const s of steps) { - rt.byteVecPush(out, s & 0xff); } - updates(a, b, data, out); } /** @@ -453,173 +555,224 @@ export function ranges(data: Uint8Array, out: rt.ByteVec): void { * the rest are read from it. */ export function updates(a: rt.u8, b: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - let base: rt.Range = new rt.Range(a, b); - rt.byteVecPush(out, 0xd0); - const field = rt.u8Div(b, 2); - rt.byteVecPush(out, 0xd1); - const range = rt.rangeClone(base); - const field2 = field; - const made = new rt.Range(range.start, field2); - const clone = rt.rangeClone(base); - const whole = new rt.Range(clone.start, clone.end); - rt.byteVecExtendFromSlice(out, Uint8Array.of(made.start, made.end, whole.start, whole.end)); - const start = rt.u8Div(a, 2); - const end = base.end; - for (let i = start; i < end; i++) { - base.end = rt.u8WrappingAdd(base.end, 1); - rt.byteVecPush(out, i); + let base!: rt.Range; + let made!: rt.Range; + let _7!: rt.u8; + let whole!: rt.Range; + let _14!: rt.Range; + let iterStart!: rt.u8; + let iterEnd!: rt.u8; + let _29!: rt.u8; + let i!: rt.u8; + let _33!: rt.u8; + let len!: rt.usize; + let to!: rt.usize; + let from!: rt.usize; + let _41!: [rt.usize, rt.usize]; + let all!: rt.Range; + let copied!: rt.ByteVec; + let _76!: Uint8Array; + base = new rt.Range(a, b); + rt.byteVecPush(out, 208); + _7 = rt.u8Div(b, 2); + rt.byteVecPush(out, 209); + made = new rt.Range(rt.rangeClone(base).start, _7); + _14 = rt.rangeClone(base); + whole = new rt.Range(_14.start, _14.end); + rt.byteVecExtendFromSlice(out, Uint8Array.of(made.start, _7, whole.start, whole.end)); + iterStart = rt.u8Div(a, 2); + iterEnd = base.end; + while (true) { + if (!((_29 = iterStart++) < iterEnd)) { + rt.byteVecPush(out, base.end); + len = data.length; + _41 = [rt.min(b as rt.usize, len), rt.min(a as rt.usize, len)] as [rt.usize, rt.usize]; + to = _41[0]; + from = _41[1]; + all = new rt.Range(0, len); + rt.byteVecPush(out, 210); + rt.byteVecPush(out, 211); + rt.byteVecPush(out, 212); + rt.byteVecExtendFromSlice(out, rt.sliceRange(data, from, rt.rangeClone(all).end)); + rt.byteVecPush(out, 213); + rt.byteVecPush(out, rt.sliceRange(data, 0).length & 0xff); + rt.byteVecPush(out, 214); + rt.byteVecPush(out, rt.sliceRange(data, 0).length & 0xff); + fullRange(out); + rt.byteVecPush(out, rt.sliceRange(data, 0).length & 0xff); + rt.byteVecPush(out, rt.sliceRange(data, 0).length & 0xff); + copied = rt.sliceToByteVec(data); + _76 = rt.byteVecView(copied); + rt.sliceCopyWithin(_76, 0, to, 0); + rt.byteVecExtendFromSlice(out, rt.byteVecView(copied)); + return; + } else { + i = _29; + _33 = rt.u8WrappingAdd(base.end, 1); + base.end = _33; + rt.byteVecPush(out, i); + } } - rt.byteVecPush(out, base.end); - const len = data.length; - const [to, from] = [rt.min(b as rt.usize, len), rt.min(a as rt.usize, len)] as [rt.usize, rt.usize]; - const all = new rt.Range(0, len); - rt.byteVecPush(out, 0xd2); - const arg = data; - rt.byteVecPush(out, 0xd3); - const field3 = from; - rt.byteVecPush(out, 0xd4); - const range2 = rt.rangeClone(all); - const sliced = rt.sliceRange(arg, field3, range2.end); - rt.byteVecExtendFromSlice(out, sliced); - const arg2 = data; - rt.byteVecPush(out, 0xd5); - const full = rt.sliceRange(arg2, 0); - rt.byteVecPush(out, full.length & 0xff); - const arg3 = data; - rt.byteVecPush(out, 0xd6); - const full2 = rt.sliceRange(arg3, 0); - rt.byteVecPush(out, full2.length & 0xff); - const arg4 = data; - fullRange(out); - const full3 = rt.sliceRange(arg4, 0); - rt.byteVecPush(out, full3.length & 0xff); - const full4 = rt.sliceRange(data, 0); - rt.byteVecPush(out, full4.length & 0xff); - let copied: rt.ByteVec = rt.sliceToByteVec(data); - const arg5 = rt.byteVecView(copied); - const field4 = to; - rt.sliceCopyWithin(arg5, all.start, field4, 0); - rt.byteVecExtendFromSlice(out, rt.byteVecView(copied)); } /** `..`, logging that it was made. */ export function fullRange(out: rt.ByteVec): undefined { - rt.byteVecPush(out, 0xd7); - return undefined; + rt.byteVecPush(out, 215); } /** Iterators of `Option`, which keep each `None` apart from their end. */ export function options(data: Uint8Array, out: rt.ByteVec): void { - const maybe = (b: rt.u8): rt.u8 | undefined => { - if (rt.u8Rem(b, 3) === 0) { - return undefined; + let all!: Array; + let iter!: rt.Iter; + let _15!: rt.u8 | undefined | rt.Done; + let item!: rt.u8 | undefined; + let flat!: rt.ByteVec; + let first!: rt.u8 | undefined; + let iter2!: rt.Iter; + let _49!: rt.u8 | rt.Done; + let _57!: rt.Iter; + let n!: rt.u8; + let counted!: rt.ByteVec; + let iter3!: Gaps.Gaps; + let _70!: rt.u8 | undefined | rt.Done; + all = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (b2: rt.u8): rt.u8 | undefined => { + if (!(rt.u8Rem(b2, 3) === 0)) { + return b2; } else { - return b; + return undefined; } - }; - const all = rt.iterToArray(rt.iterMap(rt.iterSlice(data), maybe)); + })); rt.byteVecPush(out, all.length & 0xff); - const iter = rt.iterMap(rt.iterSlice(data), maybe); - while (true) { - const item = iter.next(); - if (item === rt.DONE) { - break; - } - if (item !== undefined) { - const b2 = item; - rt.byteVecPush(out, b2); + iter = rt.iterMap(rt.iterSlice(data), (b3: rt.u8): rt.u8 | undefined => { + if (!(rt.u8Rem(b3, 3) === 0)) { + return b3; } else { - rt.byteVecPush(out, 0); - } - } - const flat = rt.iterToByteVec(rt.iterFlatten(rt.iterMap(rt.iterSlice(data), maybe), (value: rt.u8 | undefined) => rt.iterOption(value))); - rt.byteVecExtendFromSlice(out, rt.byteVecView(flat)); - const somes = rt.iterCount(rt.iterFilter(rt.iterSlice(all), (o: rt.u8 | undefined): boolean => { - return o !== undefined; - })); - rt.byteVecPush(out, somes & 0xff); - rt.byteVecPush(out, rt.optionUnwrapOr(second$Map_Iter_u8_options_closure0(rt.iterMap(rt.iterSlice(data), maybe)), 0xcd)); - const first = rt.sliceFirst(data); - const iter2 = rt.iterChain(rt.iterOption(first), rt.iterOnce(0x99)); - while (true) { - const b3 = iter2.next(); - if (b3 === rt.DONE) { - break; + return undefined; } - rt.byteVecPush(out, b3); - } - rt.iterExtendBytes(out, rt.iterChain(rt.iterOption(first), rt.iterEmpty())); - let n: rt.u8 = 0; - const counted = rt.iterToByteVec(rt.iterFromFn((): rt.u8 | undefined => { - n = rt.u8Add(n, 1); - return rt.thenSome(n < 4, n); - })); - rt.byteVecExtendFromSlice(out, rt.byteVecView(counted)); - const gaps = { data, at: 0 }; + }); while (true) { - const gap = Gaps.next$Iterator(gaps); - if (gap === rt.DONE) { - break; + _15 = iter.next(); + if (_15 === rt.DONE) { + flat = rt.iterToByteVec(rt.iterFlatten(rt.iterMap(rt.iterSlice(data), (b4: rt.u8): rt.u8 | undefined => { + if (!(rt.u8Rem(b4, 3) === 0)) { + return b4; + } else { + return undefined; + } + }), (value: rt.u8 | undefined) => rt.iterOption(value))); + rt.byteVecExtendFromSlice(out, rt.byteVecView(flat)); + rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterSlice(all), (o: rt.u8 | undefined): boolean => { + return o !== undefined; + })) & 0xff); + rt.byteVecPush(out, rt.optionUnwrapOr(second$Map_Iter_u8_options_closure0(rt.iterMap(rt.iterSlice(data), (b5: rt.u8): rt.u8 | undefined => { + if (!(rt.u8Rem(b5, 3) === 0)) { + return b5; + } else { + return undefined; + } + })), 205)); + first = rt.sliceFirst(data); + iter2 = rt.iterChain(rt.iterOption(first), rt.iterOnce(153)); + while (true) { + _49 = iter2.next(); + if (_49 === rt.DONE) { + _57 = rt.iterOption(first); + rt.iterEmpty(); + rt.iterExtendBytes(out, rt.iterChain(_57, rt.iterEmpty())); + n = 0; + counted = rt.iterToByteVec(rt.iterFromFn((): rt.u8 | undefined => { + n = rt.u8Add(n, 1); + return rt.thenSome(n < 4, n); + })); + rt.byteVecExtendFromSlice(out, rt.byteVecView(counted)); + iter3 = { data, at: 0 }; + while (true) { + _70 = Gaps.next$Iterator(iter3); + if (_70 === rt.DONE) { + return; + } else { + rt.byteVecPush(out, rt.optionMapOr(_70, 170, (b6: rt.u8): rt.u8 => { + return b6; + })); + } + } + } else { + rt.byteVecPush(out, _49); + } + } + } else { + item = _15; + if (item === undefined) { + rt.byteVecPush(out, 0); + } else { + rt.byteVecPush(out, item); + } } - rt.byteVecPush(out, rt.optionMapOr(gap, 0xaa, (b4: rt.u8): rt.u8 => { - return b4; - })); } } /** The second item of an iterator of options, through `?`, which tests for its end. */ export function second$Map_Iter_u8_options_closure0(items: rt.Iter): rt.u8 | undefined { - const next = items.next(); - if (next === rt.DONE) { - return undefined; - } - const next2 = items.next(); - if (next2 === rt.DONE) { + let _2!: rt.u8 | undefined | rt.Done; + let _7!: rt.u8 | undefined | rt.Done; + _2 = items.next(); + if (_2 !== rt.DONE) { + _7 = items.next(); + if (_7 !== rt.DONE) { + return rt.optionUnwrapOr(_7, 171); + } else { + return undefined; + } + } else { return undefined; } - const item = next2; - return rt.optionUnwrapOr(item, 0xab); } /** The crate's own iterators, through `for`, adaptors, and `next`. */ export function own(data: Uint8Array, out: rt.ByteVec): void { - const left = rt.optionUnwrapOr(rt.sliceFirst(data), 0); - const step = rt.max(rt.optionUnwrapOr(rt.sliceGet(data, 1), 1), 1); - const iter = { left, step }; - while (true) { - const n = Countdown.next$Iterator(iter); - if (n === rt.DONE) { - break; - } - rt.byteVecPush(out, n); - } - const total = rt.iterSum(rt.iterMap(rt.iterFrom({ left, step }, (it: Countdown.Countdown) => Countdown.next$Iterator(it)), (n2: rt.u8): rt.u64 => { - return rt.u64Div(rt.u64Mul(n2 as rt.u64, 1000), 7); - }), rt.u64Add, 0); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(total)); - let down: Countdown.Countdown = { left, step }; + let left!: rt.u8; + let step!: rt.u8; + let iter!: Countdown.Countdown; + let _13!: rt.u8 | rt.Done; + let down!: Countdown.Countdown; + let _26!: rt.u8 | rt.Done; + let evens!: rt.ByteVec; + let byRef!: Evens.Evens; + let firsts!: rt.ByteVec; + let halves!: rt.ByteVec; + left = rt.optionUnwrapOr(rt.sliceFirst(data), 0); + step = rt.max(rt.optionUnwrapOr(rt.sliceGet(data, 1), 1), 1); + iter = { left, step }; while (true) { - const next = rt.iterToOption(Countdown.next$Iterator(down)); - if (next !== undefined) { - const n3 = next; - if (rt.u8Rem(n3, 5) === 0) { - break; + _13 = Countdown.next$Iterator(iter); + if (_13 === rt.DONE) { + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.iterSum(rt.iterMap(rt.iterFrom({ left, step }, (it: Countdown.Countdown) => Countdown.next$Iterator(it)), (n3: rt.u8): rt.u64 => { + return rt.u64Div(rt.u64Mul(n3 as rt.u64, 1000), 7); + }), rt.u64Add, 0))); + down = { left, step }; + l1: while (true) { + _26 = Countdown.next$Iterator(down); + if (_26 !== rt.DONE) { + if (!(rt.u8Rem(_26, 5) === 0)) { + continue l1; + } + } + rt.byteVecPush(out, down.left); + evens = rt.iterToByteVec(rt.iterFrom({ inner: rt.iterSlice(data) }, (it: Evens.Evens) => Evens.next$Iterator(it))); + rt.byteVecExtendFromSlice(out, rt.byteVecView(evens)); + byRef = { inner: rt.iterSlice(rt.sliceRange(data, rt.min(data.length, 1))) }; + firsts = rt.iterToByteVec(rt.iterTake(rt.iterFrom(byRef, (it: Evens.Evens) => Evens.next$Iterator(it)), 2)); + rt.byteVecExtendFromSlice(out, rt.byteVecView(firsts)); + rt.byteVecPush(out, rt.iterCount(rt.iterFrom(byRef, (it: Evens.Evens) => Evens.next$Iterator(it))) & 0xff); + halves = rt.iterToByteVec(rt.iterFrom(new Halving.Halving({ value: left }), (it: Halving.Halving) => Halving.next$Iterator_u8(it))); + rt.byteVecExtendFromSlice(out, rt.byteVecView(halves)); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.iterSum(rt.iterFrom(new Halving.Halving({ value: rt.u64Mul(left as rt.u64, 4294967297) }), (it: Halving.Halving) => Halving.next$Iterator_u64(it)), rt.u64Add, 0))); + return; } } else { - break; + rt.byteVecPush(out, _13); } } - rt.byteVecPush(out, down.left); - const evens = rt.iterToByteVec(rt.iterFrom({ inner: rt.iterSlice(data) }, (it: Evens.Evens) => Evens.next$Iterator(it))); - rt.byteVecExtendFromSlice(out, rt.byteVecView(evens)); - let byRef: Evens.Evens = { inner: rt.iterSlice(rt.sliceRange(data, rt.min(data.length, 1))) }; - const firsts = rt.iterToByteVec(rt.iterTake(rt.iterFrom(byRef, (it: Evens.Evens) => Evens.next$Iterator(it)), 2)); - rt.byteVecExtendFromSlice(out, rt.byteVecView(firsts)); - rt.byteVecPush(out, rt.iterCount(rt.iterFrom(byRef, (it: Evens.Evens) => Evens.next$Iterator(it))) & 0xff); - const halves = rt.iterToByteVec(rt.iterFrom(new Halving.Halving({ value: left }), (it: Halving.Halving) => Halving.next$Iterator_u8(it))); - rt.byteVecExtendFromSlice(out, rt.byteVecView(halves)); - const total2 = rt.iterSum(rt.iterFrom(new Halving.Halving({ value: rt.u64Mul(left as rt.u64, 0x1_0000_0001) }), (it: Halving.Halving) => Halving.next$Iterator_u64(it)), rt.u64Add, 0); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(total2)); } /** @@ -639,67 +792,85 @@ export function odds(data: Uint8Array): rt.Iter { /** Iterators as values: returned, stored, and printed. */ export function values(data: Uint8Array, out: rt.ByteVec): void { - const iter = tail(Uint8Array.of(1, 2, 3), data); - while (true) { - const item = iter.next(); - if (item === rt.DONE) { - break; - } - const b = item; - rt.byteVecPush(out, b); - } - let held: Held.Held = { it: rt.iterSlice(data) }; - rt.byteVecPush(out, Held.skipOne(held)); - const iter2 = odds(data); - while (true) { - const b2 = iter2.next(); - if (b2 === rt.DONE) { - break; - } - rt.byteVecPush(out, b2); - } - const arg = { _0: data }; - const arg2 = { _0: rt.sliceRange(data, 0, rt.min(data.length, 2)) }; - const printed = rt.fmtFormat([(f: rt.Formatter) => Doubled.fmt$Debug(arg, f), "|", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => Doubled.fmt$Debug(arg2, f))]); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(printed)); - const tags = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (arg3: rt.u8): Tag.Tag => { - const b3 = arg3; - return { bytes: rt.sliceToByteVec(Uint8Array.of(b3, ~b3 & 0xff)) }; - })); - let cloned: Tag.Tag[] = rt.iterToArray(rt.iterMap(rt.iterSlice(tags), Tag.clone$Clone)); - const iter3 = rt.iterSlice(cloned); + let iter!: rt.Iter; + let _8!: rt.u8 | rt.Done; + let held!: Held.Held; + let iter2!: rt.Iter; + let _21!: rt.u8 | rt.Done; + let printed!: string; + let args2!: rt.Fmt[]; + let _39!: rt.Fmt; + let tags!: Tag.Tag[]; + let cloned!: Tag.Tag[]; + let iter3!: rt.Iter; + let _59!: Tag.Tag | rt.Done; + let iter4!: rt.Iter; + let _74!: Tag.Tag | rt.Done; + let bumps!: Bumped.Bumped[]; + let wrapped!: Wrapper.Wrapper[]; + iter = tail(Uint8Array.of(1, 2, 3), data); while (true) { - const tag = iter3.next(); - if (tag === rt.DONE) { - break; - } - rt.byteVecPush(tag.bytes, 0x77); - } - const iter4 = rt.iterChain(rt.iterSlice(tags), rt.iterSlice(cloned)); - while (true) { - const tag2 = iter4.next(); - if (tag2 === rt.DONE) { - break; + _8 = iter.next(); + if (_8 === rt.DONE) { + held = { it: rt.iterSlice(data) }; + rt.byteVecPush(out, Held.skipOne(held)); + iter2 = odds(data); + while (true) { + _21 = iter2.next(); + if (_21 === rt.DONE) { + [{ _0: data }, { _0: rt.sliceRange(data, 0, rt.min(data.length, 2)) }] as [Doubled.Doubled, Doubled.Doubled]; + const arg = { _0: data }; + _39 = (f: rt.Formatter) => Doubled.fmt$Debug(arg, f); + const arg2 = { _0: rt.sliceRange(data, 0, rt.min(data.length, 2)) }; + args2 = [_39, (f: rt.Formatter) => Doubled.fmt$Debug(arg2, f)]; + printed = rt.fmtFormat([args2[0], "|", rt.fmtSpec({ alternate: true }, args2[1])]); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(printed)); + tags = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (_2: rt.u8): Tag.Tag => { + let b3!: rt.u8; + b3 = _2; + return { bytes: rt.sliceToByteVec(Uint8Array.of(b3, ~b3 & 0xff)) }; + })); + cloned = rt.iterToArray(rt.iterMap(rt.iterSlice(tags), Tag.clone$Clone)); + iter3 = rt.iterSlice(cloned); + while (true) { + _59 = iter3.next(); + if (_59 === rt.DONE) { + iter4 = rt.iterChain(rt.iterSlice(tags), rt.iterSlice(cloned)); + while (true) { + _74 = iter4.next(); + if (_74 === rt.DONE) { + bumps = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (_22: rt.u8): Bumped.Bumped => { + return { _0: _22 }; + })); + rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(bumps), Bumped.clone$Clone), (b5: Bumped.Bumped): rt.u8 => { + return b5._0; + })); + rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(bumps), rt.copy), (b6: Bumped.Bumped): rt.u8 => { + return b6._0; + })); + wrapped = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (_23: rt.u8): Wrapper.Wrapper => { + return new Wrapper.Wrapper({ _0: _23 }); + })); + rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(wrapped), Wrapper.clone$Clone_Bumped), (w: Wrapper.Wrapper): rt.u8 => { + return w._0._0; + })); + return; + } else { + rt.byteVecExtendFromSlice(out, rt.byteVecView(_74.bytes)); + } + } + } else { + rt.byteVecPush(_59.bytes, 119); + } + } + } else { + rt.byteVecPush(out, _21); + } + } + } else { + rt.byteVecPush(out, _8); } - rt.byteVecExtendFromSlice(out, rt.byteVecView(tag2.bytes)); } - const bumps = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (arg4: rt.u8): Bumped.Bumped => { - const b4 = arg4; - return { _0: b4 }; - })); - rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(bumps), Bumped.clone$Clone), (b5: Bumped.Bumped): rt.u8 => { - return b5._0; - })); - rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(bumps), rt.copy), (b6: Bumped.Bumped): rt.u8 => { - return b6._0; - })); - const wrapped = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (arg5: rt.u8): Wrapper.Wrapper => { - const b7 = arg5; - return new Wrapper.Wrapper({ _0: b7 }); - })); - rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(wrapped), Wrapper.clone$Clone_Bumped), (w: Wrapper.Wrapper): rt.u8 => { - return w._0._0; - })); } //# sourceMappingURL=iters.ts.map diff --git a/ts/fixtures/lang/expected/shapes.Meters.ts b/ts/fixtures/lang/expected/shapes.Meters.ts index 538a61deb..343a34b72 100644 --- a/ts/fixtures/lang/expected/shapes.Meters.ts +++ b/ts/fixtures/lang/expected/shapes.Meters.ts @@ -13,7 +13,7 @@ export function area$Area(self: Meters): rt.u64 { /** A default method, monomorphized for each type. */ export function describe$Area(self: Meters, out: rt.ByteVec): void { - rt.byteVecPush(out, 0xaa); + rt.byteVecPush(out, 170); rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(self._0)); } diff --git a/ts/fixtures/lang/expected/shapes.Moved.ts b/ts/fixtures/lang/expected/shapes.Moved.ts index 8ea849406..4f4c7216d 100644 --- a/ts/fixtures/lang/expected/shapes.Moved.ts +++ b/ts/fixtures/lang/expected/shapes.Moved.ts @@ -3,7 +3,13 @@ import * as rt from "./rt.ts"; export function fmt$Debug(self: Moved, f: rt.Formatter): rt.Result { - return rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(rt.fmtDebugTuple(f, "Moved"), (f: rt.Formatter) => rt.u8Display(self._0, f)), (f: rt.Formatter) => rt.u16Display(self._1, f))); + let _3!: string; + let _4!: rt.Fmt; + let _6!: rt.Fmt; + _3 = "Moved"; + _4 = (f: rt.Formatter) => rt.u8Display(self._0, f); + _6 = (f: rt.Formatter) => rt.u16Display(self._1, f); + return rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4), _6)); } /** A tuple struct that is not `Copy`, so struct update syntax reads its base in place. */ diff --git a/ts/fixtures/lang/expected/shapes.Point.ts b/ts/fixtures/lang/expected/shapes.Point.ts index 578bdb159..795b24283 100644 --- a/ts/fixtures/lang/expected/shapes.Point.ts +++ b/ts/fixtures/lang/expected/shapes.Point.ts @@ -3,11 +3,25 @@ import * as rt from "./rt.ts"; export function fmt$Debug(self: Point, f: rt.Formatter): rt.Result { - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Point"), "x", (f: rt.Formatter) => rt.i32Display(self.x, f)), "y", (f: rt.Formatter) => rt.i32Display(self.y, f))); + let _3!: string; + let _4!: string; + let _5!: rt.Fmt; + let _7!: string; + let _8!: rt.Fmt; + _3 = "Point"; + _4 = "x"; + _5 = (f: rt.Formatter) => rt.i32Display(self.x, f); + _7 = "y"; + _8 = (f: rt.Formatter) => rt.i32Display(self.y, f); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function eq$PartialEq(self: Point, other: Point): boolean { - return self.x === other.x && self.y === other.y; + if (!(self.x === other.x)) { + return false; + } else { + return self.y === other.y; + } } /** A `Copy` struct, which Rust copies where JS would share. */ @@ -22,6 +36,7 @@ function new_(x: rt.i32, y: rt.i32): Point { /** Changes `self`, which a caller's copy must not see. */ export function shift(self: Point, by: rt.i32): Point { + self = rt.copy(self); self.x = rt.i32Add(self.x, by); return rt.copy(self); } diff --git a/ts/fixtures/lang/expected/shapes.Shape.ts b/ts/fixtures/lang/expected/shapes.Shape.ts index e9a1ea58d..eb4cafb82 100644 --- a/ts/fixtures/lang/expected/shapes.Shape.ts +++ b/ts/fixtures/lang/expected/shapes.Shape.ts @@ -4,17 +4,32 @@ import * as rt from "./rt.ts"; import * as Point from "./shapes.Point.ts"; export function fmt$Debug(self: Shape, f: rt.Formatter): rt.Result { + let _7!: string; + let _8!: rt.Fmt; + let _9!: rt.Fmt; + let _14!: string; + let _15!: string; + let _16!: rt.Fmt; + let _17!: string; + let _18!: rt.Fmt; + let _19!: string; + let _20!: rt.Fmt; if (self.tag === "Dot") { return rt.fmtWriteStr(f, "Dot"); } else if (self.tag === "Line") { - const __self0 = self._0; - const __self1 = self._1; - return rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(rt.fmtDebugTuple(f, "Line"), (f: rt.Formatter) => Point.fmt$Debug(__self0, f)), (f: rt.Formatter) => Point.fmt$Debug(__self1, f))); + _7 = "Line"; + _8 = (f: rt.Formatter) => Point.fmt$Debug(self._0, f); + _9 = (f: rt.Formatter) => Point.fmt$Debug(self._1, f); + return rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(rt.fmtDebugTuple(f, _7), _8), _9)); } else { - const __self02 = self.corner; - const __self12 = self.width; - const __self2 = self.height; - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Rect"), "corner", (f: rt.Formatter) => Point.fmt$Debug(__self02, f)), "width", (f: rt.Formatter) => rt.u16Display(__self12, f)), "height", (f: rt.Formatter) => rt.u16Display(__self2, f))); + _14 = "Rect"; + _15 = "corner"; + _16 = (f: rt.Formatter) => Point.fmt$Debug(self.corner, f); + _17 = "width"; + _18 = (f: rt.Formatter) => rt.u16Display(self.width, f); + _19 = "height"; + _20 = (f: rt.Formatter) => rt.u16Display(self.height, f); + return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _14), _15, _16), _17, _18), _19, _20)); } } @@ -31,13 +46,15 @@ export function describe$Area(self: Shape, out: rt.ByteVec): void { } export function area$Area(self: Shape): rt.u64 { + let width!: rt.u16; + let height!: rt.u16; if (self.tag === "Dot") { return 0; } else if (self.tag === "Line") { return 0; } else { - const width = self.width; - const height = self.height; + width = self.width; + height = self.height; return rt.u64Mul(width as rt.u64, height as rt.u64); } } diff --git a/ts/fixtures/lang/expected/shapes.Void.ts b/ts/fixtures/lang/expected/shapes.Void.ts index ed108a3d6..136df03fe 100644 --- a/ts/fixtures/lang/expected/shapes.Void.ts +++ b/ts/fixtures/lang/expected/shapes.Void.ts @@ -2,8 +2,8 @@ import * as rt from "./rt.ts"; -export function fmt$Debug(self: Void, _f: rt.Formatter): rt.Result { - rt.unreachable(self); +export function fmt$Debug(_self: Void, _f: rt.Formatter): rt.Result { + rt.unreachable(undefined); } /** An enum without variants: no value of it exists. */ diff --git a/ts/fixtures/lang/expected/shapes.ts b/ts/fixtures/lang/expected/shapes.ts index 23703598c..1ec7b3610 100644 --- a/ts/fixtures/lang/expected/shapes.ts +++ b/ts/fixtures/lang/expected/shapes.ts @@ -12,129 +12,216 @@ import * as Void from "./shapes.Void.ts"; import type * as Wide from "./shapes.Wide.ts"; export function total$Meters(items: Meters.Meters[], out: rt.ByteVec): rt.u64 { - let sum: rt.u64 = 0; - for (const item of items) { - Meters.describe$Area(item, out); - sum = rt.u64SaturatingAdd(sum, Meters.area$Area(item)); + let sum!: rt.u64; + let iterS!: Meters.Meters[]; + let iterI!: number; + let _6!: Meters.Meters | rt.Done; + sum = 0; + iterS = items; + iterI = 0; + while (true) { + _6 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_6 === rt.DONE) { + return sum; + } else { + Meters.describe$Area(_6, out); + sum = rt.u64SaturatingAdd(sum, Meters.area$Area(_6)); + } } - return sum; } export function total$Shape(items: Shape.Shape[], out: rt.ByteVec): rt.u64 { - let sum: rt.u64 = 0; - for (const item of items) { - Shape.describe$Area(item, out); - sum = rt.u64SaturatingAdd(sum, Shape.area$Area(item)); + let sum!: rt.u64; + let iterS!: Shape.Shape[]; + let iterI!: number; + let _6!: Shape.Shape | rt.Done; + sum = 0; + iterS = items; + iterI = 0; + while (true) { + _6 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_6 === rt.DONE) { + return sum; + } else { + Shape.describe$Area(_6, out); + sum = rt.u64SaturatingAdd(sum, Shape.area$Area(_6)); + } } - return sum; } export function from$From_Dir_u8(dir_: Dir.Dir): rt.u8 { - return { North: 1, East: 2, South: 4, West: 8 }[dir_]; + return { North: 1, East: 2, South: 4, West: 8 }[dir_] & 0xff; } export function dir(byte: rt.u8): Dir.Dir | undefined { - const value = rt.u8Rem(byte, 5); - if (value === 0) { - return "North"; - } else if (value === 1) { - return "East"; - } else if (value === 2) { - return "South"; - } else if (value === 3) { - return "West"; + let _2!: rt.u8; + _2 = rt.u8Rem(byte, 5); + if (_2 === 0) { + return "North" as Dir.Dir; + } else if (_2 === 1) { + return "East" as Dir.Dir; + } else if (_2 === 2) { + return "South" as Dir.Dir; + } else if (_2 === 3) { + return "West" as Dir.Dir; } else { return undefined; } } export function shape(data: Uint8Array): Shape.Shape { - const splitFirst = rt.sliceSplitFirst(data); - if (splitFirst === undefined) { - return { tag: "Dot" }; - } - const kind = splitFirst[0]; - const rest = splitFirst[1]; - const at = (i: rt.usize): rt.i32 => { - return rt.i32Sub(rt.optionUnwrapOr(rt.sliceGet(rest, i), 0) as rt.i32, 128); - }; - const value = rt.u8Rem(kind, 3); - if (value === 0) { - return { tag: "Dot" }; - } else if (value === 1) { - return { tag: "Line", _0: Point.new(at(0), at(1)), _1: Point.new(at(2), at(3)) }; + let kind!: rt.u8; + let _4!: [rt.u8, Uint8Array] | undefined; + let at!: (a0: rt.usize) => rt.i32; + let _7!: rt.u8; + _4 = rt.sliceSplitFirst(data); + if (_4 !== undefined) { + kind = _4[0]; + at = (i: rt.usize): rt.i32 => { + return rt.i32Sub(rt.optionUnwrapOr(rt.sliceGet(_4[1], i), 0) as rt.i32, 128); + }; + _7 = rt.u8Rem(kind, 3); + if (_7 === 0) { + return { tag: "Dot" } as Shape.Shape; + } else if (_7 === 1) { + return { tag: "Line", _0: Point.new(at(0), at(1)), _1: Point.new(at(2), at(3)) } as Shape.Shape; + } else { + return { tag: "Rect", corner: Point.new(at(0), at(1)), width: rt.u16Mul(rt.optionUnwrapOr(rt.sliceGet(_4[1], 2), 0) as rt.u16, 300), height: rt.optionUnwrapOr(rt.sliceGet(_4[1], 3), 0) as rt.u16 } as Shape.Shape; + } } else { - return { tag: "Rect", corner: Point.new(at(0), at(1)), width: rt.u16Mul(rt.optionUnwrapOr(rt.sliceGet(rest, 2), 0) as rt.u16, 300), height: rt.optionUnwrapOr(rt.sliceGet(rest, 3), 0) as rt.u16 }; + return { tag: "Dot" } as Shape.Shape; } } /** `Copy` aggregates: a copy changes apart from its original. */ export function copies(data: Uint8Array, out: rt.ByteVec): void { - const p = Point.new(rt.optionUnwrapOr(rt.sliceFirst(data), 0) as rt.i32, 7); - let q: Point.Point = rt.copy(p); - q.x = rt.i32Add(q.x, 100); + let p!: Point.Point; + let q!: Point.Point; + let _9!: rt.i32; + let r!: Point.Point; + let pair!: [Point.Point, rt.u8]; + let saved!: [Point.Point, rt.u8]; + let grid!: Point.Point[]; + let row!: Point.Point[]; + let _20!: Point.Point; + let _25!: rt.i32; + let _26!: rt.i32; + let _27!: rt.i32; + let _28!: rt.i32; + let _29!: rt.i32; + let _30!: rt.i32; + let _31!: rt.i32; + let _32!: rt.i32; + let _35!: rt.i32; + let iter!: rt.Iter; + let _42!: rt.i32 | rt.Done; + let a!: Point.Point; + let b!: Point.Point; + let old!: Point.Point; + let _66!: Point.Point; + let _71!: rt.u8; + let _73!: rt.u8; + let n!: rt.u32; + let both!: [rt.u32, rt.u32]; + let word!: Uint8Array; + let converted!: rt.u32; + let cell!: Uint8Array; + let source!: Uint8Array; + let returned!: Uint8Array; + let _128!: rt.u8; + let marked!: boolean; + let opt!: Meters.Meters | undefined; + let taken!: Meters.Meters | undefined; + let res!: rt.Result; + let first!: Point.Point; + let fail!: rt.Result; + let err!: Point.Point; + p = Point.new(rt.optionUnwrapOr(rt.sliceFirst(data), 0) as rt.i32, 7); + q = rt.copy(p); + _9 = rt.i32Add(q.x, 100); + q.x = _9; Point.bump(q); - const r = Point.shift(rt.copy(p), 5); - let pair: [Point.Point, rt.u8] = [rt.copy(p), 3]; - const saved = rt.copy(pair); + r = Point.shift(p, 5); + pair = [rt.copy(p), 3] as [Point.Point, rt.u8]; + saved = rt.copy(pair); pair[0].y = -1; pair[1] = rt.u8Add(pair[1], 1); - const point = rt.copy(p); - let grid: Point.Point[] = Array.from({ length: 3 }, (): Point.Point => { - return rt.copy(point); + const item = rt.copy(p); + grid = Array.from({ length: 3 }, (): Point.Point => { + return rt.copy(item); }); grid[1].x = 9; - const row = rt.copy(grid); - const value = rt.copy(q); - grid[2] = value; - for (const v of [p.x, p.y, q.x, q.y, r.x, saved[0].y, pair[0].y, row[1].x, row[2].x, grid[2].x]) { - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v)); + row = rt.copy(grid); + _20 = rt.copy(q); + grid[2] = rt.copy(_20); + _25 = p.x; + _26 = p.y; + _27 = q.x; + _28 = q.y; + _29 = r.x; + _30 = saved[0].y; + _31 = pair[0].y; + _32 = row[1].x; + _35 = row[2].x; + iter = rt.iterSlice([_25, _26, _27, _28, _29, _30, _31, _32, _35, grid[2].x]); + while (true) { + _42 = iter.next(); + if (_42 === rt.DONE) { + rt.byteVecPush(out, saved[1]); + rt.byteVecPush(out, pair[1]); + rt.byteVecPush(out, Point.eq$PartialEq(p, saved[0]) ? 1 : 0); + a = rt.copy(Point.new(1, 2)); + b = rt.copy(Point.new(3, 4)); + const swapped = a; + a = b; + b = swapped; + undefined; + _66 = Point.new(5, 6); + const old2 = a; + a = rt.copy(_66); + old = old2; + _71 = a.x & 0xff; + _73 = b.x & 0xff; + rt.byteVecExtendFromSlice(out, Uint8Array.of(_71, _73, old.x & 0xff)); + n = data.length as rt.u32; + both = [n, n] as [rt.u32, rt.u32]; + n = 9; + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32Add(rt.u32Add(both[0], both[1]), n))); + word = Uint8Array.of(0, 0, 0, data.length & 0xff); + converted = rt.u32FromBeBytes(word); + word[0] = 9; + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32Add(converted, word[0] as rt.u32))); + cell = Uint8Array.of(data.length & 0xff); + rt.byteVecPush(out, writeThenRead(rt.copy(cell), cell)); + source = Uint8Array.of(data.length & 0xff); + returned = same(rt.copy(source)); + source[0] = 9; + _128 = returned[0]; + rt.byteVecExtendFromSlice(out, Uint8Array.of(_128, source[0])); + rt.byteVecPush(out, copyThenWrite([data.length & 0xff, 0] as [rt.u8, rt.u8])); + marked = mark(out, 1) === 0; + mark(out, 2); + rt.byteVecPush(out, marked ? 1 : 0); + opt = rt.copy({ _0: 9 }); + const taken2 = opt; + opt = undefined; + taken = taken2; + rt.byteVecPush(out, opt === undefined ? 1 : 0); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionMapOr(taken, 0, (m: Meters.Meters): rt.u64 => { + return m._0; + }))); + res = rt.Ok(p); + first = rt.copy(rt.resultUnwrap(res, rt.u8Display)); + first.x = 2; + fail = rt.Err(rt.copy(q)); + err = rt.copy(rt.resultUnwrapErr(fail, rt.u8Display)); + err.y = 3; + rt.byteVecExtendFromSlice(out, Uint8Array.of(first.x & 0xff, rt.resultUnwrap(res, rt.u8Display).x & 0xff, err.y & 0xff, rt.resultUnwrapErr(fail, rt.u8Display).y & 0xff)); + return; + } else { + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(_42)); + } } - rt.byteVecPush(out, saved[1]); - rt.byteVecPush(out, pair[1]); - rt.byteVecPush(out, Point.eq$PartialEq(p, saved[0]) ? 1 : 0); - let a: Point.Point = Point.new(1, 2); - let b: Point.Point = Point.new(3, 4); - const swapped = a; - a = b; - b = swapped; - const old = a; - a = Point.new(5, 6); - const old2 = old; - rt.byteVecExtendFromSlice(out, Uint8Array.of(a.x & 0xff, b.x & 0xff, old2.x & 0xff)); - let n: rt.u32 = data.length as rt.u32; - const both = [n, n] as [rt.u32, rt.u32]; - n = 9; - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32Add(rt.u32Add(both[0], both[1]), n))); - let word: Uint8Array = Uint8Array.of(0, 0, 0, data.length & 0xff); - const converted = rt.u32FromBeBytes(word); - word[0] = 9; - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32Add(converted, word[0] as rt.u32))); - let cell: Uint8Array = Uint8Array.of(data.length & 0xff); - rt.byteVecPush(out, writeThenRead(rt.copy(cell), cell)); - let source: Uint8Array = Uint8Array.of(data.length & 0xff); - const returned = same(rt.copy(source)); - source[0] = 9; - rt.byteVecExtendFromSlice(out, Uint8Array.of(returned[0], source[0])); - rt.byteVecPush(out, copyThenWrite([data.length & 0xff, 0])); - const marked = mark(out, 1) === 0; - mark(out, 2); - rt.byteVecPush(out, marked ? 1 : 0); - let opt: Meters.Meters | undefined = { _0: 9 }; - const taken = opt; - opt = undefined; - const taken2 = taken; - rt.byteVecPush(out, opt === undefined ? 1 : 0); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionMapOr(rt.copy(taken2), 0, (m: Meters.Meters): rt.u64 => { - return m._0; - }))); - const res = rt.Ok(rt.copy(p)); - let first: Point.Point = rt.resultUnwrap(rt.copy(res), rt.u8Display); - first.x = 2; - const fail = rt.Err(rt.copy(q)); - let err: Point.Point = rt.resultUnwrapErr(rt.copy(fail), rt.u8Display); - err.y = 3; - rt.byteVecExtendFromSlice(out, Uint8Array.of(first.x & 0xff, rt.resultUnwrap(rt.copy(res), rt.u8Display).x & 0xff, err.y & 0xff, rt.resultUnwrapErr(rt.copy(fail), rt.u8Display).y & 0xff)); } /** `a`'s byte, after writing `b`'s. */ @@ -145,14 +232,16 @@ export function writeThenRead(a: Uint8Array, b: Uint8Array): rt.u8 { /** A copy of `a` read after `a` changes in place, which it doesn't see. */ export function copyThenWrite(a: [rt.u8, rt.u8]): rt.u8 { - const b = rt.copy(a); + let b!: [rt.u8, rt.u8]; + a = rt.copy(a); + b = rt.copy(a); a[0] = 9; return rt.u8WrappingAdd(b[0], a[0]); } /** `a` itself. */ export function same(a: Uint8Array): Uint8Array { - return rt.copy(a); + return a; } /** Logs `b`, returning how much is logged. */ @@ -166,46 +255,97 @@ export function mark(out: rt.ByteVec, b: rt.u8): rt.usize { * written: each field logs as it runs. */ export function order(data: Uint8Array, out: rt.ByteVec): void { - const at = (i: rt.usize): rt.u8 => { - return rt.optionUnwrapOr(rt.sliceGet(data, i), 0); + let at!: (a0: rt.usize) => rt.u8; + let rect!: Shape.Shape; + let _5!: rt.u16; + let _10!: rt.u16; + let _16!: rt.i32; + let _18!: rt.i32; + let line!: Shape.Shape; + let _21!: Point.Point; + let _24!: Point.Point; + let pair!: Pair.Pair; + let _28!: rt.i64; + let _30!: rt.u8; + let n!: Uint8Array; + let read!: Point.Point; + let _37!: rt.i32; + let _41!: rt.i32; + let base!: Moved.Moved; + let updated!: Moved.Moved; + let _49!: rt.u16; + let taken!: Shape.Shape; + let _57!: rt.u16; + let _59!: Point.Point; + let _63!: rt.usize; + let _64!: rt.usize; + let sum!: rt.usize; + let _70!: rt.usize; + let iterStart!: rt.usize; + let iterEnd!: rt.usize; + let _75!: rt.usize; + let len!: rt.usize; + let _82!: Uint8Array; + let _83!: Uint8Array; + let _85!: rt.usize; + let _87!: rt.usize; + let text!: string; + let _102!: Shape.Shape; + let _103!: rt.usize; + let args2!: rt.Fmt[]; + at = (i2: rt.usize): rt.u8 => { + return rt.optionUnwrapOr(rt.sliceGet(data, i2), 0); }; - const arg = mark(out, at(0)) & 0xffff; - const arg2 = mark(out, at(1)) & 0xffff; - const field = mark(out, 2) | 0; - const field2 = arg; - const field3 = arg2; - const rect = { tag: "Rect", corner: { x: mark(out, 3) | 0, y: field }, width: field3, height: field2 } as Shape.Shape; - const field4 = Point.new(mark(out, 4) | 0, 0); - const line = { tag: "Line", _0: Point.new(mark(out, 5) | 0, 0), _1: field4 } as Shape.Shape; - const field5 = mark(out, 6) as rt.i64; - const pair = { _0: mark(out, 7) & 0xff, _1: field5 }; - let n: Uint8Array = Uint8Array.of(at(2)); - const field6 = n[0] as rt.i32; - const read = { x: increment(n) as rt.i32, y: field6 }; - let base: Moved.Moved = { _0: at(4), _1: 0 }; - const field7 = reset(base); - const updated = { _0: base._0, _1: field7 }; - let taken: Shape.Shape; + _5 = mark(out, at(0)) & 0xffff; + _10 = mark(out, at(1)) & 0xffff; + _16 = mark(out, 2) | 0; + _18 = mark(out, 3) | 0; + rect = { tag: "Rect", corner: { x: _18, y: _16 }, width: _10, height: _5 } as Shape.Shape; + _21 = Point.new(mark(out, 4) | 0, 0); + _24 = Point.new(mark(out, 5) | 0, 0); + line = { tag: "Line", _0: _24, _1: _21 } as Shape.Shape; + _28 = mark(out, 6) as rt.i64; + _30 = mark(out, 7) & 0xff; + pair = { _0: _30, _1: _28 }; + n = Uint8Array.of(at(2)); + _37 = n[0] as rt.i32; + _41 = increment(n) as rt.i32; + read = { x: _41, y: _37 }; + base = { _0: at(4), _1: 0 }; + _49 = reset(base); + updated = { _0: base._0, _1: _49 }; if (rt.u8Rem(at(3), 2) === 0) { - const field8 = mark(out, 8) & 0xffff; - taken = { tag: "Rect", corner: Point.new(0, mark(out, 9) | 0), width: field8, height: 1 }; + _57 = mark(out, 8) & 0xffff; + _59 = Point.new(0, mark(out, 9) | 0); + taken = { tag: "Rect", corner: _59, width: _57, height: 1 } as Shape.Shape; } else { - taken = { tag: "Dot" }; + taken = { tag: "Dot" } as Shape.Shape; } - const field9 = mark(out, 10); - const range = new rt.Range(rt.usizeDiv(mark(out, 11), 2), field9); - let sum: rt.usize = 0; - const end = mark(out, 12); - for (let i2 = rt.usizeSub(mark(out, 13), 4); i2 < end; i2++) { - sum = rt.usizeAdd(sum, i2); + _63 = mark(out, 10); + _64 = rt.usizeDiv(mark(out, 11), 2); + new rt.Range(_64, _63); + sum = 0; + _70 = mark(out, 12); + iterStart = rt.usizeSub(mark(out, 13), 4); + iterEnd = _70; + while (true) { + if (!((_75 = iterStart++) < iterEnd)) { + len = data.length; + _83 = logged(data, out); + _85 = rt.min(mark(out, 14), len); + _87 = rt.usizeDiv(rt.min(mark(out, 15), len), 2); + _82 = rt.sliceRange(_83, _87, _85); + _102 = taken; + _103 = sum; + args2 = [(f: rt.Formatter) => Shape.fmt$Debug(rect, f), (f: rt.Formatter) => Shape.fmt$Debug(line, f), (f: rt.Formatter) => Pair.fmt$Debug(pair, f), (f: rt.Formatter) => Point.fmt$Debug(read, f), (f: rt.Formatter) => Moved.fmt$Debug(updated, f), (f: rt.Formatter) => Shape.fmt$Debug(_102, f), (f: rt.Formatter) => rt.usizeDisplay(_64, f), (f: rt.Formatter) => rt.usizeDisplay(_63, f), (f: rt.Formatter) => rt.usizeDisplay(_103, f), (f: rt.Formatter) => rt.fmtList(_82, f, rt.u8Display)]; + text = rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7], " ", args2[8], " ", args2[9]]); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(text)); + indexed(data, out); + return; + } else { + sum = rt.usizeAdd(sum, _75); + } } - const len = data.length; - const arg3 = logged(data, out); - const field10 = rt.min(mark(out, 14), len); - const slice = rt.sliceRange(arg3, rt.usizeDiv(rt.min(mark(out, 15), len), 2), field10); - const text = rt.fmtFormat([(f: rt.Formatter) => Shape.fmt$Debug(rect, f), " ", (f: rt.Formatter) => Shape.fmt$Debug(line, f), " ", (f: rt.Formatter) => Pair.fmt$Debug(pair, f), " ", (f: rt.Formatter) => Point.fmt$Debug(read, f), " ", (f: rt.Formatter) => Moved.fmt$Debug(updated, f), " ", (f: rt.Formatter) => Shape.fmt$Debug(taken, f), " ", (f: rt.Formatter) => rt.usizeDisplay(range.start, f), " ", (f: rt.Formatter) => rt.usizeDisplay(range.end, f), " ", (f: rt.Formatter) => rt.usizeDisplay(sum, f), " ", (f: rt.Formatter) => rt.fmtList(slice, f, rt.u8Display)]); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(text)); - indexed(data, out); } /** @@ -214,50 +354,67 @@ export function order(data: Uint8Array, out: rt.ByteVec): void { * earlier operand read. */ export function indexed(data: Uint8Array, out: rt.ByteVec): void { - const at = (i: rt.usize): rt.u8 => { + let at!: (a0: rt.usize) => rt.u8; + let first!: rt.u8; + let _7!: rt.ByteVec; + let bytes!: Uint8Array; + let _23!: Uint8Array; + let _30!: Uint8Array; + let _36!: Uint8Array; + let second!: rt.u8; + let _41!: Uint8Array; + let f!: (a0: rt.u8) => rt.u8; + let called!: rt.u8; + let _50!: (a0: rt.u8) => rt.u8; + let n!: rt.u8; + let slots!: Uint8Array; + let _58!: rt.u8; + let _68!: rt.u8; + at = (i: rt.usize): rt.u8 => { return rt.optionUnwrapOr(rt.sliceGet(data, i), 0); }; - const arg = rt.byteVecView(listed(out, at(0))); - rt.byteVecPush(out, 0xe1); - const first = rt.at(arg, 1); - let bytes: Uint8Array = Uint8Array.of(at(1), at(2), at(3), 4); - const arg2 = loggedMut(bytes, out); - rt.byteVecPush(out, 0xe3); - const arg3 = arg2; - rt.byteVecPush(out, 0xe4); - rt.sliceCopyWithin(arg3, 1, 3, 0); - const slice = loggedMut(bytes, out); - const arg4 = slice; - const arg5 = slice.length; - rt.byteVecPush(out, 0xe5); - rt.sliceCopyWithin(arg4, 2, arg5, 1); - const slice2 = loggedMut(bytes, out); - rt.sliceCopyWithin(slice2, 3, slice2.length, 0); - const value = logged(bytes, out); - rt.byteVecPush(out, 0xe6); - const second = rt.at(value, 1); - let f: (a0: rt.u8) => rt.u8 = halve; - const arg6 = f; + _7 = listed(out, at(0)); + rt.byteVecPush(out, 225); + const slice = rt.byteVecView(_7); + const at2 = rt.idx(slice, 1); + first = slice[at2]; + bytes = Uint8Array.of(at(1), at(2), at(3), 4); + _23 = loggedMut(bytes, out); + rt.byteVecPush(out, 227); + rt.byteVecPush(out, 228); + rt.sliceCopyWithin(_23, 1, 3, 0); + _30 = loggedMut(bytes, out); + rt.byteVecPush(out, 229); + rt.sliceCopyWithin(_30, 2, _30.length, 1); + _36 = loggedMut(bytes, out); + rt.sliceCopyWithin(_36, 3, _36.length, 0); + _41 = logged(bytes, out); + rt.byteVecPush(out, 230); + rt.idx(_41, 1); + second = _41[1]; + f = halve; + _50 = f; f = twice; - const called = arg6(at(4)); - let n: rt.u8 = at(5); - let slots: Uint8Array = rt.bytes(2); - const value2 = n; + called = _50(at(4)); + n = at(5); + slots = rt.bytes(2); + _58 = n; n = rt.u8WrappingAdd(n, 1); - slots[rt.idx(slots, 0)] = rt.u8Add(slots[rt.idx(slots, 0)], value2); - rt.byteVecExtendFromSlice(out, Uint8Array.of(first, second, called, f(1), slots[0], n)); + slots[0] = rt.u8Add(slots[0], _58); + _68 = f(1); + rt.byteVecExtendFromSlice(out, Uint8Array.of(first, second, called, _68, slots[0], n)); rt.byteVecExtendFromSlice(out, bytes); } /** A vector of `b`, logging that it was made. */ export function listed(out: rt.ByteVec, b: rt.u8): rt.ByteVec { - rt.byteVecPush(out, 0xe0); + rt.byteVecPush(out, 224); return rt.sliceToByteVec(Uint8Array.of(b, b ^ 1)); } /** `s`, logging that it was read. */ export function loggedMut(s: Uint8Array, out: rt.ByteVec): Uint8Array { - rt.byteVecPush(out, 0xe2); + rt.byteVecPush(out, 226); return s; } @@ -271,14 +428,15 @@ export function twice(b: rt.u8): rt.u8 { /** `data`, logging that it was read. */ export function logged(data: Uint8Array, out: rt.ByteVec): Uint8Array { - rt.byteVecPush(out, 0xee); + rt.byteVecPush(out, 238); return data; } /** `n`'s byte, incremented. */ export function increment(n: Uint8Array): rt.u8 { - const value = rt.u8WrappingAdd(n[0], 1); - n[0] = value; + let _2!: rt.u8; + _2 = rt.u8WrappingAdd(n[0], 1); + n[0] = _2; return n[0]; } @@ -290,21 +448,48 @@ export function reset(m: Moved.Moved): rt.u16 { /** Fieldless enums cast to every width, past their discriminant's range and sign. */ export function discriminants(data: Uint8Array, out: rt.ByteVec): void { - for (const item of data) { - const b = item; - const value = rt.u8Rem(b, 3); - const wide = value === 0 ? "Low" as Wide.Wide : value === 1 ? "High" as Wide.Wide : "Top" as Wide.Wide; - const value2 = rt.u8Rem(b, 3); - const signed = value2 === 0 ? "Neg" as Signed.Signed : value2 === 1 ? "Min" as Signed.Signed : "Pos" as Signed.Signed; - rt.byteVecPush(out, { Low: 1, High: 44, Top: 255 }[wide]); - rt.byteVecPush(out, { Low: 1, High: 44, Top: -1 }[wide] & 0xff); - rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes({ Low: 1, High: 300, Top: -1 }[wide])); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes({ Low: 1, High: 300, Top: 65535 }[wide])); - rt.byteVecPush(out, { Neg: 255, Min: 128, Pos: 100 }[signed]); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes({ Neg: 65535, Min: 65408, Pos: 100 }[signed])); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes({ Neg: 4294967295, Min: 4294967168, Pos: 100 }[signed])); - rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes({ Neg: -1, Min: -128, Pos: 100 }[signed])); - rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes({ Neg: rt.u128Of(340282366920938463463374607431768211455n), Min: rt.u128Of(340282366920938463463374607431768211328n), Pos: 100 }[signed])); + let iterS!: Uint8Array; + let iterI!: number; + let _5!: rt.u8 | rt.Done; + let b!: rt.u8; + let wide!: Wide.Wide; + let _10!: rt.u8; + let signed!: Signed.Signed; + let _13!: rt.u8; + iterS = data; + iterI = 0; + while (true) { + _5 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_5 === rt.DONE) { + return; + } else { + b = _5; + _10 = rt.u8Rem(b, 3); + if (_10 === 0) { + wide = "Low" as Wide.Wide; + } else if (_10 === 1) { + wide = "High" as Wide.Wide; + } else { + wide = "Top" as Wide.Wide; + } + _13 = rt.u8Rem(b, 3); + if (_13 === 0) { + signed = "Neg" as Signed.Signed; + } else if (_13 === 1) { + signed = "Min" as Signed.Signed; + } else { + signed = "Pos" as Signed.Signed; + } + rt.byteVecPush(out, { Low: 1, High: 300, Top: 65535 }[wide] & 0xff); + rt.byteVecPush(out, (({ Low: 1, High: 300, Top: 65535 }[wide] << 24) >> 24) & 0xff); + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(({ Low: 1, High: 300, Top: 65535 }[wide] << 16) >> 16)); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes({ Low: 1, High: 300, Top: 65535 }[wide] as rt.u64)); + rt.byteVecPush(out, { Neg: -1, Min: -128, Pos: 100 }[signed] & 0xff); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes({ Neg: -1, Min: -128, Pos: 100 }[signed] & 0xffff)); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes({ Neg: -1, Min: -128, Pos: 100 }[signed] >>> 0)); + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes({ Neg: -1, Min: -128, Pos: 100 }[signed] as rt.i64)); + rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(rt.u128Cast({ Neg: -1, Min: -128, Pos: 100 }[signed]))); + } } } @@ -313,107 +498,178 @@ export function discriminants(data: Uint8Array, out: rt.ByteVec): void { * and values of type `!`. */ export function loops(data: Uint8Array, out: rt.ByteVec): void { - let stack: rt.ByteVec = rt.sliceToByteVec(data); - let popped: rt.u32 = 0; - while (true) { - const pop = rt.byteVecPop(stack); - if (pop !== undefined) { - const top = pop; - if (top === 0) { - continue; + let stack!: rt.ByteVec; + let popped!: rt.u32; + let _5!: rt.u8 | undefined; + let top!: rt.u8; + let found!: [rt.usize, rt.usize] | undefined; + let iterStart!: rt.usize; + let iterEnd!: rt.usize; + let _24!: rt.usize; + let i!: rt.usize; + let iterStart2!: rt.usize; + let iterEnd2!: rt.usize; + let _34!: rt.usize; + let j!: rt.usize; + let _39!: rt.u8; + let i2!: rt.usize; + let j2!: rt.usize; + let n!: rt.u64; + let steps!: rt.u8; + let _65!: rt.u64; + let count!: rt.u8; + let iter3!: rt.RangeInclusive; + let _84!: rt.u8 | rt.Done; + let i3!: rt.i8; + let lo!: rt.i32; + let r!: rt.Range; + let first!: rt.i32 | undefined; + let second!: rt.i32 | undefined; + let iterStart3!: rt.i32; + let iterEnd3!: rt.i32; + let _124!: rt.i32; + let iterStart4!: rt.i8; + let iterEnd4!: rt.i8; + let _136!: rt.i8; + let _158!: (a0: rt.u8) => rt.u8; + _158 = (x3: rt.u8): rt.u8 => { + while (true) { + if (!(x3 < 10)) { + x3 = rt.u8Div(x3, 3); + } else { + return x3; } - const value = top as rt.u32; - popped = rt.u32Add(popped, value); - if (popped > 1000) { - break; + } + }; + stack = rt.sliceToByteVec(data); + popped = 0; + l0: while (true) { + _5 = rt.byteVecPop(stack); + if (_5 !== undefined) { + top = _5; + if (!(top === 0)) { + popped = rt.u32Add(popped, top as rt.u32); + if (!(popped > 1000)) { + continue l0; + } + } else { + continue l0; } - } else { - break; } - } - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(popped)); - let found: [rt.usize, rt.usize] | undefined = undefined; - const end = data.length; - loop2: for (let i = 0; i < end; i++) { - const start = rt.usizeAdd(i, 1); - const end2 = data.length; - for (let j = start; j < end2; j++) { - if (rt.at(data, i) === rt.at(data, j)) { - found = [i, j] as [rt.usize, rt.usize]; - break loop2; + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(popped)); + found = undefined; + iterStart = 0; + iterEnd = data.length; + l2: while (true) { + b3: { + if ((_24 = iterStart++) < iterEnd) { + i = _24; + iterStart2 = rt.usizeAdd(i, 1); + iterEnd2 = data.length; + while (true) { + if (!((_34 = iterStart2++) < iterEnd2)) { + continue l2; + } else { + j = _34; + rt.idx(data, i); + _39 = data[i]; + rt.idx(data, j); + if (!(_39 === data[j])) { + rt.idx(data, j); + if (data[j] === 0) { + continue l2; + } + } else { + found = [i, j] as [rt.usize, rt.usize]; + break b3; + } + } + } + } } - if (rt.at(data, j) === 0) { - continue loop2; + if (found === undefined) { + rt.byteVecPush(out, 255); + } else { + i2 = found[0]; + j2 = found[1]; + rt.byteVecExtendFromSlice(out, Uint8Array.of(i2 & 0xff, j2 & 0xff)); } - } - } - if (found !== undefined) { - const i2 = found[0]; - const j2 = found[1]; - rt.byteVecExtendFromSlice(out, Uint8Array.of(i2 & 0xff, j2 & 0xff)); - } else { - rt.byteVecPush(out, 0xff); - } - let n: rt.u64 = data.length as rt.u64; - let steps: rt.u8; - while (true) { - if (rt.u64Le(n, 1)) { - steps = 0; - break; - } - n = rt.u64Rem(n, 2) === 0 ? rt.u64Div(n, 2) : rt.u64Add(rt.u64Mul(3, n), 1); - if (rt.u64Gt(n, 100)) { - steps = 1; - break; - } - } - rt.byteVecPush(out, steps); - let count: rt.u8 = 0; - for (let _ = 0; _ <= 3; _++) { - count = rt.u8Add(count, 1); - } - let i3: rt.i8 = 10; - while (i3 > -3) { - i3 = rt.i8Sub(i3, 4); - count = rt.u8Add(count, 1); - } - rt.byteVecPush(out, count); - const lo = rt.i32Neg(rt.usizeRem(data.length, 4) | 0); - let r: rt.Range = new rt.Range(lo, rt.i32Add(lo, 3)); - const first = rt.iterToOption(r.next()); - r.end = r.start; - const second = rt.iterToOption(r.next()); - if (first !== undefined) { - const x = first; - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(x)); - } - if (second !== undefined) { - const x2 = second; - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(x2)); - } - for (let k = lo; k < 2; k++) { - rt.byteVecPush(out, k & 0xff); - } - for (let k2 = rt.i8Sub(124, (lo << 24) >> 24); k2 < 127; k2++) { - rt.byteVecPush(out, k2 & 0xff); - } - rt.byteVecPush(out, firstRepeat(data)); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(tailBreak(data))); - rt.byteVecPush(out, armLoop(data)); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(position$u8(data, 0) as rt.u32)); - const settle = (x3: rt.u8): rt.u8 => { - while (true) { - if (x3 < 10) { - return x3; + n = data.length as rt.u64; + l6: while (true) { + if (!rt.u64Le(n, 1)) { + if (!(rt.u64Rem(n, 2) === 0)) { + _65 = rt.u64Add(rt.u64Mul(3, n), 1); + } else { + _65 = rt.u64Div(n, 2); + } + n = _65; + if (!rt.u64Gt(n, 100)) { + continue l6; + } else { + steps = 1; + } + } else { + steps = 0; + } + rt.byteVecPush(out, steps); + count = 0; + iter3 = new rt.RangeInclusive(0, 3, rt.u8Step); + while (true) { + _84 = iter3.next(); + if (_84 === rt.DONE) { + i3 = 10; + while (true) { + if (!(i3 > -3)) { + rt.byteVecPush(out, count); + lo = rt.i32Neg(rt.usizeRem(data.length, 4) | 0); + r = new rt.Range(lo, rt.i32Add(lo, 3)); + first = r.start < r.end ? r.start++ : undefined; + r.end = r.start; + second = r.start < r.end ? r.start++ : undefined; + if (first !== undefined) { + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(first)); + } + if (second !== undefined) { + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(second)); + } + iterStart3 = lo; + iterEnd3 = 2; + while (true) { + if (!((_124 = iterStart3++) < iterEnd3)) { + iterStart4 = rt.i8Sub(124, (lo << 24) >> 24); + iterEnd4 = 127; + while (true) { + if (!((_136 = iterStart4++) < iterEnd4)) { + rt.byteVecPush(out, firstRepeat(data)); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(tailBreak(data))); + rt.byteVecPush(out, armLoop(data)); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(position$u8(data, 0) as rt.u32)); + rt.byteVecPush(out, _158(rt.u8Mul(data.length & 0xff, 7))); + drain(data, out); + rt.byteVecPush(out, returnedLoop(data)); + branchLoops(data, out); + diverging(data, out); + return; + } else { + rt.byteVecPush(out, _136 & 0xff); + } + } + } else { + rt.byteVecPush(out, _124 & 0xff); + } + } + } else { + i3 = rt.i8Sub(i3, 4); + count = rt.u8Add(count, 1); + } + } + } else { + count = rt.u8Add(count, 1); + } + } } - x3 = rt.u8Div(x3, 3); } - }; - rt.byteVecPush(out, settle(rt.u8Mul(data.length & 0xff, 7))); - drain(data, out); - rt.byteVecPush(out, returnedLoop(data)); - branchLoops(data, out); - diverging(data, out); + } } /** @@ -421,20 +677,26 @@ export function loops(data: Uint8Array, out: rt.ByteVec): void { * inputs run every case to its end. */ export function diverging(data: Uint8Array, out: rt.ByteVec): void { - const head = rt.sliceRange(data, 0, rt.min(data.length, 2)); - const b = rt.optionUnwrapOr(rt.sliceFirst(head), 0); - rt.byteVecPush(out, returnedNever(b, data.length)); - rt.byteVecPush(out, brokenNever(head)); - const check = (b2: rt.u8): rt.u8 => { - if (b2 === 0xfd) { - rt.panicFmt(["closure ", (f: rt.Formatter) => rt.u8Display(b2, f)]); + let head!: Uint8Array; + let b!: rt.u8; + let _15!: (a0: rt.u8) => rt.u8; + _15 = (b2: rt.u8): rt.u8 => { + let args2!: rt.Fmt[]; + if (!(b2 === 253)) { + return rt.u8Div(b2, 3); + } else { + const arg = ([b2] as [rt.u8])[0]; + args2 = [(f: rt.Formatter) => rt.u8Display(arg, f)]; + rt.panicFmt(["closure ", args2[0]]); } - return rt.u8Div(b2, 3); }; - rt.byteVecPush(out, check(b)); + head = rt.sliceRange(data, 0, rt.min(data.length, 2)); + b = rt.optionUnwrapOr(rt.sliceFirst(head), 0); + rt.byteVecPush(out, returnedNever(b, data.length)); + rt.byteVecPush(out, brokenNever(head)); + rt.byteVecPush(out, _15(b)); rt.byteVecPush(out, guardedReturn(head)); - const found = boundNever(head, out); - rt.byteVecPush(out, found); + rt.byteVecPush(out, boundNever(head, out)); rt.byteVecPush(out, closureNever(b)); genericNever(b, data.length); } @@ -444,33 +706,43 @@ export function diverging(data: Uint8Array, out: rt.ByteVec): void { * function made: a statement, a bound value, and the tail. */ export function closureNever(b: rt.u8): rt.u8 { - const fail: (a0: rt.u8) => never = (b2: rt.u8): never => { - rt.panicFmt(["closure failed on ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u8LowerHex(b2, f))]); + let x!: rt.u8; + let _2!: (a0: rt.u8) => never; + let ptr!: (a0: rt.u8) => never; + let _4!: (a0: rt.u8) => never; + _2 = (b2: rt.u8): never => { + let args2!: rt.Fmt[]; + const arg = ([b2] as [rt.u8])[0]; + args2 = [(f: rt.Formatter) => rt.u8LowerHex(arg, f)]; + rt.panicFmt(["closure failed on ", rt.fmtSpec({ alternate: true }, args2[0])]); }; - const ptr: (a0: rt.u8) => never = bail; - const made: (a0: rt.u8) => never = madeNever(); - if (b === 0xf5) { - fail(b); - } - let x: rt.u8; - if (b === 0xf4) { - ptr(b); - } else { - x = rt.u8Div(b, 5); - } - if (b === 243) { - fail(b); - } else if (b === 250) { - made(b); + _4 = madeNever(); + ptr = bail; + if (!(b === 245)) { + if (!(b === 244)) { + x = rt.u8Div(b, 5); + if (b === 243) { + _2(b); + } else if (b === 250) { + _4(b); + } else { + return x; + } + } else { + ptr(b); + } } else { - return x; + _2(b); } } /** A closure that never returns, made by a function. */ export function madeNever(): (a0: rt.u8) => never { return (b: rt.u8): never => { - rt.panicFmt(["made ", (f: rt.Formatter) => rt.u8Display(b, f)]); + let args2!: rt.Fmt[]; + const arg = ([b] as [rt.u8])[0]; + args2 = [(f: rt.Formatter) => rt.u8Display(arg, f)]; + rt.panicFmt(["made ", args2[0]]); }; } @@ -479,103 +751,127 @@ export function madeNever(): (a0: rt.u8) => never { * never exists: given one, and given an `Option` of none, which then calls one. */ export function genericNever(b: rt.u8, len: rt.usize): void { - if (b === 0xf1) { - pass$never(bail(b)); - } - if (b === 0xf6) { - let value: never; - rt.panicFmt(["passed ", (f: rt.Formatter) => rt.u8Display(b, f)]); - pass$never(value); - } - if (b === 0xf9) { - let o: never | undefined; - if (len > 1) { - o = undefined; + let args2!: rt.Fmt[]; + let args4!: rt.Fmt[]; + if (!(b === 241)) { + if (!(b === 246)) { + if (b === 249) { + if (!(len > 1)) { + const arg2 = ([b] as [rt.u8])[0]; + args4 = [(f: rt.Formatter) => rt.u8Display(arg2, f)]; + rt.panicFmt(["some ", args4[0]]); + } else { + unwrapOrBail$never(undefined, b); + } + } } else { - let value2: never; - rt.panicFmt(["some ", (f: rt.Formatter) => rt.u8Display(b, f)]); - o = value2; + const arg = ([b] as [rt.u8])[0]; + args2 = [(f: rt.Formatter) => rt.u8Display(arg, f)]; + rt.panicFmt(["passed ", args2[0]]); } - unwrapOrBail$never(o, b); + } else { + bail(b); } } -export function pass$never(x: never): never { - rt.unreachable(x); +export function pass$never(_: never): never { + rt.unreachable(undefined); } export function unwrapOrBail$never(o: never | undefined, b: rt.u8): never { - if (o !== undefined) { - const x = o; - pass$never(rt.unreachable(x)); - } else { + if (o === undefined) { bail(b); + } else { + pass$never(rt.unreachable(undefined)); + rt.unreachable(undefined); } } /** A function that never returns. */ export function bail(b: rt.u8): never { - rt.panicFmt(["failed on ", rt.fmtSpec({ alternate: true }, (f: rt.Formatter) => rt.u8LowerHex(b, f))]); + let args2!: rt.Fmt[]; + const arg = ([b] as [rt.u8])[0]; + args2 = [(f: rt.Formatter) => rt.u8LowerHex(arg, f)]; + rt.panicFmt(["failed on ", rt.fmtSpec({ alternate: true }, args2[0])]); } /** `return`, and `break` out of the function's labeled block, with values that never exist. */ export function returnedNever(b: rt.u8, len: rt.usize): rt.u8 { + let args2!: rt.Fmt[]; + let args4!: rt.Fmt[]; if (b === 247) { - rt.panicFmt(["returned ", (f: rt.Formatter) => rt.u8Display(b, f)]); + const arg2 = ([b] as [rt.u8])[0]; + args2 = [(f: rt.Formatter) => rt.u8Display(arg2, f)]; + rt.panicFmt(["returned ", args2[0]]); } else if (b === 248) { - if (rt.usizeRem(len, 2) === 0) { - rt.panicFmt(["then ", (f: rt.Formatter) => rt.u8Display(b, f)]); - } else { - bail(b); - } - } - { - if (b === 0xfe) { + if (!(rt.usizeRem(len, 2) === 0)) { bail(b); + } else { + const arg = ([b] as [rt.u8])[0]; + args4 = [(f: rt.Formatter) => rt.u8Display(arg, f)]; + rt.panicFmt(["then ", args4[0]]); } - return b ^ 0x11; + } else if (!(b === 254)) { + return b ^ 17; + } else { + bail(b); } } /** A `return` of a `match` that guards, whose arms fall through to the next. */ export function guardedReturn(data: Uint8Array): rt.u8 { + let a!: rt.u8; + let b!: rt.u8; if (!((data.length === 0))) { - arms: { - if (data.length === 2) { - const a = data[0]; - const b = data[1]; - if (a > b) { - return rt.u8Sub(a, b); - } + if (data.length === 2) { + a = data[0]; + b = data[1]; + if (a > b) { + return rt.u8Sub(a, b); } - if (data.length >= 1) { - const a2 = data[0]; - if (a2 > 0x80) { - return 1; - } + } + if (data.length >= 1) { + if (data[0] > 128) { + return 1; } - return 2; } + return 2; + } else { + return 3; } - return 3; } /** A loop ending the function, left by `break` with values that never exist. */ export function brokenNever(data: Uint8Array): rt.u8 { - let i: rt.usize = 0; - while (true) { - if (i >= data.length) { - return 0xcc; - } - const value = data[rt.idx(data, i)]; - if (value === 251) { - rt.panicFmt(["broken at ", (f: rt.Formatter) => rt.usizeDisplay(i, f)]); - } else if (value === 252) { - bail(rt.at(data, i)); - } else if (value === 0) { - return i & 0xff; + let _0!: rt.u8; + let i!: rt.usize; + let _6!: rt.usize; + let args2!: rt.Fmt[]; + let _19!: rt.usize; + i = 0; + l0: while (true) { + if (!(i >= data.length)) { + _6 = i; + rt.idx(data, _6); + const value = data[_6]; + if (value === 251) { + const arg = ([i] as [rt.usize])[0]; + args2 = [(f: rt.Formatter) => rt.usizeDisplay(arg, f)]; + rt.panicFmt(["broken at ", args2[0]]); + return _0; + } else if (value === 252) { + _19 = i; + rt.idx(data, _19); + bail(data[_19]); + return _0; + } else if (value === 0) { + return i & 0xff; + } else { + i = rt.usizeAdd(i, 1); + continue l0; + } } else { - i = rt.usizeAdd(i, 1); + return 204; } } } @@ -584,352 +880,449 @@ export function brokenNever(data: Uint8Array): rt.u8 { * Values that never exist where a value is needed: bound, and passed. A loop that * only `return` leaves gives the function's result. */ -export function boundNever(data: Uint8Array, out: rt.ByteVec): rt.u8 { - let i: rt.usize = 0; - let found: rt.u8; - while (true) { - if (i >= data.length) { - return 0xbb; - } - const value = data[rt.idx(data, i)]; - if (value === 239) { - let x: rt.u8; - rt.panicFmt(["bound at ", (f: rt.Formatter) => rt.usizeDisplay(i, f)]); - rt.byteVecPush(out, x); - } else if (value === 240) { - const arg = out; - let value2: rt.u8; - bail(rt.at(data, i)); - rt.byteVecPush(arg, value2); - } else if (value === 0) { - const arg2 = out; - let value3: rt.u8; - return i & 0xff; - rt.byteVecPush(arg2, value3); - } else if (value === 128) { - const arg3 = out; - let value4: rt.u8; - while (true) { - i = rt.usizeAdd(i, 1); - if (i >= data.length || rt.at(data, i) < 0x80) { +export function boundNever(data: Uint8Array, _out: rt.ByteVec): rt.u8 { + let _0!: rt.u8; + let i!: rt.usize; + let _8!: rt.usize; + let args2!: rt.Fmt[]; + let _22!: rt.usize; + let _32!: rt.usize; + i = 0; + l0: while (true) { + if (!(i >= data.length)) { + _8 = i; + rt.idx(data, _8); + const value = data[_8]; + if (value === 239) { + const arg = ([i] as [rt.usize])[0]; + args2 = [(f: rt.Formatter) => rt.usizeDisplay(arg, f)]; + rt.panicFmt(["bound at ", args2[0]]); + return _0; + } else if (value === 240) { + _22 = i; + rt.idx(data, _22); + bail(data[_22]); + return _0; + } else if (value === 0) { + return i & 0xff; + } else if (value === 128) { + l2: while (true) { + i = rt.usizeAdd(i, 1); + if (!(i >= data.length)) { + _32 = i; + rt.idx(data, _32); + if (!(data[_32] < 128)) { + continue l2; + } + } return i & 0xff; } + } else { + i = rt.usizeAdd(i, 1); + continue l0; } - rt.byteVecPush(arg3, value4); + } else { + return 187; } - i = rt.usizeAdd(i, 1); } - return found; } /** Loops that `break` ending a guarded `match` arm and an `if let` chain branch. */ export function branchLoops(data: Uint8Array, out: rt.ByteVec): void { - let i: rt.usize = 0; - while (rt.usizeAdd(i, 1) < data.length) { - const w = rt.sliceRange(data, i, rt.usizeAdd(i, 2)); - i = rt.usizeAdd(i, 2); - arms: { - if (w.length === 2) { - const a = w[0]; - const b = w[1]; - if (a > b) { - let n: rt.u8 = a; - while (true) { - if (n <= b) { - break; + let i!: rt.usize; + let w!: Uint8Array; + let a!: rt.u8; + let b!: rt.u8; + let n!: rt.u8; + let n2!: rt.u8; + i = 0; + l0: while (true) { + if (!(rt.usizeAdd(i, 1) < data.length)) { + return; + } else { + w = rt.sliceRange(data, i, rt.usizeAdd(i, 2)); + b1: { + i = rt.usizeAdd(i, 2); + if (w.length === 2) { + a = w[0]; + b = w[1]; + if (a > b) { + n = a; + while (true) { + if (!(n <= b)) { + n = rt.u8Sub(n, 1); + rt.byteVecPush(out, n); + } else { + break b1; + } } - n = rt.u8Sub(n, 1); - rt.byteVecPush(out, n); } - break arms; + } + if (w.length >= 1) { + rt.byteVecPush(out, w[0]); } } - if (w.length >= 1) { - const a2 = w[0]; - rt.byteVecPush(out, a2); - break arms; - } - } - chain: { if (w.length === 2) { - const a3 = w[0]; - const b2 = w[1]; - if (rt.u8Rem(a3, 3) === rt.u8Rem(b2, 3)) { - let n2: rt.u8 = a3; + if (rt.u8Rem(w[0], 3) === rt.u8Rem(w[1], 3)) { + n2 = w[0]; while (true) { n2 = rt.u8Div(n2, 2); rt.byteVecPush(out, n2); if (n2 < 4) { - break; + continue l0; } } - break chain; } } - rt.byteVecPush(out, 0xaa); + rt.byteVecPush(out, 170); } } } /** A loop that only `return` leaves, returned itself, around loops that `break`. */ export function returnedLoop(data: Uint8Array): rt.u8 { - let i: rt.usize = 0; - while (true) { - if (i >= data.length) { - return 0xdd; - } - for (const item of rt.sliceRange(data, i)) { - const b = item; - if (b === 0) { - break; - } - if (b > 0xf0) { - return b ^ (i & 0xff); + let i!: rt.usize; + let iterS!: Uint8Array; + let iterI!: number; + let _11!: rt.u8 | rt.Done; + let b!: rt.u8; + i = 0; + l0: while (true) { + if (!(i >= data.length)) { + iterS = rt.sliceRange(data, i); + iterI = 0; + l2: while (true) { + _11 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_11 !== rt.DONE) { + b = _11; + if (!(b === 0)) { + if (!(b > 240)) { + continue l2; + } else { + return b ^ (i & 0xff); + } + } + } + i = rt.usizeAdd(i, 1); + continue l0; } + } else { + return 221; } - i = rt.usizeAdd(i, 1); } } /** A loop that ends the function, left only by `return` from nested scopes. */ export function firstRepeat(data: Uint8Array): rt.u8 { - let i: rt.usize = 0; - loop: while (true) { - if (i >= data.length) { - return 0xff; - } - let j: rt.usize = rt.usizeAdd(i, 1); - while (j < data.length) { - if (rt.at(data, j) === 0) { - i = rt.usizeAdd(j, 1); - continue loop; - } - if (rt.at(data, i) === rt.at(data, j)) { - return rt.at(data, j) ^ (i & 0xff); + let i!: rt.usize; + let j!: rt.usize; + let _14!: rt.usize; + let _20!: rt.u8; + let _21!: rt.usize; + let _25!: rt.usize; + let _29!: rt.usize; + i = 0; + l0: while (true) { + if (!(i >= data.length)) { + j = rt.usizeAdd(i, 1); + while (true) { + if (!(j < data.length)) { + i = rt.usizeAdd(i, 1); + continue l0; + } else { + _14 = j; + rt.idx(data, _14); + if (!(data[_14] === 0)) { + _21 = i; + rt.idx(data, _21); + _20 = data[_21]; + _25 = j; + rt.idx(data, _25); + if (!(_20 === data[_25])) { + j = rt.usizeAdd(j, 1); + } else { + _29 = j; + rt.idx(data, _29); + return data[_29] ^ (i & 0xff); + } + } else { + i = rt.usizeAdd(j, 1); + continue l0; + } + } } - j = rt.usizeAdd(j, 1); + } else { + return 255; } - i = rt.usizeAdd(i, 1); } } /** A loop that ends the function, left by `break` with a value from nested scopes. */ export function tailBreak(data: Uint8Array): rt.u16 { - let i: rt.usize = 0; - while (true) { - if (i >= data.length) { - return 0x100; - } - const b = rt.at(data, i); - i = rt.usizeAdd(i, 1); - const value = rt.u8Rem(b, 4); - if (value === 0) { - continue; - } else if (value === 1) { - for (const item of rt.sliceRange(data, i)) { - const c = item; - if (c === b) { - return rt.u16Mul(c as rt.u16, 2); + let i!: rt.usize; + let b!: rt.u8; + let _7!: rt.usize; + let _11!: rt.u8; + let iterS!: Uint8Array; + let iterI!: number; + let _18!: rt.u8 | rt.Done; + let c!: rt.u8; + let n!: rt.u8; + i = 0; + l0: while (true) { + if (!(i >= data.length)) { + _7 = i; + rt.idx(data, _7); + b = data[_7]; + i = rt.usizeAdd(i, 1); + _11 = rt.u8Rem(b, 4); + if (_11 === 0) { + continue l0; + } else if (_11 === 1) { + iterS = rt.sliceRange(data, i); + iterI = 0; + while (true) { + _18 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_18 === rt.DONE) { + continue l0; + } else { + c = _18; + if (c === b) { + return rt.u16Mul(c as rt.u16, 2); + } + } + } + } else if (_11 === 2) { + if (b > 100) { + return rt.u16Add(b as rt.u16, i & 0xffff); } } - } else if (value === 2 && b > 100) { - return rt.u16Add(b as rt.u16, i & 0xffff); - } else { - let n: rt.u8 = b; + n = b; while (true) { - if (n < 10) { - break; - } - n = rt.u8Div(n, 3); - if (n === 7) { - return 7; + if (!(n < 10)) { + n = rt.u8Div(n, 3); + if (n === 7) { + return 7; + } + } else { + continue l0; } } + } else { + return 256; } } } /** A loop that only `return` leaves, in a `match` arm that needs a value. */ export function armLoop(data: Uint8Array): rt.u8 { - let k: rt.usize = 0; - let start: rt.u8; - const first = rt.sliceFirst(data); - arms: { - if (first !== undefined) { - const b = first; - if (b >= 0x80) { - start = b; - break arms; - } + let k!: rt.usize; + let _3!: rt.u8 | undefined; + let _13!: rt.usize; + let _17!: rt.usize; + k = 0; + _3 = rt.sliceFirst(data); + if (_3 !== undefined) { + if (_3 >= 128) { + return rt.u8Div(_3, 2); } - while (true) { - if (k >= data.length) { - return 0xee; - } - if (rt.at(data, k) >= 0x80) { - return rt.u8Sub(rt.at(data, k), 0x80); + } + while (true) { + if (!(k >= data.length)) { + _13 = k; + rt.idx(data, _13); + if (!(data[_13] >= 128)) { + k = rt.usizeAdd(k, 1); + } else { + _17 = k; + rt.idx(data, _17); + return rt.u8Sub(data[_17], 128); } - k = rt.usizeAdd(k, 1); + } else { + return 238; } } - return rt.u8Div(start, 2); } /** A generic function ending in a loop. */ export function position$u8(items: Uint8Array, want: rt.u8): rt.usize { - let i: rt.usize = 0; - while (true) { - if (i === items.length || items[rt.idx(items, i)] === want) { + let i!: rt.usize; + let _9!: rt.usize; + i = 0; + l0: while (true) { + if (!(i === items.length)) { + _9 = i; + rt.idx(items, _9); + if (!((items[_9] === want))) { + i = rt.usizeAdd(i, 1); + continue l0; + } else { + return i; + } + } else { return i; } - i = rt.usizeAdd(i, 1); } } /** A unit function ending in a loop. */ export function drain(data: Uint8Array, out: rt.ByteVec): void { - let i: rt.usize = 0; + let i!: rt.usize; + let _10!: rt.usize; + i = 0; while (true) { - if (i >= data.length) { + if (!(i >= data.length)) { + _10 = i; + rt.idx(data, _10); + rt.byteVecPush(out, data[_10] ^ 90); + i = rt.usizeAdd(i, 2); + } else { return; } - rt.byteVecPush(out, rt.at(data, i) ^ 0x5a); - i = rt.usizeAdd(i, 2); } } /** Patterns: slices, ranges, guards that bind, `@` bindings, and let chains. */ export function patterns(data: Uint8Array, out: rt.ByteVec): void { - arms: { - if (data.length === 0) { - rt.byteVecPush(out, 0); - break arms; - } - if (data.length === 1) { - const one = data[0]; - rt.byteVecPush(out, one); - break arms; - } - if (data.length >= 2) { - const first = data[0]; - const last = data[data.length - 1]; - if (first === last) { + let iterS!: Uint8Array; + let iterI!: number; + let _33!: rt.u8 | rt.Done; + let b!: rt.u8; + let class_!: rt.u8; + let _56!: Dir.Dir | undefined; + let d!: Dir.Dir; + let shape_!: Shape.Shape; + let area!: rt.i64; + let x!: rt.i32; + let _74!: rt.i64; + let width2!: rt.u16; + let height!: rt.u16; + let a!: Point.Point; + let b2!: Point.Point; + let either!: rt.Result; + let v!: rt.u8; + let bytes!: Uint8Array; + let parsed!: rt.Result; + let a2!: rt.u8; + let b3!: rt.u8; + let _166!: string; + let args2!: rt.Fmt[]; + if (!(data.length === 0)) { + if (!(data.length === 1)) { + if (!(data.length >= 2)) { + rt.unreachable(undefined); + } else if (!((data[0] === data[data.length - 1]))) { + rt.byteVecPush(out, data[0] ^ data[1]); + rt.byteVecPush(out, data.subarray(2, data.length - 0).length & 0xff); + } else { rt.byteVecPush(out, 2); - break arms; } + } else { + rt.byteVecPush(out, data[0]); } - const first2 = data[0]; - const second = data[1]; - const rest = data.subarray(2, data.length - 0); - rt.byteVecPush(out, first2 ^ second); - rt.byteVecPush(out, rest.length & 0xff); + } else { + rt.byteVecPush(out, 0); } - for (const item of rt.sliceRange(data, 0, rt.min(data.length, 4))) { - const b = item; - let class_: rt.u8; - arms2: { - if (b === 0) { - class_ = 0; - break arms2; - } - if (1 <= b && b <= 9) { - class_ = 1; - break arms2; - } - if (b === 10 || b === 20 || b === 30) { - class_ = 2; - break arms2; + iterS = rt.sliceRange(data, 0, rt.min(data.length, 4)); + iterI = 0; + while (true) { + _33 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_33 === rt.DONE) { + b5: { + if (data.length >= 2) { + _56 = dir(data[0]); + if (_56 !== undefined) { + d = _56; + if (data[1] > 10) { + rt.byteVecPush(out, from$From_Dir_u8(d)); + break b5; + } + } + } + rt.byteVecPush(out, 238); } - if (100 <= b && b < 200) { - const n = b; - if (rt.u8Rem(n, 2) === 0) { - class_ = 3; - break arms2; + shape_ = shape(data); + b7: { + if (shape_.tag !== "Dot") { + if (shape_.tag === "Line") { + a = shape_._0; + b2 = shape_._1; + area = rt.i64Mul(rt.i32Sub(a.x, b2.x) as rt.i64, rt.i32Sub(a.y, b2.y) as rt.i64); + break b7; + } else if (shape_.width !== 0) { + if (!(shape_.corner.x > 0)) { + width2 = shape_.width; + height = shape_.height; + area = rt.i64Neg(rt.i64Mul(width2 as rt.i64, height as rt.i64)); + break b7; + } else { + x = shape_.corner.x; + _74 = shape_.width as rt.i64; + area = rt.i64Mul(_74, x as rt.i64); + break b7; + } + } } + area = 0; } - const n2 = b; - if (n2 >= 250) { - class_ = 4; - break arms2; + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(area)); + if (!(rt.usizeRem(data.length, 2) === 0)) { + either = rt.Err(160); + } else { + either = rt.Ok(data.length & 0xff); } - class_ = 5; - } - rt.byteVecPush(out, class_); - } - chain: { - if (data.length >= 2) { - const a = data[0]; - const b2 = data[1]; - const dir_ = dir(a); - if (dir_ !== undefined) { - const d = dir_; - if (b2 > 10) { - rt.byteVecPush(out, from$From_Dir_u8(d)); - break chain; - } + if (either.ok) { + v = either.value; + } else { + v = either.error; } - } - rt.byteVecPush(out, 0xee); - } - const shape_ = shape(data); - let area: rt.i64; - arms3: { - if ((shape_.tag === "Rect" && shape_.width === 0) || shape_.tag === "Dot") { - area = 0; - break arms3; - } - if (shape_.tag === "Rect") { - const x = shape_.corner.x; - const width = shape_.width; - if (x > 0) { - area = rt.i64Mul(width as rt.i64, x as rt.i64); - break arms3; + rt.byteVecPush(out, v); + rt.byteVecPush(out, rt.u8Add(Uint8Array.of().length & 0xff, rt.iterSum(rt.iterSlice(Uint8Array.of()), rt.u8Add, 0))); + bytes = Uint8Array.of(data.length & 0xff, 1, 2); + bytes.subarray(1, 3)[0] = 9; + rt.byteVecExtendFromSlice(out, bytes); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.u64Add(total$Shape([shape_, { tag: "Dot" } as Shape.Shape], out), total$Meters([{ _0: 3 }, { _0: rt.u64Of(18446744073709551615n) }], out)))); + parsed = rt.Ok(data.length & 0xff); + a2 = (parsed as { ok: true; value: rt.u8 }).value; + b3 = (parsed as { ok: true; value: rt.u8 }).value; + rt.byteVecExtendFromSlice(out, Uint8Array.of(a2, b3, (parsed as { ok: true; value: rt.u8 }).value, early(a2))); + const arg = ([parsed] as [rt.Result])[0]; + args2 = [(f: rt.Formatter) => rt.fmtResult(arg, f, rt.u8Display, (value: Void.Void, f: rt.Formatter) => Void.fmt$Debug(value, f))]; + _166 = rt.fmtFormat([args2[0]]); + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_166)); + return; + } else { + b2: { + b = _33; + if (b === 0) { + class_ = 0; + } else if (b === 10 || b === 20 || b === 30) { + class_ = 2; + } else { + if (1 <= b) { + if (b <= 9) { + class_ = 1; + break b2; + } + } + if (100 <= b) { + if (b < 200) { + if (rt.u8Rem(b, 2) === 0) { + class_ = 3; + break b2; + } + } + } + if (!(b >= 250)) { + class_ = 5; + } else { + class_ = 4; + } + } } + rt.byteVecPush(out, class_); } - if (shape_.tag === "Rect") { - const width2 = shape_.width; - const height = shape_.height; - area = rt.i64Neg(rt.i64Mul(width2 as rt.i64, height as rt.i64)); - break arms3; - } - const a2 = rt.copy(shape_._0); - const b3 = rt.copy(shape_._1); - area = rt.i64Mul(rt.i32Sub(a2.x, b3.x) as rt.i64, rt.i32Sub(a2.y, b3.y) as rt.i64); } - rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(area)); - let bytes: Uint8Array = Uint8Array.of(data.length & 0xff, 1, 2); - const tail = bytes.subarray(1, 3); - tail[0] = 9; - rt.byteVecExtendFromSlice(out, bytes); - const total = rt.u64Add(total$Shape([shape_, { tag: "Dot" } as Shape.Shape], out), total$Meters([{ _0: 3 }, { _0: rt.u64Of(18446744073709551615n) }], out)); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(total)); - const parsed = rt.Ok(data.length & 0xff); - let a3: rt.u8; - if (parsed.ok) { - const v = parsed.value; - a3 = v; - } else { - const e = parsed.error; - a3 = absurd([e, 1]); - } - let b4: rt.u8; - if (parsed.ok) { - const v2 = parsed.value; - b4 = v2; - } else { - const e2 = parsed.error; - rt.unreachable(e2); - } - let c: rt.u8; - const v3 = parsed.value; - c = v3; - rt.byteVecExtendFromSlice(out, Uint8Array.of(a3, b4, c, early(a3))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([(f: rt.Formatter) => rt.fmtResult(parsed, f, rt.u8Display, (value: Void.Void, f: rt.Formatter) => Void.fmt$Debug(value, f))]))); -} - -/** A value holding a `Void` can't exist either. */ -export function absurd(v: [Void.Void, rt.u8]): rt.u8 { - rt.unreachable(rt.copy(v)); } /** A `match` without arms on a scrutinee that diverges, not on an empty type. */ @@ -939,39 +1332,82 @@ export function early(n: rt.u8): rt.u8 { /** Closures capturing by reference and by move, and functions as values. */ export function closures(data: Uint8Array, out: rt.ByteVec): void { - let sum: rt.u32 = 0; - let add: (a0: rt.u8) => void = (v: rt.u8): void => { - const value = v as rt.u32; - sum = rt.u32Add(sum, value); - }; - for (const item of data) { - const b = item; - add(b); - } - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(sum)); - const base = data.length as rt.u32; - const scale = (v2: rt.u32): rt.u32 => { - return rt.u32Add(rt.u32Mul(v2, 3), base); + let sum!: rt.u32; + let add!: (a0: rt.u8) => void; + let iterS!: Uint8Array; + let iterI!: number; + let _8!: rt.u8 | rt.Done; + let base!: rt.u32; + let n!: rt.u32; + let whole!: Uint8Array; + let parsed!: Array; + let iterS2!: Uint8Array; + let iterI2!: number; + let _53!: rt.u8 | rt.Done; + let _59!: Dir.Dir | undefined; + let tags!: rt.ByteVec; + let iterS3!: Array; + let iterI3!: number; + let _64!: Dir.Dir | undefined | rt.Done; + let _70!: rt.u8; + sum = 0; + add = (v: rt.u8): void => { + sum = rt.u32Add(sum, v as rt.u32); }; - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(apply$closures_closure1(scale, sum))); - let whole: Uint8Array = Uint8Array.of(data.length & 0xff); - overwrite(whole); - rt.byteVecPush(out, whole[0]); - let parsed: Array = []; - for (const item2 of data) { - const b2 = item2; - parsed.push(dir(b2)); - } - let tags: rt.ByteVec = new rt.ByteVec(); - for (const d of parsed) { - rt.byteVecPush(tags, rt.optionUnwrapOr(rt.optionMap(d, from$From_Dir_u8), 0)); + iterS = data; + iterI = 0; + while (true) { + _8 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_8 === rt.DONE) { + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(sum)); + base = data.length as rt.u32; + const captured = base; + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(apply$closures_closure1((v2: rt.u32): rt.u32 => { + return rt.u32Add(rt.u32Mul(v2, 3), captured); + }, sum))); + n = base; + const captured2 = n; + n = rt.u32Add(n, 10); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32Add(((): rt.u32 => { + return rt.u32Add(captured2, 1); + })(), n))); + whole = Uint8Array.of(data.length & 0xff); + overwrite(whole); + rt.byteVecPush(out, whole[0]); + parsed = []; + iterS2 = data; + iterI2 = 0; + while (true) { + _53 = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; + if (_53 === rt.DONE) { + tags = new rt.ByteVec(); + iterS3 = parsed; + iterI3 = 0; + while (true) { + _64 = iterI3 < iterS3.length ? iterS3[iterI3++] : rt.DONE; + if (_64 === rt.DONE) { + rt.byteVecExtendFromSlice(out, rt.byteVecView(tags)); + return; + } else { + _70 = rt.optionUnwrapOr(rt.optionMap(_64, from$From_Dir_u8), 0); + rt.byteVecPush(tags, _70); + } + } + } else { + _59 = dir(_53); + parsed.push(_59); + } + } + } else { + add(_8); + } } - rt.byteVecExtendFromSlice(out, rt.byteVecView(tags)); } /** Replaces `a` whole from a closure. */ export function overwrite(a: Uint8Array): void { - let write: () => void = (): void => { + let write!: () => void; + write = (): void => { a.set(Uint8Array.of(9)); }; write(); @@ -983,44 +1419,84 @@ export function apply$closures_closure1(f: (a0: rt.u32) => rt.u32, v: rt.u32): r /** Options, results, `?`, and strings. */ export function library(data: Uint8Array, out: rt.ByteVec): void { - const checked = (a: rt.u8, b: rt.u8): rt.u8 | undefined => { - const checkedAdd = rt.u8CheckedAdd(a, b); - if (checkedAdd === undefined) { + let _3!: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined; + let a!: rt.u8; + let b!: rt.u8; + let parsed!: rt.Result; + let mapped!: rt.Result; + let _30!: (a0: rt.u8) => rt.Poll>; + let _32!: rt.Poll>; + let _45!: rt.Result; + let s!: string; + _3 = (a2: rt.u8, b2: rt.u8): rt.u8 | undefined => { + let _4!: rt.u8 | undefined; + let _82!: rt.u8 | undefined; + _4 = rt.u8CheckedAdd(a2, b2); + if (_4 !== undefined) { + _82 = rt.u8CheckedMul(_4, 2); + if (_82 !== undefined) { + return rt.u8Sub(_82, 1); + } else { + return undefined; + } + } else { return undefined; } - const sum = checkedAdd; - const checkedMul = rt.u8CheckedMul(sum, 2); - if (checkedMul === undefined) { - return undefined; + }; + _30 = (a3: rt.u8): rt.Poll> => { + let half!: rt.Result; + let _43!: Dir.Dir | undefined; + let _132!: rt.Result; + let residual!: rt.Result; + _43 = dir(a3); + b0: { + if (_43 !== undefined) { + if (rt.u8Rem(a3, 2) === 1) { + half = rt.Err(_43); + break b0; + } + } + half = rt.Ok(rt.u8Div(a3, 2)); + } + _132 = half; + if (_132.ok) { + return rt.Ok(_132.value); + } else { + residual = _132; + return rt.Err(from$From_Dir_u8((residual as { ok: false; error: Dir.Dir }).error)); } - const doubled = checkedMul; - return rt.u8Sub(doubled, 1); }; - const a2 = rt.optionUnwrapOr(rt.sliceFirst(data), 0); - const b2 = rt.optionUnwrapOr(rt.sliceGet(data, 1), 0); - rt.byteVecPush(out, rt.optionUnwrapOr(checked(a2, b2), 0xff)); - let parsed: rt.Result; - if (a2 === 0) { + a = rt.optionUnwrapOr(rt.sliceFirst(data), 0); + b = rt.optionUnwrapOr(rt.sliceGet(data, 1), 0); + rt.byteVecPush(out, rt.optionUnwrapOr(_3(a, b), 255)); + if (a === 0) { parsed = rt.Err("zero"); } else { - const n = a2; - parsed = rt.Ok(n); + parsed = rt.Ok(a); } - const mapped = rt.resultMapErr(rt.resultMap(parsed, (n2: rt.u8): rt.u8 => { - return rt.u8Div(n2, 2); - }), (e: string): rt.u8 => { - return rt.stringLen(e) & 0xff; + mapped = rt.resultMapErr(rt.resultMap(parsed, (n5: rt.u8): rt.u8 => { + return rt.u8Div(n5, 2); + }), (e2: string): rt.u8 => { + return rt.stringLen(e2) & 0xff; }); if (mapped.ok) { - const n3 = mapped.value; - rt.byteVecExtendFromSlice(out, Uint8Array.of(0, n3)); + rt.byteVecExtendFromSlice(out, Uint8Array.of(0, mapped.value)); + } else { + rt.byteVecExtendFromSlice(out, Uint8Array.of(1, mapped.error)); + } + _32 = _30(b); + if (_32 !== rt.Pending) { + if (_32.ok) { + rt.byteVecExtendFromSlice(out, Uint8Array.of(2, _32.value)); + } else { + rt.byteVecExtendFromSlice(out, Uint8Array.of(3, _32.error)); + } } else { - const n4 = mapped.error; - rt.byteVecExtendFromSlice(out, Uint8Array.of(1, n4)); + rt.byteVecPush(out, 4); } - const fromUtf8 = rt.stringFromUtf8(rt.sliceToByteVec(data)); - if (fromUtf8.ok) { - const s = fromUtf8.value; + _45 = rt.stringFromUtf8(rt.sliceToByteVec(data)); + if (_45.ok) { + s = _45.value; rt.byteVecPush(out, 1); rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.stringLen(s) as rt.u32)); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); diff --git a/ts/fixtures/lang/src/fmt.rs b/ts/fixtures/lang/src/fmt.rs index 67ee6347a..90860d2be 100644 --- a/ts/fixtures/lang/src/fmt.rs +++ b/ts/fixtures/lang/src/fmt.rs @@ -350,7 +350,7 @@ pub fn written(data: &[u8], out: &mut Vec) { /// Panics, each with the message native Rust formats. pub fn panics(kind: u8, rest: &[u8], out: &mut Vec) { let n = rest.first().copied().unwrap_or(0); - match kind % 19 { + match kind % 20 { 0 => panic!("bad {n}: {:?}", rest), 1 => unreachable!("never {n:#x} {}", Hex(n.into())), 2 => assert!(n > 200, "small {} {:?}", n, Pair(n, 0)), @@ -405,6 +405,7 @@ pub fn panics(kind: u8, rest: &[u8], out: &mut Vec) { buf.copy_within((n % 6) as usize..(n / 6 % 6) as usize, dest); put(out, &format!("{buf:?}")); } + 18 => put(out, &rest[(n % 8) as usize].to_string()), _ => { let r: Result = if n % 2 == 0 { Err(n) } else { Ok(n) }; put(out, &format!("{}", r.unwrap_err())); diff --git a/ts/fixtures/lang/src/ints.rs b/ts/fixtures/lang/src/ints.rs index 2b16c423d..14685a958 100644 --- a/ts/fixtures/lang/src/ints.rs +++ b/ts/fixtures/lang/src/ints.rs @@ -30,7 +30,7 @@ macro_rules! ops { } None => out.push(0), }; - match op % 24 { + match op % 25 { 0 => put(out, a + b), 1 => put(out, a - b), 2 => put(out, a * b), @@ -60,6 +60,13 @@ macro_rules! ops { // Against a literal, which a wide value equals only in one form. out.push((a.wrapping_sub(b) == 0) as u8); } + 23 => { + // Products nothing reads still overflow, of a sum that does too. + let x = a + b; + let _ = x * b; + let _ = (x - b) * a; + out.push(1); + } _ => { // Compound assignment, with constants folded beside variables. let mut x = a; @@ -71,6 +78,9 @@ macro_rules! ops { x |= 1 << 3; x ^= b; x &= !(1 << 2); + // By a constant, whose overflow check a signed type folds. + x %= 7; + x /= 3; put(out, x); } } diff --git a/ts/fixtures/lang/src/iters.rs b/ts/fixtures/lang/src/iters.rs index 75ddd7bd2..be5240292 100644 --- a/ts/fixtures/lang/src/iters.rs +++ b/ts/fixtures/lang/src/iters.rs @@ -247,6 +247,10 @@ pub fn ranges(data: &[u8], out: &mut Vec) { out.push(*inclusive.start()); out.push(*inclusive.end()); out.push(inclusive.contains(&b) as u8); + // Of constants, which is itself a constant. + const LOW: u64 = 0x20; + const HIGH: u64 = 0x7f; + out.push((LOW..=HIGH).contains(&u64::from(a)) as u8); // `nth` past the end, or past the type's last value, leaves the range as std's does. let mut near = a.max(200)..=255; out.push(near.nth(b as usize).unwrap_or(0xee)); diff --git a/ts/fixtures/lang/src/shapes.rs b/ts/fixtures/lang/src/shapes.rs index 236e5f1d6..aac088ae8 100644 --- a/ts/fixtures/lang/src/shapes.rs +++ b/ts/fixtures/lang/src/shapes.rs @@ -879,6 +879,18 @@ pub fn patterns(data: &[u8], out: &mut Vec) { Shape::Line(a, b) => (a.x - b.x) as i64 * (a.y - b.y) as i64, }; out.extend_from_slice(&area.to_be_bytes()); + // One binding from either side of an or-pattern. + let either: Result = if data.len() % 2 == 0 { + Ok(data.len() as u8) + } else { + Err(0xa0) + }; + match either { + Ok(v) | Err(v) => out.push(v), + } + // An empty repeat, which MIR never assigns since it holds nothing. + let none = [data.len() as u8; 0]; + out.push(none.len() as u8 + none.iter().sum::()); // A rest pattern borrowing bytes changes them where they are. let mut bytes = [data.len() as u8, 1, 2]; let [_, tail @ ..] = &mut bytes; @@ -931,6 +943,11 @@ pub fn closures(data: &[u8], out: &mut Vec) { let base = data.len() as u32; let scale = move |v: u32| v * 3 + base; out.extend_from_slice(&apply(scale, sum).to_be_bytes()); + // A `move` closure copies what it captured, which a later change to the original misses. + let mut n = base; + let copied = move || n + 1; + n += 10; + out.extend_from_slice(&(copied() + n).to_be_bytes()); // A closure writing a whole array through a reference it captured changes the caller's. let mut whole = [data.len() as u8]; @@ -979,6 +996,21 @@ pub fn library(data: &[u8], out: &mut Vec) { Err(n) => out.extend_from_slice(&[1, n]), } + // `?` in a function that returns a `Poll`, converting the error. + let ready = |a: u8| -> std::task::Poll> { + let half: Result = match dir(a) { + Some(d) if a % 2 == 1 => Err(d), + _ => Ok(a / 2), + }; + let n = half?; + std::task::Poll::Ready(Ok(n)) + }; + match ready(b) { + std::task::Poll::Ready(Ok(n)) => out.extend_from_slice(&[2, n]), + std::task::Poll::Ready(Err(e)) => out.extend_from_slice(&[3, e]), + std::task::Poll::Pending => out.push(4), + } + match String::from_utf8(data.to_vec()) { Ok(s) => { out.push(1); diff --git a/ts/fixtures/reject/census.md b/ts/fixtures/reject/census.md index a1eed1335..d6b6403da 100644 --- a/ts/fixtures/reject/census.md +++ b/ts/fixtures/reject/census.md @@ -1,70 +1,55 @@ # Census of `reject-fixture` -- Refusals: 87 -- Function instances: 79 +- Refusals: 69 +- Function instances: 61 - Generic functions no instance reached, lowered over their type parameters: 3 ## By construct | Count | Construct | First | | ---: | --- | --- | -| 6 | unsupported type `_` | fixtures/reject/src/lib.rs:6:1 | -| 4 | replacing the `_` behind a reference, whose JS object is shared or private | fixtures/reject/src/lib.rs:218:2 | -| 4 | replacing the value behind a reference to `_` | fixtures/reject/src/lib.rs:161:17 | -| 4 | unsupported call to `_` | fixtures/reject/src/lib.rs:36:4 | -| 3 | `_` is not supported: its `None` and `Some` would both be `undefined` | fixtures/reject/src/lib.rs:31:15 | -| 3 | a `_` binding: a JS value of `_` is a copy, so it can't change | fixtures/reject/src/lib.rs:19:13 | -| 3 | an iterator that owns `_`, which drops, which is not supported yet | fixtures/reject/src/lib.rs:364:4 | -| 3 | dropping `_`, which is not supported yet | fixtures/reject/src/lib.rs:59:31 | -| 2 | `_`: a JS value of `_` is a copy, so a reference can't change it | fixtures/reject/src/lib.rs:19:13 | -| 2 | a `for` loop over values that drop, which is not supported yet | fixtures/reject/src/lib.rs:69:6 | -| 2 | a `match` on a temporary that drops, which it doesn't move out of whole | fixtures/reject/src/lib.rs:210:2 | -| 2 | a closure that copies a mutable variable | fixtures/reject/src/lib.rs:142:18 | -| 2 | a field of `_` | fixtures/reject/src/lib.rs:441:7 | -| 2 | a field of a temporary that drops: bind it to a variable first | fixtures/reject/src/lib.rs:55:2 | -| 2 | an iterator of the crate implementing `_`, which is not supported yet | fixtures/reject/src/lib.rs:302:1 | -| 2 | overriding `_`, which std's adaptors call in place of `next` or beside it | fixtures/reject/src/lib.rs:282:2 | -| 1 | `Binary` formatting, as in `{:b}`, is not supported | fixtures/reject/src/lib.rs:125:3 | -| 1 | `LowerExp` formatting, as in `{:e}`, is not supported | fixtures/reject/src/lib.rs:127:3 | -| 1 | `Octal` formatting, as in `{:o}`, is not supported | fixtures/reject/src/lib.rs:126:3 | -| 1 | `Pointer` formatting, as in `{:p}`, is not supported | fixtures/reject/src/lib.rs:130:3 | -| 1 | `_` holds `_`, which is `undefined` as `None` is, which is not supported | fixtures/reject/src/lib.rs:451:6 | -| 1 | `_` is generic and implements `Drop`, which is not supported yet | fixtures/reject/src/lib.rs:90:1 | -| 1 | `_` is not supported: it would be pending two ways with one value | fixtures/reject/src/lib.rs:222:20 | -| 1 | `_` of `_` by `_`, which is not supported yet | fixtures/reject/src/lib.rs:486:6 | -| 1 | `_` of `_`, which may drop a `_`, which is not supported yet | fixtures/reject/src/lib.rs:469:6 | -| 1 | `_` of `_`, which may drop what it holds, which is not supported yet | fixtures/reject/src/lib.rs:446:6 | -| 1 | `_`, which is not supported yet | fixtures/reject/src/lib.rs:494:9 | -| 1 | a `let` on a temporary that drops, which it doesn't move out of whole | fixtures/reject/src/lib.rs:193:2 | -| 1 | a `zip` of `_`, whose closures std calls one item further through `next` than through `fold` | fixtures/reject/src/lib.rs:315:51 | +| 6 | an assignment through a reference to `_` | fixtures/reject/src/lib.rs:20:2 | +| 5 | `_`: a JS value of `_` is a copy, so a reference can't change it | fixtures/reject/src/lib.rs:19:1 | +| 5 | unsupported call to `_` | fixtures/reject/src/lib.rs:36:4 | +| 4 | unsupported type `_` | fixtures/reject/src/lib.rs:6:1 | +| 3 | `_` is not supported: its `None` and `Some` would both be `undefined` | fixtures/reject/src/lib.rs:31:1 | +| 3 | an iterator that owns `_`, which drops, which is not supported yet | fixtures/reject/src/lib.rs:59:2 | +| 3 | replacing the value behind a reference to `_` | fixtures/reject/src/lib.rs:133:2 | +| 2 | `_` is not supported: it would be pending two ways with one value | fixtures/reject/src/lib.rs:159:1 | +| 2 | a field of `_` | fixtures/reject/src/lib.rs:326:7 | +| 2 | an iterator of the crate implementing `_`, which is not supported yet | fixtures/reject/src/lib.rs:218:1 | +| 2 | constructing `_` from another crate | fixtures/reject/src/lib.rs:204:23 | +| 2 | overriding `_`, which std's adaptors call in place of `next` or beside it | fixtures/reject/src/lib.rs:198:2 | +| 1 | `Binary` formatting, as in `{:b}`, is not supported | fixtures/reject/src/lib.rs:110:3 | +| 1 | `LowerExp` formatting, as in `{:e}`, is not supported | fixtures/reject/src/lib.rs:112:3 | +| 1 | `Octal` formatting, as in `{:o}`, is not supported | fixtures/reject/src/lib.rs:111:3 | +| 1 | `Pointer` formatting, as in `{:p}`, is not supported | fixtures/reject/src/lib.rs:115:3 | +| 1 | `_` holds `_`, which is `undefined` as `None` is, which is not supported | fixtures/reject/src/lib.rs:336:6 | +| 1 | `_` is generic and implements `Drop`, which is not supported yet | fixtures/reject/src/lib.rs:75:1 | +| 1 | `_` of `_` by `_`, which is not supported yet | fixtures/reject/src/lib.rs:371:6 | +| 1 | `_` of `_`, which may drop a `_`, which is not supported yet | fixtures/reject/src/lib.rs:354:6 | +| 1 | `_` of `_`, which may drop what it holds, which is not supported yet | fixtures/reject/src/lib.rs:331:6 | +| 1 | `_`, which is not supported yet | fixtures/reject/src/lib.rs:379:9 | +| 1 | a `_` cast from `_` to `_` | fixtures/reject/src/lib.rs:144:2 | +| 1 | a `zip` of `_`, whose closures std calls one item further through `next` than through `fold` | fixtures/reject/src/lib.rs:231:51 | | 1 | a cast from `_` | fixtures/reject/src/lib.rs:11:2 | -| 1 | a cast to `_` | fixtures/reject/src/lib.rs:172:2 | -| 1 | a closure of type `_` | fixtures/reject/src/lib.rs:114:10 | -| 1 | a closure that captures a value that drops, which is not supported yet | fixtures/reject/src/lib.rs:61:23 | -| 1 | a mutable borrow of a subslice of `_`, which JS would copy, having no views | fixtures/reject/src/lib.rs:404:13 | -| 1 | a mutable reference to `_`, which is no object it can change in place | fixtures/reject/src/lib.rs:137:17 | -| 1 | a parameter that drops bound by a pattern, which is not supported yet | fixtures/reject/src/lib.rs:76:21 | -| 1 | a precision, as in `{:.2}`, is not supported | fixtures/reject/src/lib.rs:122:3 | -| 1 | a printable type must implement `Display` or `Debug` | fixtures/reject/src/lib.rs:168:1 | -| 1 | a rest pattern that moves values that drop out of a place, which is not supported yet | fixtures/reject/src/lib.rs:398:14 | -| 1 | a variable from outside the function | fixtures/reject/src/lib.rs:77:2 | -| 1 | a width or precision from an argument, as in `{:1$}`, is not supported | fixtures/reject/src/lib.rs:129:3 | -| 1 | an `.await` in an operand after one that drops, which is not supported yet: bind the awaited value first | fixtures/reject/src/lib.rs:183:13 | -| 1 | an `.await` in the place an assignment of a value that drops writes to, which is not supported yet: bind the awaited value first | fixtures/reject/src/lib.rs:200:2 | -| 1 | an `if let` on a temporary that drops, which it doesn't move out of whole | fixtures/reject/src/lib.rs:234:9 | -| 1 | an array repeat of a value that drops, which is not supported yet | fixtures/reject/src/lib.rs:417:14 | -| 1 | an async body returning `_` is not supported: its `Ready` could be pending | fixtures/reject/src/lib.rs:238:54 | -| 1 | an async body that borrows `_` mutably, which is no object it can change in place | fixtures/reject/src/lib.rs:106:3 | -| 1 | an or-pattern with bindings | fixtures/reject/src/lib.rs:149:3 | +| 1 | a constant of type `_` | fixtures/reject/src/lib.rs:128:2 | +| 1 | a copy of a closure that changes what it captured | fixtures/reject/src/lib.rs:320:14 | +| 1 | a mutable borrow of a subslice of `_`, which JS would copy, having no views | fixtures/reject/src/lib.rs:295:13 | +| 1 | a precision, as in `{:.2}`, is not supported | fixtures/reject/src/lib.rs:107:3 | +| 1 | a printable type must implement `Display` or `Debug` | fixtures/reject/src/lib.rs:140:1 | +| 1 | a scalar constant of type `_` | fixtures/reject/src/lib.rs:7:2 | +| 1 | a width or precision from an argument, as in `{:1$}`, is not supported | fixtures/reject/src/lib.rs:114:3 | +| 1 | a zero-sized constant of type `_` | fixtures/reject/src/lib.rs:100:2 | | 1 | arithmetic on `_` | fixtures/reject/src/lib.rs:7:2 | -| 1 | comparing `_` as a key, which is not supported yet | fixtures/reject/src/lib.rs:456:52 | -| 1 | hashing `_` as a key, which is not supported yet | fixtures/reject/src/lib.rs:456:52 | -| 1 | hex `Debug`, as in `{:x?}`, is not supported | fixtures/reject/src/lib.rs:128:3 | -| 1 | passing `_`, which drops, to `_`, which is not supported yet | fixtures/reject/src/lib.rs:393:4 | -| 1 | the `+` flag of a format spec is not supported | fixtures/reject/src/lib.rs:123:3 | -| 1 | the `-` flag of a format spec is not supported | fixtures/reject/src/lib.rs:124:3 | -| 1 | unsupported expression: StaticRef | fixtures/reject/src/lib.rs:156:2 | -| 1 | unsupported literal of type `_` | fixtures/reject/src/lib.rs:7:6 | +| 1 | comparing `_` as a key, which is not supported yet | fixtures/reject/src/lib.rs:341:52 | +| 1 | dropping `_`, which is not supported yet | fixtures/reject/src/lib.rs:151:1 | +| 1 | dropping a closure that owns a value that drops, which is not supported yet | fixtures/reject/src/lib.rs:54:1 | +| 1 | hashing `_` as a key, which is not supported yet | fixtures/reject/src/lib.rs:341:52 | +| 1 | hex `Debug`, as in `{:x?}`, is not supported | fixtures/reject/src/lib.rs:113:3 | +| 1 | passing `_`, which drops, to `_`, which is not supported yet | fixtures/reject/src/lib.rs:290:4 | +| 1 | the `+` flag of a format spec is not supported | fixtures/reject/src/lib.rs:108:3 | +| 1 | the `-` flag of a format spec is not supported | fixtures/reject/src/lib.rs:109:3 | ## By API @@ -72,300 +57,270 @@ The type or module each refused type or path belongs to. | Count | API | First | | ---: | --- | --- | -| 6 | `f64` | fixtures/reject/src/lib.rs:6:1 | -| 4 | `Option` | fixtures/reject/src/lib.rs:31:15 | -| 4 | `std::string::String` | fixtures/reject/src/lib.rs:135:16 | -| 4 | `u32` | fixtures/reject/src/lib.rs:19:13 | -| 3 | `Meters` | fixtures/reject/src/lib.rs:161:17 | -| 3 | `std::collections::HashMap` | fixtures/reject/src/lib.rs:446:6 | -| 3 | `std::vec::Vec` | fixtures/reject/src/lib.rs:364:4 | -| 2 | `HashMap` | fixtures/reject/src/lib.rs:446:6 | -| 2 | `Iterator` | fixtures/reject/src/lib.rs:282:2 | -| 2 | `Noisy` | fixtures/reject/src/lib.rs:364:16 | -| 2 | `char` | fixtures/reject/src/lib.rs:10:18 | -| 2 | `std::option::Option` | fixtures/reject/src/lib.rs:393:4 | -| 2 | `std::pin::Pin` | fixtures/reject/src/lib.rs:254:2 | -| 2 | `std::sync::Arc` | fixtures/reject/src/lib.rs:176:42 | -| 2 | `u8` | fixtures/reject/src/lib.rs:106:3 | -| 2 | `{async closure}` | fixtures/reject/src/lib.rs:114:6 | -| 1 | `Boxed` | fixtures/reject/src/lib.rs:90:1 | -| 1 | `DoubleEndedIterator` | fixtures/reject/src/lib.rs:302:1 | -| 1 | `FusedIterator` | fixtures/reject/src/lib.rs:356:1 | -| 1 | `HashSet` | fixtures/reject/src/lib.rs:469:6 | -| 1 | `Hasher` | fixtures/reject/src/lib.rs:494:9 | -| 1 | `Loud` | fixtures/reject/src/lib.rs:469:6 | -| 1 | `Poll` | fixtures/reject/src/lib.rs:222:20 | -| 1 | `Slot` | fixtures/reject/src/lib.rs:86:1 | -| 1 | `[u8; 1]` | fixtures/reject/src/lib.rs:424:45 | -| 1 | `dyn std::ops::Fn(u8) -> u8` | fixtures/reject/src/lib.rs:14:16 | -| 1 | `std::collections::HashSet` | fixtures/reject/src/lib.rs:469:6 | -| 1 | `std::iter::Chain` | fixtures/reject/src/lib.rs:315:51 | -| 1 | `std::ops::RangeFrom` | fixtures/reject/src/lib.rs:441:48 | -| 1 | `std::ops::RangeTo` | fixtures/reject/src/lib.rs:441:7 | -| 1 | `std::ops::Range` | fixtures/reject/src/lib.rs:323:8 | -| 1 | `std::slice::Iter` | fixtures/reject/src/lib.rs:269:11 | +| 5 | `f64` | fixtures/reject/src/lib.rs:6:1 | +| 4 | `Option` | fixtures/reject/src/lib.rs:31:1 | +| 4 | `std::vec::Vec` | fixtures/reject/src/lib.rs:59:2 | +| 4 | `u32` | fixtures/reject/src/lib.rs:19:1 | +| 4 | `u8` | fixtures/reject/src/lib.rs:90:10 | +| 3 | `std::collections::HashMap` | fixtures/reject/src/lib.rs:331:6 | +| 2 | `HashMap` | fixtures/reject/src/lib.rs:331:6 | +| 2 | `Iterator` | fixtures/reject/src/lib.rs:198:2 | +| 2 | `Meters` | fixtures/reject/src/lib.rs:133:2 | +| 2 | `Poll` | fixtures/reject/src/lib.rs:159:1 | +| 2 | `char` | fixtures/reject/src/lib.rs:10:1 | +| 2 | `std::option::Option` | fixtures/reject/src/lib.rs:290:4 | +| 2 | `std::pin::Pin` | fixtures/reject/src/lib.rs:175:2 | +| 2 | `std::string::String` | fixtures/reject/src/lib.rs:120:1 | +| 2 | `std::sync::Arc` | fixtures/reject/src/lib.rs:151:1 | +| 1 | `Boxed` | fixtures/reject/src/lib.rs:75:1 | +| 1 | `DoubleEndedIterator` | fixtures/reject/src/lib.rs:218:1 | +| 1 | `FusedIterator` | fixtures/reject/src/lib.rs:272:1 | +| 1 | `HashSet` | fixtures/reject/src/lib.rs:354:6 | +| 1 | `Hasher` | fixtures/reject/src/lib.rs:379:9 | +| 1 | `IntToFloat` | fixtures/reject/src/lib.rs:144:2 | +| 1 | `Loud` | fixtures/reject/src/lib.rs:354:6 | +| 1 | `Noisy` | fixtures/reject/src/lib.rs:285:20 | +| 1 | `Slot` | fixtures/reject/src/lib.rs:73:1 | +| 1 | `[u8; 1]` | fixtures/reject/src/lib.rs:309:22 | +| 1 | `dyn std::ops::Fn(u8) -> u8` | fixtures/reject/src/lib.rs:14:1 | +| 1 | `std::collections::HashSet` | fixtures/reject/src/lib.rs:354:6 | +| 1 | `std::iter::Chain` | fixtures/reject/src/lib.rs:231:51 | +| 1 | `std::iter::Map` | fixtures/reject/src/lib.rs:204:23 | +| 1 | `std::iter::Rev` | fixtures/reject/src/lib.rs:225:14 | +| 1 | `std::mem` | fixtures/reject/src/lib.rs:52:18 | +| 1 | `std::ops::RangeFrom` | fixtures/reject/src/lib.rs:326:48 | +| 1 | `std::ops::RangeTo` | fixtures/reject/src/lib.rs:326:7 | +| 1 | `std::ops::Range` | fixtures/reject/src/lib.rs:239:8 | +| 1 | `std::slice::Iter` | fixtures/reject/src/lib.rs:185:11 | | 1 | `std::slice` | fixtures/reject/src/lib.rs:36:4 | -| 1 | `std::sync::MutexGuard` | fixtures/reject/src/lib.rs:264:2 | -| 1 | `std::task::Poll` | fixtures/reject/src/lib.rs:238:54 | -| 1 | `{closure}` | fixtures/reject/src/lib.rs:59:31 | +| 1 | `std::sync::MutexGuard` | fixtures/reject/src/lib.rs:180:2 | +| 1 | `u64` | fixtures/reject/src/lib.rs:144:2 | +| 1 | `{async closure}` | fixtures/reject/src/lib.rs:100:2 | ## By type or path | Count | Construct | Type or path | First | | ---: | --- | --- | --- | -| 3 | `_` is not supported: its `None` and `Some` would both be `undefined` | `Option` | fixtures/reject/src/lib.rs:31:15 | -| 3 | replacing the value behind a reference to `_` | `Meters` | fixtures/reject/src/lib.rs:161:17 | -| 3 | unsupported type `_` | `f64` | fixtures/reject/src/lib.rs:6:1 | -| 2 | a `_` binding: a JS value of `_` is a copy, so it can't change | `&mut u32`, `u32` | fixtures/reject/src/lib.rs:19:13 | -| 2 | an iterator that owns `_`, which drops, which is not supported yet | `Noisy` | fixtures/reject/src/lib.rs:364:16 | -| 2 | replacing the `_` behind a reference, whose JS object is shared or private | `std::pin::Pin` | fixtures/reject/src/lib.rs:254:2 | -| 1 | `_` holds `_`, which is `undefined` as `None` is, which is not supported | `std::collections::HashMap`, `std::option::Option` | fixtures/reject/src/lib.rs:451:6 | -| 1 | `_` is generic and implements `Drop`, which is not supported yet | `Boxed` | fixtures/reject/src/lib.rs:90:1 | -| 1 | `_` is not supported: it would be pending two ways with one value | `Poll` | fixtures/reject/src/lib.rs:222:20 | -| 1 | `_` of `_` by `_`, which is not supported yet | `HashMap::contains_key`, `std::collections::HashMap`, `u8` | fixtures/reject/src/lib.rs:486:6 | -| 1 | `_` of `_`, which may drop a `_`, which is not supported yet | `HashSet::remove`, `std::collections::HashSet`, `Loud` | fixtures/reject/src/lib.rs:469:6 | -| 1 | `_` of `_`, which may drop what it holds, which is not supported yet | `HashMap::clear`, `std::collections::HashMap` | fixtures/reject/src/lib.rs:446:6 | -| 1 | `_`, which is not supported yet | `Hasher::write` | fixtures/reject/src/lib.rs:494:9 | -| 1 | `_`: a JS value of `_` is a copy, so a reference can't change it | `&mut std::string::String`, `std::string::String` | fixtures/reject/src/lib.rs:135:16 | -| 1 | `_`: a JS value of `_` is a copy, so a reference can't change it | `&mut u32`, `u32` | fixtures/reject/src/lib.rs:19:13 | -| 1 | a `_` binding: a JS value of `_` is a copy, so it can't change | `&mut std::string::String`, `std::string::String` | fixtures/reject/src/lib.rs:135:16 | -| 1 | a `zip` of `_`, whose closures std calls one item further through `next` than through `fold` | `std::iter::Chain` | fixtures/reject/src/lib.rs:315:51 | +| 3 | `_` is not supported: its `None` and `Some` would both be `undefined` | `Option` | fixtures/reject/src/lib.rs:31:1 | +| 2 | `_` is not supported: it would be pending two ways with one value | `Poll` | fixtures/reject/src/lib.rs:159:1 | +| 2 | `_`: a JS value of `_` is a copy, so a reference can't change it | `&mut u32`, `u32` | fixtures/reject/src/lib.rs:19:1 | +| 2 | an assignment through a reference to `_` | `std::pin::Pin` | fixtures/reject/src/lib.rs:175:2 | +| 2 | an iterator that owns `_`, which drops, which is not supported yet | `std::vec::Vec` | fixtures/reject/src/lib.rs:59:2 | +| 2 | replacing the value behind a reference to `_` | `Meters` | fixtures/reject/src/lib.rs:133:2 | +| 2 | unsupported type `_` | `f64` | fixtures/reject/src/lib.rs:6:1 | +| 1 | `_` holds `_`, which is `undefined` as `None` is, which is not supported | `std::collections::HashMap`, `std::option::Option` | fixtures/reject/src/lib.rs:336:6 | +| 1 | `_` is generic and implements `Drop`, which is not supported yet | `Boxed` | fixtures/reject/src/lib.rs:75:1 | +| 1 | `_` of `_` by `_`, which is not supported yet | `HashMap::contains_key`, `std::collections::HashMap`, `u8` | fixtures/reject/src/lib.rs:371:6 | +| 1 | `_` of `_`, which may drop a `_`, which is not supported yet | `HashSet::remove`, `std::collections::HashSet`, `Loud` | fixtures/reject/src/lib.rs:354:6 | +| 1 | `_` of `_`, which may drop what it holds, which is not supported yet | `HashMap::clear`, `std::collections::HashMap` | fixtures/reject/src/lib.rs:331:6 | +| 1 | `_`, which is not supported yet | `Hasher::write` | fixtures/reject/src/lib.rs:379:9 | +| 1 | `_`: a JS value of `_` is a copy, so a reference can't change it | `&mut Slot`, `Slot` | fixtures/reject/src/lib.rs:73:1 | +| 1 | `_`: a JS value of `_` is a copy, so a reference can't change it | `&mut std::string::String`, `std::string::String` | fixtures/reject/src/lib.rs:120:1 | +| 1 | `_`: a JS value of `_` is a copy, so a reference can't change it | `&mut u8`, `u8` | fixtures/reject/src/lib.rs:90:10 | +| 1 | a `_` cast from `_` to `_` | `IntToFloat`, `u64`, `f64` | fixtures/reject/src/lib.rs:144:2 | +| 1 | a `zip` of `_`, whose closures std calls one item further through `next` than through `fold` | `std::iter::Chain` | fixtures/reject/src/lib.rs:231:51 | | 1 | a cast from `_` | `char` | fixtures/reject/src/lib.rs:11:2 | -| 1 | a cast to `_` | `f64` | fixtures/reject/src/lib.rs:172:2 | -| 1 | a closure of type `_` | `{async closure}` | fixtures/reject/src/lib.rs:114:10 | -| 1 | a field of `_` | `std::ops::RangeFrom` | fixtures/reject/src/lib.rs:441:48 | -| 1 | a field of `_` | `std::ops::RangeTo` | fixtures/reject/src/lib.rs:441:7 | -| 1 | a mutable borrow of a subslice of `_`, which JS would copy, having no views | `u32` | fixtures/reject/src/lib.rs:404:13 | -| 1 | a mutable reference to `_`, which is no object it can change in place | `std::string::String` | fixtures/reject/src/lib.rs:137:17 | -| 1 | an async body returning `_` is not supported: its `Ready` could be pending | `std::task::Poll` | fixtures/reject/src/lib.rs:238:54 | -| 1 | an async body that borrows `_` mutably, which is no object it can change in place | `u8` | fixtures/reject/src/lib.rs:106:3 | -| 1 | an iterator of the crate implementing `_`, which is not supported yet | `DoubleEndedIterator` | fixtures/reject/src/lib.rs:302:1 | -| 1 | an iterator of the crate implementing `_`, which is not supported yet | `FusedIterator` | fixtures/reject/src/lib.rs:356:1 | -| 1 | an iterator that owns `_`, which drops, which is not supported yet | `std::vec::Vec` | fixtures/reject/src/lib.rs:364:4 | +| 1 | a constant of type `_` | `&u8` | fixtures/reject/src/lib.rs:128:2 | +| 1 | a field of `_` | `std::ops::RangeFrom` | fixtures/reject/src/lib.rs:326:48 | +| 1 | a field of `_` | `std::ops::RangeTo` | fixtures/reject/src/lib.rs:326:7 | +| 1 | a mutable borrow of a subslice of `_`, which JS would copy, having no views | `u32` | fixtures/reject/src/lib.rs:295:13 | +| 1 | a scalar constant of type `_` | `f64` | fixtures/reject/src/lib.rs:7:2 | +| 1 | a zero-sized constant of type `_` | `{async closure}` | fixtures/reject/src/lib.rs:100:2 | +| 1 | an assignment through a reference to `_` | `std::sync::Arc` | fixtures/reject/src/lib.rs:155:2 | +| 1 | an assignment through a reference to `_` | `std::sync::MutexGuard` | fixtures/reject/src/lib.rs:180:2 | +| 1 | an assignment through a reference to `_` | `u32` | fixtures/reject/src/lib.rs:20:2 | +| 1 | an assignment through a reference to `_` | `u8` | fixtures/reject/src/lib.rs:91:3 | +| 1 | an iterator of the crate implementing `_`, which is not supported yet | `DoubleEndedIterator` | fixtures/reject/src/lib.rs:218:1 | +| 1 | an iterator of the crate implementing `_`, which is not supported yet | `FusedIterator` | fixtures/reject/src/lib.rs:272:1 | +| 1 | an iterator that owns `_`, which drops, which is not supported yet | `Noisy` | fixtures/reject/src/lib.rs:285:20 | | 1 | arithmetic on `_` | `f64` | fixtures/reject/src/lib.rs:7:2 | -| 1 | comparing `_` as a key, which is not supported yet | `std::vec::Vec` | fixtures/reject/src/lib.rs:456:52 | -| 1 | dropping `_`, which is not supported yet | `Slot` | fixtures/reject/src/lib.rs:86:1 | -| 1 | dropping `_`, which is not supported yet | `std::sync::Arc` | fixtures/reject/src/lib.rs:176:42 | -| 1 | dropping `_`, which is not supported yet | `{closure}` | fixtures/reject/src/lib.rs:59:31 | -| 1 | hashing `_` as a key, which is not supported yet | `std::vec::Vec` | fixtures/reject/src/lib.rs:456:52 | -| 1 | overriding `_`, which std's adaptors call in place of `next` or beside it | `Iterator::fold` | fixtures/reject/src/lib.rs:282:2 | -| 1 | overriding `_`, which std's adaptors call in place of `next` or beside it | `Iterator::size_hint` | fixtures/reject/src/lib.rs:336:2 | -| 1 | passing `_`, which drops, to `_`, which is not supported yet | `std::option::Option`, `Option::unwrap_or` | fixtures/reject/src/lib.rs:393:4 | -| 1 | replacing the `_` behind a reference, whose JS object is shared or private | `std::sync::Arc` | fixtures/reject/src/lib.rs:218:2 | -| 1 | replacing the `_` behind a reference, whose JS object is shared or private | `std::sync::MutexGuard` | fixtures/reject/src/lib.rs:264:2 | -| 1 | replacing the value behind a reference to `_` | `[u8; 1]` | fixtures/reject/src/lib.rs:424:45 | -| 1 | unsupported call to `_` | `::cycle` | fixtures/reject/src/lib.rs:269:11 | -| 1 | unsupported call to `_` | `::write_fmt` | fixtures/reject/src/lib.rs:137:10 | -| 1 | unsupported call to `_` | `std::ops::Range::contains` | fixtures/reject/src/lib.rs:323:8 | +| 1 | comparing `_` as a key, which is not supported yet | `std::vec::Vec` | fixtures/reject/src/lib.rs:341:52 | +| 1 | constructing `_` from another crate | `std::iter::Map` | fixtures/reject/src/lib.rs:204:23 | +| 1 | constructing `_` from another crate | `std::iter::Rev` | fixtures/reject/src/lib.rs:225:14 | +| 1 | dropping `_`, which is not supported yet | `std::sync::Arc` | fixtures/reject/src/lib.rs:151:1 | +| 1 | hashing `_` as a key, which is not supported yet | `std::vec::Vec` | fixtures/reject/src/lib.rs:341:52 | +| 1 | overriding `_`, which std's adaptors call in place of `next` or beside it | `Iterator::fold` | fixtures/reject/src/lib.rs:198:2 | +| 1 | overriding `_`, which std's adaptors call in place of `next` or beside it | `Iterator::size_hint` | fixtures/reject/src/lib.rs:252:2 | +| 1 | passing `_`, which drops, to `_`, which is not supported yet | `std::option::Option`, `Option::unwrap_or` | fixtures/reject/src/lib.rs:290:4 | +| 1 | replacing the value behind a reference to `_` | `[u8; 1]` | fixtures/reject/src/lib.rs:309:22 | +| 1 | unsupported call to `_` | `::cycle` | fixtures/reject/src/lib.rs:185:11 | +| 1 | unsupported call to `_` | `::write_fmt` | fixtures/reject/src/lib.rs:122:10 | +| 1 | unsupported call to `_` | `std::mem::size_of_val` | fixtures/reject/src/lib.rs:52:18 | +| 1 | unsupported call to `_` | `std::ops::Range::contains` | fixtures/reject/src/lib.rs:239:8 | | 1 | unsupported call to `_` | `std::slice::sort` | fixtures/reject/src/lib.rs:36:4 | -| 1 | unsupported literal of type `_` | `f64` | fixtures/reject/src/lib.rs:7:6 | -| 1 | unsupported type `_` | `char` | fixtures/reject/src/lib.rs:10:18 | -| 1 | unsupported type `_` | `dyn std::ops::Fn(u8) -> u8` | fixtures/reject/src/lib.rs:14:16 | -| 1 | unsupported type `_` | `{async closure}` | fixtures/reject/src/lib.rs:114:6 | +| 1 | unsupported type `_` | `char` | fixtures/reject/src/lib.rs:10:1 | +| 1 | unsupported type `_` | `dyn std::ops::Fn(u8) -> u8` | fixtures/reject/src/lib.rs:14:1 | ## Spans -
unsupported type `_` (6) +
an assignment through a reference to `_` (6) -- fixtures/reject/src/lib.rs:6:1: unsupported type `f64` -- fixtures/reject/src/lib.rs:6:14: unsupported type `f64` -- fixtures/reject/src/lib.rs:10:18: unsupported type `char` -- fixtures/reject/src/lib.rs:14:16: unsupported type `dyn std::ops::Fn(u8) -> u8` -- fixtures/reject/src/lib.rs:114:6: unsupported type `{async closure@fixtures/reject/src/lib.rs:114:10: 114:18}` -- fixtures/reject/src/lib.rs:170:1: unsupported type `f64` +- fixtures/reject/src/lib.rs:20:2: an assignment through a reference to `u32` +- fixtures/reject/src/lib.rs:91:3: an assignment through a reference to `u8` +- fixtures/reject/src/lib.rs:155:2: an assignment through a reference to `std::sync::Arc` +- fixtures/reject/src/lib.rs:175:2: an assignment through a reference to `std::pin::Pin>` +- fixtures/reject/src/lib.rs:180:2: an assignment through a reference to `std::sync::MutexGuard<'_, u8>` +- fixtures/reject/src/lib.rs:303:2: an assignment through a reference to `std::pin::Pin<&mut Noisy>`
-
replacing the `_` behind a reference, whose JS object is shared or private (4) +
`_`: a JS value of `_` is a copy, so a reference can't change it (5) -- fixtures/reject/src/lib.rs:218:2: replacing the `std::sync::Arc` behind a reference, whose JS object is shared or private -- fixtures/reject/src/lib.rs:254:2: replacing the `std::pin::Pin>` behind a reference, whose JS object is shared or private -- fixtures/reject/src/lib.rs:264:2: replacing the `std::sync::MutexGuard<'_, u8>` behind a reference, whose JS object is shared or private -- fixtures/reject/src/lib.rs:412:2: replacing the `std::pin::Pin<&mut Noisy>` behind a reference, whose JS object is shared or private +- fixtures/reject/src/lib.rs:19:1: `&mut u32`: a JS value of `u32` is a copy, so a reference can't change it +- fixtures/reject/src/lib.rs:24:1: `&mut u32`: a JS value of `u32` is a copy, so a reference can't change it +- fixtures/reject/src/lib.rs:73:1: `&mut Slot`: a JS value of `Slot` is a copy, so a reference can't change it +- fixtures/reject/src/lib.rs:90:10: `&mut u8`: a JS value of `u8` is a copy, so a reference can't change it +- fixtures/reject/src/lib.rs:120:1: `&mut std::string::String`: a JS value of `std::string::String` is a copy, so a reference can't change it
-
replacing the value behind a reference to `_` (4) +
unsupported call to `_` (5) -- fixtures/reject/src/lib.rs:161:17: replacing the value behind a reference to `Meters` -- fixtures/reject/src/lib.rs:161:20: replacing the value behind a reference to `Meters` -- fixtures/reject/src/lib.rs:165:25: replacing the value behind a reference to `Meters` -- fixtures/reject/src/lib.rs:424:45: replacing the value behind a reference to `[u8; 1]` +- fixtures/reject/src/lib.rs:36:4: unsupported call to `std::slice::::sort` +- fixtures/reject/src/lib.rs:52:18: unsupported call to `std::mem::size_of_val::` +- fixtures/reject/src/lib.rs:122:10: unsupported call to `::write_fmt` +- fixtures/reject/src/lib.rs:185:11: unsupported call to ` as std::iter::Iterator>::cycle` +- fixtures/reject/src/lib.rs:239:8: unsupported call to `std::ops::Range::::contains::`
-
unsupported call to `_` (4) +
unsupported type `_` (4) -- fixtures/reject/src/lib.rs:36:4: unsupported call to `std::slice::::sort` -- fixtures/reject/src/lib.rs:137:10: unsupported call to `::write_fmt` -- fixtures/reject/src/lib.rs:269:11: unsupported call to ` as std::iter::Iterator>::cycle` -- fixtures/reject/src/lib.rs:323:8: unsupported call to `std::ops::Range::::contains::` +- fixtures/reject/src/lib.rs:6:1: unsupported type `f64` +- fixtures/reject/src/lib.rs:10:1: unsupported type `char` +- fixtures/reject/src/lib.rs:14:1: unsupported type `dyn std::ops::Fn(u8) -> u8` +- fixtures/reject/src/lib.rs:142:1: unsupported type `f64`
`_` is not supported: its `None` and `Some` would both be `undefined` (3) -- fixtures/reject/src/lib.rs:31:15: `Option>` is not supported: its `None` and `Some` would both be `undefined` +- fixtures/reject/src/lib.rs:31:1: `Option>` is not supported: its `None` and `Some` would both be `undefined` - fixtures/reject/src/lib.rs:40:42: `Option>` is not supported: its `None` and `Some` would both be `undefined` -- fixtures/reject/src/lib.rs:227:19: `Option>` is not supported: its `None` and `Some` would both be `undefined` - -
- -
a `_` binding: a JS value of `_` is a copy, so it can't change (3) - -- fixtures/reject/src/lib.rs:19:13: a `&mut u32` binding: a JS value of `u32` is a copy, so it can't change -- fixtures/reject/src/lib.rs:25:6: a `&mut u32` binding: a JS value of `u32` is a copy, so it can't change -- fixtures/reject/src/lib.rs:135:16: a `&mut std::string::String` binding: a JS value of `std::string::String` is a copy, so it can't change +- fixtures/reject/src/lib.rs:164:1: `Option>` is not supported: its `None` and `Some` would both be `undefined`
an iterator that owns `_`, which drops, which is not supported yet (3) -- fixtures/reject/src/lib.rs:364:4: an iterator that owns `std::vec::Vec`, which drops, which is not supported yet -- fixtures/reject/src/lib.rs:364:16: an iterator that owns `Noisy`, which drops, which is not supported yet -- fixtures/reject/src/lib.rs:369:20: an iterator that owns `Noisy`, which drops, which is not supported yet - -
- -
dropping `_`, which is not supported yet (3) - -- fixtures/reject/src/lib.rs:59:31: dropping `{closure@fixtures/reject/src/lib.rs:61:10: 61:17}`, which is not supported yet -- fixtures/reject/src/lib.rs:86:1: dropping `Slot`, which is not supported yet -- fixtures/reject/src/lib.rs:176:42: dropping `std::sync::Arc<&Noisy>`, which is not supported yet - -
- -
`_`: a JS value of `_` is a copy, so a reference can't change it (2) - -- fixtures/reject/src/lib.rs:19:13: `&mut u32`: a JS value of `u32` is a copy, so a reference can't change it -- fixtures/reject/src/lib.rs:135:16: `&mut std::string::String`: a JS value of `std::string::String` is a copy, so a reference can't change it - -
- -
a `for` loop over values that drop, which is not supported yet (2) - -- fixtures/reject/src/lib.rs:69:6: a `for` loop over values that drop, which is not supported yet -- fixtures/reject/src/lib.rs:385:6: a `for` loop over values that drop, which is not supported yet +- fixtures/reject/src/lib.rs:59:2: an iterator that owns `std::vec::Vec`, which drops, which is not supported yet +- fixtures/reject/src/lib.rs:280:4: an iterator that owns `std::vec::Vec`, which drops, which is not supported yet +- fixtures/reject/src/lib.rs:285:20: an iterator that owns `Noisy`, which drops, which is not supported yet
-
a `match` on a temporary that drops, which it doesn't move out of whole (2) +
replacing the value behind a reference to `_` (3) -- fixtures/reject/src/lib.rs:210:2: a `match` on a temporary that drops, which it doesn't move out of whole -- fixtures/reject/src/lib.rs:245:16: a `match` on a temporary that drops, which it doesn't move out of whole +- fixtures/reject/src/lib.rs:133:2: replacing the value behind a reference to `Meters` +- fixtures/reject/src/lib.rs:137:2: replacing the value behind a reference to `Meters` +- fixtures/reject/src/lib.rs:309:22: replacing the value behind a reference to `[u8; 1]`
-
a closure that copies a mutable variable (2) +
`_` is not supported: it would be pending two ways with one value (2) -- fixtures/reject/src/lib.rs:142:18: a closure that copies a mutable variable -- fixtures/reject/src/lib.rs:432:3: a closure that copies a mutable variable +- fixtures/reject/src/lib.rs:159:1: `Poll>>` is not supported: it would be pending two ways with one value +- fixtures/reject/src/lib.rs:169:54: `Poll>` is not supported: it would be pending two ways with one value
a field of `_` (2) -- fixtures/reject/src/lib.rs:441:7: a field of `std::ops::RangeTo` -- fixtures/reject/src/lib.rs:441:48: a field of `std::ops::RangeFrom` +- fixtures/reject/src/lib.rs:326:7: a field of `std::ops::RangeTo` +- fixtures/reject/src/lib.rs:326:48: a field of `std::ops::RangeFrom`
-
a field of a temporary that drops: bind it to a variable first (2) +
an iterator of the crate implementing `_`, which is not supported yet (2) -- fixtures/reject/src/lib.rs:55:2: a field of a temporary that drops: bind it to a variable first -- fixtures/reject/src/lib.rs:259:2: a field of a temporary that drops: bind it to a variable first +- fixtures/reject/src/lib.rs:218:1: an iterator of the crate implementing `DoubleEndedIterator`, which is not supported yet +- fixtures/reject/src/lib.rs:272:1: an iterator of the crate implementing `FusedIterator`, which is not supported yet
-
an iterator of the crate implementing `_`, which is not supported yet (2) +
constructing `_` from another crate (2) -- fixtures/reject/src/lib.rs:302:1: an iterator of the crate implementing `DoubleEndedIterator`, which is not supported yet -- fixtures/reject/src/lib.rs:356:1: an iterator of the crate implementing `FusedIterator`, which is not supported yet +- fixtures/reject/src/lib.rs:204:23: constructing `std::iter::Map` from another crate +- fixtures/reject/src/lib.rs:225:14: constructing `std::iter::Rev` from another crate
overriding `_`, which std's adaptors call in place of `next` or beside it (2) -- fixtures/reject/src/lib.rs:282:2: overriding `Iterator::fold`, which std's adaptors call in place of `next` or beside it -- fixtures/reject/src/lib.rs:336:2: overriding `Iterator::size_hint`, which std's adaptors call in place of `next` or beside it +- fixtures/reject/src/lib.rs:198:2: overriding `Iterator::fold`, which std's adaptors call in place of `next` or beside it +- fixtures/reject/src/lib.rs:252:2: overriding `Iterator::size_hint`, which std's adaptors call in place of `next` or beside it
`Binary` formatting, as in `{:b}`, is not supported (1) -- fixtures/reject/src/lib.rs:125:3: `Binary` formatting, as in `{:b}`, is not supported +- fixtures/reject/src/lib.rs:110:3: `Binary` formatting, as in `{:b}`, is not supported
`LowerExp` formatting, as in `{:e}`, is not supported (1) -- fixtures/reject/src/lib.rs:127:3: `LowerExp` formatting, as in `{:e}`, is not supported +- fixtures/reject/src/lib.rs:112:3: `LowerExp` formatting, as in `{:e}`, is not supported
`Octal` formatting, as in `{:o}`, is not supported (1) -- fixtures/reject/src/lib.rs:126:3: `Octal` formatting, as in `{:o}`, is not supported +- fixtures/reject/src/lib.rs:111:3: `Octal` formatting, as in `{:o}`, is not supported
`Pointer` formatting, as in `{:p}`, is not supported (1) -- fixtures/reject/src/lib.rs:130:3: `Pointer` formatting, as in `{:p}`, is not supported +- fixtures/reject/src/lib.rs:115:3: `Pointer` formatting, as in `{:p}`, is not supported
`_` holds `_`, which is `undefined` as `None` is, which is not supported (1) -- fixtures/reject/src/lib.rs:451:6: `std::collections::HashMap>` holds `std::option::Option`, which is `undefined` as `None` is, which is not supported +- fixtures/reject/src/lib.rs:336:6: `std::collections::HashMap>` holds `std::option::Option`, which is `undefined` as `None` is, which is not supported
`_` is generic and implements `Drop`, which is not supported yet (1) -- fixtures/reject/src/lib.rs:90:1: `Boxed` is generic and implements `Drop`, which is not supported yet - -
- -
`_` is not supported: it would be pending two ways with one value (1) - -- fixtures/reject/src/lib.rs:222:20: `Poll>>` is not supported: it would be pending two ways with one value +- fixtures/reject/src/lib.rs:75:1: `Boxed` is generic and implements `Drop`, which is not supported yet
`_` of `_` by `_`, which is not supported yet (1) -- fixtures/reject/src/lib.rs:486:6: `HashMap::contains_key` of `std::collections::HashMap` by `u8`, which is not supported yet +- fixtures/reject/src/lib.rs:371:6: `HashMap::contains_key` of `std::collections::HashMap` by `u8`, which is not supported yet
`_` of `_`, which may drop a `_`, which is not supported yet (1) -- fixtures/reject/src/lib.rs:469:6: `HashSet::remove` of `std::collections::HashSet`, which may drop a `Loud`, which is not supported yet +- fixtures/reject/src/lib.rs:354:6: `HashSet::remove` of `std::collections::HashSet`, which may drop a `Loud`, which is not supported yet
`_` of `_`, which may drop what it holds, which is not supported yet (1) -- fixtures/reject/src/lib.rs:446:6: `HashMap::clear` of `std::collections::HashMap`, which may drop what it holds, which is not supported yet +- fixtures/reject/src/lib.rs:331:6: `HashMap::clear` of `std::collections::HashMap`, which may drop what it holds, which is not supported yet
`_`, which is not supported yet (1) -- fixtures/reject/src/lib.rs:494:9: `Hasher::write`, which is not supported yet +- fixtures/reject/src/lib.rs:379:9: `Hasher::write`, which is not supported yet
-
a `let` on a temporary that drops, which it doesn't move out of whole (1) +
a `_` cast from `_` to `_` (1) -- fixtures/reject/src/lib.rs:193:2: a `let` on a temporary that drops, which it doesn't move out of whole +- fixtures/reject/src/lib.rs:144:2: a `IntToFloat` cast from `u64` to `f64`
a `zip` of `_`, whose closures std calls one item further through `next` than through `fold` (1) -- fixtures/reject/src/lib.rs:315:51: a `zip` of `std::iter::Chain, {closure@fixtures/reject/src/lib.rs:315:15: 315:18}>, std::iter::Copied>>`, whose closures std calls one item further through `next` than through `fold` +- fixtures/reject/src/lib.rs:231:51: a `zip` of `std::iter::Chain, {closure@fixtures/reject/src/lib.rs:231:15: 231:18}>, std::iter::Copied>>`, whose closures std calls one item further through `next` than through `fold`
@@ -375,164 +330,104 @@ The type or module each refused type or path belongs to.
-
a cast to `_` (1) - -- fixtures/reject/src/lib.rs:172:2: a cast to `f64` - -
- -
a closure of type `_` (1) +
a constant of type `_` (1) -- fixtures/reject/src/lib.rs:114:10: a closure of type `{async closure@fixtures/reject/src/lib.rs:114:10: 114:18}` +- fixtures/reject/src/lib.rs:128:2: a constant of type `&u8`
-
a closure that captures a value that drops, which is not supported yet (1) +
a copy of a closure that changes what it captured (1) -- fixtures/reject/src/lib.rs:61:23: a closure that captures a value that drops, which is not supported yet +- fixtures/reject/src/lib.rs:320:14: a copy of a closure that changes what it captured
a mutable borrow of a subslice of `_`, which JS would copy, having no views (1) -- fixtures/reject/src/lib.rs:404:13: a mutable borrow of a subslice of `u32`, which JS would copy, having no views - -
- -
a mutable reference to `_`, which is no object it can change in place (1) - -- fixtures/reject/src/lib.rs:137:17: a mutable reference to `std::string::String`, which is no object it can change in place - -
- -
a parameter that drops bound by a pattern, which is not supported yet (1) - -- fixtures/reject/src/lib.rs:76:21: a parameter that drops bound by a pattern, which is not supported yet +- fixtures/reject/src/lib.rs:295:13: a mutable borrow of a subslice of `u32`, which JS would copy, having no views
a precision, as in `{:.2}`, is not supported (1) -- fixtures/reject/src/lib.rs:122:3: a precision, as in `{:.2}`, is not supported +- fixtures/reject/src/lib.rs:107:3: a precision, as in `{:.2}`, is not supported
a printable type must implement `Display` or `Debug` (1) -- fixtures/reject/src/lib.rs:168:1: a printable type must implement `Display` or `Debug` +- fixtures/reject/src/lib.rs:140:1: a printable type must implement `Display` or `Debug`
-
a rest pattern that moves values that drop out of a place, which is not supported yet (1) +
a scalar constant of type `_` (1) -- fixtures/reject/src/lib.rs:398:14: a rest pattern that moves values that drop out of a place, which is not supported yet - -
- -
a variable from outside the function (1) - -- fixtures/reject/src/lib.rs:77:2: a variable from outside the function +- fixtures/reject/src/lib.rs:7:2: a scalar constant of type `f64`
a width or precision from an argument, as in `{:1$}`, is not supported (1) -- fixtures/reject/src/lib.rs:129:3: a width or precision from an argument, as in `{:1$}`, is not supported - -
- -
an `.await` in an operand after one that drops, which is not supported yet: bind the awaited value first (1) - -- fixtures/reject/src/lib.rs:183:13: an `.await` in an operand after one that drops, which is not supported yet: bind the awaited value first - -
- -
an `.await` in the place an assignment of a value that drops writes to, which is not supported yet: bind the awaited value first (1) - -- fixtures/reject/src/lib.rs:200:2: an `.await` in the place an assignment of a value that drops writes to, which is not supported yet: bind the awaited value first - -
- -
an `if let` on a temporary that drops, which it doesn't move out of whole (1) - -- fixtures/reject/src/lib.rs:234:9: an `if let` on a temporary that drops, which it doesn't move out of whole +- fixtures/reject/src/lib.rs:114:3: a width or precision from an argument, as in `{:1$}`, is not supported
-
an array repeat of a value that drops, which is not supported yet (1) +
a zero-sized constant of type `_` (1) -- fixtures/reject/src/lib.rs:417:14: an array repeat of a value that drops, which is not supported yet +- fixtures/reject/src/lib.rs:100:2: a zero-sized constant of type `{async closure@fixtures/reject/src/lib.rs:99:10: 99:18}`
-
an async body returning `_` is not supported: its `Ready` could be pending (1) - -- fixtures/reject/src/lib.rs:238:54: an async body returning `std::task::Poll` is not supported: its `Ready` could be pending - -
- -
an async body that borrows `_` mutably, which is no object it can change in place (1) +
arithmetic on `_` (1) -- fixtures/reject/src/lib.rs:106:3: an async body that borrows `u8` mutably, which is no object it can change in place +- fixtures/reject/src/lib.rs:7:2: arithmetic on `f64`
-
an or-pattern with bindings (1) +
comparing `_` as a key, which is not supported yet (1) -- fixtures/reject/src/lib.rs:149:3: an or-pattern with bindings +- fixtures/reject/src/lib.rs:341:52: comparing `std::vec::Vec` as a key, which is not supported yet
-
arithmetic on `_` (1) +
dropping `_`, which is not supported yet (1) -- fixtures/reject/src/lib.rs:7:2: arithmetic on `f64` +- fixtures/reject/src/lib.rs:151:1: dropping `std::sync::Arc<&Noisy>`, which is not supported yet
-
comparing `_` as a key, which is not supported yet (1) +
dropping a closure that owns a value that drops, which is not supported yet (1) -- fixtures/reject/src/lib.rs:456:52: comparing `std::vec::Vec` as a key, which is not supported yet +- fixtures/reject/src/lib.rs:54:1: dropping a closure that owns a value that drops, which is not supported yet
hashing `_` as a key, which is not supported yet (1) -- fixtures/reject/src/lib.rs:456:52: hashing `std::vec::Vec` as a key, which is not supported yet +- fixtures/reject/src/lib.rs:341:52: hashing `std::vec::Vec` as a key, which is not supported yet
hex `Debug`, as in `{:x?}`, is not supported (1) -- fixtures/reject/src/lib.rs:128:3: hex `Debug`, as in `{:x?}`, is not supported +- fixtures/reject/src/lib.rs:113:3: hex `Debug`, as in `{:x?}`, is not supported
passing `_`, which drops, to `_`, which is not supported yet (1) -- fixtures/reject/src/lib.rs:393:4: passing `std::option::Option`, which drops, to `Option::unwrap_or`, which is not supported yet +- fixtures/reject/src/lib.rs:290:4: passing `std::option::Option`, which drops, to `Option::unwrap_or`, which is not supported yet
the `+` flag of a format spec is not supported (1) -- fixtures/reject/src/lib.rs:123:3: the `+` flag of a format spec is not supported +- fixtures/reject/src/lib.rs:108:3: the `+` flag of a format spec is not supported
the `-` flag of a format spec is not supported (1) -- fixtures/reject/src/lib.rs:124:3: the `-` flag of a format spec is not supported - -
- -
unsupported expression: StaticRef (1) - -- fixtures/reject/src/lib.rs:156:2: unsupported expression: StaticRef - -
- -
unsupported literal of type `_` (1) - -- fixtures/reject/src/lib.rs:7:6: unsupported literal of type `f64` +- fixtures/reject/src/lib.rs:109:3: the `-` flag of a format spec is not supported
diff --git a/ts/fixtures/reject/expected-mir.txt b/ts/fixtures/reject/expected-mir.txt deleted file mode 100644 index d4270c809..000000000 --- a/ts/fixtures/reject/expected-mir.txt +++ /dev/null @@ -1,70 +0,0 @@ -a root must not be generic at fixtures/reject/src/lib.rs:170:1 -no item `missing` in the crate -a printable type must implement `Display` or `Debug` at fixtures/reject/src/lib.rs:168:1 -unsupported type `f64` at fixtures/reject/src/lib.rs:6:1 -a scalar constant of type `f64` at fixtures/reject/src/lib.rs:7:2 -arithmetic on `f64` at fixtures/reject/src/lib.rs:7:2 -unsupported type `char` at fixtures/reject/src/lib.rs:10:1 -a cast from `char` at fixtures/reject/src/lib.rs:11:2 -unsupported type `dyn std::ops::Fn(u8) -> u8` at fixtures/reject/src/lib.rs:14:1 -`&mut u32`: a JS value of `u32` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:19:1 -an assignment through a reference to `u32` at fixtures/reject/src/lib.rs:20:2 -`&mut u32`: a JS value of `u32` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:24:1 -`Option>` is not supported: its `None` and `Some` would both be `undefined` at fixtures/reject/src/lib.rs:31:1 -unsupported call to `std::slice::::sort` at fixtures/reject/src/lib.rs:36:4 -`Option>` is not supported: its `None` and `Some` would both be `undefined` at fixtures/reject/src/lib.rs:40:42 -`Option>` is not supported: its `None` and `Some` would both be `undefined` at fixtures/reject/src/lib.rs:39:1 -an iterator that owns `std::vec::Vec`, which drops, which is not supported yet at fixtures/reject/src/lib.rs:69:11 -`&mut Slot`: a JS value of `Slot` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:88:1 -`Boxed` is generic and implements `Drop`, which is not supported yet at fixtures/reject/src/lib.rs:98:10 -`&mut u8`: a JS value of `u8` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:105:10 -an assignment through a reference to `u8` at fixtures/reject/src/lib.rs:106:3 -a zero-sized constant of type `{async closure@fixtures/reject/src/lib.rs:114:10: 114:18}` at fixtures/reject/src/lib.rs:115:2 -a precision, as in `{:.2}`, is not supported at fixtures/reject/src/lib.rs:122:3 -the `+` flag of a format spec is not supported at fixtures/reject/src/lib.rs:123:3 -the `-` flag of a format spec is not supported at fixtures/reject/src/lib.rs:124:3 -formatting by `new_binary` is not supported at fixtures/reject/src/lib.rs:125:12 -formatting by `new_octal` is not supported at fixtures/reject/src/lib.rs:126:12 -formatting by `new_lower_exp` is not supported at fixtures/reject/src/lib.rs:127:12 -hex `Debug`, as in `{:x?}`, is not supported at fixtures/reject/src/lib.rs:128:3 -a width or precision from an argument, as in `{:1$}`, is not supported at fixtures/reject/src/lib.rs:129:15 -a width or precision from an argument, as in `{:1$}`, is not supported at fixtures/reject/src/lib.rs:129:3 -formatting by `new_pointer` is not supported at fixtures/reject/src/lib.rs:130:12 -`&mut std::string::String`: a JS value of `std::string::String` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:135:1 -unsupported call to `::write_fmt` at fixtures/reject/src/lib.rs:137:10 -a constant of type `&u8` at fixtures/reject/src/lib.rs:156:2 -replacing the value behind a reference to `Meters` at fixtures/reject/src/lib.rs:161:2 -replacing the value behind a reference to `Meters` at fixtures/reject/src/lib.rs:165:2 -dropping `std::sync::Arc<&Noisy>`, which is not supported yet at fixtures/reject/src/lib.rs:179:1 -an assignment through a reference to `std::sync::Arc` at fixtures/reject/src/lib.rs:218:2 -`Poll>>` is not supported: it would be pending two ways with one value at fixtures/reject/src/lib.rs:222:1 -`Option>` is not supported: its `None` and `Some` would both be `undefined` at fixtures/reject/src/lib.rs:227:1 -`Poll>` is not supported: it would be pending two ways with one value at fixtures/reject/src/lib.rs:238:54 -an assignment through a reference to `std::pin::Pin>` at fixtures/reject/src/lib.rs:254:2 -an assignment through a reference to `std::sync::MutexGuard<'_, u8>` at fixtures/reject/src/lib.rs:264:2 -unsupported call to ` as std::iter::Iterator>::cycle` at fixtures/reject/src/lib.rs:269:11 -constructing `std::iter::Map` from another crate at fixtures/reject/src/lib.rs:288:23 -constructing `std::iter::Rev` from another crate at fixtures/reject/src/lib.rs:309:14 -a `zip` of `std::iter::Chain, {closure@fixtures/reject/src/lib.rs:315:15: 315:18}>, std::iter::Copied>>`, whose closures std calls one item further through `next` than through `fold` at fixtures/reject/src/lib.rs:315:51 -unsupported call to `std::ops::Range::::contains::` at fixtures/reject/src/lib.rs:323:8 -an iterator that owns `std::vec::Vec`, which drops, which is not supported yet at fixtures/reject/src/lib.rs:364:4 -an iterator that owns `Noisy`, which drops, which is not supported yet at fixtures/reject/src/lib.rs:369:20 -passing `std::option::Option`, which drops, to `Option::unwrap_or`, which is not supported yet at fixtures/reject/src/lib.rs:393:4 -a mutable borrow of a subslice of `u32`, which JS would copy, having no views at fixtures/reject/src/lib.rs:404:13 -an assignment through a reference to `std::pin::Pin<&mut Noisy>` at fixtures/reject/src/lib.rs:412:2 -replacing the value behind a reference to `[u8; 1]` at fixtures/reject/src/lib.rs:424:22 -a copy of a closure that changes what it captured at fixtures/reject/src/lib.rs:435:14 -a field of `std::ops::RangeTo` at fixtures/reject/src/lib.rs:441:7 -a field of `std::ops::RangeFrom` at fixtures/reject/src/lib.rs:441:48 -`HashMap::clear` of `std::collections::HashMap`, which may drop what it holds, which is not supported yet at fixtures/reject/src/lib.rs:446:6 -`std::collections::HashMap>` holds `std::option::Option`, which is `undefined` as `None` is, which is not supported at fixtures/reject/src/lib.rs:451:6 -`Option<&std::option::Option>` is not supported: its `None` and `Some` would both be `undefined` at fixtures/reject/src/lib.rs:450:1 -hashing `std::vec::Vec` as a key, which is not supported yet at fixtures/reject/src/lib.rs:456:52 -comparing `std::vec::Vec` as a key, which is not supported yet at fixtures/reject/src/lib.rs:456:52 -`HashSet::remove` of `std::collections::HashSet`, which may drop a `Loud`, which is not supported yet at fixtures/reject/src/lib.rs:469:6 -`HashMap::contains_key` of `std::collections::HashMap` by `u8`, which is not supported yet at fixtures/reject/src/lib.rs:486:6 -overriding `Iterator::fold`, which std's adaptors call in place of `next` or beside it at fixtures/reject/src/lib.rs:282:2 -an iterator of the crate implementing `DoubleEndedIterator`, which is not supported yet at fixtures/reject/src/lib.rs:302:1 -overriding `Iterator::size_hint`, which std's adaptors call in place of `next` or beside it at fixtures/reject/src/lib.rs:336:2 -an iterator of the crate implementing `FusedIterator`, which is not supported yet at fixtures/reject/src/lib.rs:356:1 -`Hasher::write`, which is not supported yet at fixtures/reject/src/lib.rs:494:9 diff --git a/ts/fixtures/reject/expected.txt b/ts/fixtures/reject/expected.txt index 2a688ad39..cec4e6cd1 100644 --- a/ts/fixtures/reject/expected.txt +++ b/ts/fixtures/reject/expected.txt @@ -1,87 +1,70 @@ -a root must not be generic at fixtures/reject/src/lib.rs:170:1 +a root must not be generic at fixtures/reject/src/lib.rs:142:1 no item `missing` in the crate -a printable type must implement `Display` or `Debug` at fixtures/reject/src/lib.rs:168:1 -unsupported type `f64` at fixtures/reject/src/lib.rs:6:14 -unsupported literal of type `f64` at fixtures/reject/src/lib.rs:7:6 -arithmetic on `f64` at fixtures/reject/src/lib.rs:7:2 +a printable type must implement `Display` or `Debug` at fixtures/reject/src/lib.rs:140:1 unsupported type `f64` at fixtures/reject/src/lib.rs:6:1 -unsupported type `char` at fixtures/reject/src/lib.rs:10:18 +a scalar constant of type `f64` at fixtures/reject/src/lib.rs:7:2 +arithmetic on `f64` at fixtures/reject/src/lib.rs:7:2 +unsupported type `char` at fixtures/reject/src/lib.rs:10:1 a cast from `char` at fixtures/reject/src/lib.rs:11:2 -unsupported type `dyn std::ops::Fn(u8) -> u8` at fixtures/reject/src/lib.rs:14:16 -a `&mut u32` binding: a JS value of `u32` is a copy, so it can't change at fixtures/reject/src/lib.rs:19:13 -`&mut u32`: a JS value of `u32` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:19:13 -a `&mut u32` binding: a JS value of `u32` is a copy, so it can't change at fixtures/reject/src/lib.rs:25:6 -`Option>` is not supported: its `None` and `Some` would both be `undefined` at fixtures/reject/src/lib.rs:31:15 +unsupported type `dyn std::ops::Fn(u8) -> u8` at fixtures/reject/src/lib.rs:14:1 +`&mut u32`: a JS value of `u32` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:19:1 +an assignment through a reference to `u32` at fixtures/reject/src/lib.rs:20:2 +`&mut u32`: a JS value of `u32` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:24:1 +`Option>` is not supported: its `None` and `Some` would both be `undefined` at fixtures/reject/src/lib.rs:31:1 unsupported call to `std::slice::::sort` at fixtures/reject/src/lib.rs:36:4 `Option>` is not supported: its `None` and `Some` would both be `undefined` at fixtures/reject/src/lib.rs:40:42 -a field of a temporary that drops: bind it to a variable first at fixtures/reject/src/lib.rs:55:2 -a closure that captures a value that drops, which is not supported yet at fixtures/reject/src/lib.rs:61:23 -dropping `{closure@fixtures/reject/src/lib.rs:61:10: 61:17}`, which is not supported yet at fixtures/reject/src/lib.rs:59:31 -a `for` loop over values that drop, which is not supported yet at fixtures/reject/src/lib.rs:69:6 -a parameter that drops bound by a pattern, which is not supported yet at fixtures/reject/src/lib.rs:76:21 -a variable from outside the function at fixtures/reject/src/lib.rs:77:2 -dropping `Slot`, which is not supported yet at fixtures/reject/src/lib.rs:86:1 -`Boxed` is generic and implements `Drop`, which is not supported yet at fixtures/reject/src/lib.rs:98:6 -an async body that borrows `u8` mutably, which is no object it can change in place at fixtures/reject/src/lib.rs:106:3 -unsupported type `{async closure@fixtures/reject/src/lib.rs:114:10: 114:18}` at fixtures/reject/src/lib.rs:114:6 -a closure of type `{async closure@fixtures/reject/src/lib.rs:114:10: 114:18}` at fixtures/reject/src/lib.rs:114:10 -a precision, as in `{:.2}`, is not supported at fixtures/reject/src/lib.rs:122:3 -the `+` flag of a format spec is not supported at fixtures/reject/src/lib.rs:123:3 -the `-` flag of a format spec is not supported at fixtures/reject/src/lib.rs:124:3 -`Binary` formatting, as in `{:b}`, is not supported at fixtures/reject/src/lib.rs:125:3 -`Octal` formatting, as in `{:o}`, is not supported at fixtures/reject/src/lib.rs:126:3 -`LowerExp` formatting, as in `{:e}`, is not supported at fixtures/reject/src/lib.rs:127:3 -hex `Debug`, as in `{:x?}`, is not supported at fixtures/reject/src/lib.rs:128:3 -a width or precision from an argument, as in `{:1$}`, is not supported at fixtures/reject/src/lib.rs:129:3 -`Pointer` formatting, as in `{:p}`, is not supported at fixtures/reject/src/lib.rs:130:3 -a `&mut std::string::String` binding: a JS value of `std::string::String` is a copy, so it can't change at fixtures/reject/src/lib.rs:135:16 -`&mut std::string::String`: a JS value of `std::string::String` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:135:16 -a mutable reference to `std::string::String`, which is no object it can change in place at fixtures/reject/src/lib.rs:137:17 -unsupported call to `::write_fmt` at fixtures/reject/src/lib.rs:137:10 -a closure that copies a mutable variable at fixtures/reject/src/lib.rs:142:18 -an or-pattern with bindings at fixtures/reject/src/lib.rs:149:3 -unsupported expression: StaticRef at fixtures/reject/src/lib.rs:156:2 -replacing the value behind a reference to `Meters` at fixtures/reject/src/lib.rs:161:17 -replacing the value behind a reference to `Meters` at fixtures/reject/src/lib.rs:161:20 -replacing the value behind a reference to `Meters` at fixtures/reject/src/lib.rs:165:25 -dropping `std::sync::Arc<&Noisy>`, which is not supported yet at fixtures/reject/src/lib.rs:176:42 -an `.await` in an operand after one that drops, which is not supported yet: bind the awaited value first at fixtures/reject/src/lib.rs:183:13 -a `let` on a temporary that drops, which it doesn't move out of whole at fixtures/reject/src/lib.rs:193:2 -an `.await` in the place an assignment of a value that drops writes to, which is not supported yet: bind the awaited value first at fixtures/reject/src/lib.rs:200:2 -a `match` on a temporary that drops, which it doesn't move out of whole at fixtures/reject/src/lib.rs:210:2 -replacing the `std::sync::Arc` behind a reference, whose JS object is shared or private at fixtures/reject/src/lib.rs:218:2 -`Poll>>` is not supported: it would be pending two ways with one value at fixtures/reject/src/lib.rs:222:20 -`Option>` is not supported: its `None` and `Some` would both be `undefined` at fixtures/reject/src/lib.rs:227:19 -an `if let` on a temporary that drops, which it doesn't move out of whole at fixtures/reject/src/lib.rs:234:9 -an async body returning `std::task::Poll` is not supported: its `Ready` could be pending at fixtures/reject/src/lib.rs:238:54 -a `match` on a temporary that drops, which it doesn't move out of whole at fixtures/reject/src/lib.rs:245:16 -replacing the `std::pin::Pin>` behind a reference, whose JS object is shared or private at fixtures/reject/src/lib.rs:254:2 -a field of a temporary that drops: bind it to a variable first at fixtures/reject/src/lib.rs:259:2 -replacing the `std::sync::MutexGuard<'_, u8>` behind a reference, whose JS object is shared or private at fixtures/reject/src/lib.rs:264:2 -unsupported call to ` as std::iter::Iterator>::cycle` at fixtures/reject/src/lib.rs:269:11 -a `zip` of `std::iter::Chain, {closure@fixtures/reject/src/lib.rs:315:15: 315:18}>, std::iter::Copied>>`, whose closures std calls one item further through `next` than through `fold` at fixtures/reject/src/lib.rs:315:51 -unsupported call to `std::ops::Range::::contains::` at fixtures/reject/src/lib.rs:323:8 -an iterator that owns `Noisy`, which drops, which is not supported yet at fixtures/reject/src/lib.rs:364:16 -an iterator that owns `std::vec::Vec`, which drops, which is not supported yet at fixtures/reject/src/lib.rs:364:4 -an iterator that owns `Noisy`, which drops, which is not supported yet at fixtures/reject/src/lib.rs:369:20 -a `for` loop over values that drop, which is not supported yet at fixtures/reject/src/lib.rs:385:6 -passing `std::option::Option`, which drops, to `Option::unwrap_or`, which is not supported yet at fixtures/reject/src/lib.rs:393:4 -a rest pattern that moves values that drop out of a place, which is not supported yet at fixtures/reject/src/lib.rs:398:14 -a mutable borrow of a subslice of `u32`, which JS would copy, having no views at fixtures/reject/src/lib.rs:404:13 -replacing the `std::pin::Pin<&mut Noisy>` behind a reference, whose JS object is shared or private at fixtures/reject/src/lib.rs:412:2 -an array repeat of a value that drops, which is not supported yet at fixtures/reject/src/lib.rs:417:14 -replacing the value behind a reference to `[u8; 1]` at fixtures/reject/src/lib.rs:424:45 -a closure that copies a mutable variable at fixtures/reject/src/lib.rs:432:3 -a field of `std::ops::RangeTo` at fixtures/reject/src/lib.rs:441:7 -a field of `std::ops::RangeFrom` at fixtures/reject/src/lib.rs:441:48 -`HashMap::clear` of `std::collections::HashMap`, which may drop what it holds, which is not supported yet at fixtures/reject/src/lib.rs:446:6 -`std::collections::HashMap>` holds `std::option::Option`, which is `undefined` as `None` is, which is not supported at fixtures/reject/src/lib.rs:451:6 -hashing `std::vec::Vec` as a key, which is not supported yet at fixtures/reject/src/lib.rs:456:52 -comparing `std::vec::Vec` as a key, which is not supported yet at fixtures/reject/src/lib.rs:456:52 -`HashSet::remove` of `std::collections::HashSet`, which may drop a `Loud`, which is not supported yet at fixtures/reject/src/lib.rs:469:6 -`HashMap::contains_key` of `std::collections::HashMap` by `u8`, which is not supported yet at fixtures/reject/src/lib.rs:486:6 -overriding `Iterator::fold`, which std's adaptors call in place of `next` or beside it at fixtures/reject/src/lib.rs:282:2 -an iterator of the crate implementing `DoubleEndedIterator`, which is not supported yet at fixtures/reject/src/lib.rs:302:1 -overriding `Iterator::size_hint`, which std's adaptors call in place of `next` or beside it at fixtures/reject/src/lib.rs:336:2 -an iterator of the crate implementing `FusedIterator`, which is not supported yet at fixtures/reject/src/lib.rs:356:1 -`Hasher::write`, which is not supported yet at fixtures/reject/src/lib.rs:494:9 +unsupported call to `std::mem::size_of_val::` at fixtures/reject/src/lib.rs:52:18 +dropping a closure that owns a value that drops, which is not supported yet at fixtures/reject/src/lib.rs:54:1 +an iterator that owns `std::vec::Vec`, which drops, which is not supported yet at fixtures/reject/src/lib.rs:59:11 +`&mut Slot`: a JS value of `Slot` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:73:1 +`Boxed` is generic and implements `Drop`, which is not supported yet at fixtures/reject/src/lib.rs:83:10 +`&mut u8`: a JS value of `u8` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:90:10 +an assignment through a reference to `u8` at fixtures/reject/src/lib.rs:91:3 +a zero-sized constant of type `{async closure@fixtures/reject/src/lib.rs:99:10: 99:18}` at fixtures/reject/src/lib.rs:100:2 +a precision, as in `{:.2}`, is not supported at fixtures/reject/src/lib.rs:107:3 +the `+` flag of a format spec is not supported at fixtures/reject/src/lib.rs:108:3 +the `-` flag of a format spec is not supported at fixtures/reject/src/lib.rs:109:3 +`Binary` formatting, as in `{:b}`, is not supported at fixtures/reject/src/lib.rs:110:12 +`Octal` formatting, as in `{:o}`, is not supported at fixtures/reject/src/lib.rs:111:12 +`LowerExp` formatting, as in `{:e}`, is not supported at fixtures/reject/src/lib.rs:112:12 +hex `Debug`, as in `{:x?}`, is not supported at fixtures/reject/src/lib.rs:113:3 +a width or precision from an argument, as in `{:1$}`, is not supported at fixtures/reject/src/lib.rs:114:15 +a width or precision from an argument, as in `{:1$}`, is not supported at fixtures/reject/src/lib.rs:114:3 +`Pointer` formatting, as in `{:p}`, is not supported at fixtures/reject/src/lib.rs:115:12 +`&mut std::string::String`: a JS value of `std::string::String` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:120:1 +unsupported call to `::write_fmt` at fixtures/reject/src/lib.rs:122:10 +a constant of type `&u8` at fixtures/reject/src/lib.rs:128:2 +replacing the value behind a reference to `Meters` at fixtures/reject/src/lib.rs:133:2 +replacing the value behind a reference to `Meters` at fixtures/reject/src/lib.rs:137:2 +dropping `std::sync::Arc<&Noisy>`, which is not supported yet at fixtures/reject/src/lib.rs:151:1 +an assignment through a reference to `std::sync::Arc` at fixtures/reject/src/lib.rs:155:2 +`Poll>>` is not supported: it would be pending two ways with one value at fixtures/reject/src/lib.rs:159:1 +`Option>` is not supported: its `None` and `Some` would both be `undefined` at fixtures/reject/src/lib.rs:164:1 +`Poll>` is not supported: it would be pending two ways with one value at fixtures/reject/src/lib.rs:169:54 +an assignment through a reference to `std::pin::Pin>` at fixtures/reject/src/lib.rs:175:2 +an assignment through a reference to `std::sync::MutexGuard<'_, u8>` at fixtures/reject/src/lib.rs:180:2 +unsupported call to ` as std::iter::Iterator>::cycle` at fixtures/reject/src/lib.rs:185:11 +constructing `std::iter::Map` from another crate at fixtures/reject/src/lib.rs:204:23 +constructing `std::iter::Rev` from another crate at fixtures/reject/src/lib.rs:225:14 +a `zip` of `std::iter::Chain, {closure@fixtures/reject/src/lib.rs:231:15: 231:18}>, std::iter::Copied>>`, whose closures std calls one item further through `next` than through `fold` at fixtures/reject/src/lib.rs:231:51 +unsupported call to `std::ops::Range::::contains::` at fixtures/reject/src/lib.rs:239:8 +an iterator that owns `std::vec::Vec`, which drops, which is not supported yet at fixtures/reject/src/lib.rs:280:4 +an iterator that owns `Noisy`, which drops, which is not supported yet at fixtures/reject/src/lib.rs:285:20 +passing `std::option::Option`, which drops, to `Option::unwrap_or`, which is not supported yet at fixtures/reject/src/lib.rs:290:4 +a mutable borrow of a subslice of `u32`, which JS would copy, having no views at fixtures/reject/src/lib.rs:295:13 +an assignment through a reference to `std::pin::Pin<&mut Noisy>` at fixtures/reject/src/lib.rs:303:2 +replacing the value behind a reference to `[u8; 1]` at fixtures/reject/src/lib.rs:309:22 +a copy of a closure that changes what it captured at fixtures/reject/src/lib.rs:320:14 +a field of `std::ops::RangeTo` at fixtures/reject/src/lib.rs:326:7 +a field of `std::ops::RangeFrom` at fixtures/reject/src/lib.rs:326:48 +`HashMap::clear` of `std::collections::HashMap`, which may drop what it holds, which is not supported yet at fixtures/reject/src/lib.rs:331:6 +`std::collections::HashMap>` holds `std::option::Option`, which is `undefined` as `None` is, which is not supported at fixtures/reject/src/lib.rs:336:6 +hashing `std::vec::Vec` as a key, which is not supported yet at fixtures/reject/src/lib.rs:341:52 +comparing `std::vec::Vec` as a key, which is not supported yet at fixtures/reject/src/lib.rs:341:52 +`HashSet::remove` of `std::collections::HashSet`, which may drop a `Loud`, which is not supported yet at fixtures/reject/src/lib.rs:354:6 +`HashMap::contains_key` of `std::collections::HashMap` by `u8`, which is not supported yet at fixtures/reject/src/lib.rs:371:6 +overriding `Iterator::fold`, which std's adaptors call in place of `next` or beside it at fixtures/reject/src/lib.rs:198:2 +an iterator of the crate implementing `DoubleEndedIterator`, which is not supported yet at fixtures/reject/src/lib.rs:218:1 +overriding `Iterator::size_hint`, which std's adaptors call in place of `next` or beside it at fixtures/reject/src/lib.rs:252:2 +an iterator of the crate implementing `FusedIterator`, which is not supported yet at fixtures/reject/src/lib.rs:272:1 +`Hasher::write`, which is not supported yet at fixtures/reject/src/lib.rs:379:9 diff --git a/ts/fixtures/reject/src/lib.rs b/ts/fixtures/reject/src/lib.rs index 84fc19360..34246a631 100644 --- a/ts/fixtures/reject/src/lib.rs +++ b/ts/fixtures/reject/src/lib.rs @@ -46,21 +46,11 @@ impl Drop for Noisy { fn drop(&mut self) {} } -pub fn make() -> Noisy { - Noisy(1) -} - -/// The temporary drops at the end of the statement, which nothing in JS marks. -pub fn temporary() -> u8 { - make().0 -} - -/// Dropping the closure would drop what it captured. +/// Dropping the closure would drop what it captured, which lives in an arrow function. pub fn owning_closure() -> u8 { - let n = make(); - let f = move || drop(n); - f(); - 0 + let n = Noisy(1); + let f = move || std::mem::size_of_val(&n) as u8; + f() } /// Each element drops at the end of its iteration, and the rest on a `break`. @@ -72,11 +62,6 @@ pub fn each(v: Vec) -> u8 { sum } -/// The part the pattern skips drops at the end of the function, which nothing marks. -pub fn destructured((a, _): (Noisy, Noisy)) -> u8 { - a.0 -} - pub enum Slot { Empty, Full(Noisy), @@ -137,19 +122,6 @@ pub fn written(s: &mut String, n: u8) { let _ = write!(s, "{n}"); } -pub fn captured() -> u8 { - let mut n = 1; - let f = move || n + 1; - n += 10; - f() + n -} - -pub fn or_bindings(x: Result) -> u8 { - match x { - Ok(v) | Err(v) => v, - } -} - static COUNT: u8 = 0; pub fn statics() -> u8 { @@ -178,41 +150,6 @@ pub fn shared_borrow(n: &Noisy) -> usize { std::sync::Arc::strong_count(&a) } -/// `n` would wait out the `.await` where no scope drops it if the future is cancelled. -pub async fn held_across(n: Noisy) -> u8 { - consume(n, async { 1u8 }.await) -} - -fn consume(n: Noisy, v: u8) -> u8 { - drop(n); - v -} - -/// The skipped element drops at the end of the statement, which nothing marks. -pub fn skipped() -> u8 { - let [kept, _] = [make(), make()]; - kept.0 -} - -/// `n` would wait out the `.await` in the index where no scope drops it on a cancel. -pub async fn assigned(n: Noisy) -> u8 { - let mut slots = [make(), make()]; - slots[index().await] = n; - slots[0].0 -} - -async fn index() -> usize { - 1 -} - -/// `Some(..)` leaves the payload in the temporary, which drops after the `match`. -pub fn unnamed() -> u8 { - match Some(make()) { - Some(..) => 1, - None => 0, - } -} - /// Every clone of an `Arc` is one JS object: replacing the payload would reach them all. pub fn replace_shared(dst: &mut std::sync::Arc, src: std::sync::Arc) { *dst = src; @@ -228,37 +165,16 @@ pub fn ready_unit(p: Option>) -> bool { matches!(p, None) } -/// The payload of the `Some` that fails the test drops after the `if let`. -#[allow(clippy::redundant_pattern_matching, reason = "the `if let` is under test")] -pub fn unmatched() -> u8 { - if let None = Some(make()) { 1 } else { 0 } -} - /// A future's `Ready(Pending)` would be `rt.Pending`, as its own pending is. pub async fn pending_output() -> std::task::Poll { std::task::Poll::Pending } -/// The temporary drops after the `match`, which nothing marks. -#[allow(clippy::match_like_matches_macro, reason = "the `match` is under test")] -pub fn tested() -> u8 { - let matched = match Some(make()) { - Some(_) => 1, - None => 0, - }; - matched + 1 -} - /// A `Pin` is its pointer in JS: replacing the `Arc` would reach every clone. pub fn replace_pinned(dst: &mut std::pin::Pin>, src: std::pin::Pin>) { *dst = src; } -/// The box drops its `Noisy` at the end of the statement, which nothing marks. -pub fn boxed_field() -> u8 { - Box::new(make()).0 -} - /// A guard is its mutex in JS: replacing it would copy the other mutex's value in. pub fn replace_guard<'a>(dst: &mut std::sync::MutexGuard<'a, u8>, src: std::sync::MutexGuard<'a, u8>) { *dst = src; @@ -369,36 +285,11 @@ pub fn counted() -> usize { (0..2).map(Noisy).count() } -/// An iterator that drops, after the loop. -pub struct Countdown(pub Noisy); - -impl Iterator for Countdown { - type Item = u8; - - fn next(&mut self) -> Option { - None - } -} - -pub fn looped(c: Countdown) -> u8 { - let mut n = 0; - for i in c { - n += i; - } - n -} - /// `unwrap_or` drops its fallback when the option holds a value. pub fn fallback(a: Option, b: Noisy) -> Noisy { a.unwrap_or(b) } -/// `rest` moves the tail out of `pair`, which would still drop it. -pub fn rest_moved(pair: [Noisy; 2]) -> u8 { - let [first, rest @ ..] = pair; - first.0 + rest[0].0 -} - /// `rest` borrows the tail of `items` mutably, but a JS array has no views. pub fn rest_mut(items: &mut [u32; 3]) -> u32 { if let [_, rest @ ..] = items { @@ -412,12 +303,6 @@ pub fn replace_pinned_ref<'a>(dst: &mut std::pin::Pin<&'a mut Noisy>, src: std:: *dst = src; } -/// `[n; 0]` drops `n` at once, which no element of the array would. -pub fn repeated(n: Noisy) -> usize { - let empty = [n; 0]; - empty.len() -} - /// A reference copied into a closure holds its referent's object: replacing through it /// would change the copy, not the referent. pub fn replace_captured(a: &mut [u8; 1]) -> [u8; 1] { diff --git a/ts/fixtures/reject/ts.toml b/ts/fixtures/reject/ts.toml index 24e70f007..7c898faff 100644 --- a/ts/fixtures/reject/ts.toml +++ b/ts/fixtures/reject/ts.toml @@ -9,35 +9,24 @@ roots = [ "sorted", "iterators", "Noisy", - "temporary", "owning_closure", "each", - "destructured", "slot", "boxed", "async_borrow", "async_closure", "specs", "written", - "captured", - "or_bindings", "statics", "swapped", "replaced", "generic", "shared_borrow", - "held_across", - "skipped", - "assigned", - "unnamed", "replace_shared", "nested_poll", "ready_unit", - "unmatched", "pending_output", - "tested", "replace_pinned", - "boxed_field", "replace_guard", "cycled", "folds", @@ -48,12 +37,9 @@ roots = [ "fused", "drained", "counted", - "looped", "fallback", - "rest_moved", "rest_mut", "replace_pinned_ref", - "repeated", "replace_captured", "copied_closure", "one_sided", diff --git a/ts/fixtures/task/expected/kio.Consumer.ts b/ts/fixtures/task/expected/kio.Consumer.ts index 4a9c2784a..919f8870d 100644 --- a/ts/fixtures/task/expected/kio.Consumer.ts +++ b/ts/fixtures/task/expected/kio.Consumer.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; -import { recvBody } from "./kio.ts"; +import { recvFuture } from "./kio.ts"; import type * as State from "./kio.State.ts"; import * as Waiter from "./kio.Waiter.ts"; @@ -26,22 +26,31 @@ export class Consumer { /** The next value, or `None` once the channel closed and every value was read. */ export function pollRecv(self: Consumer, waiter: Waiter.Waiter): rt.Poll { - let state: rt.Mutex = self.state.value; - if (self.next < state.value.queue.length) { - const value = rt.at(state.value.queue, self.next); + let state!: rt.Mutex; + let value!: rt.u64; + let _16!: State.State; + let _18!: rt.usize; + state = self.state.value; + if (!(self.next < state.value.queue.length)) { + if (!state.value.closed) { + Waiter.register(waiter, state.value.waiters); + return rt.Pending; + } else { + return undefined; + } + } else { + _16 = state.value; + _18 = self.next; + const at = rt.idx(_16.queue, _18); + value = _16.queue[at]; self.next = rt.usizeAdd(self.next, 1); return value; } - if (state.value.closed) { - return undefined; - } - Waiter.register(waiter, state.value.waiters); - return rt.Pending; } /** kio's one-line wrapper over a `poll_*` method. */ export function recv(self: Consumer): rt.Future { - return rt.future(recvBody, undefined, self); + return new recvFuture(self); } //# sourceMappingURL=kio.Consumer.ts.map diff --git a/ts/fixtures/task/expected/kio.Park.ts b/ts/fixtures/task/expected/kio.Park.ts index ab1292b01..6820dd6af 100644 --- a/ts/fixtures/task/expected/kio.Park.ts +++ b/ts/fixtures/task/expected/kio.Park.ts @@ -25,17 +25,17 @@ export class Park { * dropping the old and so its registrations. */ export function hold(self: Park, cx: rt.Context): Waiter.Waiter { - let reuse: boolean; - if (self._0 !== undefined) { - const waiter = self._0; - reuse = cx.willWake(waiter.waker); - } else { + let reuse!: boolean; + let _10!: Waiter.Waiter | undefined; + if (self._0 === undefined) { reuse = false; + } else { + reuse = cx.willWake(self._0.waker); } if (!reuse) { - const value = Waiter.new(cx.clone()); + _10 = Waiter.new(cx.clone()); rt.drop(self._0); - self._0 = value; + self._0 = _10; } return rt.optionUnwrap(self._0); } diff --git a/ts/fixtures/task/expected/kio.Pending.ts b/ts/fixtures/task/expected/kio.Pending.ts index 5eb0ca08f..fce8c486e 100644 --- a/ts/fixtures/task/expected/kio.Pending.ts +++ b/ts/fixtures/task/expected/kio.Pending.ts @@ -21,9 +21,9 @@ export class Pending { } export function poll$Future_recv_closure0_closure0(self: Pending<(a0: Waiter.Waiter) => rt.Poll>, cx: rt.Context): rt.Poll { - const this_ = self; - const waiter = Park.hold(this_.park, cx); - return this_.poll(waiter); + let this_!: Pending<(a0: Waiter.Waiter) => rt.Poll>; + this_ = self; + return this_.poll(Park.hold(this_.park, cx)); } //# sourceMappingURL=kio.Pending.ts.map diff --git a/ts/fixtures/task/expected/kio.Producer.ts b/ts/fixtures/task/expected/kio.Producer.ts index a7b184ac0..4405b31a0 100644 --- a/ts/fixtures/task/expected/kio.Producer.ts +++ b/ts/fixtures/task/expected/kio.Producer.ts @@ -20,15 +20,18 @@ export class Producer { } function new_(): Producer { - const state = { queue: [], closed: false, producers: 1, waiters: WaiterList.new() }; - return new Producer({ state: new rt.Arc(new rt.Mutex(state)) }); + let _2!: rt.u64[]; + _2 = []; + return new Producer({ state: new rt.Arc(new rt.Mutex({ queue: _2, closed: false, producers: 1, waiters: WaiterList.new() })) }); } /** Queue `value` and wake every consumer, after releasing the lock. */ export function send(self: Producer, value: rt.u64): void { - let state: rt.Mutex = self.state.value; + let waiters!: WaiterList.WaiterList; + let state!: rt.Mutex; + state = self.state.value; state.value.queue.push(value); - let waiters: WaiterList.WaiterList = WaiterList.take(state.value.waiters); + waiters = WaiterList.take(state.value.waiters); WaiterList.wake(waiters); } @@ -37,19 +40,26 @@ export function consume(self: Producer): Consumer.Consumer { } export function clone$Clone(self: Producer): Producer { - self.state.value.value.producers = rt.usizeAdd(self.state.value.value.producers, 1); + let _2!: State.State; + let _4!: rt.Mutex; + _4 = self.state.value; + _2 = _4.value; + _2.producers = rt.usizeAdd(_2.producers, 1); return new Producer({ state: rt.arcClone(self.state) }); } export function drop$Drop(self: Producer): void { - let state: rt.Mutex = self.state.value; - state.value.producers = rt.usizeSub(state.value.producers, 1); - if (state.value.producers > 0) { - return; + let waiters!: WaiterList.WaiterList; + let state!: rt.Mutex; + let _7!: State.State; + state = self.state.value; + _7 = state.value; + _7.producers = rt.usizeSub(_7.producers, 1); + if (!(state.value.producers > 0)) { + state.value.closed = true; + waiters = WaiterList.take(state.value.waiters); + WaiterList.wake(waiters); } - state.value.closed = true; - let waiters: WaiterList.WaiterList = WaiterList.take(state.value.waiters); - WaiterList.wake(waiters); } export { new_ as new }; diff --git a/ts/fixtures/task/expected/kio.Waiter.ts b/ts/fixtures/task/expected/kio.Waiter.ts index aa363482f..58d151d43 100644 --- a/ts/fixtures/task/expected/kio.Waiter.ts +++ b/ts/fixtures/task/expected/kio.Waiter.ts @@ -20,20 +20,20 @@ export class Waiter { } function new_(waker: rt.Waker): Waiter { + let shared!: rt.Arc; + let _5!: rt.Waker; + let unwind: number = 0; try { - let shared = new rt.Arc(waker.clone()); - try { - const waker2 = waker; - waker = undefined!; - const arg = waker2; - const shared2 = shared; - shared = undefined!; - return new Waiter({ waker: arg, shared: shared2 }); - } finally { - rt.drop(shared); + unwind = 4; + shared = new rt.Arc(waker.clone()); + _5 = waker; + return new Waiter({ waker: _5, shared }); + } catch (e) { + if (unwind === 0) { + throw e; } - } finally { rt.drop(waker); + throw e; } } diff --git a/ts/fixtures/task/expected/kio.WaiterList.ts b/ts/fixtures/task/expected/kio.WaiterList.ts index d25b4a3d4..af8a17feb 100644 --- a/ts/fixtures/task/expected/kio.WaiterList.ts +++ b/ts/fixtures/task/expected/kio.WaiterList.ts @@ -15,35 +15,78 @@ function new_(): WaiterList { } export function register(self: WaiterList, waiter: Waiter.Waiter): void { - const weak = new rt.Weak(waiter.shared); - for (const entry of self.entries) { - if (entry.arc === weak.arc) { - return; - } - } - let probes: rt.usize = rt.min(self.entries.length, 2); - while (probes > 0) { - if (rt.at(self.entries, self.cursor).arc.strong === 0) { - const value = weak; - self.entries[rt.idx(self.entries, self.cursor)] = value; - return; - } - self.cursor = rt.usizeRem(rt.usizeAdd(self.cursor, 1), self.entries.length); - probes = rt.usizeSub(probes, 1); - } - if (self.entries.length >= 4) { - let live: rt.Weak[] = []; - const taken = self.entries; - self.entries = []; - for (const entry2 of taken) { - if (entry2.arc.strong > 0) { - live.push(entry2); + let weak!: rt.Weak; + let iterS!: rt.Weak[]; + let iterI!: number; + let _8!: rt.Weak | rt.Done; + let probes!: rt.usize; + let _23!: rt.usize; + let _24!: rt.Weak; + let _27!: rt.usize; + let live!: rt.Weak[]; + let iterS2!: rt.Weak[]; + let iterI2!: number; + let _43!: rt.Weak | rt.Done; + let entry!: rt.Weak; + let _53!: rt.Weak[]; + weak = new rt.Weak(waiter.shared); + iterS = self.entries; + iterI = 0; + l0: while (true) { + _8 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + b1: { + b2: { + if (_8 === rt.DONE) { + probes = rt.min(self.entries.length, 2); + while (true) { + if (!(probes > 0)) { + b4: { + if (self.entries.length >= 4) { + live = []; + const taken = self.entries; + self.entries = []; + iterS2 = taken; + iterI2 = 0; + while (true) { + _43 = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; + if (_43 === rt.DONE) { + _53 = live; + self.entries = _53; + self.cursor = 0; + break b4; + } else { + entry = _43; + if (entry.arc.strong > 0) { + live.push(entry); + } + } + } + } + } + self.entries.push(weak); + break b1; + } else { + _23 = self.cursor; + const at = rt.idx(self.entries, _23); + if (!(self.entries[at].arc.strong === 0)) { + self.cursor = rt.usizeRem(rt.usizeAdd(self.cursor, 1), self.entries.length); + probes = rt.usizeSub(probes, 1); + } else { + _24 = weak; + _27 = self.cursor; + const at2 = rt.idx(self.entries, _27); + self.entries[at2] = _24; + break b2; + } + } + } + } else if (!((_8.arc === weak.arc))) { + continue l0; + } } } - self.entries = live; - self.cursor = 0; + return; } - self.entries.push(weak); } /** Drain every entry into a new list, leaving this one empty. */ @@ -56,19 +99,41 @@ export function take(self: WaiterList): WaiterList { /** Wake every live waiter, draining the list. */ export function wake(self: WaiterList): void { - self.cursor = 0; - const taken = self.entries; - self.entries = []; - for (const entry of taken) { - const upgrade = rt.weakUpgrade(entry); - if (upgrade !== undefined) { - const waker = upgrade; - try { - waker.value.wakeByRef(); - } finally { - rt.drop(waker); + let iterS!: rt.Weak[]; + let iterI!: number; + let _6!: rt.Weak | rt.Done; + let entry!: rt.Weak; + let _10!: rt.Arc | undefined; + let waker!: rt.Arc; + let unwind: number = 0; + try { + self.cursor = 0; + const taken = self.entries; + self.entries = []; + iterS = taken; + iterI = 0; + while (true) { + _6 = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_6 === rt.DONE) { + return; + } else { + entry = _6; + _10 = rt.weakUpgrade(entry); + if (_10 !== undefined) { + unwind = 15; + waker = _10; + waker.value.wakeByRef(); + unwind = 0; + rt.drop(waker); + } } } + } catch (e) { + if (unwind === 0) { + throw e; + } + rt.drop(waker); + throw e; } } diff --git a/ts/fixtures/task/expected/kio.ts b/ts/fixtures/task/expected/kio.ts index 5618f5f14..57e6cbe09 100644 --- a/ts/fixtures/task/expected/kio.ts +++ b/ts/fixtures/task/expected/kio.ts @@ -8,25 +8,63 @@ import type * as Waiter from "./kio.Waiter.ts"; /** A future from a poll function that receives a [`Waiter`]. */ export function wait$recv_closure0_closure0_Option_u64(poll: (a0: Waiter.Waiter) => rt.Poll): Pending.Pending<(a0: Waiter.Waiter) => rt.Poll> { - return new Pending.Pending({ poll, park: Park.default$Default() }); + let _2!: (a0: Waiter.Waiter) => rt.Poll; + _2 = poll; + return new Pending.Pending({ poll: _2, park: Park.default$Default() }); } -export function* recvBody(_taskContext: rt.Context, self: Consumer.Consumer): Generator { - const self2 = self; - let __awaitee: Pending.Pending<(a0: Waiter.Waiter) => rt.Poll> = wait$recv_closure0_closure0_Option_u64((waiter: Waiter.Waiter): rt.Poll => { - return Consumer.pollRecv(self2, waiter); - }); - try { - while (true) { - const poll = Pending.poll$Future_recv_closure0_closure0(__awaitee, _taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class recvFuture { + state: number = 0; + self: Consumer.Consumer; + __awaitee_!: Pending.Pending<(a0: Waiter.Waiter) => rt.Poll>; + + constructor(self: Consumer.Consumer) { + this.self = self; + } + + [Symbol.dispose](): void { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } + } + + poll(_2: rt.Context): rt.Poll { + let self!: Consumer.Consumer; + let _7!: rt.Poll; + let unwind: number = 0; + try { + if (this.state === 0) { + unwind = 12; + self = this.self; + this.__awaitee_ = wait$recv_closure0_closure0_Option_u64((waiter: Waiter.Waiter): rt.Poll => { + return Consumer.pollRecv(self, waiter); + }); + } else if (this.state === 1) { + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _7 = Pending.poll$Future_recv_closure0_closure0(this.__awaitee_, _2); + if (_7 !== rt.Pending) { + unwind = 12; + rt.drop(this.__awaitee_); + this.state = 1; + return _7; + } else { + this.state = 3; + return rt.Pending; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); } - _taskContext = yield; + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } diff --git a/ts/fixtures/task/expected/log.Log.ts b/ts/fixtures/task/expected/log.Log.ts index 5cf8c6122..c910ec3bb 100644 --- a/ts/fixtures/task/expected/log.Log.ts +++ b/ts/fixtures/task/expected/log.Log.ts @@ -25,18 +25,33 @@ function new_(): Log { /** Append one event. */ export function note(self: Log, event: string): void { - self._0.value.value.push(event); + let _4!: string[]; + let _6!: rt.Mutex; + _6 = self._0.value; + _4 = _6.value; + _4.push(event); } /** Every event so far, one per line. */ export function text(self: Log): rt.ByteVec { - const events = self._0.value; - let out: rt.ByteVec = new rt.ByteVec(); - for (const event of events.value) { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(event)); - rt.byteVecPush(out, 10); + let events!: rt.Mutex; + let out!: rt.ByteVec; + let iter!: rt.Iter; + let _13!: string | rt.Done; + let _19!: Uint8Array; + events = self._0.value; + out = new rt.ByteVec(); + iter = rt.iterSlice(events.value); + while (true) { + _13 = iter.next(); + if (_13 === rt.DONE) { + return out; + } else { + _19 = rt.stringAsBytes(_13); + rt.byteVecExtendFromSlice(out, _19); + rt.byteVecPush(out, 10); + } } - return out; } export { new_ as new }; diff --git a/ts/fixtures/task/expected/model.Channel.ts b/ts/fixtures/task/expected/model.Channel.ts index 79a136086..6f1790ecb 100644 --- a/ts/fixtures/task/expected/model.Channel.ts +++ b/ts/fixtures/task/expected/model.Channel.ts @@ -21,30 +21,42 @@ export class Channel { } export function open(): Channel { - let producer = Producer.new(); + let _0!: Channel; + let producer!: Producer.Producer; + let consumer_!: Consumer.Consumer; + let producers!: Producer.Producer[]; + let _10!: boolean; + let unwind: number = 0; try { - let consumer_ = Producer.consume(producer); - try { - let producers: Producer.Producer[] = []; - try { - const arg = producers; - const producer2 = producer; - producer = undefined!; - arg.push(producer2); - const producers2 = producers; - producers = undefined!; - const arg2 = producers2; - const consumer2 = consumer_; - consumer_ = undefined!; - return new Channel({ producers: arg2, consumer: consumer2 }); - } finally { + _10 = false; + _10 = true; + producer = Producer.new(); + unwind = 10; + consumer_ = Producer.consume(producer); + unwind = 7; + producers = []; + unwind = 6; + _10 = false; + producers.push(producer); + _0 = new Channel({ producers, consumer: consumer_ }); + _10 = false; + return _0; + } catch (e) { + b0: { + if (unwind === 0) { + throw e; + } + if (unwind === 6) { rt.dropAll(producers); + } else if (unwind !== 7) { + break b0; } - } finally { rt.drop(consumer_); } - } finally { - rt.drop(producer); + if (_10) { + rt.drop(producer); + } + throw e; } } @@ -55,52 +67,39 @@ export function consumer(self: Channel): Consumer.Consumer { /** Send `value` through the first producer, if one is open. */ export function send(self: Channel, value: rt.u64): boolean { - const first = rt.sliceFirst(self.producers); - if (first !== undefined) { - const producer = first; - Producer.send(producer, value); - return true; - } else { + let _3!: Producer.Producer | undefined; + _3 = rt.sliceFirst(self.producers); + if (_3 === undefined) { return false; + } else { + Producer.send(_3, value); + return true; } } /** Drop the last producer, if one is open: the last closes the channel. */ export function close(self: Channel): boolean { - const pop = self.producers.pop(); - if (pop !== undefined) { - let producer = pop; - try { - const producer2 = producer; - producer = undefined!; - rt.drop(producer2); - return true; - } finally { - rt.drop(producer); - } - } else { + let _2!: Producer.Producer | undefined; + _2 = self.producers.pop(); + if (_2 === undefined) { return false; + } else { + rt.drop(_2); + return true; } } /** Open another producer, if one is open to clone. */ export function cloneProducer(self: Channel): boolean { - let clone: Producer.Producer = undefined!; - try { - const first = rt.sliceFirst(self.producers); - if (first !== undefined) { - const producer = first; - clone = Producer.clone$Clone(producer); - } else { - return false; - } - const arg = self.producers; - const clone2 = clone; - clone = undefined!; - arg.push(clone2); + let clone!: Producer.Producer; + let _3!: Producer.Producer | undefined; + _3 = rt.sliceFirst(self.producers); + if (_3 === undefined) { + return false; + } else { + clone = Producer.clone$Clone(_3); + self.producers.push(clone); return true; - } finally { - rt.drop(clone); } } diff --git a/ts/fixtures/task/expected/model.Countdown.ts b/ts/fixtures/task/expected/model.Countdown.ts new file mode 100644 index 000000000..c07d605f4 --- /dev/null +++ b/ts/fixtures/task/expected/model.Countdown.ts @@ -0,0 +1,31 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import * as Guard from "./model.Guard.ts"; + +/** Counts down, holding a guard the loop drops after its last turn. */ +export class Countdown { + left: rt.u32; + guard: Guard.Guard; + + constructor(fields: { left: rt.u32; guard: Guard.Guard }) { + this.left = fields.left; + this.guard = fields.guard; + } + + [Symbol.dispose](): void { + rt.drop(this.guard); + } +} + +export function next$Iterator(self: Countdown): rt.u32 | rt.Done { + if (!(self.left === 0)) { + self.left = rt.u32Sub(self.left, 1); + Guard.note(self.guard, "count"); + return self.left; + } else { + return rt.DONE; + } +} + +//# sourceMappingURL=model.Countdown.ts.map diff --git a/ts/fixtures/task/expected/model.Guard.ts b/ts/fixtures/task/expected/model.Guard.ts index 6d3d45fc5..3204e1ab4 100644 --- a/ts/fixtures/task/expected/model.Guard.ts +++ b/ts/fixtures/task/expected/model.Guard.ts @@ -20,33 +20,46 @@ export class Guard { } function new_(id: rt.u32, log: Log.Log): Guard { - try { - const arg = id; - const log2 = log; - log = undefined!; - return new Guard({ id: arg, log: log2 }); - } finally { - rt.drop(log); - } + return new Guard({ id, log }); } /** Log `event` as this guard's. */ export function note(self: Guard, event: string): void { - Log.note(self.log, rt.fmtFormat(["g", (f: rt.Formatter) => rt.u32Display(self.id, f), " ", (f: rt.Formatter) => rt.fmtPad(f, event)])); + let _5!: string; + let args2!: rt.Fmt[]; + const arg = self.id; + args2 = [(f: rt.Formatter) => rt.u32Display(arg, f), (f: rt.Formatter) => rt.fmtPad(f, event)]; + _5 = rt.fmtFormat(["g", args2[0], " ", args2[1]]); + Log.note(self.log, _5); } /** Log `event`, then drop: `self`, taken by value, drops as the call returns. */ export function finish(self: Guard, event: string): rt.u32 { + let _0!: rt.u32; + let unwind: number = 0; try { + unwind = 4; note(self, event); - return self.id; - } finally { + unwind = 0; + _0 = self.id; + rt.drop(self); + return _0; + } catch (e) { + if (unwind === 0) { + throw e; + } rt.drop(self); + throw e; } } export function drop$Drop(self: Guard): void { - Log.note(self.log, rt.fmtFormat(["g", (f: rt.Formatter) => rt.u32Display(self.id, f), " drop"])); + let _4!: string; + let args2!: rt.Fmt[]; + const arg = ([self.id] as [rt.u32])[0]; + args2 = [(f: rt.Formatter) => rt.u32Display(arg, f)]; + _4 = rt.fmtFormat(["g", args2[0], " drop"]); + Log.note(self.log, _4); } export { new_ as new }; diff --git a/ts/fixtures/task/expected/model.ts b/ts/fixtures/task/expected/model.ts index 664611f1c..38ce177be 100644 --- a/ts/fixtures/task/expected/model.ts +++ b/ts/fixtures/task/expected/model.ts @@ -3,6 +3,7 @@ import * as rt from "./rt.ts"; import * as Consumer from "./kio.Consumer.ts"; import * as Log from "./log.Log.ts"; +import * as Countdown from "./model.Countdown.ts"; import * as Guard from "./model.Guard.ts"; import * as Inner from "./model.Inner.ts"; import type * as Mark from "./model.Mark.ts"; @@ -14,61 +15,168 @@ import type * as Tally from "./model.Tally.ts"; * each await beside the one it was given. It panics on 99. */ export function sum(rx: Consumer.Consumer, guard: Guard.Guard): rt.Future { - return rt.future(sumBody, sumDrop, rx, guard); + return new sumFuture(rx, guard); } -export function* sumBody(_taskContext: rt.Context, rx: Consumer.Consumer, guard: Guard.Guard): Generator { - let rx2: Consumer.Consumer = rx; - rx = undefined!; - try { - const guard2 = guard; - guard = undefined!; +export class sumFuture { + state: number = 0; + rx: Consumer.Consumer; + guard: Guard.Guard; + rx_!: Consumer.Consumer; + guard_!: Guard.Guard; + inner_!: Guard.Guard; + total_!: rt.u64; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer, guard: Guard.Guard) { + this.rx = rx; + this.guard = guard; + } + + [Symbol.dispose](): void { + let unwind: number = 0; try { - const inner = Guard.new(rt.u32Add(guard2.id, 100), Log.clone$Clone(guard2.log)); - try { - let total: rt.u64 = 0; - while (true) { - let option: rt.u64 | undefined; - let __awaitee: rt.Future = Consumer.recv(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - option = result; - break; - } - _taskContext = yield; - } - } finally { - rt.drop(__awaitee); + if (this.state === 0) { + unwind = 17; + rt.drop(this.rx); + unwind = 0; + rt.drop(this.guard); + } else if (this.state === 3) { + unwind = 10; + rt.drop(this.__awaitee_); + unwind = 12; + rt.drop(this.inner_); + unwind = 13; + rt.drop(this.guard_); + unwind = 0; + rt.drop(this.rx_); + } + } catch (e) { + b0: { + b1: { + if (unwind === 0) { + throw e; } - if (option !== undefined) { - const value = option; - if (value === 99) { - rt.panicFmt(["g", (f: rt.Formatter) => rt.u32Display(guard2.id, f), " poisoned"]); + if (unwind === 10) { + rt.drop(this.inner_); + } else if (unwind !== 12) { + if (unwind === 13) { + break b1; + } else { + rt.drop(this.guard); + break b0; } - Log.note(inner.log, rt.fmtFormat(["g", (f: rt.Formatter) => rt.u32Display(guard2.id, f), " got ", (f: rt.Formatter) => rt.u64Display(value, f)])); - total = rt.u64Add(total, value); - } else { - break; } + rt.drop(this.guard_); } - return total; - } finally { - rt.drop(inner); + rt.drop(this.rx_); } - } finally { - rt.drop(guard2); + throw e; } - } finally { - rt.drop(rx2); } -} -export function sumDrop(rx: Consumer.Consumer, guard: Guard.Guard): void { - rt.drop(rx); - rt.drop(guard); + poll(_2: rt.Context): rt.Poll { + let _11!: rt.Poll; + let result!: rt.u64 | undefined; + let value!: rt.u64; + let args2!: rt.Fmt[]; + let _32!: string; + let args4!: rt.Fmt[]; + let _47!: rt.u64; + let unwind: number = 0; + try { + let bb0: number = 0; + l0: while (true) { + switch (bb0) { + case 0: + if (this.state === 0) { + unwind = 33; + this.rx_ = this.rx; + this.guard_ = this.guard; + this.inner_ = Guard.new(rt.u32Add(this.guard_.id, 100), Log.clone$Clone(this.guard_.log)); + this.total_ = 0; + bb0 = 4; + continue l0; + } else if (this.state === 1) { + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + rt.panic("`async fn` resumed after panicking"); + } else { + bb0 = 7; + continue l0; + } + case 4: + unwind = 32; + this.__awaitee_ = Consumer.recv(this.rx_); + bb0 = 7; + continue l0; + case 7: + unwind = 31; + _11 = this.__awaitee_.poll(_2); + if (_11 !== rt.Pending) { + unwind = 32; + result = _11; + rt.drop(this.__awaitee_); + if (result !== undefined) { + value = result; + if (!(value !== 99)) { + const arg2 = ([this.guard_.id] as [rt.u32])[0]; + args2 = [(f: rt.Formatter) => rt.u32Display(arg2, f)]; + rt.panicFmt(["g", args2[0], " poisoned"]); + } else { + const arg = this.guard_.id; + args4 = [(f: rt.Formatter) => rt.u32Display(arg, f), (f: rt.Formatter) => rt.u64Display(value, f)]; + _32 = rt.fmtFormat(["g", args4[0], " got ", args4[1]]); + Log.note(this.inner_.log, _32); + this.total_ = rt.u64Add(this.total_, value); + bb0 = 4; + continue l0; + } + } else { + unwind = 33; + _47 = this.total_; + rt.drop(this.inner_); + unwind = 34; + rt.drop(this.guard_); + unwind = 35; + rt.drop(this.rx_); + this.state = 1; + return _47; + } + } else { + this.state = 3; + return rt.Pending; + } + } + } + } catch (e) { + b1: { + b2: { + b3: { + if (unwind === 0) { + throw e; + } + if (unwind === 31) { + rt.drop(this.__awaitee_); + } else if (unwind !== 32) { + if (unwind === 33) { + break b3; + } else if (unwind === 34) { + break b2; + } else { + break b1; + } + } + rt.drop(this.inner_); + } + rt.drop(this.guard_); + } + rt.drop(this.rx_); + } + this.state = 2; + throw e; + } + } } /** @@ -76,224 +184,1097 @@ export function sumDrop(rx: Consumer.Consumer, guard: Guard.Guard): void { * dropping the block must not drop; a copy, which a later change to the original must * not reach; a mutable borrow the block replaces whole, which the caller must see; a * move on one path only; and a move the block only borrows, which drops when the block - * returns or is cancelled. Between them, a value of two types that hold each other. + * returns or is cancelled. Between them, a value of two types that hold each other, and + * guards held across awaits that read values first. */ export function blocks(rx: Consumer.Consumer, guard: Guard.Guard, moves: boolean): rt.Future { - return rt.future(blocksBody, blocksDrop, rx, guard, moves); + return new blocksFuture(rx, guard, moves); } -export function* blocksBody(_taskContext: rt.Context, rx: Consumer.Consumer, guard: Guard.Guard, moves: boolean): Generator { - let rx2: Consumer.Consumer = rx; - rx = undefined!; - try { - let guard2 = guard; - guard = undefined!; +export class blocksFuture { + state: number = 0; + rx: Consumer.Consumer; + guard: Guard.Guard; + moves: boolean; + rx_!: Consumer.Consumer; + guard_!: Guard.Guard; + moves_!: boolean; + first_!: Guard.Guard; + second_!: Guard.Guard; + waited_!: rt.u64; + saved!: Guard.Guard; + __awaitee_!: rt.Future; + slots_!: Guard.Guard[]; + _saved!: Guard.Guard; + ___awaitee_!: rt.Future; + tally_!: Tally.Tally; + _saved$2!: Guard.Guard; + _saved$3!: rt.u32; + ___awaitee_$2!: rt.Future; + mark_!: Mark.Mark; + replaced_!: rt.u32; + ___awaitee_$3!: rt.Future; + _nested_!: Inner.Inner; + chosen_!: Guard.Guard; + ___awaitee_$4!: rt.Future; + _saved$4!: boolean; + _saved$5!: boolean; + _saved$6!: boolean; + _saved$7!: boolean; + _saved$8!: boolean; + _saved$9!: boolean; + _saved$10!: boolean; + + constructor(rx: Consumer.Consumer, guard: Guard.Guard, moves: boolean) { + this.rx = rx; + this.guard = guard; + this.moves = moves; + } + + [Symbol.dispose](): void { + let unwind: number = 0; try { - const moves2 = moves; - let first = Guard.new(rt.u32Add(guard2.id, 200), Log.clone$Clone(guard2.log)); - try { - let second = Guard.new(rt.u32Add(guard2.id, 300), Log.clone$Clone(guard2.log)); - try { - rt.drop(rt.future(blocksBody$2, undefined, first)); - turns(guard2.log, rt.u32Rem(guard2.id, 5)); - let tally: Tally.Tally = { n: guard2.id }; - let seen = rt.future(blocksBody$3, undefined, rt.copy(tally)); - try { - tally.n = rt.u32Add(tally.n, 1000); - const arg2 = guard2; - const arg = tally.n; - let value: rt.u32; - const seen2 = seen; - seen = undefined!; - let __awaitee: rt.Future = seen2; - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - value = result; - break; + b0: { + b1: { + if (this.state === 0) { + unwind = 82; + rt.drop(this.rx); + unwind = 0; + rt.drop(this.guard); + return; + } else if (this.state === 3) { + unwind = 56; + rt.drop(this.__awaitee_); + unwind = 57; + rt.drop(this.saved); + this._saved$10 = false; + break b0; + } else if (this.state === 4) { + unwind = 51; + rt.drop(this.___awaitee_); + unwind = 52; + rt.drop(this._saved); + this._saved$9 = false; + break b1; + } else if (this.state === 5) { + unwind = 47; + rt.drop(this.___awaitee_$2); + } else if (this.state === 6) { + unwind = 44; + rt.drop(this.___awaitee_$3); + } else if (this.state === 7) { + unwind = 37; + rt.drop(this.___awaitee_$4); + unwind = 40; + rt.drop(this.chosen_); + unwind = 42; + rt.drop(this._nested_); + } else { + return; + } + this._saved$8 = false; + } + unwind = 55; + rt.dropAll(this.slots_); + } + if (this._saved$5) { + unwind = 60; + rt.drop(this.second_); + } + this._saved$5 = false; + if (this._saved$6) { + unwind = 61; + rt.drop(this.first_); + } + this._saved$6 = false; + if (this._saved$4) { + unwind = 62; + rt.drop(this.guard_); + } + this._saved$4 = false; + if (this._saved$7) { + unwind = 0; + rt.drop(this.rx_); + } + this._saved$7 = false; + } catch (e) { + b8: { + b9: { + b10: { + b11: { + b12: { + b13: { + b14: { + b15: { + b16: { + b17: { + b18: { + b19: { + if (unwind === 0) { + throw e; + } + if (unwind === 37) { + rt.drop(this.chosen_); + break b18; + } else if (unwind === 40) { + break b18; + } else if (unwind === 42) { + break b17; + } else if (unwind === 44) { + break b16; + } else if (unwind === 47) { + break b15; + } else if (unwind === 51) { + rt.drop(this._saved); + break b19; + } else if (unwind === 52) { + break b19; + } else if (unwind === 55) { + break b13; + } else if (unwind === 56) { + rt.drop(this.saved); + } else if (unwind !== 57) { + if (unwind === 60) { + break b11; + } else if (unwind === 61) { + break b10; + } else if (unwind === 62) { + break b9; + } else { + rt.drop(this.guard); + break b8; + } + } + this._saved$10 = false; + break b12; + } + this._saved$9 = false; + break b14; + } + rt.drop(this._nested_); + } + } + } + this._saved$8 = false; + } + rt.dropAll(this.slots_); } - _taskContext = yield; } - } finally { - rt.drop(__awaitee); + if (this._saved$5) { + rt.drop(this.second_); + } + } + this._saved$5 = false; + if (this._saved$6) { + rt.drop(this.first_); } - Guard.note(arg2, rt.fmtFormat(["tally ", (f: rt.Formatter) => rt.u32Display(arg, f), " then ", (f: rt.Formatter) => rt.u32Display(value, f)])); - let mark: Mark.Mark = { n: 1 }; - let replaced: rt.u32; - let __awaitee2: rt.Future = rt.future(blocksBody$4, undefined, mark); - try { - while (true) { - const poll2 = __awaitee2.poll(_taskContext); - if (poll2 !== rt.Pending) { - const result2 = poll2; - replaced = result2; - break; + } + this._saved$6 = false; + if (this._saved$4) { + rt.drop(this.guard_); + } + } + this._saved$4 = false; + if (this._saved$7) { + rt.drop(this.rx_); + } + this._saved$7 = false; + } + throw e; + } + } + + poll(_2: rt.Context): rt.Poll { + let _18!: rt.u32; + let _32!: rt.Poll; + let result!: rt.u64 | undefined; + let _40!: Guard.Guard; + let _46!: Guard.Guard; + let _60!: rt.Poll; + let result2!: rt.usize; + let _73!: string; + let _75!: string; + let args2!: rt.Fmt[]; + let seen!: rt.Future; + let _86!: rt.u32; + let _88!: string; + let _90!: string; + let _95!: rt.u32; + let _98!: rt.Poll; + let args4!: rt.Fmt[]; + let _114!: rt.Poll; + let _124!: string; + let _126!: string; + let args6!: rt.Fmt[]; + let _133!: rt.Fmt; + let _138!: Inner.Inner | undefined; + let _139!: Guard.Guard; + let _146!: Outer.Outer; + let third!: Guard.Guard; + let _161!: rt.Poll; + let result5!: rt.u64; + let unwind: number = 0; + try { + b0: { + b1: { + b2: { + b3: { + if (this.state === 0) { + unwind = 132; + this._saved$7 = false; + this._saved$4 = false; + this._saved$6 = false; + this._saved$5 = false; + this._saved$10 = false; + this._saved$9 = false; + this._saved$8 = false; + this._saved$7 = true; + this.rx_ = this.rx; + this._saved$4 = true; + this.guard_ = this.guard; + this.moves_ = this.moves; + this.first_ = Guard.new(rt.u32Add(this.guard_.id, 200), Log.clone$Clone(this.guard_.log)); + unwind = 131; + this._saved$6 = true; + this.second_ = Guard.new(rt.u32Add(this.guard_.id, 300), Log.clone$Clone(this.guard_.log)); + unwind = 142; + this._saved$5 = true; + rt.drop(new blocksFuture$2(this.first_)); + _18 = rt.u32Rem(this.guard_.id, 5); + turns(this.guard_.log, _18); + temporaries(this.guard_.log, this.guard_.id); + unwind = 130; + this.saved = Guard.new(rt.u32Add(this.guard_.id, 900), Log.clone$Clone(this.guard_.log)); + unwind = 128; + this._saved$10 = true; + this.__awaitee_ = Consumer.recv(this.rx_); + } else if (this.state === 1) { + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + rt.panic("`async fn` resumed after panicking"); + } else if (this.state !== 3) { + if (this.state === 4) { + break b3; + } else if (this.state === 5) { + break b2; + } else if (this.state === 6) { + break b1; + } else { + break b0; } - _taskContext = yield; } - } finally { - rt.drop(__awaitee2); + unwind = 125; + _32 = this.__awaitee_.poll(_2); + if (_32 !== rt.Pending) { + unwind = 126; + result = _32; + rt.drop(this.__awaitee_); + this._saved$10 = false; + this.waited_ = consume(this.saved, result); + unwind = 142; + this._saved$10 = false; + _40 = Guard.new(rt.u32Add(this.guard_.id, 910), Log.clone$Clone(this.guard_.log)); + unwind = 124; + _46 = Guard.new(rt.u32Add(this.guard_.id, 920), Log.clone$Clone(this.guard_.log)); + unwind = 122; + this.slots_ = [_40, _46]; + this._saved = Guard.new(rt.u32Add(this.guard_.id, 930), Log.clone$Clone(this.guard_.log)); + unwind = 120; + this._saved$9 = true; + this.___awaitee_ = slot(this.rx_); + } else { + this.state = 3; + return rt.Pending; + } } - Guard.note(guard2, rt.fmtFormat(["mark ", (f: rt.Formatter) => rt.u32Display(replaced, f), " ", (f: rt.Formatter) => rt.u32Display(mark.n, f)])); - let cycle = new Outer.Outer({ inner: undefined, guard: Guard.new(rt.u32Add(guard2.id, 800), Log.clone$Clone(guard2.log)) }); - try { - const cycle2 = cycle; - cycle = undefined!; - const _nested = new Inner.Inner({ outer: cycle2 }); - try { - let third = Guard.new(rt.u32Add(guard2.id, 400), Log.clone$Clone(guard2.log)); - try { - let chosen: Guard.Guard = undefined!; - try { - if (moves2) { - const third2 = third; - third = undefined!; - chosen = third2; - } else { - const third3 = third; - third = undefined!; - chosen = third3; - } - Guard.note(chosen, "chosen"); - if (moves2) { - const guard22 = guard2; - guard2 = undefined!; - rt.drop(rt.future(blocksBody$5, blocksDrop$2, guard22)); - } - const first2 = first; - first = undefined!; - const second2 = second; - second = undefined!; - const rx22 = rx2; - rx2 = undefined!; - let read_ = rt.future(blocksBody$6, blocksDrop$3, first2, second2, rx22); - try { - const read2 = read_; - read_ = undefined!; - let __awaitee4: rt.Future = read2; - try { - while (true) { - const poll4 = __awaitee4.poll(_taskContext); - if (poll4 !== rt.Pending) { - const result4 = poll4; - return result4; + unwind = 118; + _60 = this.___awaitee_.poll(_2); + if (_60 !== rt.Pending) { + unwind = 139; + result2 = _60; + rt.drop(this.___awaitee_); + if (!(result2 < 2)) { + rt.panic("index out of bounds: the len is " + 2 + " but the index is " + result2); + } + unwind = 44; + rt.drop(this.slots_[result2]); + unwind = 123; + this._saved$9 = false; + this.slots_[result2] = this._saved; + this._saved$9 = false; + const arg = ([this.waited_] as [rt.u64])[0]; + args2 = [(f: rt.Formatter) => rt.u64Display(arg, f)]; + _75 = rt.fmtFormat(["slot after ", args2[0]]); + unwind = 117; + _73 = _75; + Guard.note(this.slots_[0], _73); + unwind = 137; + this.tally_ = { n: this.guard_.id }; + this._saved$8 = true; + seen = new blocksFuture$3(rt.copy(this.tally_)); + _86 = rt.u32Add(this.tally_.n, 1000); + this.tally_.n = _86; + this._saved$2 = this.guard_; + this._saved$3 = this.tally_.n; + this._saved$8 = false; + this.___awaitee_$2 = seen; + } else { + this.state = 4; + return rt.Pending; + } + } + unwind = 115; + _98 = this.___awaitee_$2.poll(_2); + if (_98 !== rt.Pending) { + unwind = 137; + _95 = _98; + rt.drop(this.___awaitee_$2); + const arg2 = this._saved$3; + args4 = [(f: rt.Formatter) => rt.u32Display(arg2, f), (f: rt.Formatter) => rt.u32Display(_95, f)]; + _90 = rt.fmtFormat(["tally ", args4[0], " then ", args4[1]]); + unwind = 114; + _88 = _90; + Guard.note(this._saved$2, _88); + unwind = 137; + this.mark_ = { n: 1 }; + this.___awaitee_$3 = new blocksFuture$4(this.mark_); + } else { + this.state = 5; + return rt.Pending; + } + } + unwind = 113; + _114 = this.___awaitee_$3.poll(_2); + if (_114 !== rt.Pending) { + unwind = 137; + this.replaced_ = _114; + rt.drop(this.___awaitee_$3); + const arg3 = this.replaced_; + _133 = (f: rt.Formatter) => rt.u32Display(arg3, f); + const arg4 = this.mark_.n; + args6 = [_133, (f: rt.Formatter) => rt.u32Display(arg4, f)]; + _126 = rt.fmtFormat(["mark ", args6[0], " ", args6[1]]); + unwind = 112; + _124 = _126; + Guard.note(this.guard_, _124); + unwind = 111; + _138 = undefined; + _139 = Guard.new(rt.u32Add(this.guard_.id, 800), Log.clone$Clone(this.guard_.log)); + unwind = 137; + _146 = new Outer.Outer({ inner: _138, guard: _139 }); + unwind = 110; + this._nested_ = new Inner.Inner({ outer: _146 }); + third = Guard.new(rt.u32Add(this.guard_.id, 400), Log.clone$Clone(this.guard_.log)); + if (!this.moves_) { + this.chosen_ = third; + } else { + this.chosen_ = third; + } + unwind = 109; + Guard.note(this.chosen_, "chosen"); + if (this.moves_) { + this._saved$4 = false; + rt.drop(new blocksFuture$5(this.guard_)); + } + unwind = 109; + this._saved$6 = false; + this._saved$5 = false; + this._saved$7 = false; + this.___awaitee_$4 = new blocksFuture$6(this.first_, this.second_, this.rx_); + } else { + this.state = 6; + return rt.Pending; + } + } + unwind = 108; + _161 = this.___awaitee_$4.poll(_2); + if (_161 !== rt.Pending) { + unwind = 109; + result5 = _161; + rt.drop(this.___awaitee_$4); + unwind = 110; + rt.drop(this.chosen_); + unwind = 137; + rt.drop(this._nested_); + unwind = 142; + this._saved$8 = false; + rt.dropAll(this.slots_); + this._saved$5 = false; + this._saved$6 = false; + if (this._saved$4) { + unwind = 133; + rt.drop(this.guard_); + } + this._saved$4 = false; + this._saved$7 = false; + this.state = 1; + return result5; + } else { + this.state = 7; + return rt.Pending; + } + } catch (e) { + b8: { + b9: { + b10: { + b11: { + b12: { + b13: { + b14: { + b15: { + b16: { + if (unwind === 0) { + throw e; + } + if (unwind === 44) { + this._saved$9 = false; + this.slots_[result2] = this._saved; + break b13; + } else if (unwind === 108) { + rt.drop(this.___awaitee_$4); + break b16; + } else if (unwind === 109) { + break b16; + } else if (unwind === 110) { + break b15; + } else if (unwind === 111) { + rt.drop(_138); + break b14; + } else if (unwind === 112) { + break b14; + } else if (unwind === 113) { + rt.drop(this.___awaitee_$3); + break b14; + } else if (unwind === 114) { + break b14; + } else if (unwind === 115) { + rt.drop(this.___awaitee_$2); + break b14; + } else if (unwind === 117) { + break b12; + } else if (unwind === 118) { + rt.drop(this.___awaitee_); + break b13; + } else if (unwind === 120) { + rt.drop(this._saved); + this._saved$9 = false; + break b12; + } else if (unwind === 122) { + this._saved$9 = false; + break b12; + } else if (unwind === 123) { + break b12; + } else if (unwind === 124) { + rt.drop(_40); + break b11; + } else if (unwind === 125) { + rt.drop(this.__awaitee_); + } else if (unwind !== 126) { + if (unwind === 128) { + rt.drop(this.saved); + this._saved$10 = false; + break b11; + } else if (unwind === 130) { + this._saved$10 = false; + break b11; + } else if (unwind === 131) { + break b10; + } else if (unwind === 132) { + break b9; + } else if (unwind === 133) { + break b8; + } else if (unwind === 137) { + break b14; + } else if (unwind === 139) { + break b13; + } else { + break b11; } - _taskContext = yield; } - } finally { - rt.drop(__awaitee4); + if (this._saved$10) { + rt.drop(this.saved); + } + this._saved$10 = false; + break b11; } - } finally { - rt.drop(read_); + rt.drop(this.chosen_); } - } finally { - rt.drop(chosen); + rt.drop(this._nested_); } - } finally { - rt.drop(third); + if (this._saved$8) { + rt.drop(seen); + } + this._saved$8 = false; + break b12; + } + if (this._saved$9) { + rt.drop(this._saved); } - } finally { - rt.drop(_nested); + this._saved$9 = false; } - } finally { - rt.drop(cycle); + rt.dropAll(this.slots_); + } + if (this._saved$5) { + rt.drop(this.second_); } - } finally { - rt.drop(seen); } - } finally { - rt.drop(second); + this._saved$5 = false; + if (this._saved$6) { + rt.drop(this.first_); + } + } + this._saved$6 = false; + if (this._saved$4) { + rt.drop(this.guard_); } - } finally { - rt.drop(first); } - } finally { - rt.drop(guard2); + this._saved$4 = false; + if (this._saved$7) { + rt.drop(this.rx_); + } + this._saved$7 = false; + this.state = 2; + throw e; } - } finally { - rt.drop(rx2); } } -export function blocksDrop(rx: Consumer.Consumer, guard: Guard.Guard, _moves: boolean): void { - rt.drop(rx); - rt.drop(guard); -} +export class blocksFuture$2 { + state: number = 0; + first: Guard.Guard; -export function* blocksBody$2(_taskContext2: rt.Context, first: Guard.Guard): Generator { - Guard.note(first, "borrowed"); -} + constructor(first: Guard.Guard) { + this.first = first; + } -export function* blocksBody$3(_taskContext3: rt.Context, tally: Tally.Tally): Generator { - return read(rt.copy(tally)); + [Symbol.dispose](): void { + } + + poll(_2: rt.Context): rt.Poll { + let unwind: number = 0; + try { + if (this.state === 0) { + unwind = 3; + Guard.note(this.first, "borrowed"); + this.state = 1; + return undefined; + } else if (this.state === 1) { + rt.panic("`async fn` resumed after completion"); + } else { + rt.panic("`async fn` resumed after panicking"); + } + } catch (e) { + if (unwind === 0) { + throw e; + } + this.state = 2; + throw e; + } + } } -export function* blocksBody$4(_taskContext4: rt.Context, mark: Mark.Mark): Generator { - Object.assign(mark, { n: 2 }); - return mark.n; +export class blocksFuture$3 { + state: number = 0; + tally: Tally.Tally; + + constructor(tally: Tally.Tally) { + this.tally = tally; + } + + [Symbol.dispose](): void { + } + + poll(_2: rt.Context): rt.Poll { + let _0!: rt.Poll; + let unwind: number = 0; + try { + if (this.state === 0) { + unwind = 3; + _0 = read(this.tally); + this.state = 1; + return _0; + } else if (this.state === 1) { + rt.panic("`async fn` resumed after completion"); + } else { + rt.panic("`async fn` resumed after panicking"); + } + } catch (e) { + if (unwind === 0) { + throw e; + } + this.state = 2; + throw e; + } + } } -export function* blocksBody$5(_taskContext5: rt.Context, guard2: Guard.Guard): Generator { - try { - Guard.note(guard2, "moved"); - } finally { - rt.drop(guard2); +export class blocksFuture$4 { + state: number = 0; + mark: Mark.Mark; + + constructor(mark: Mark.Mark) { + this.mark = mark; + } + + [Symbol.dispose](): void { + } + + poll(_2: rt.Context): rt.Poll { + let _0!: rt.Poll; + let _3!: Mark.Mark; + let _4!: Mark.Mark; + if (this.state === 0) { + _3 = { n: 2 }; + _4 = this.mark; + Object.assign(_4, _3); + _0 = this.mark.n; + this.state = 1; + return _0; + } else { + rt.panic("`async fn` resumed after completion"); + } } } -export function blocksDrop$2(guard2: Guard.Guard): void { - rt.drop(guard2); +export class blocksFuture$5 { + state: number = 0; + guard: Guard.Guard; + + constructor(guard: Guard.Guard) { + this.guard = guard; + } + + [Symbol.dispose](): void { + if (this.state === 0) { + rt.drop(this.guard); + } + } + + poll(_2: rt.Context): rt.Poll { + let unwind: number = 0; + try { + if (this.state === 0) { + unwind = 4; + Guard.note(this.guard, "moved"); + unwind = 5; + rt.drop(this.guard); + this.state = 1; + return undefined; + } else if (this.state === 1) { + rt.panic("`async fn` resumed after completion"); + } else { + rt.panic("`async fn` resumed after panicking"); + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 4) { + rt.drop(this.guard); + } + this.state = 2; + throw e; + } + } } -export function* blocksBody$6(_taskContext6: rt.Context, first: Guard.Guard, second: Guard.Guard, rx2: Consumer.Consumer): Generator { - try { +export class blocksFuture$6 { + state: number = 0; + first: Guard.Guard; + second: Guard.Guard; + rx: Consumer.Consumer; + _held_!: Guard.Guard; + __awaitee_!: rt.Future; + + constructor(first: Guard.Guard, second: Guard.Guard, rx: Consumer.Consumer) { + this.first = first; + this.second = second; + this.rx = rx; + } + + [Symbol.dispose](): void { + let unwind: number = 0; + try { + if (this.state === 0) { + unwind = 22; + rt.drop(this.first); + unwind = 21; + rt.drop(this.second); + unwind = 0; + rt.drop(this.rx); + } else if (this.state === 3) { + unwind = 8; + rt.drop(this.__awaitee_); + unwind = 10; + rt.drop(this._held_); + unwind = 14; + rt.drop(this.first); + unwind = 13; + rt.drop(this.second); + unwind = 0; + rt.drop(this.rx); + } + } catch (e) { + b0: { + b1: { + b2: { + if (unwind === 0) { + throw e; + } + if (unwind === 8) { + rt.drop(this._held_); + break b1; + } else if (unwind === 10) { + break b1; + } else if (unwind === 13) { + break b2; + } else if (unwind === 14) { + rt.drop(this.second); + break b2; + } else if (unwind !== 21) { + rt.drop(this.second); + } + rt.drop(this.rx); + break b0; + } + rt.drop(this.rx); + break b0; + } + rt.drop(this.first); + rt.drop(this.second); + rt.drop(this.rx); + } + throw e; + } + } + + poll(_2: rt.Context): rt.Poll { + let _17!: rt.Poll; + let result!: rt.u64 | undefined; + let _27!: rt.u64; + let unwind: number = 0; try { - try { - Guard.note(first, "reads"); - Guard.note(second, "reads"); - const _held = Guard.new(rt.u32Add(second.id, 100), Log.clone$Clone(second.log)); - try { - let option: rt.u64 | undefined; - let __awaitee3: rt.Future = Consumer.recv(rx2); - try { - while (true) { - const poll3 = __awaitee3.poll(_taskContext6); - if (poll3 !== rt.Pending) { - const result3 = poll3; - option = result3; - break; + if (this.state === 0) { + unwind = 30; + Guard.note(this.first, "reads"); + Guard.note(this.second, "reads"); + this._held_ = Guard.new(rt.u32Add(this.second.id, 100), Log.clone$Clone(this.second.log)); + unwind = 21; + this.__awaitee_ = Consumer.recv(this.rx); + } else if (this.state === 1) { + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + rt.panic("`async fn` resumed after panicking"); + } + unwind = 20; + _17 = this.__awaitee_.poll(_2); + if (_17 !== rt.Pending) { + unwind = 21; + result = _17; + rt.drop(this.__awaitee_); + if (result === undefined) { + _27 = 0; + } else { + _27 = result; + } + unwind = 30; + rt.drop(this._held_); + unwind = 24; + rt.drop(this.first); + unwind = 23; + rt.drop(this.second); + unwind = 22; + rt.drop(this.rx); + this.state = 1; + return _27; + } else { + this.state = 3; + return rt.Pending; + } + } catch (e) { + b2: { + b3: { + b4: { + if (unwind === 0) { + throw e; + } + if (unwind === 20) { + rt.drop(this.__awaitee_); + break b4; + } else if (unwind === 21) { + break b4; + } else if (unwind === 22) { + break b2; + } else if (unwind !== 23) { + if (unwind === 24) { + rt.drop(this.second); + } else { + break b3; } - _taskContext6 = yield; } - } finally { - rt.drop(__awaitee3); + rt.drop(this.rx); + break b2; } - if (option !== undefined) { - const value2 = option; - return value2; - } else { - return 0; + rt.drop(this._held_); + } + rt.drop(this.first); + rt.drop(this.second); + rt.drop(this.rx); + } + this.state = 2; + throw e; + } + } +} + +/** `v`, or 0, plus the id of `guard`, which it drops. */ +export function consume(guard: Guard.Guard, v: rt.u64 | undefined): rt.u64 { + return rt.u64Add(Guard.finish(guard, "consumed") as rt.u64, rt.optionUnwrapOr(v, 0)); +} + +/** The slot the next value picks. */ +export function slot(rx: Consumer.Consumer): rt.Future { + return new slotFuture(rx); +} + +export class slotFuture { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } + } + + poll(_2: rt.Context): rt.Poll { + let _6!: rt.Poll; + let result!: rt.u64 | undefined; + let _18!: rt.usize; + let unwind: number = 0; + try { + if (this.state === 0) { + unwind = 16; + this.__awaitee_ = Consumer.recv(this.rx); + } else if (this.state === 1) { + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + rt.panic("`async fn` resumed after panicking"); + } + unwind = 15; + _6 = this.__awaitee_.poll(_2); + if (_6 !== rt.Pending) { + unwind = 16; + result = _6; + rt.drop(this.__awaitee_); + if (result === undefined) { + _18 = 0; + } else { + _18 = rt.usizeRem(rt.u64Low(result), 2); + } + this.state = 1; + return _18; + } else { + this.state = 3; + return rt.Pending; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 15) { + rt.drop(this.__awaitee_); + } + this.state = 2; + throw e; + } + } +} + +/** + * Guards no binding holds to the end of the scope, each dropping where Rust drops it: a + * temporary at the end of its statement, a scrutinee after its `match` or `if let`, a + * boxed temporary, the part a parameter's pattern skips at the end of the call, the rest + * a pattern moves out of an array, an empty repeat at once, a closure's captures in its + * call, and an iterator's after its loop. + */ +export function temporaries(log: Log.Log, id: rt.u32): void { + let guard!: (a0: rt.u32) => Guard.Guard; + let _7!: string; + let _11!: Guard.Guard; + let args2!: rt.Fmt[]; + let matched!: rt.i32; + let _19!: Guard.Guard | undefined; + let _24!: Guard.Guard | undefined; + let _35!: string; + let _39!: Guard.Guard; + let args4!: rt.Fmt[]; + let _57!: Guard.Guard; + let _60!: Guard.Guard; + let args6!: rt.Fmt[]; + let head!: Guard.Guard; + let rest!: Guard.Guard[]; + let _69!: Guard.Guard[]; + let _70!: Guard.Guard; + let _73!: Guard.Guard; + let _76!: Guard.Guard; + let args8!: rt.Fmt[]; + let args10!: rt.Fmt[]; + let sum_!: rt.u32; + let iter!: Countdown.Countdown; + let _126!: rt.u32 | rt.Done; + let args12!: rt.Fmt[]; + let unwind: number = 0; + try { + guard = (n2: rt.u32): Guard.Guard => { + return Guard.new(rt.u32Add(id, n2), Log.clone$Clone(log)); + }; + _11 = guard(1000); + unwind = 83; + const arg = ([_11.id] as [rt.u32])[0]; + args2 = [(f: rt.Formatter) => rt.u32Display(arg, f)]; + _7 = rt.fmtFormat(["temporary ", args2[0]]); + unwind = 0; + rt.drop(_11); + Log.note(log, _7); + _19 = guard(1010); + if (_19 === undefined) { + matched = 0; + } else { + matched = 1; + } + unwind = 0; + rt.drop(_19); + _24 = guard(1020); + if (_24 === undefined) { + unwind = 82; + Log.note(log, rt.fmtFormat(["unmatched"])); + unwind = 0; + rt.drop(_24); + } else { + rt.drop(_24); + } + unwind = 0; + _39 = guard(1030); + unwind = 81; + const arg2 = _39.id; + args4 = [(f: rt.Formatter) => rt.u32Display(arg2, f), (f: rt.Formatter) => rt.i32Display(matched, f)]; + _35 = rt.fmtFormat(["boxed temporary ", args4[0], " ", args4[1]]); + unwind = 0; + rt.drop(_39); + Log.note(log, _35); + _57 = guard(1040); + unwind = 80; + _60 = guard(1050); + unwind = 0; + const arg3 = ([first([_57, _60] as [Guard.Guard, Guard.Guard])] as [rt.u32])[0]; + args6 = [(f: rt.Formatter) => rt.u32Display(arg3, f)]; + Log.note(log, rt.fmtFormat(["skipped ", args6[0]])); + _70 = guard(1060); + unwind = 79; + _73 = guard(1070); + unwind = 78; + _76 = guard(1080); + unwind = 76; + _69 = [_70, _73, _76]; + head = _69[0]; + rest = _69.slice(1, 3); + Guard.note(head, "head"); + Guard.note(rest[1], "rest"); + rt.drop(guard(1090)); + const arg4 = ([([] as Guard.Guard[]).length] as [rt.usize])[0]; + args8 = [(f: rt.Formatter) => rt.usizeDisplay(arg4, f)]; + Log.note(log, rt.fmtFormat(["empty ", args8[0]])); + const captured = guard(1100); + const arg5 = ([((): rt.u32 => { + return Guard.finish(captured, "closure"); + })()] as [rt.u32])[0]; + args10 = [(f: rt.Formatter) => rt.u32Display(arg5, f)]; + Log.note(log, rt.fmtFormat(["closed ", args10[0]])); + sum_ = 0; + iter = new Countdown.Countdown({ left: 2, guard: guard(1110) }); + while (true) { + unwind = 75; + _126 = Countdown.next$Iterator(iter); + if (_126 === rt.DONE) { + unwind = 76; + rt.drop(iter); + const arg6 = ([sum_] as [rt.u32])[0]; + args12 = [(f: rt.Formatter) => rt.u32Display(arg6, f)]; + Log.note(log, rt.fmtFormat(["counted ", args12[0]])); + unwind = 77; + rt.dropAll(rest); + unwind = 0; + rt.drop(head); + return; + } else { + sum_ = rt.u32Add(sum_, _126); + } + } + } catch (e) { + b3: { + b4: { + b5: { + if (unwind === 0) { + throw e; } - } finally { - rt.drop(_held); + if (unwind === 75) { + rt.drop(iter); + break b5; + } else if (unwind === 76) { + break b5; + } else if (unwind === 77) { + break b4; + } else if (unwind === 78) { + rt.drop(_73); + } else if (unwind !== 79) { + if (unwind === 80) { + rt.drop(_57); + break b3; + } else if (unwind === 81) { + rt.drop(_39); + break b3; + } else if (unwind === 82) { + rt.drop(_24); + break b3; + } else { + rt.drop(_11); + break b3; + } + } + rt.drop(_70); + break b3; } - } finally { - rt.drop(first); + rt.dropAll(rest); } - } finally { - rt.drop(second); + rt.drop(head); } - } finally { - rt.drop(rx2); + throw e; } } -export function blocksDrop$3(first: Guard.Guard, second: Guard.Guard, rx2: Consumer.Consumer): void { - rt.drop(first); - rt.drop(second); - rt.drop(rx2); +/** The id of the first guard, which it drops; the second drops as the call returns. */ +export function first(_1: [Guard.Guard, Guard.Guard]): rt.u32 { + let _0!: rt.u32; + let unwind: number = 0; + try { + unwind = 5; + _0 = Guard.finish(_1[0], "first"); + unwind = 0; + rt.drop(_1[1]); + return _0; + } catch (e) { + if (unwind === 0) { + throw e; + } + rt.drop(_1[1]); + throw e; + } } export function read(t: Tally.Tally): rt.u32 { @@ -302,7 +1283,10 @@ export function read(t: Tally.Tally): rt.u32 { /** `i`, noted as picked. */ export function pick(log: Log.Log, i: rt.usize): rt.usize { - Log.note(log, rt.fmtFormat(["pick ", (f: rt.Formatter) => rt.usizeDisplay(i, f)])); + let args2!: rt.Fmt[]; + const arg = ([i] as [rt.usize])[0]; + args2 = [(f: rt.Formatter) => rt.usizeDisplay(arg, f)]; + Log.note(log, rt.fmtFormat(["pick ", args2[0]])); return i; } @@ -316,85 +1300,156 @@ export function pick(log: Log.Log, i: rt.usize): rt.usize { * guard a method takes by value, which drops inside it. */ export function turns(log: Log.Log, count: rt.u32): void { - const pair = [Guard.new(rt.u32Add(count, 10), Log.clone$Clone(log)), Guard.new(rt.u32Add(count, 20), Log.clone$Clone(log))]; + let pair!: Guard.Guard[]; + let _4!: Guard.Guard; + let _8!: Guard.Guard; + let kept!: Guard.Guard; + let pinned!: Guard.Guard; + let held!: Guard.Guard; + let _34!: Guard.Guard; + let scoped!: rt.u32; + let _42!: Guard.Guard; + let args2!: rt.Fmt[]; + let boxed!: Guard.Guard; + let args4!: rt.Fmt[]; + let _70!: rt.Fmt; + let args6!: rt.Fmt[]; + let spares!: Guard.Guard[]; + let _91!: Guard.Guard; + let _95!: Guard.Guard; + let _99!: rt.usize; + let left!: rt.u32; + let turn!: Guard.Guard; + let _119!: rt.u32; + let unwind: number = 0; try { - const kept = pair[0]; - pair[0] = undefined!; - try { - Guard.note(kept, "kept"); - const pinned = Guard.new(rt.u32Add(count, 40), Log.clone$Clone(log)); - try { - Guard.note(pinned, "pinned"); - const held = Guard.new(rt.u32Add(count, 50), Log.clone$Clone(log)); - try { - const borrowed = held; - Guard.note(borrowed, "borrowed"); - const extended = Guard.new(rt.u32Add(count, 60), Log.clone$Clone(log)); - try { - Guard.note(extended, "extended"); - let value: rt.u32; - const inner = Guard.new(rt.u32Add(count, 90), Log.clone$Clone(log)); - try { - value = inner.id; - } finally { - rt.drop(inner); - } - const scoped = value; - Log.note(log, rt.fmtFormat(["after ", (f: rt.Formatter) => rt.u32Display(scoped, f)])); - const boxed = Guard.new(rt.u32Add(count, 100), Log.clone$Clone(log)); - try { - const once = boxed.id; - Log.note(log, rt.fmtFormat(["boxed ", (f: rt.Formatter) => rt.u32Display(once, f), " ", (f: rt.Formatter) => rt.u32Display(boxed.id, f)])); - const finished = Guard.finish(Guard.new(rt.u32Add(count, 110), Log.clone$Clone(log)), "finishing"); - Log.note(log, rt.fmtFormat(["finished ", (f: rt.Formatter) => rt.u32Display(finished, f)])); - const spares = [Guard.new(rt.u32Add(count, 70), Log.clone$Clone(log)), Guard.new(rt.u32Add(count, 80), Log.clone$Clone(log))]; - try { - const index = pick(log, rt.usizeRem(count as rt.usize, 2)); - spares[rt.idx(spares, index)]; - arms: { - if (count === 0) { - Log.note(log, "no turns"); - break arms; + _4 = Guard.new(rt.u32Add(count, 10), Log.clone$Clone(log)); + unwind = 94; + _8 = Guard.new(rt.u32Add(count, 20), Log.clone$Clone(log)); + unwind = 93; + pair = [_4, _8]; + kept = pair[0]; + Guard.note(kept, "kept"); + pinned = Guard.new(rt.u32Add(count, 40), Log.clone$Clone(log)); + unwind = 92; + Guard.note(pinned, "pinned"); + held = Guard.new(rt.u32Add(count, 50), Log.clone$Clone(log)); + unwind = 91; + Guard.note(held, "borrowed"); + _34 = Guard.new(rt.u32Add(count, 60), Log.clone$Clone(log)); + unwind = 90; + Guard.note(_34, "extended"); + _42 = Guard.new(rt.u32Add(count, 90), Log.clone$Clone(log)); + scoped = _42.id; + rt.drop(_42); + const arg = ([scoped] as [rt.u32])[0]; + args2 = [(f: rt.Formatter) => rt.u32Display(arg, f)]; + Log.note(log, rt.fmtFormat(["after ", args2[0]])); + boxed = Guard.new(rt.u32Add(count, 100), Log.clone$Clone(log)); + unwind = 89; + const arg2 = boxed.id; + _70 = (f: rt.Formatter) => rt.u32Display(arg2, f); + const arg3 = boxed.id; + args4 = [_70, (f: rt.Formatter) => rt.u32Display(arg3, f)]; + Log.note(log, rt.fmtFormat(["boxed ", args4[0], " ", args4[1]])); + const arg4 = ([Guard.finish(Guard.new(rt.u32Add(count, 110), Log.clone$Clone(log)), "finishing")] as [rt.u32])[0]; + args6 = [(f: rt.Formatter) => rt.u32Display(arg4, f)]; + Log.note(log, rt.fmtFormat(["finished ", args6[0]])); + _91 = Guard.new(rt.u32Add(count, 70), Log.clone$Clone(log)); + unwind = 88; + _95 = Guard.new(rt.u32Add(count, 80), Log.clone$Clone(log)); + unwind = 87; + spares = [_91, _95]; + _99 = pick(log, rt.usizeRem(count as rt.usize, 2)); + if (!(_99 < 2)) { + rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _99); + } + b0: { + if (count === 0) { + Log.note(log, rt.fmtFormat(["no turns"])); + } else if (!(count < 4)) { + Log.note(log, rt.fmtFormat(["many turns"])); + } else { + left = count; + while (true) { + turn = Guard.new(left, Log.clone$Clone(log)); + if (!(left === 1)) { + unwind = 86; + Guard.note(turn, "turn"); + _119 = rt.u32Sub(left, 1); + unwind = 87; + left = _119; + rt.drop(turn); + } else { + rt.drop(turn); + break b0; + } + } + } + } + unwind = 89; + rt.dropAll(spares); + unwind = 90; + rt.drop(boxed); + unwind = 91; + rt.drop(_34); + unwind = 92; + rt.drop(held); + unwind = 93; + rt.drop(pinned); + unwind = 96; + rt.drop(kept); + unwind = 0; + rt.dropAll(pair.slice(1, 2)); + } catch (e) { + b2: { + b3: { + b4: { + b5: { + b6: { + b7: { + b8: { + if (unwind === 0) { + throw e; } - const n = count; - if (n < 4) { - let left: rt.u32 = n; - while (true) { - const turn = Guard.new(left, Log.clone$Clone(log)); - try { - if (left === 1) { - break; - } - Guard.note(turn, "turn"); - left = rt.u32Sub(left, 1); - } finally { - rt.drop(turn); - } + if (unwind === 86) { + rt.drop(turn); + } else if (unwind !== 87) { + if (unwind === 88) { + rt.drop(_91); + break b8; + } else if (unwind === 89) { + break b8; + } else if (unwind === 90) { + break b7; + } else if (unwind === 91) { + break b6; + } else if (unwind === 92) { + break b5; + } else if (unwind === 93) { + break b4; + } else if (unwind === 94) { + rt.drop(_4); + break b2; + } else { + break b3; } - break arms; } - Log.note(log, "many turns"); + rt.dropAll(spares); } - } finally { - rt.dropAll(spares); + rt.drop(boxed); } - } finally { - rt.drop(boxed); + rt.drop(_34); } - } finally { - rt.drop(extended); + rt.drop(held); } - } finally { - rt.drop(held); + rt.drop(pinned); } - } finally { - rt.drop(pinned); + rt.drop(kept); } - } finally { - rt.drop(kept); + rt.dropAll(pair.slice(1, 2)); } - } finally { - rt.dropAll(pair); + throw e; } } @@ -403,392 +1458,1002 @@ export function turns(log: Log.Log, count: rt.u32): void { * deep: 1, 4, or 16. */ export function drain(rx: Consumer.Consumer, depth: rt.u32): rt.Future { - return rt.future(drainBody, drainDrop, rx, depth); + return new drainFuture(rx, depth); } -export function* drainBody(_taskContext: rt.Context, rx: Consumer.Consumer, depth: rt.u32): Generator { - let rx2: Consumer.Consumer = rx; - rx = undefined!; - try { - const depth2 = depth; - let total: rt.u64 = 0; - while (true) { - let next: rt.u64 | undefined; - if (depth2 === 1) { - let __awaitee: rt.Future = Consumer.recv(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - next = result; - break; +export class drainFuture { + state: number = 0; + rx: Consumer.Consumer; + depth: rt.u32; + rx_!: Consumer.Consumer; + depth_!: rt.u32; + total_!: rt.u64; + __awaitee_!: rt.Future; + ___awaitee_!: rt.Future; + ___awaitee_$2!: rt.Future; + + constructor(rx: Consumer.Consumer, depth: rt.u32) { + this.rx = rx; + this.depth = depth; + } + + [Symbol.dispose](): void { + let unwind: number = 0; + try { + if (this.state === 0) { + unwind = 0; + rt.drop(this.rx); + return; + } else if (this.state === 3) { + unwind = 19; + rt.drop(this.__awaitee_); + } else if (this.state === 4) { + unwind = 17; + rt.drop(this.___awaitee_); + } else if (this.state === 5) { + unwind = 15; + rt.drop(this.___awaitee_$2); + } else { + return; + } + unwind = 0; + rt.drop(this.rx_); + } catch (e) { + if (unwind === 0) { + throw e; + } + rt.drop(this.rx_); + throw e; + } + } + + poll(_2: rt.Context): rt.Poll { + let next!: rt.u64 | undefined; + let _7!: rt.Poll; + let _18!: rt.Poll; + let _29!: rt.Poll; + let _40!: rt.u64; + let unwind: number = 0; + try { + let bb0: number = 0; + l0: while (true) { + switch (bb0) { + case 0: + if (this.state === 0) { + this.rx_ = this.rx; + this.depth_ = this.depth; + this.total_ = 0; + bb0 = 1; + continue l0; + } else if (this.state === 1) { + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + rt.panic("`async fn` resumed after panicking"); + } else if (this.state === 3) { + bb0 = 7; + continue l0; + } else if (this.state === 4) { + bb0 = 15; + continue l0; + } else { + bb0 = 22; + continue l0; } - _taskContext = yield; - } - } finally { - rt.drop(__awaitee); - } - } else if (depth2 === 4) { - let __awaitee2: rt.Future = level3(rx2); - try { - while (true) { - const poll2 = __awaitee2.poll(_taskContext); - if (poll2 !== rt.Pending) { - const result2 = poll2; - next = result2; - break; + case 1: + if (this.depth_ === 1) { + unwind = 36; + this.__awaitee_ = Consumer.recv(this.rx_); + bb0 = 7; + continue l0; + } else if (this.depth_ === 4) { + unwind = 36; + this.___awaitee_ = level3(this.rx_); + bb0 = 15; + continue l0; + } else { + unwind = 36; + this.___awaitee_$2 = level15(this.rx_); + bb0 = 22; + continue l0; } - _taskContext = yield; - } - } finally { - rt.drop(__awaitee2); - } - } else { - let __awaitee3: rt.Future = level15(rx2); - try { - while (true) { - const poll3 = __awaitee3.poll(_taskContext); - if (poll3 !== rt.Pending) { - const result3 = poll3; - next = result3; - break; + case 22: + unwind = 33; + _29 = this.___awaitee_$2.poll(_2); + if (_29 !== rt.Pending) { + unwind = 36; + next = _29; + rt.drop(this.___awaitee_$2); + bb0 = 27; + continue l0; + } else { + this.state = 5; + return rt.Pending; + } + case 15: + unwind = 34; + _18 = this.___awaitee_.poll(_2); + if (_18 !== rt.Pending) { + unwind = 36; + next = _18; + rt.drop(this.___awaitee_); + bb0 = 27; + continue l0; + } else { + this.state = 4; + return rt.Pending; + } + case 7: + unwind = 35; + _7 = this.__awaitee_.poll(_2); + if (_7 !== rt.Pending) { + unwind = 36; + next = _7; + rt.drop(this.__awaitee_); + bb0 = 27; + continue l0; + } else { + this.state = 3; + return rt.Pending; + } + case 27: + if (next === undefined) { + unwind = 37; + _40 = this.total_; + rt.drop(this.rx_); + this.state = 1; + return _40; + } else { + unwind = 36; + this.total_ = rt.u64Add(this.total_, next); + bb0 = 1; + continue l0; } - _taskContext = yield; - } - } finally { - rt.drop(__awaitee3); } } - if (next !== undefined) { - const value = next; - total = rt.u64Add(total, value); - } else { - break; + } catch (e) { + b1: { + if (unwind === 0) { + throw e; + } + if (unwind === 33) { + rt.drop(this.___awaitee_$2); + } else if (unwind === 34) { + rt.drop(this.___awaitee_); + } else if (unwind === 35) { + rt.drop(this.__awaitee_); + } else if (unwind !== 36) { + break b1; + } + rt.drop(this.rx_); } + this.state = 2; + throw e; } - return total; - } finally { - rt.drop(rx2); } } -export function drainDrop(rx: Consumer.Consumer, _depth: rt.u32): void { - rt.drop(rx); -} - export function level1(rx: Consumer.Consumer): rt.Future { - return rt.future(level1Body, undefined, rx); + return new level1Future(rx); } -export function* level1Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = Consumer.recv(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level1Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } + } + + poll(_2: rt.Context): rt.Poll { + let _6!: rt.Poll; + let unwind: number = 0; + try { + if (this.state === 0) { + unwind = 12; + this.__awaitee_ = Consumer.recv(this.rx); + } else if (this.state === 1) { + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _6 = this.__awaitee_.poll(_2); + if (_6 !== rt.Pending) { + unwind = 12; + rt.drop(this.__awaitee_); + this.state = 1; + return _6; + } else { + this.state = 3; + return rt.Pending; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); } - _taskContext = yield; + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level10(rx: Consumer.Consumer): rt.Future { - return rt.future(level10Body, undefined, rx); + return new level10Future(rx); } -export function* level10Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level9(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level10Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } + } + + poll(_2: rt.Context): rt.Poll { + let _6!: rt.Poll; + let unwind: number = 0; + try { + if (this.state === 0) { + unwind = 12; + this.__awaitee_ = level9(this.rx); + } else if (this.state === 1) { + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _6 = this.__awaitee_.poll(_2); + if (_6 !== rt.Pending) { + unwind = 12; + rt.drop(this.__awaitee_); + this.state = 1; + return _6; + } else { + this.state = 3; + return rt.Pending; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); } - _taskContext = yield; + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level11(rx: Consumer.Consumer): rt.Future { - return rt.future(level11Body, undefined, rx); + return new level11Future(rx); } -export function* level11Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level10(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level11Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } + } + + poll(_2: rt.Context): rt.Poll { + let _6!: rt.Poll; + let unwind: number = 0; + try { + if (this.state === 0) { + unwind = 12; + this.__awaitee_ = level10(this.rx); + } else if (this.state === 1) { + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _6 = this.__awaitee_.poll(_2); + if (_6 !== rt.Pending) { + unwind = 12; + rt.drop(this.__awaitee_); + this.state = 1; + return _6; + } else { + this.state = 3; + return rt.Pending; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); } - _taskContext = yield; + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level12(rx: Consumer.Consumer): rt.Future { - return rt.future(level12Body, undefined, rx); + return new level12Future(rx); } -export function* level12Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level11(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level12Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } + } + + poll(_2: rt.Context): rt.Poll { + let _6!: rt.Poll; + let unwind: number = 0; + try { + if (this.state === 0) { + unwind = 12; + this.__awaitee_ = level11(this.rx); + } else if (this.state === 1) { + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _6 = this.__awaitee_.poll(_2); + if (_6 !== rt.Pending) { + unwind = 12; + rt.drop(this.__awaitee_); + this.state = 1; + return _6; + } else { + this.state = 3; + return rt.Pending; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); } - _taskContext = yield; + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level13(rx: Consumer.Consumer): rt.Future { - return rt.future(level13Body, undefined, rx); + return new level13Future(rx); } -export function* level13Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level12(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level13Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } + } + + poll(_2: rt.Context): rt.Poll { + let _6!: rt.Poll; + let unwind: number = 0; + try { + if (this.state === 0) { + unwind = 12; + this.__awaitee_ = level12(this.rx); + } else if (this.state === 1) { + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _6 = this.__awaitee_.poll(_2); + if (_6 !== rt.Pending) { + unwind = 12; + rt.drop(this.__awaitee_); + this.state = 1; + return _6; + } else { + this.state = 3; + return rt.Pending; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); } - _taskContext = yield; + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level14(rx: Consumer.Consumer): rt.Future { - return rt.future(level14Body, undefined, rx); + return new level14Future(rx); } -export function* level14Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level13(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level14Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } + } + + poll(_2: rt.Context): rt.Poll { + let _6!: rt.Poll; + let unwind: number = 0; + try { + if (this.state === 0) { + unwind = 12; + this.__awaitee_ = level13(this.rx); + } else if (this.state === 1) { + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _6 = this.__awaitee_.poll(_2); + if (_6 !== rt.Pending) { + unwind = 12; + rt.drop(this.__awaitee_); + this.state = 1; + return _6; + } else { + this.state = 3; + return rt.Pending; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); } - _taskContext = yield; + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level15(rx: Consumer.Consumer): rt.Future { - return rt.future(level15Body, undefined, rx); + return new level15Future(rx); } -export function* level15Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level14(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level15Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } + } + + poll(_2: rt.Context): rt.Poll { + let _6!: rt.Poll; + let unwind: number = 0; + try { + if (this.state === 0) { + unwind = 12; + this.__awaitee_ = level14(this.rx); + } else if (this.state === 1) { + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _6 = this.__awaitee_.poll(_2); + if (_6 !== rt.Pending) { + unwind = 12; + rt.drop(this.__awaitee_); + this.state = 1; + return _6; + } else { + this.state = 3; + return rt.Pending; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); } - _taskContext = yield; + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level2(rx: Consumer.Consumer): rt.Future { - return rt.future(level2Body, undefined, rx); + return new level2Future(rx); } -export function* level2Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level1(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level2Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } + } + + poll(_2: rt.Context): rt.Poll { + let _6!: rt.Poll; + let unwind: number = 0; + try { + if (this.state === 0) { + unwind = 12; + this.__awaitee_ = level1(this.rx); + } else if (this.state === 1) { + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _6 = this.__awaitee_.poll(_2); + if (_6 !== rt.Pending) { + unwind = 12; + rt.drop(this.__awaitee_); + this.state = 1; + return _6; + } else { + this.state = 3; + return rt.Pending; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); } - _taskContext = yield; + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level3(rx: Consumer.Consumer): rt.Future { - return rt.future(level3Body, undefined, rx); + return new level3Future(rx); } -export function* level3Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level2(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level3Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } + } + + poll(_2: rt.Context): rt.Poll { + let _6!: rt.Poll; + let unwind: number = 0; + try { + if (this.state === 0) { + unwind = 12; + this.__awaitee_ = level2(this.rx); + } else if (this.state === 1) { + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _6 = this.__awaitee_.poll(_2); + if (_6 !== rt.Pending) { + unwind = 12; + rt.drop(this.__awaitee_); + this.state = 1; + return _6; + } else { + this.state = 3; + return rt.Pending; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); } - _taskContext = yield; + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level4(rx: Consumer.Consumer): rt.Future { - return rt.future(level4Body, undefined, rx); + return new level4Future(rx); } -export function* level4Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level3(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level4Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } + } + + poll(_2: rt.Context): rt.Poll { + let _6!: rt.Poll; + let unwind: number = 0; + try { + if (this.state === 0) { + unwind = 12; + this.__awaitee_ = level3(this.rx); + } else if (this.state === 1) { + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _6 = this.__awaitee_.poll(_2); + if (_6 !== rt.Pending) { + unwind = 12; + rt.drop(this.__awaitee_); + this.state = 1; + return _6; + } else { + this.state = 3; + return rt.Pending; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); } - _taskContext = yield; + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level5(rx: Consumer.Consumer): rt.Future { - return rt.future(level5Body, undefined, rx); + return new level5Future(rx); } -export function* level5Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level4(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level5Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } + } + + poll(_2: rt.Context): rt.Poll { + let _6!: rt.Poll; + let unwind: number = 0; + try { + if (this.state === 0) { + unwind = 12; + this.__awaitee_ = level4(this.rx); + } else if (this.state === 1) { + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _6 = this.__awaitee_.poll(_2); + if (_6 !== rt.Pending) { + unwind = 12; + rt.drop(this.__awaitee_); + this.state = 1; + return _6; + } else { + this.state = 3; + return rt.Pending; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); } - _taskContext = yield; + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level6(rx: Consumer.Consumer): rt.Future { - return rt.future(level6Body, undefined, rx); + return new level6Future(rx); } -export function* level6Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level5(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level6Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } + } + + poll(_2: rt.Context): rt.Poll { + let _6!: rt.Poll; + let unwind: number = 0; + try { + if (this.state === 0) { + unwind = 12; + this.__awaitee_ = level5(this.rx); + } else if (this.state === 1) { + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _6 = this.__awaitee_.poll(_2); + if (_6 !== rt.Pending) { + unwind = 12; + rt.drop(this.__awaitee_); + this.state = 1; + return _6; + } else { + this.state = 3; + return rt.Pending; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); } - _taskContext = yield; + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level7(rx: Consumer.Consumer): rt.Future { - return rt.future(level7Body, undefined, rx); + return new level7Future(rx); } -export function* level7Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level6(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level7Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } + } + + poll(_2: rt.Context): rt.Poll { + let _6!: rt.Poll; + let unwind: number = 0; + try { + if (this.state === 0) { + unwind = 12; + this.__awaitee_ = level6(this.rx); + } else if (this.state === 1) { + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _6 = this.__awaitee_.poll(_2); + if (_6 !== rt.Pending) { + unwind = 12; + rt.drop(this.__awaitee_); + this.state = 1; + return _6; + } else { + this.state = 3; + return rt.Pending; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); } - _taskContext = yield; + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level8(rx: Consumer.Consumer): rt.Future { - return rt.future(level8Body, undefined, rx); + return new level8Future(rx); } -export function* level8Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level7(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level8Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } + } + + poll(_2: rt.Context): rt.Poll { + let _6!: rt.Poll; + let unwind: number = 0; + try { + if (this.state === 0) { + unwind = 12; + this.__awaitee_ = level7(this.rx); + } else if (this.state === 1) { + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _6 = this.__awaitee_.poll(_2); + if (_6 !== rt.Pending) { + unwind = 12; + rt.drop(this.__awaitee_); + this.state = 1; + return _6; + } else { + this.state = 3; + return rt.Pending; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); } - _taskContext = yield; + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } export function level9(rx: Consumer.Consumer): rt.Future { - return rt.future(level9Body, undefined, rx); + return new level9Future(rx); } -export function* level9Body(_taskContext: rt.Context, rx: Consumer.Consumer): Generator { - const rx2 = rx; - let __awaitee: rt.Future = level8(rx2); - try { - while (true) { - const poll = __awaitee.poll(_taskContext); - if (poll !== rt.Pending) { - const result = poll; - return result; +export class level9Future { + state: number = 0; + rx: Consumer.Consumer; + __awaitee_!: rt.Future; + + constructor(rx: Consumer.Consumer) { + this.rx = rx; + } + + [Symbol.dispose](): void { + if (this.state === 3) { + rt.drop(this.__awaitee_); + } + } + + poll(_2: rt.Context): rt.Poll { + let _6!: rt.Poll; + let unwind: number = 0; + try { + if (this.state === 0) { + unwind = 12; + this.__awaitee_ = level8(this.rx); + } else if (this.state === 1) { + rt.panic("`async fn` resumed after completion"); + } else if (this.state === 2) { + rt.panic("`async fn` resumed after panicking"); + } + unwind = 11; + _6 = this.__awaitee_.poll(_2); + if (_6 !== rt.Pending) { + unwind = 12; + rt.drop(this.__awaitee_); + this.state = 1; + return _6; + } else { + this.state = 3; + return rt.Pending; + } + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 11) { + rt.drop(this.__awaitee_); } - _taskContext = yield; + this.state = 2; + throw e; } - } finally { - rt.drop(__awaitee); } } diff --git a/ts/fixtures/task/src/model.rs b/ts/fixtures/task/src/model.rs index edbd64016..2be0352b8 100644 --- a/ts/fixtures/task/src/model.rs +++ b/ts/fixtures/task/src/model.rs @@ -104,12 +104,23 @@ pub async fn sum(mut rx: Consumer, guard: Guard) -> u64 { /// dropping the block must not drop; a copy, which a later change to the original must /// not reach; a mutable borrow the block replaces whole, which the caller must see; a /// move on one path only; and a move the block only borrows, which drops when the block -/// returns or is cancelled. Between them, a value of two types that hold each other. +/// returns or is cancelled. Between them, a value of two types that hold each other, and +/// guards held across awaits that read values first. pub async fn blocks(mut rx: Consumer, guard: Guard, moves: bool) -> u64 { let first = Guard::new(guard.id + 200, guard.log.clone()); let second = Guard::new(guard.id + 300, guard.log.clone()); drop(async { first.note("borrowed") }); turns(&guard.log, guard.id % 5); + temporaries(&guard.log, guard.id); + // A guard passed beside an await waits it out, as does one assigned to the slot an + // await picks: a cancel drops both. + let waited = consume(Guard::new(guard.id + 900, guard.log.clone()), rx.recv().await); + let mut slots = [ + Guard::new(guard.id + 910, guard.log.clone()), + Guard::new(guard.id + 920, guard.log.clone()), + ]; + slots[slot(&mut rx).await] = Guard::new(guard.id + 930, guard.log.clone()); + slots[0].note(&format!("slot after {waited}")); let mut tally = Tally { n: guard.id }; let seen = async move { read(tally) }; tally.n += 1000; @@ -154,6 +165,79 @@ struct Mark { n: u32, } +/// `v`, or 0, plus the id of `guard`, which it drops. +fn consume(guard: Guard, v: Option) -> u64 { + u64::from(guard.finish("consumed")) + v.unwrap_or(0) +} + +/// The slot the next value picks. +async fn slot(rx: &mut Consumer) -> usize { + match rx.recv().await { + Some(v) => v as usize % 2, + None => 0, + } +} + +/// Guards no binding holds to the end of the scope, each dropping where Rust drops it: a +/// temporary at the end of its statement, a scrutinee after its `match` or `if let`, a +/// boxed temporary, the part a parameter's pattern skips at the end of the call, the rest +/// a pattern moves out of an array, an empty repeat at once, a closure's captures in its +/// call, and an iterator's after its loop. +#[expect(clippy::redundant_pattern_matching, reason = "the `if let` is under test")] +fn temporaries(log: &Log, id: u32) { + let guard = |n: u32| Guard::new(id + n, log.clone()); + log.note(format!("temporary {}", guard(1000).id)); + let matched = match Some(guard(1010)) { + Some(..) => 1, + None => 0, + }; + if let None = Some(guard(1020)) { + log.note(format!("unmatched")); + } + log.note(format!("boxed temporary {} {matched}", Box::new(guard(1030)).id)); + log.note(format!("skipped {}", first((guard(1040), guard(1050))))); + let [head, rest @ ..] = [guard(1060), guard(1070), guard(1080)]; + head.note("head"); + rest[1].note("rest"); + let empty = [guard(1090); 0]; + log.note(format!("empty {}", empty.len())); + let once = guard(1100); + let finish = move || once.finish("closure"); + log.note(format!("closed {}", finish())); + let mut sum = 0; + for n in (Countdown { + left: 2, + guard: guard(1110), + }) { + sum += n; + } + log.note(format!("counted {sum}")); +} + +/// The id of the first guard, which it drops; the second drops as the call returns. +fn first((a, _): (Guard, Guard)) -> u32 { + a.finish("first") +} + +/// Counts down, holding a guard the loop drops after its last turn. +struct Countdown { + left: u32, + guard: Guard, +} + +impl Iterator for Countdown { + type Item = u32; + + fn next(&mut self) -> Option { + if self.left == 0 { + return None; + } + self.left -= 1; + self.guard.note("count"); + Some(self.left) + } +} + /// Drops through `guard`, and `Inner` through it: deciding `Outer` first must not leave /// `Inner` decided as dropping nothing. struct Outer { diff --git a/ts/runtime/rt/task.ts b/ts/runtime/rt/task.ts index f4e0dbc11..026498b78 100644 --- a/ts/runtime/rt/task.ts +++ b/ts/runtime/rt/task.ts @@ -2,9 +2,9 @@ // futures do that plain JS does not. `rt.ts` re-exports all of it. // // A value whose drop JS can observe has `[Symbol.dispose]`, which runs its `Drop` impl -// and drops its fields. A moved-out place holds `undefined`, which drops as nothing. +// and drops its fields. `None` is `undefined`, which drops as nothing. -import { Panic, panic } from "../rt.ts"; +import { Panic } from "../rt.ts"; // Drops @@ -101,78 +101,6 @@ export interface Future extends Disposable { poll(cx: Context): Poll; } -/** - * The body of an `async fn` or block, a generator of what it captured: it yields at - * each `.await` that is pending. - */ -export type Body = (cx: Context, ...upvars: A) => Generator; - -const Unresumed = 0; -const Suspended = 1; -const Returned = 2; -const Panicked = 3; - -/** - * An `async fn`'s future, around its body as a generator. Nothing runs until the first - * poll. Dropping it unresumed drops what it captured, and suspended runs the `finally` - * blocks that drop its live locals. - */ -class Async implements Future { - #state = Unresumed; - #body: Body; - #drop: ((...upvars: A) => void) | undefined; - #upvars: A | undefined; - #gen: Generator | undefined; - - constructor(body: Body, drop: ((...upvars: A) => void) | undefined, upvars: A) { - this.#body = body; - this.#drop = drop; - this.#upvars = upvars; - } - - poll(cx: Context): Poll { - const state = this.#state; - if (state === Returned) panic("`async fn` resumed after completion"); - if (state === Panicked) panic("`async fn` resumed after panicking"); - this.#state = Panicked; - let next: IteratorResult; - if (state === Unresumed) { - const gen = this.#body(cx, ...this.#upvars!); - this.#upvars = undefined; - this.#gen = gen; - next = gen.next(); - } else { - next = this.#gen!.next(cx); - } - if (next.done) { - this.#state = Returned; - this.#gen = undefined; - return next.value; - } - this.#state = Suspended; - return Pending; - } - - [Symbol.dispose](): void { - const state = this.#state; - this.#state = Returned; - if (state === Unresumed) this.#drop?.(...this.#upvars!); - else if (state === Suspended) this.#gen!.return(undefined as T); - } -} - -/** - * An `async fn`'s future: `body` runs on what it captured at the first poll, and `drop` - * drops that if it never does. - */ -export function future( - body: Body, - drop: ((...upvars: A) => void) | undefined, - ...upvars: A -): Future { - return new Async(body, drop, upvars); -} - // Executor /** diff --git a/ts/src/cli.rs b/ts/src/cli.rs index 86ce71cb4..bba1152c9 100644 --- a/ts/src/cli.rs +++ b/ts/src/cli.rs @@ -10,17 +10,14 @@ use crate::config::{self, Config}; /// holds exactly, and its `cfg`s are the browser's. const TARGET: &str = "wasm32-unknown-unknown"; -const USAGE: &str = "usage: rust2-ts --config (--out | --census ) [--manifest-path ] [--lower thir|mir] [-- ] +const USAGE: &str = "usage: rust2-ts --config (--out | --census ) [--manifest-path ] [-- ] Translates the library of the package that ts.toml names to TypeScript in . The package's Cargo.toml is beside ts.toml unless --manifest-path says where. Cargo args, such as --features, are passed to `cargo check`. --census writes a Markdown report of every construct translation refuses in the library, -reached from each of its items as if each were a root, instead of translating it. - ---lower picks what function bodies lower from: THIR, the default, or MIR, the spike's -prototype."; +reached from each of its items as if each were a root, instead of translating it."; pub fn run(args: &[String]) -> ExitCode { match try_run(args) { @@ -33,7 +30,7 @@ pub fn run(args: &[String]) -> ExitCode { } fn try_run(args: &[String]) -> Result { - let Some(args) = Args::parse(args, USAGE, &["--lower"])? else { + let Some(args) = Args::parse(args, USAGE)? else { return Ok(ExitCode::SUCCESS); }; let config = Config::load(&args.config)?; @@ -41,13 +38,7 @@ fn try_run(args: &[String]) -> Result { Output::Dir(out) => (config::env::OUT, out.as_os_str()), Output::Census(census) => (config::env::CENSUS, census.as_os_str()), }; - let mut env = vec![(config::env::CONFIG, args.config.as_os_str()), output]; - for (_, lower) in &args.options { - if !matches!(lower.as_str(), "thir" | "mir") { - return Err(format!("--lower takes thir or mir, not {lower}\n\n{USAGE}")); - } - env.push((config::env::LOWER, lower.as_ref())); - } + let env = [(config::env::CONFIG, args.config.as_os_str()), output]; Check { tool: "rust2-ts", manifest: &args.manifest, diff --git a/ts/src/config.rs b/ts/src/config.rs index 88abccf4c..f5f65437e 100644 --- a/ts/src/config.rs +++ b/ts/src/config.rs @@ -38,6 +38,4 @@ pub mod env { pub const OUT: &str = "RUST2_TS_OUT"; /// Where to write a census instead of translating, absolute. pub const CENSUS: &str = "RUST2_TS_CENSUS"; - /// What bodies lower from: `thir`, the default, or `mir`. - pub const LOWER: &str = "RUST2_TS_LOWER"; } diff --git a/ts/src/driver.rs b/ts/src/driver.rs index d9a39e1d2..3269071f0 100644 --- a/ts/src/driver.rs +++ b/ts/src/driver.rs @@ -19,11 +19,9 @@ pub fn run(args: Vec) -> ExitCode { // pointers, such as a box's: JS has no pointers to check. And with the cleanups a // panic unwinds through, which wasm32's default of aborting leaves out: a JS caller // can catch a panic and go on. - if job.as_ref().is_some_and(|job| job.mir) { + if job.is_some() { args.push("-Zub-checks=no".into()); - if std::env::var_os("RUST2_TS_ABORT").is_none() { - args.push("-Cpanic=unwind".into()); - } + args.push("-Cpanic=unwind".into()); } Ok(job.map(|job| Box::new(job) as rust2_driver::rustc::Job)) }) @@ -33,8 +31,6 @@ pub fn run(args: Vec) -> ExitCode { struct Translate { config: Config, output: Output, - /// Whether bodies lower from MIR rather than THIR. - mir: bool, } /// What the job writes. @@ -69,30 +65,23 @@ impl Translate { )); } }; - let mir = match std::env::var(config::env::LOWER).as_deref() { - Ok("mir") => true, - Ok("thir") | Err(_) => false, - Ok(other) => return Err(format!("{} must be thir or mir, not {other}", config::env::LOWER)), - }; - Ok(Some(Self { config, output, mir })) + Ok(Some(Self { config, output })) } } impl Callbacks for Translate { fn after_expansion<'tcx>(&mut self, _compiler: &Compiler, tcx: TyCtxt<'tcx>) -> Compilation { - // Copy each body's THIR before borrow checking steals it. - let bodies = lower::Bodies::collect(tcx); tcx.ensure_ok().analysis(()); if tcx.dcx().has_errors().is_some() { return Compilation::Stop; } // Only a program rustc accepts is translated. let written = match &self.output { - Output::Dir(out) => match lower::translate(tcx, &self.config, &bodies, self.mir) { + Output::Dir(out) => match lower::translate(tcx, &self.config) { Some(program) if tcx.dcx().has_errors().is_none() => program.write(out), _ => Ok(()), }, - Output::Census(path) => match lower::census(tcx, &self.config, &bodies, self.mir) { + Output::Census(path) => match lower::census(tcx, &self.config) { Some(census) => program::write_file(path, &census.render(&self.config.package)), None => Ok(()), }, diff --git a/ts/src/lower/body.rs b/ts/src/lower/body.rs index aa3ea05f5..46f5e8799 100644 --- a/ts/src/lower/body.rs +++ b/ts/src/lower/body.rs @@ -1,191 +1,28 @@ -//! Function bodies: THIR expressions to TypeScript statements and expressions. -//! -//! Rust is all expressions and JS is not, so each expression lowers either for its -//! value (`expr`), which may first push statements, or into a destination (`stmt`), -//! which lets control flow return or assign from each branch directly. Statements -//! pushed ahead of a value keep Rust's evaluation order: an earlier operand with an -//! effect is saved to a temporary first. +//! A function body being lowered: its names, and the calls the library mappings make +//! through it, to the crate's own functions, constructors, and std's. -use rustc_data_structures::fx::{FxHashMap, FxHashSet}; -use rustc_hir::{HirId, MatchSource}; -use rustc_middle::middle::region; -use rustc_middle::mir::BorrowKind; -use rustc_middle::thir::{self, ArmId, BlockId, ExprId, ExprKind, LocalVarId, Pat, PatKind, StmtId, Thir}; -use rustc_middle::ty::adjustment::PointerCoercion; +use rustc_data_structures::fx::FxHashSet; use rustc_middle::ty::{self, GenericArgsRef, Instance, Ty, TypeVisitableExt}; -use rustc_span::{Span, Symbol}; +use rustc_span::Span; -use super::drop::Owned; -use super::library::{self, Args}; -use super::{AdtRepr, ObjectKind, Translator, camel, escape}; -use crate::program::SymKind; -use crate::ts::{self, Expr, Key, Param, Stmt, StmtKind, Target, Type}; - -/// Translate one function instance's body. -pub fn function<'a, 'tcx>( - t: &mut Translator<'a, 'tcx>, - instance: Instance<'tcx>, - thir: &'a Thir<'tcx>, - expr: ExprId, -) -> Option { - let tcx = t.tcx; - let def_id = instance.def_id(); - let sig = tcx.instantiate_bound_regions_with_erased(tcx.fn_sig(def_id).skip_binder()); - let sig = t.subst(instance.args, sig); - let mut b = Body { - t, - thir, - args: instance.args, - locals: FxHashMap::default(), - names: FxHashSet::default(), - read: reads(tcx, thir), - breakables: Vec::new(), - ret: sig.output(), - visited: FxHashSet::default(), - scopes: Vec::new(), - moved: FxHashSet::default(), - borrowed: FxHashSet::default(), - yields: 0, - done: super::iter::is_next(tcx, def_id), - }; - let span = tcx.def_span(def_id); - if b.done { - super::iter::check_impl(b.t, def_id); - } - let mut body = Vec::new(); - let mut params = Vec::new(); - b.open_scope(); - for param in thir.params.iter() { - let ty = b.subst(param.ty); - match ¶m.pat { - Some(pat) => { - let name = b.param(pat, &mut body); - let ty = b.t.ty(ty, pat.span); - params.push(Param { name, ty: Some(ty) }); - } - None => { - let name = b.fresh("arg"); - let ty = b.t.ty(ty, span); - params.push(Param { name, ty: Some(ty) }); - } - } - } - let ret = b.ret; - let dest = match ret.is_unit() || ret.is_never() { - true => Dest::Discard, - false => Dest::Return, - }; - b.stmt(expr, dest, &mut body); - b.close_scope(&mut body, 0, span); - // A `self` the body never names, such as a unit struct's derived `Display`, takes a `_` - // so it passes `noUnusedParameters`. - if let Some(param) = params.first_mut() - && param.name == "self" - && !ts::mentions(&body, "self") - { - param.name = "_self".into(); - } - let ret = match (b.done, ret.kind()) { - (true, ty::Adt(_, args)) => Type::Union(vec![b.t.ty(args.type_at(0), span), Type::Rt("Done", Vec::new())]), - _ => b.t.ret_ty(ret, span), - }; - Some(ts::Function { - sym: 0, - params, - ret, - body, - loc: None, - doc: None, - generator: false, - }) -} - -/// Where a lowered value goes. -#[derive(Clone, Debug)] -pub enum Dest { - /// Nowhere: only its effects run. - Discard, - /// Returned from the function or closure. - Return, - /// Assigned to a declared variable. - Assign(String), -} - -#[derive(Clone)] -enum Local { - Name { - name: String, - mutable: bool, - }, - /// A function item, which is a type and no value: calls name it statically. - FnItem, -} - -/// A loop or labeled block that `break` can target. -struct Breakable { - scope: region::Scope, - label: String, - used: bool, - dest: Dest, - is_loop: bool, -} +use super::library; +use super::{AdtRepr, Translator, escape}; +use crate::ts::{Expr, Key, Param, Stmt, StmtKind}; pub struct Body<'b, 'a, 'tcx> { pub t: &'b mut Translator<'a, 'tcx>, - pub thir: &'a Thir<'tcx>, + /// The instance's generic arguments. pub args: GenericArgsRef<'tcx>, - locals: FxHashMap, - /// Every name in the function, closures included, so none shadows another. + /// Every name in the function, so none shadows another. names: FxHashSet, - /// Every variable the function and its closures read. - read: FxHashSet, - breakables: Vec, - /// The return type of the function or closure being lowered. - ret: Ty<'tcx>, - /// Expressions lowered so far, by THIR and id, so a refused call lowers only the - /// arguments its mapping did not. - visited: FxHashSet<(*const Thir<'tcx>, ExprId)>, - /// The variables each open scope drops when it closes, innermost last. - pub(super) scopes: Vec>>, - /// The variables a move left `undefined`, which are declared `let` for it. - pub(super) moved: FxHashSet, - /// The variables a generator lowered so far borrows mutably: each is a parameter - /// holding the caller's object, so replacing it whole must change that object. - borrowed: FxHashSet, - /// How many `yield`s are lowered so far, so an operand can tell whether it awaits. - yields: usize, - /// Whether this is an `Iterator::next`, which returns an item or `rt.DONE` rather - /// than an `Option`: its closures are not. - done: bool, -} - -/// One `&&`-joined part of an `if` condition. -enum CondPart<'a, 'tcx> { - Bool(ExprId), - Let(ExprId, &'a Pat<'tcx>), } impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { - /// A body with no THIR of its own: what a MIR lowering calls the library mappings - /// through, passing their arguments already lowered. It names the locals. - pub fn detached(t: &'b mut Translator<'a, 'tcx>, args: GenericArgsRef<'tcx>, ret: Ty<'tcx>) -> Self { - let bodies: &'a super::Bodies<'tcx> = t.bodies; - let thir = &bodies.empty; + pub fn new(t: &'b mut Translator<'a, 'tcx>, args: GenericArgsRef<'tcx>) -> Self { Body { t, - thir, args, - locals: FxHashMap::default(), names: FxHashSet::default(), - read: FxHashSet::default(), - breakables: Vec::new(), - ret, - visited: FxHashSet::default(), - scopes: Vec::new(), - moved: FxHashSet::default(), - borrowed: FxHashSet::default(), - yields: 0, - done: false, } } @@ -193,1811 +30,47 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { self.t.subst(self.args, value) } - pub fn ty_of(&self, id: ExprId) -> Ty<'tcx> { - self.subst(self.thir[id].ty) - } - - /// Record that `id` is lowered, or is being. - pub fn visit(&mut self, id: ExprId) { - self.visited.insert((std::ptr::from_ref(self.thir), id)); - } - - fn visited(&self, id: ExprId) -> bool { - self.visited.contains(&(std::ptr::from_ref(self.thir), id)) - } - - pub fn span(&self, id: ExprId) -> Span { - self.thir[id].span - } - pub fn err(&mut self, span: Span, msg: impl Into) -> Expr { self.t.err(span, msg); Expr::undefined() } - /// Whether anything reads `var`, so its binding is worth declaring. - pub fn is_read(&self, var: LocalVarId) -> bool { - self.read.contains(&var.0) - } - - /// A name no other binding in the function has. - pub fn fresh(&mut self, base: &str) -> String { - let base = escape(base); - let mut name = base.clone(); - let mut n = 2; - while !self.names.insert(name.clone()) { - name = format!("{base}{n}"); - n += 1; - } - name - } - - /// A temporary named after what it holds. - pub fn temp_for(&mut self, id: ExprId) -> String { - let base = self.temp_base(id); - self.fresh(&base) - } - - fn temp_base(&self, id: ExprId) -> String { - match &self.thir[id].kind { - ExprKind::Scope { value, .. } | ExprKind::Borrow { arg: value, .. } => self.temp_base(*value), - ExprKind::Call { ty, .. } => match self.subst(*ty).kind() { - ty::FnDef(def_id, _) => camel(self.t.tcx.item_name(*def_id).as_str()), - _ => "value".into(), - }, - _ => match self.ty_of(id).kind() { - ty::Adt(adt, _) => { - let name = self.t.tcx.item_name(adt.did()).to_string(); - let mut chars = name.chars(); - chars - .next() - .map_or(name.clone(), |c| c.to_lowercase().chain(chars).collect()) - } - _ => "value".into(), - }, - } - } - - /// Declare a binding for a Rust variable of type `ty`, which its scope drops if it - /// `owns` the value rather than borrowing it. - pub(super) fn bind_var( - &mut self, - var: LocalVarId, - name: Symbol, - mutable: bool, - ty: Ty<'tcx>, - span: Span, - owns: bool, - ) -> String { - // A JS variable holding a number is a copy: writing through it reaches nothing. - if let ty::Ref(_, inner, rustc_ast::Mutability::Mut) = self.subst(ty).kind() - && self.t.object_kind(*inner).is_none() - { - self.t.err( - span, - format!("a `&mut {inner}` binding: a JS value of `{inner}` is a copy, so it can't change"), - ); - } - let name = self.fresh(&camel(name.as_str())); - self.locals.insert( - var.0, - Local::Name { - name: name.clone(), - mutable, - }, - ); - if owns { - let ty = self.subst(ty); - self.own(&name, ty); - } - name - } - - /// A parameter's name, declaring its pattern's bindings at the top of the body. - fn param(&mut self, pat: &Pat<'tcx>, out: &mut Vec) -> String { - match &pat.kind { - PatKind::Binding { - name, - var, - mode, - subpattern: None, - .. - } if mode.0 == rustc_hir::ByRef::No => { - let mutable = mode.1 == rustc_ast::Mutability::Mut; - // A parameter nothing reads, such as `other` in a derived `eq` of two - // `struct E {}`, takes a `_` so it passes `noUnusedParameters`. - let name = match self.is_read(*var) || name.as_str().starts_with('_') { - true => *name, - false => Symbol::intern(&format!("_{name}")), - }; - self.bind_var(*var, name, mutable, pat.ty, pat.span, true) - } - _ if self.t.drops(self.subst(pat.ty)) => { - self.t.err( - pat.span, - "a parameter that drops bound by a pattern, which is not supported yet", - ); - self.fresh("arg") - } - PatKind::Wild => self.fresh("_"), - _ => { - let name = self.fresh("arg"); - let scrut = Expr::ident(&name); - if self.pat_test(pat, &scrut).is_some() { - self.t.err(pat.span, "a refutable parameter pattern"); - } - self.pat_bind(pat, &scrut, false, out); - name - } - } - } - - fn local(&mut self, var: HirId, span: Span) -> Expr { - match self.locals.get(&var) { - Some(Local::Name { name, .. }) => Expr::ident(name), - Some(Local::FnItem) => self.err(span, "a function item read as a value"), - None => self.err(span, "a variable from outside the function"), - } - } - - // Statements - - fn push(&mut self, out: &mut Vec, kind: StmtKind, span: Span) { - let loc = self.t.loc(span); - out.push(kind.at(loc)); - } - - /// Deliver an already-lowered value to `dest`. - fn deliver(&mut self, value: Expr, dest: &Dest, span: Span, out: &mut Vec) { - match dest { - Dest::Discard => { - if !value.is_path() { - self.push(out, StmtKind::Expr(value), span); - } - } - Dest::Return if self.done => { - if let ty::Adt(_, args) = self.ret.kind() { - super::iter::option_ok(self, args.type_at(0), span); - } - let value = Expr::rt("iterFromOption", vec![value]); - self.push(out, StmtKind::Return(Some(value)), span); - } - Dest::Return => self.push(out, StmtKind::Return(Some(value.typed())), span), - Dest::Assign(name) => self.push(out, StmtKind::Expr(Expr::ident(name).assign(value.typed())), span), - } - } - - /// Lower `id` so its value goes to `dest`. - pub fn stmt(&mut self, id: ExprId, dest: Dest, out: &mut Vec) { - self.visit(id); - let e = &self.thir[id]; - let span = e.span; - let ty = self.ty_of(id); - if self.t.ignored_macro(span) { - if !ty.is_unit() { - self.t.err(span, "an ignored macro must evaluate to `()`"); - } - return; - } - let dest = match ty.is_unit() || ty.is_never() { - true => Dest::Discard, - false => dest, - }; - match &e.kind { - ExprKind::Scope { - value, region_scope, .. - } => match self.scoped_loop(*value) { - Some(body) => self.lp(*region_scope, body, dest, out), - None => self.stmt(*value, dest, out), - }, - ExprKind::ValueTypeAscription { source, .. } | ExprKind::ValueExpr { source } => { - self.stmt(*source, dest, out) - } - ExprKind::NeverToAny { source } => self.stmt(*source, Dest::Discard, out), - ExprKind::Block { block } => self.block(*block, dest, out), - ExprKind::If { - cond, then, else_opt, .. - } => self.if_(*cond, *then, *else_opt, dest, span, out), - ExprKind::Match { - scrutinee, - arms, - match_source, - } if !arms.is_empty() => self.match_(id, *scrutinee, arms, *match_source, dest, out), - ExprKind::Loop { .. } => { - self.err(span, "a loop outside a scope"); - } - ExprKind::Break { label, value } => self.break_(*label, *value, span, out), - ExprKind::Continue { label } => { - let label = self.target(*label, true); - self.push(out, StmtKind::Continue(label), span); - } - ExprKind::Return { value } => match value { - // `stmt` returns from every branch that makes a value; a `!` value makes none. - Some(value) if !self.ty_of(*value).is_unit() => self.stmt(*value, Dest::Return, out), - Some(value) => { - self.stmt(*value, Dest::Discard, out); - self.push(out, StmtKind::Return(None), span); - } - None => self.push(out, StmtKind::Return(None), span), - }, - ExprKind::Assign { lhs, rhs } => self.assign(*lhs, *rhs, span, out), - ExprKind::AssignOp { op, lhs, rhs } => self.assign_op(*op, *lhs, *rhs, span, out), - _ => { - if self.done - && let Dest::Return = dest - && let Some(value) = self.done_value(id, out) - { - self.push(out, StmtKind::Return(Some(value)), span); - return; - } - let value = self.expr(id, out); - // A value that goes nowhere drops here. - if let Dest::Discard = dest - && let Some(dropped) = self.t.drop_value(value.clone(), ty, span) - { - self.push(out, StmtKind::Expr(dropped), span); - return; - } - self.deliver(value, &dest, span, out); - } - } - } - - /// What an `Iterator::next` returns for `id` without an `Option` between: `rt.DONE` - /// for `None`, the item for `Some(item)`, and another iterator's `next` as is. - fn done_value(&mut self, id: ExprId, out: &mut Vec) -> Option { - match &self.thir[id].kind { - ExprKind::Adt(adt) if library::Std::of(self.t.tcx, adt.adt_def.did()) == Some(library::Std::Option) => { - self.visit(id); - Some(match adt.fields.first() { - None => Expr::Rt("DONE".into()), - Some(field) => self.operand(field.expr, out).typed(), - }) - } - _ => self.raw_next(id, out), - } - } - - /// `id` lowered by the iterator protocol if it is a call to `Iterator::next`: an item - /// or `rt.DONE`, rather than an `Option`. - fn raw_next(&mut self, id: ExprId, out: &mut Vec) -> Option { - let ExprKind::Call { ty, args, .. } = &self.thir[self.strip(id)].kind else { - return None; - }; - let ty::FnDef(def_id, _) = *self.subst(*ty).kind() else { - return None; - }; - if !super::iter::is_next(self.t.tcx, def_id) { - return None; - } - self.visit(id); - let recv_ty = self.ty_of(args[0]); - let recv = self.operand(args[0], out); - Some(super::iter::next(self, recv_ty, recv)) - } - - fn block(&mut self, id: BlockId, dest: Dest, out: &mut Vec) { - let block = &self.thir[id]; - if block.targeted_by_break { - let label = self.fresh("block"); - self.breakables.push(Breakable { - scope: block.region_scope, - label, - used: false, - dest: dest.clone(), - is_loop: false, - }); - let mut body = Vec::new(); - self.block_body(id, dest, &mut body); - let breakable = self.breakables.pop().unwrap(); - let label = breakable.used.then_some(breakable.label); - let span = block.span; - self.push(out, StmtKind::Block { label, body }, span); - return; - } - self.block_body(id, dest, out); - } - - fn block_body(&mut self, id: BlockId, dest: Dest, out: &mut Vec) { - let block = &self.thir[id]; - let start = out.len(); - self.open_scope(); - for &stmt in &block.stmts { - self.stmt_item(stmt, out); - } - if let Some(expr) = block.expr { - self.stmt(expr, dest, out); - } - self.close_scope(out, start, block.span); - } - - fn stmt_item(&mut self, id: StmtId, out: &mut Vec) { - match &self.thir[id].kind { - thir::StmtKind::Expr { expr, .. } => self.stmt(*expr, Dest::Discard, out), - thir::StmtKind::Let { - pattern, - initializer, - else_block, - span, - .. - } => self.let_(pattern, *initializer, *else_block, *span, out), - } - } - - fn let_( - &mut self, - pat: &'a Pat<'tcx>, - init: Option, - els: Option, - span: Span, - out: &mut Vec, - ) { - let pat_ty = self.subst(pat.ty); - if let Some(init) = init - && self.t.ignored_macro(self.span(init)) - { - self.t.err(span, "a binding of an ignored macro"); - return; - } - // A simple binding. - if let PatKind::Binding { - name, - var, - mode, - subpattern: None, - .. - } = &pat.kind - && els.is_none() - { - if matches!(pat_ty.kind(), ty::FnDef(..)) { - if let Some(init) = init - && !self.simple(init) - { - self.stmt(init, Dest::Discard, out); - } - self.locals.insert(var.0, Local::FnItem); - return; - } - if mode.0 != rustc_hir::ByRef::No { - self.ref_binding(mode.0, pat_ty, pat.span); - } - let mutable = mode.1 == rustc_ast::Mutability::Mut; - let by_value = mode.0 == rustc_hir::ByRef::No; - let ty = self.t.ty(pat_ty, pat.span); - let Some(init) = init else { - let name = self.bind_var(*var, *name, true, pat_ty, pat.span, by_value); - self.push(out, StmtKind::decl(true, name, Some(ty), None), span); - return; - }; - // A `ref` binding borrows a place where it is, and keeps a temporary alive to the - // end of the block, which then drops it as it would a variable. - let borrows = !by_value && self.is_place(init); - let owns = !borrows; - if self.needs_dest(init) { - let name = self.bind_var(*var, *name, true, pat_ty, pat.span, owns); - self.push(out, StmtKind::decl(true, name.clone(), Some(ty), None), span); - self.stmt(init, Dest::Assign(name), out); - return; - } - // A move from another variable or field: it is left `undefined`. - if by_value && self.moves(init) { - let place = self.place(init, out); - let name = self.bind_var(*var, *name, mutable, pat_ty, pat.span, owns); - let annotate = mutable || diverges_when_called(pat_ty); - self.push( - out, - StmtKind::decl(mutable, name, annotate.then_some(ty), Some(place.clone())), - span, - ); - self.clear(place, out); - return; - } - let value = match borrows { - true => self.place(init, out), - false => self.operand(init, out), - }; - let name = self.bind_var(*var, *name, mutable, pat_ty, pat.span, owns); - let annotate = mutable || needs_annotation(&value) || diverges_when_called(pat_ty); - self.push( - out, - StmtKind::decl(mutable, name, annotate.then_some(ty), Some(value)), - span, - ); - return; - } - - let Some(init) = init else { - // `let _: T;`, as derives write to assert a bound, binds nothing. - if !matches!(pat.kind, PatKind::Wild) { - self.t.err(span, "a pattern binding without an initializer"); - } - return; - }; - // `let _ = value;` drops a value at once, and evaluates a place without moving it: - // an index still runs, and checks its bounds. - if let PatKind::Wild = pat.kind - && els.is_none() - && self.t.drops(pat_ty) - { - match self.is_place(init) { - true => { - let place = self.place(init, out); - if !place.is_path() { - self.push(out, StmtKind::Expr(place), span); - } - } - false => { - let value = self.operand(init, out); - if let Some(dropped) = self.t.drop_value(value, pat_ty, span) { - self.push(out, StmtKind::Expr(dropped), span); - } - } - } - return; - } - // What the pattern leaves unbound drops with its place, or at the end of the - // statement from a temporary, which nothing marks. The shortcut below would move a - // place out whole, so a place binds part by part instead. - let leaves = self.leaves_drop(pat); - if leaves && !self.is_place(init) { - self.t.err( - span, - "a `let` on a temporary that drops, which it doesn't move out of whole", - ); - } - // `const [a, b] = ...` for a tuple or array of plain bindings. - if els.is_none() && !leaves && self.destructurable(pat, true) { - let value = self.operand(init, out); - let mut mutable = false; - let target = self.destructure(pat, &mut mutable); - self.push( - out, - StmtKind::Decl { - mutable, - target, - ty: None, - init: Some(value), - }, - span, - ); - return; - } - - let owned = !self.is_place(init); - let value = match owned { - true => self.operand(init, out), - false => self.place(init, out), - }; - let scrut = self.path(value, init, out); - if let Some(els) = els { - match self.pat_test(pat, &scrut) { - Some(test) => { - let mut body = Vec::new(); - self.block(els, Dest::Discard, &mut body); - self.push( - out, - StmtKind::If { - cond: test.not(), - then: body, - els: Vec::new(), - }, - span, - ); - } - None => self.t.err(span, "`let ... else` with an irrefutable pattern"), - } - } else if self.pat_test(pat, &scrut).is_some() { - self.t.err(span, "a refutable pattern in `let`"); - } - self.pat_bind(pat, &scrut, owned, out); - } - - /// Whether binding `pat` by value leaves part of a value that drops unbound: under a - /// `_` or a `..`, in a field it doesn't name, or in another variant than the one it - /// matches. - fn leaves_drop(&mut self, pat: &Pat<'tcx>) -> bool { - let ty = self.subst(pat.ty); - if !self.t.drops(ty) { - return false; - } - let tcx = self.t.tcx; - match &pat.kind { - PatKind::Binding { - mode, subpattern: None, .. - } => mode.0 != rustc_hir::ByRef::No, - PatKind::Leaf { subpatterns } | PatKind::Variant { subpatterns, .. } => { - let (variant, others) = match (ty.kind(), &pat.kind) { - (ty::Tuple(tys), _) => (tys.to_vec(), Vec::new()), - (ty::Adt(adt, args), PatKind::Variant { variant_index, .. }) => { - let fields = |v: &ty::VariantDef| -> Vec> { - v.fields.iter().map(|f| f.ty(tcx, args).skip_norm_wip()).collect() - }; - let others = adt - .variants() - .iter_enumerated() - .filter(|(i, _)| i != variant_index) - .flat_map(|(_, v)| fields(v)) - .collect(); - (fields(adt.variant(*variant_index)), others) - } - (ty::Adt(adt, args), _) => ( - adt.non_enum_variant() - .fields - .iter() - .map(|f| f.ty(tcx, args).skip_norm_wip()) - .collect(), - Vec::new(), - ), - _ => return true, - }; - others.into_iter().any(|t| self.t.drops(t)) - || variant.into_iter().enumerate().any(|(i, field)| { - match subpatterns.iter().find(|f| f.field.index() == i) { - Some(f) => self.leaves_drop(&f.pattern), - None => self.t.drops(field), - } - }) - } - PatKind::Array { - prefix, - slice: None, - suffix, - } => prefix.iter().chain(suffix.iter()).any(|p| self.leaves_drop(p)), - _ => true, - } - } - - /// Whether `pat` is a tuple or array of plain bindings, which JS destructures. - fn destructurable(&self, pat: &Pat<'tcx>, top: bool) -> bool { - let ty = self.subst(pat.ty); - match &pat.kind { - PatKind::Deref { subpattern, .. } => self.destructurable(subpattern, top), - PatKind::Leaf { subpatterns } if matches!(ty.kind(), ty::Tuple(_)) => { - // Every field, in order. - let arity = match ty.kind() { - ty::Tuple(tys) => tys.len(), - _ => unreachable!(), - }; - subpatterns.len() == arity - && subpatterns - .iter() - .enumerate() - .all(|(i, f)| f.field.index() == i && self.destructurable(&f.pattern, false)) - } - // Bytes are a `Uint8Array`, which JS destructures through its iterator: indexing - // reads them faster. - PatKind::Array { - prefix, - slice: None, - suffix, - } => { - !matches!(ty.kind(), ty::Array(elem, _) if matches!(elem.kind(), ty::Uint(ty::UintTy::U8))) - && suffix.is_empty() - && prefix.iter().all(|p| self.destructurable(p, false)) - } - PatKind::Binding { - mode, subpattern: None, .. - } if !top => match mode.0 { - rustc_hir::ByRef::No => !self.needs_copy(ty), - // A shared reference to a primitive reads as its value. - rustc_hir::ByRef::Yes(_, rustc_ast::Mutability::Not) => { - matches!(ty.peel_refs().kind(), ty::Bool | ty::Int(_) | ty::Uint(_)) - } - _ => false, - }, - PatKind::Wild => !top, - _ => false, - } - } - - /// The destructuring target of a [`Self::destructurable`] pattern, binding its names. - fn destructure(&mut self, pat: &Pat<'tcx>, mutable: &mut bool) -> Target { - match &pat.kind { - PatKind::Deref { subpattern, .. } => self.destructure(subpattern, mutable), - PatKind::Leaf { subpatterns } => Target::Array( - subpatterns - .iter() - .map(|f| self.destructure_elem(&f.pattern, mutable)) - .collect(), - ), - PatKind::Array { prefix, .. } => { - Target::Array(prefix.iter().map(|p| self.destructure_elem(p, mutable)).collect()) - } - PatKind::Binding { name, var, mode, .. } => { - let is_mut = mode.1 == rustc_ast::Mutability::Mut; - *mutable |= is_mut; - Target::Name(self.bind_var(*var, *name, is_mut, pat.ty, pat.span, mode.0 == rustc_hir::ByRef::No)) - } - _ => unreachable!("checked by destructurable"), - } - } - - fn destructure_elem(&mut self, pat: &Pat<'tcx>, mutable: &mut bool) -> Option { - match pat.kind { - PatKind::Wild => None, - _ => Some(self.destructure(pat, mutable)), - } - } - - /// Whether `id` is control flow that reads best delivering into a variable. One that - /// never makes a value leaves the variable unassigned. - fn needs_dest(&mut self, id: ExprId) -> bool { - match &self.thir[id].kind { - ExprKind::Scope { value, .. } => self.needs_dest(*value), - ExprKind::If { - then, else_opt, cond, .. - } => !(self.simple(*then) && else_opt.is_some_and(|e| self.simple(e)) && self.simple(*cond)), - ExprKind::Match { match_source, .. } => { - !matches!(match_source, MatchSource::TryDesugar(_)) && !self.ternary_match(id) - } - ExprKind::Loop { .. } | ExprKind::NeverToAny { .. } => true, - _ => false, - } - } - - /// Whether `id` lowers to an expression with no statements before it. - fn simple(&mut self, id: ExprId) -> bool { - self.simple_at(id, false) - } - - /// [`Self::simple`], for `id` read as a place, which a move out of would clear. - fn simple_at(&mut self, id: ExprId, place: bool) -> bool { - // A move leaves `undefined` behind with a statement of its own. - if !place && self.moves(id) { - return false; - } - match &self.thir[id].kind { - ExprKind::Scope { value, .. } - | ExprKind::ValueTypeAscription { source: value, .. } - | ExprKind::PlaceTypeAscription { source: value, .. } => self.simple_at(*value, place), - ExprKind::Borrow { arg: value, .. } - | ExprKind::Deref { arg: value } - | ExprKind::Field { lhs: value, .. } => self.simple_at(*value, true), - ExprKind::Cast { source: value } - | ExprKind::PointerCoercion { source: value, .. } - | ExprKind::Unary { arg: value, .. } => self.simple(*value), - ExprKind::Block { block } => { - let block = &self.thir[*block]; - block.stmts.is_empty() && !block.targeted_by_break && block.expr.is_some_and(|e| self.simple(e)) - } - ExprKind::Binary { lhs, rhs, .. } => self.simple(*lhs) && self.simple(*rhs), - ExprKind::Index { lhs, index } => self.simple_at(*lhs, true) && self.simple(*index), - ExprKind::LogicalOp { lhs, rhs, .. } => self.simple(*lhs) && self.simple(*rhs), - ExprKind::Call { args, fun, .. } => self.simple(*fun) && args.iter().all(|a| self.simple(*a)), - ExprKind::Tuple { fields } | ExprKind::Array { fields } => fields.iter().all(|f| self.simple(*f)), - // Fields written out of declaration order may be spilled to keep their order. - ExprKind::Adt(adt) => { - adt.fields.iter().all(|f| self.simple(f.expr)) - && adt.fields.is_sorted_by_key(|f| f.name) - && matches!(adt.base, thir::AdtExprBase::None) - } - ExprKind::VarRef { .. } - | ExprKind::UpvarRef { .. } - | ExprKind::Literal { .. } - | ExprKind::NonHirLiteral { .. } - | ExprKind::ZstLiteral { .. } - | ExprKind::NamedConst { .. } - | ExprKind::ConstParam { .. } => true, - _ => false, - } - } - - fn break_(&mut self, label: region::Scope, value: Option, span: Span, out: &mut Vec) { - let Some(index) = self.breakables.iter().rposition(|b| b.scope == label) else { - self.t.err(span, "a `break` out of the function"); - return; - }; - let dest = self.breakables[index].dest.clone(); - if let Some(value) = value { - self.stmt(value, dest.clone(), out); - // `stmt` returned from every branch that makes a value; a `!` value makes none. - if matches!(dest, Dest::Return) { - return; - } - } - let label = self.target(label, false); - self.push(out, StmtKind::Break(label), span); - } - - /// The JS label a `break` or `continue` to `scope` needs, if any. - fn target(&mut self, scope: region::Scope, continues: bool) -> Option { - let index = self.breakables.iter().rposition(|b| b.scope == scope)?; - let innermost_loop = self.breakables.iter().rposition(|b| b.is_loop); - let needs_label = !self.breakables[index].is_loop || innermost_loop != Some(index); - debug_assert!(!continues || self.breakables[index].is_loop); - if !needs_label { - return None; - } - self.breakables[index].used = true; - Some(self.breakables[index].label.clone()) - } - - fn lp(&mut self, scope: region::Scope, body: ExprId, dest: Dest, out: &mut Vec) { - let span = self.span(body); - let label = self.fresh("loop"); - self.breakables.push(Breakable { - scope, - label, - used: false, - dest, - is_loop: true, - }); - // `while c { .. }` arrives as `loop { if c { .. } else { break } }`. - let mut stmts = Vec::new(); - let mut cond = None; - if let Some((c, then)) = self.while_shape(scope, body) { - let mut pre = Vec::new(); - let test = self.expr(c, &mut pre); - if pre.is_empty() { - cond = Some(test); - self.stmt(then, Dest::Discard, &mut stmts); - } - } - let cond = match cond { - Some(cond) => cond, - None => { - stmts.clear(); - self.stmt(body, Dest::Discard, &mut stmts); - Expr::lit("true") - } - }; - let breakable = self.breakables.pop().unwrap(); - let label = breakable.used.then_some(breakable.label); - self.push( - out, - StmtKind::While { - label, - cond, - body: stmts, - }, - span, - ); - } - - /// The body of the loop a scope holds, if it holds one. A loop that only `return` - /// leaves has type `!`, coerced to whatever its place needs. - fn scoped_loop(&self, value: ExprId) -> Option { - let value = match self.thir[value].kind { - ExprKind::NeverToAny { source } => source, - _ => value, - }; - match self.thir[value].kind { - ExprKind::Loop { body } => Some(body), - _ => None, - } - } - - /// The condition and body of a `while` loop's desugaring. - fn while_shape(&self, scope: region::Scope, body: ExprId) -> Option<(ExprId, ExprId)> { - let block = match self.thir[self.strip(body)].kind { - ExprKind::Block { block } => &self.thir[block], - _ => return None, - }; - if !block.stmts.is_empty() || block.targeted_by_break { - return None; - } - let ExprKind::If { - cond, - then, - else_opt: Some(els), - .. - } = self.thir[self.strip(block.expr?)].kind - else { - return None; - }; - if self.has_let(cond) { - return None; - } - let ExprKind::Block { block: els } = self.thir[self.strip(els)].kind else { - return None; - }; - let els = &self.thir[els]; - let only = match (els.stmts.as_ref(), els.expr) { - ([], Some(e)) => e, - ([s], None) => match self.thir[*s].kind { - thir::StmtKind::Expr { expr, .. } => expr, - _ => return None, - }, - _ => return None, - }; - match self.thir[self.strip(only)].kind { - ExprKind::Break { label, value: None } if label == scope => Some((cond, then)), - _ => None, - } - } - - /// `id` without the wrappers that change nothing. - pub fn strip(&self, id: ExprId) -> ExprId { - match self.thir[id].kind { - ExprKind::Scope { value, .. } | ExprKind::NeverToAny { source: value } => self.strip(value), - _ => id, - } - } - - fn has_let(&self, id: ExprId) -> bool { - match &self.thir[self.strip(id)].kind { - ExprKind::Let { .. } => true, - ExprKind::LogicalOp { - op: thir::LogicalOp::And, - lhs, - rhs, - } => self.has_let(*lhs) || self.has_let(*rhs), - _ => false, - } - } - - fn cond_parts(&self, id: ExprId, parts: &mut Vec>) { - let id = self.strip(id); - let thir: &'a Thir<'tcx> = self.thir; - match &thir[id].kind { - ExprKind::Let { expr, pat } => parts.push(CondPart::Let(*expr, pat)), - ExprKind::LogicalOp { - op: thir::LogicalOp::And, - lhs, - rhs, - } if self.has_let(id) => { - self.cond_parts(*lhs, parts); - self.cond_parts(*rhs, parts); - } - _ => parts.push(CondPart::Bool(id)), - } - } - - /// Lower one part of a condition: its statements to `pre`, the bindings a `let` - /// makes once it passed to `binds`, and the test, if it can fail. - fn cond_part(&mut self, part: &CondPart<'a, 'tcx>, pre: &mut Vec, binds: &mut Vec) -> Option { - match part { - CondPart::Bool(id) => Some(self.expr(*id, pre)), - CondPart::Let(expr, pat) => { - // A failed test leaves the value whole, so the pattern must take all of it - // from every variant: a `let` with no other arm to take the rest. - if !self.is_place(*expr) && self.leaves_drop(pat) { - self.t.err( - pat.span, - "an `if let` on a temporary that drops, which it doesn't move out of whole", - ); - } - let reads = self.test_reads(pat) + bindings(pat); - let (scrut, owned) = self.scrutinee(*expr, reads, pre); - let test = self.pat_test(pat, &scrut); - self.pat_bind(pat, &scrut, owned, binds); - test - } - } - } - - /// A match's scrutinee, which its patterns read `reads` times: as a path they can - /// read repeatedly, or as is when they read it at most once, first. Also whether it - /// is a temporary. - fn scrutinee(&mut self, id: ExprId, reads: usize, out: &mut Vec) -> (Expr, bool) { - let owned = !self.is_place(id); - let value = match owned { - true => self.operand(id, out), - false => self.place(id, out), - }; - match reads { - // Unread, it still runs. - 0 if !value.is_path() => { - out.push(StmtKind::Expr(value).at(None)); - (Expr::undefined(), owned) - } - 0 | 1 => (value, owned), - _ => (self.path(value, id, out), owned), - } - } - - /// How many times the test of `pat` reads its scrutinee. - fn test_reads(&self, pat: &Pat<'tcx>) -> usize { - match &pat.kind { - PatKind::Wild | PatKind::Missing => 0, - PatKind::Binding { subpattern, .. } => subpattern.as_ref().map_or(0, |p| self.test_reads(p)), - PatKind::Deref { subpattern, .. } => self.test_reads(subpattern), - PatKind::Leaf { subpatterns } => subpatterns.iter().map(|f| self.test_reads(&f.pattern)).sum(), - PatKind::Variant { subpatterns, .. } => { - 1 + subpatterns.iter().map(|f| self.test_reads(&f.pattern)).sum::() - } - PatKind::Or { pats } => pats.iter().map(|p| self.test_reads(p)).sum(), - PatKind::Array { prefix, suffix, .. } => { - prefix.iter().chain(suffix.iter()).map(|p| self.test_reads(p)).sum() - } - PatKind::Constant { .. } => 1, - PatKind::Range(range) => usize::from(range.lo.is_finite()) + usize::from(range.hi.is_finite()), - // Ranges, slices, and anything else: assume more than once. - _ => 2, - } - } - - fn if_(&mut self, cond: ExprId, then: ExprId, els: Option, dest: Dest, span: Span, out: &mut Vec) { - let mut parts = Vec::new(); - self.cond_parts(cond, &mut parts); - - // One condition, as JS writes it. - if let [part] = parts.as_slice() { - let mut then_stmts = Vec::new(); - self.open_scope(); - let test = self.cond_part(part, out, &mut then_stmts); - self.stmt(then, dest.clone(), &mut then_stmts); - self.close_scope(&mut then_stmts, 0, span); - let mut else_stmts = Vec::new(); - if let Some(els) = els { - self.stmt(els, dest, &mut else_stmts); - } - match test { - Some(test) => self.push( - out, - StmtKind::If { - cond: test, - then: then_stmts, - els: else_stmts, - }, - span, - ), - // An irrefutable `let`: the else never runs. - None => out.extend(then_stmts), - } - return; - } - - // A let chain: each part nests in the last, and any failing runs the else. - let label = self.fresh("chain"); - let mut levels = Vec::new(); - self.open_scope(); - for part in &parts { - let mut pre = Vec::new(); - let mut binds = Vec::new(); - let test = self.cond_part(part, &mut pre, &mut binds); - levels.push((pre, test, binds)); - } - if self.scope_owns() { - self.t.err(span, "a let chain that binds a value that drops"); - } - self.scopes.pop(); - let mut then_stmts = Vec::new(); - self.stmt(then, dest.clone(), &mut then_stmts); - let mut else_stmts = Vec::new(); - if let Some(els) = els { - self.stmt(els, dest, &mut else_stmts); - } - let has_else = !else_stmts.is_empty(); - if has_else && !ts::diverges(&then_stmts) { - then_stmts.push(StmtKind::Break(Some(label.clone())).at(None)); - } - let mut body = then_stmts; - for (pre, test, binds) in levels.into_iter().rev() { - let mut inner = binds; - inner.extend(body); - let mut wrapped = pre; - match test { - Some(test) => wrapped.push( - StmtKind::If { - cond: test, - then: inner, - els: Vec::new(), - } - .at(None), - ), - None => wrapped.extend(inner), - } - body = wrapped; - } - match has_else { - true => { - body.extend(else_stmts); - self.push( - out, - StmtKind::Block { - label: Some(label), - body, - }, - span, - ); - } - false => out.extend(body), - } - } - - fn match_( - &mut self, - id: ExprId, - scrutinee: ExprId, - arms: &[ArmId], - source: MatchSource, - dest: Dest, - out: &mut Vec, - ) { - let span = self.span(id); - match source { - MatchSource::TryDesugar(_) => { - let value = self.try_(scrutinee, span, out); - self.deliver(value, &dest, span, out); - return; - } - MatchSource::ForLoopDesugar => { - self.for_(scrutinee, arms, span, out); - return; - } - _ => {} - } - - let thir: &'a Thir<'tcx> = self.thir; - // One arm binding the whole value, as `.await` desugars to, is a `let` scoped to it. - if let [arm] = arms - && thir[*arm].guard.is_none() - && let PatKind::Binding { - mode, subpattern: None, .. - } = thir[*arm].pattern.kind - && mode.0 == rustc_hir::ByRef::No - { - let start = out.len(); - self.open_scope(); - self.let_(&thir[*arm].pattern, Some(scrutinee), None, span, out); - self.stmt(thir[*arm].body, dest, out); - self.close_scope(out, start, span); - return; - } - if !self.is_place(scrutinee) - && self.t.drops(self.ty_of(scrutinee)) - && !arms - .iter() - .all(|&arm| thir[arm].guard.is_none() && takes_all(&thir[arm].pattern)) - { - self.t.err( - span, - "a `match` on a temporary that drops, which it doesn't move out of whole", - ); - } - let pats: Vec<&Pat<'tcx>> = arms.iter().map(|&arm| &*thir[arm].pattern).collect(); - // The last arm is the else, whose test never runs, unless it is guarded. - let tested = match arms.last().is_some_and(|&arm| thir[arm].guard.is_none()) { - true => pats.len() - 1, - false => pats.len(), - }; - let first_reads = pats.first().map_or(0, |p| self.test_reads(p)); - let later_reads: usize = pats.iter().take(tested).skip(1).map(|p| self.test_reads(p)).sum(); - let binds: usize = pats.iter().map(|p| bindings(p)).sum(); - let reads = match first_reads <= 1 && later_reads == 0 && binds == 0 { - true => first_reads, - false => 2, - }; - let (scrut, owned) = self.scrutinee(scrutinee, reads, out); - - struct Lowered { - test: Option, - binds: Vec, - guard: Option<(Vec, Expr)>, - body: Vec, - } - let mut lowered = Vec::new(); - for &arm in arms { - let arm = &self.thir[arm]; - let test = self.pat_test(&arm.pattern, &scrut); - let mut binds = Vec::new(); - self.open_scope(); - self.pat_bind(&arm.pattern, &scrut, owned, &mut binds); - let guard = arm.guard.map(|g| { - let mut pre = Vec::new(); - let e = self.expr(g, &mut pre); - (pre, e) - }); - let mut body = Vec::new(); - self.stmt(arm.body, dest.clone(), &mut body); - // What the arm binds that drops is dropped around its bindings and body. - if self.scope_owns() { - if guard.is_some() { - self.t.err(arm.span, "a guarded arm that binds a value that drops"); - } - binds.append(&mut body); - body = std::mem::take(&mut binds); - } - self.close_scope(&mut body, 0, arm.span); - lowered.push(Lowered { - test, - binds, - guard, - body, - }); - } - - // Arms that all do nothing, such as logging left out. - if lowered.iter().all(|arm| arm.body.is_empty() && arm.guard.is_none()) { - return; - } - - let chain = lowered.iter().all(|arm| match &arm.guard { - None => true, - Some((pre, _)) => pre.is_empty() && arm.binds.is_empty(), - }); - if chain { - // An if-else chain; the last arm is what Rust proved is left. - let mut els: Vec = Vec::new(); - let count = lowered.len(); - for (i, arm) in lowered.into_iter().enumerate().rev() { - let last = i + 1 == count; - let cond = match (arm.test, arm.guard) { - (t, Some((_, g))) => Some(match t { - Some(t) => t.and(g), - None => g, - }), - (Some(_), None) if last => None, - (t, None) => t, - }; - let mut then = arm.binds; - then.extend(arm.body); - els = match cond { - Some(cond) => vec![StmtKind::If { cond, then, els }.at(None)], - None => then, - }; - } - let loc = self.t.loc(span); - if let Some(first) = els.first_mut() - && first.loc.is_none() - { - first.loc = loc; - } - out.extend(els); - return; - } - - // Guards that read the arm's bindings: each arm tests, binds, then guards. - let label = self.fresh("arms"); - let mut body = Vec::new(); - let count = lowered.len(); - for (i, arm) in lowered.into_iter().enumerate() { - let guard_free = arm.guard.is_none(); - let mut inner = arm.binds; - let mut taken = arm.body; - if i + 1 < count && !ts::diverges(&taken) { - taken.push(StmtKind::Break(Some(label.clone())).at(None)); - } - match arm.guard { - Some((pre, g)) => { - inner.extend(pre); - inner.push( - StmtKind::If { - cond: g, - then: taken, - els: Vec::new(), - } - .at(None), - ); - } - None => inner.extend(taken), - } - // The last arm without a guard is what Rust proved is left. - let test = match i + 1 == count && guard_free { - true => None, - false => arm.test, - }; - match test { - Some(test) => body.push( - StmtKind::If { - cond: test, - then: inner, - els: Vec::new(), - } - .at(None), - ), - None => body.extend(inner), - } - } - self.push( - out, - StmtKind::Block { - label: Some(label), - body, - }, - span, - ); - } - - /// Whether a `match` reads as a ternary chain: no bindings or guards, and arms that - /// are each a simple value. - fn ternary_match(&mut self, id: ExprId) -> bool { - let ExprKind::Match { arms, .. } = &self.thir[self.strip(id)].kind else { - return false; - }; - arms.iter().all(|&arm| { - let arm = &self.thir[arm]; - arm.guard.is_none() && !has_bindings(&arm.pattern) && self.simple(arm.body) - }) - } - - /// `expr?`: the value, returning early on `Err` or `None`. - fn try_(&mut self, scrutinee: ExprId, span: Span, out: &mut Vec) -> Expr { - // The scrutinee is `Try::branch(expr)`. - let ExprKind::Call { args, .. } = &self.thir[self.strip(scrutinee)].kind else { - return self.err(span, "an unexpected `?` desugaring"); - }; - let inner = args[0]; - let inner_ty = self.ty_of(inner); - // `it.next()?` tests for the end itself, so its item may be an `Option`. - let raw = self.raw_next(inner, out); - let none = match raw { - Some(_) => Expr::Rt("DONE".into()), - None => Expr::undefined(), - }; - let value = match raw { - Some(value) => value, - None => self.operand(inner, out), - }; - let name = match value { - Expr::Ident(ref name) => name.clone(), - value => { - let name = self.temp_for(inner); - self.push(out, StmtKind::decl(false, name.clone(), None, Some(value)), span); - name - } - }; - let t = Expr::ident(&name); - let ty::Adt(adt, adt_args) = inner_ty.kind() else { - return self.err(span, format!("`?` on `{inner_ty}`")); - }; - match library::Std::of(self.t.tcx, adt.did()) { - Some(library::Std::Option) => { - let ret = self.ret; - let ty::Adt(ret_adt, _) = ret.kind() else { - return self.err(span, "`?` on an `Option` in a function that returns no `Option`"); - }; - if library::Std::of(self.t.tcx, ret_adt.did()) != Some(library::Std::Option) { - return self.err(span, "`?` on an `Option` in a function that returns no `Option`"); - } - self.push( - out, - StmtKind::If { - cond: t.clone().binary("===", none), - then: vec![ - StmtKind::Return(Some(match self.done { - true => Expr::Rt("DONE".into()), - false => Expr::undefined(), - })) - .at(None), - ], - els: Vec::new(), - }, - span, - ); - t - } - Some(library::Std::Result) => { - let from = adt_args.type_at(1); - let ret = self.ret; - let to = match ret.kind() { - ty::Adt(ret_adt, ret_args) - if library::Std::of(self.t.tcx, ret_adt.did()) == Some(library::Std::Result) => - { - ret_args.type_at(1) - } - _ => return self.err(span, "`?` on a `Result` in a function that returns no `Result`"), - }; - let error = t.clone().member("error"); - let converted = self.convert(error, from, to, span, out); - self.push( - out, - StmtKind::If { - cond: t.clone().member("ok").not(), - then: vec![StmtKind::Return(Some(Expr::rt("Err", vec![converted]))).at(None)], - els: Vec::new(), - }, - span, - ); - t.member("value") - } - _ => self.err(span, format!("`?` on `{inner_ty}`")), - } - } - - /// `From::from(value)`, converting a `from` into a `to`. - pub fn convert(&mut self, value: Expr, from: Ty<'tcx>, to: Ty<'tcx>, span: Span, out: &mut Vec) -> Expr { - if from == to { - return value; - } - let tcx = self.t.tcx; - let Some(from_trait) = tcx.get_diagnostic_item(rustc_span::sym::From) else { - return self.err(span, "no `From` trait"); - }; - let Some(from_fn) = tcx - .associated_items(from_trait) - .in_definition_order() - .find(|i| i.is_fn()) - else { - return self.err(span, "no `From::from`"); - }; - let args = tcx.mk_args(&[to.into(), from.into()]); - self.call_def(from_fn.def_id, args, Args::Values(vec![value]), span, out) - } - - /// `for pat in iter { body }`, from its desugaring. - fn for_(&mut self, scrutinee: ExprId, arms: &[ArmId], span: Span, out: &mut Vec) { - // match IntoIterator::into_iter(iter) { mut it => loop { match next(&mut it) { - // None => break, Some(pat) => body } } } - let bad = |b: &mut Self| { - b.t.err(span, "an unexpected `for` desugaring"); - }; - let ExprKind::Call { args, .. } = &self.thir[self.strip(scrutinee)].kind else { - return bad(self); - }; - let iterable = args[0]; - let [arm] = arms else { - return bad(self); - }; - let arm = &self.thir[*arm]; - let ExprKind::Scope { - region_scope, value, .. - } = self.thir[arm.body].kind - else { - return bad(self); - }; - let ExprKind::Loop { body } = self.thir[value].kind else { - return bad(self); - }; - let ExprKind::Block { block } = self.thir[self.strip(body)].kind else { - return bad(self); - }; - let next = match (self.thir[block].stmts.as_ref(), self.thir[block].expr) { - ([s], None) => match self.thir[*s].kind { - thir::StmtKind::Expr { expr, .. } => expr, - _ => return bad(self), - }, - ([], Some(e)) => e, - _ => return bad(self), - }; - let ExprKind::Match { arms: next_arms, .. } = &self.thir[self.strip(next)].kind else { - return bad(self); - }; - let Some(some_arm) = next_arms - .iter() - .map(|a| &self.thir[*a]) - .find(|a| matches!(a.pattern.kind, PatKind::Variant { variant_index, .. } if variant_index.index() == 1)) - else { - return bad(self); - }; - let PatKind::Variant { subpatterns, .. } = &some_arm.pattern.kind else { - return bad(self); - }; - let pat = &subpatterns[0].pattern; - let loop_body = some_arm.body; - - let iter_ty = self.ty_of(iterable); - let source = match self.iterable(iterable, iter_ty, span, out) { - Some(source) => source, - // Refused, but what the iterable and the body refuse is reported too. - None => Iterable::Of(self.operand(iterable, out)), - }; - - let label = self.fresh("loop"); - self.breakables.push(Breakable { - scope: region_scope, - label, - used: false, - dest: Dest::Discard, - is_loop: true, - }); - let mut stmts = Vec::new(); - // The iterator drops after the loop, with what it did not yield. - if self.t.drops(self.subst(pat.ty)) || self.t.drops(iter_ty) { - self.t.err( - pat.span, - "a `for` loop over values that drop, which is not supported yet", - ); - } - self.open_scope(); - let simple_name = match &pat.kind { - PatKind::Binding { - name, - var, - mode, - subpattern: None, - .. - } if mode.1 == rustc_ast::Mutability::Not && !self.needs_copy(self.subst(pat.ty)) => { - Some(self.bind_var(*var, *name, false, pat.ty, pat.span, mode.0 == rustc_hir::ByRef::No)) - } - PatKind::Wild => Some(self.fresh("_")), - _ => None, - }; - let name = match simple_name { - Some(name) => name, - None => { - let name = self.fresh("item"); - let scrut = Expr::ident(&name); - if self.pat_test(pat, &scrut).is_some() { - self.t.err(pat.span, "a refutable `for` pattern"); - } - self.pat_bind(pat, &scrut, true, &mut stmts); - name - } - }; - self.stmt(loop_body, Dest::Discard, &mut stmts); - self.close_scope(&mut stmts, 0, span); - let breakable = self.breakables.pop().unwrap(); - let label = breakable.used.then_some(breakable.label); - let kind = match source { - Iterable::Range { start, end, inclusive } => StmtKind::ForRange { - label, - name, - start, - end, - inclusive, - body: stmts, - }, - Iterable::Of(iter) => StmtKind::ForOf { - label, - name, - iter, - body: stmts, - }, - // `while (true) { const x = iter.next(); if (x === rt.DONE) break; ... }` - Iterable::Next(next) => { - let mut body = vec![ - StmtKind::decl(false, name.clone(), None, Some(next)).at(None), - StmtKind::If { - cond: Expr::ident(&name).binary("===", Expr::Rt("DONE".into())), - then: vec![StmtKind::Break(None).at(None)], - els: Vec::new(), - } - .at(None), - ]; - body.extend(stmts); - StmtKind::While { - label, - cond: Expr::lit("true"), - body, - } - } - }; - self.push(out, kind, span); - } - - /// What a `for` loop iterates. - fn iterable(&mut self, id: ExprId, ty: Ty<'tcx>, span: Span, out: &mut Vec) -> Option { - let tcx = self.t.tcx; - match ty.kind() { - ty::Adt(adt, _) if tcx.is_lang_item(adt.did(), rustc_attr_ir::LangItem::Range) => { - let ExprKind::Adt(range) = &self.thir[self.strip(id)].kind else { - self.t - .err(span, "a `for` loop over a range that is not written in place"); - return None; - }; - let mut written = self.written(range, ty, span, out); - // `end` is read on every turn, so unless constant it is spilled, after what - // evaluates before it. - let end_at = written.iter().position(|(i, _)| *i == 1).expect("a range has an end"); - if !written[end_at].1.is_constant() { - for (i, value) in written.iter_mut().take(end_at + 1) { - if !value.is_constant() { - let saved = std::mem::replace(value, Expr::undefined()); - *value = self.spill(saved, if *i == 1 { "end" } else { "start" }, out); - } - } - } - written.sort_by_key(|(i, _)| *i); - let [(_, start), (_, end)] = <[_; 2]>::try_from(written).expect("a range has two fields"); - Some(range_of(ty, start, end, false)) - } - ty::Adt(adt, _) if tcx.is_lang_item(adt.did(), rustc_attr_ir::LangItem::RangeInclusiveStruct) => { - // `a..=b` is `RangeInclusive::new(a, b)`. - let ExprKind::Call { args, .. } = &self.thir[self.strip(id)].kind else { - self.t - .err(span, "a `for` loop over a range that is not written in place"); - return None; - }; - let args = args.clone(); - let mut values = self.operands(&args, out); - let end = values.pop().unwrap(); - let mut start = values.pop().unwrap(); - let end = match end.is_constant() { - true => end, - false => { - if !start.is_constant() { - start = self.spill(start, "start", out); - } - self.spill(end, "end", out) - } - }; - Some(range_of(ty, start, end, true)) - } - // An array by value iterates its elements, already copied. - ty::Array(..) => Some(Iterable::Of(self.operand(id, out))), - ty::Ref(_, inner, _) if matches!(inner.kind(), ty::Slice(_) | ty::Array(..)) => { - Some(Iterable::Of(self.operand(id, out))) - } - ty::Ref(_, inner, _) if self.is_vec(*inner) => { - let v = self.operand(id, out); - Some(Iterable::Of(library::vec_view(v, *inner))) - } - ty::Adt(..) if self.is_vec(ty) => { - let v = self.operand(id, out); - Some(Iterable::Of(library::vec_view(v, ty))) - } - // `slice.iter()` iterates as the slice itself does. - _ if let Some(slice) = library::iterated_slice(self, id) => { - self.visit(id); - Some(Iterable::Of(self.operand(slice, out))) - } - // Any other iterator, by the protocol. - _ => { - let value = self.operand(id, out); - let iterator = self.t.iter_item(ty).is_some(); - let value = match iterator { - true => value, - false => match super::iter::into_iter(self, ty, value, span) { - Some(value) => value, - None => { - self.t.err(span, format!("a `for` loop over `{ty}`")); - return None; - } - }, - }; - let iter = match value.is_path() { - true => value, - false => self.spill(value, "iter", out), - }; - Some(Iterable::Next(match iterator { - true => super::iter::next(self, ty, iter), - false => iter.member("next").call(Vec::new()), - })) - } - } - } - - fn is_vec(&self, ty: Ty<'tcx>) -> bool { - matches!(ty.kind(), ty::Adt(adt, _) if library::Std::of(self.t.tcx, adt.did()) == Some(library::Std::Vec)) - } - - pub fn spill(&mut self, value: Expr, base: &str, out: &mut Vec) -> Expr { - let name = self.fresh(base); - out.push(StmtKind::decl(false, name.clone(), None, Some(value)).at(None)); - Expr::ident(name) - } - - /// Fields' values by index, from the order they are written to declaration order. - /// Each that would then evaluate after one written later is spilled first, unless - /// constant, so they still evaluate as written. - pub fn declared(&mut self, mut written: Vec<(usize, Expr)>, out: &mut Vec) -> Vec<(usize, Expr)> { - // The longest tail already in declaration order evaluates in place, after the rest. - let mut tail = written.len().saturating_sub(1); - while tail > 0 && written[tail - 1].0 < written[tail].0 { - tail -= 1; - } - for (_, value) in &mut written[..tail] { - if !value.is_constant() { - let saved = std::mem::replace(value, Expr::undefined()); - *value = self.spill(saved, "field", out); - } - } - written.sort_by_key(|(i, _)| *i); - written - } - - /// `value`, from `id`, as something patterns can read more than once. - fn path(&mut self, value: Expr, id: ExprId, out: &mut Vec) -> Expr { - if value.is_path() { - return value; - } - let name = self.temp_for(id); - out.push(StmtKind::decl(false, name.clone(), None, Some(value)).at(None)); - Expr::ident(name) - } - - fn assign(&mut self, lhs: ExprId, rhs: ExprId, span: Span, out: &mut Vec) { - let mut value = self.operand(rhs, out); - let mut pre = Vec::new(); - let yields = self.yields; - let target = self.place(lhs, &mut pre); - // The value waits out the `.await` where no scope drops it if the future is cancelled. - if self.yields != yields && self.t.drops(self.ty_of(rhs)) { - self.t.err( - self.span(lhs), - "an `.await` in the place an assignment of a value that drops writes to, which is not supported yet: bind the awaited value first", - ); - } - if (!pre.is_empty() || !target.is_path()) && !value.is_constant() { - value = self.spill(value, "value", out); - } - out.extend(pre); - // The old value drops once the new one is made. - let lty = self.ty_of(lhs); - if self.t.drops(lty) { - if !target.is_path() && !matches!(target, Expr::Index(..)) { - self.t - .err(span, "an assignment that drops the old value of a computed place"); - return; - } - if !value.is_path() && !value.is_constant() { - value = self.spill(value, "value", out); - } - if let Some(dropped) = self.t.drop_value(target.clone(), lty, span) { - self.push(out, StmtKind::Expr(dropped), span); - } - } - // `*r = v` through a reference replaces what it points to, as does replacing a - // variable a generator borrows mutably. - let through_ref = match self.thir[self.strip(lhs)].kind { - ExprKind::Deref { arg } => matches!(self.ty_of(arg).kind(), ty::Ref(..)) && self.is_place(arg), - ExprKind::UpvarRef { var_hir_id, .. } => self.borrowed.contains(&var_hir_id.0), - _ => false, - }; - if through_ref { - let pointee = self.ty_of(lhs); - // Every clone of an `Arc` or waker is one JS object, a guard is its mutex, a - // reference is its referent, and a future keeps its state private: copying fields - // in would change the other handles, or nothing. A `Pin` or `Box` is its pointee - // in JS. - let mut erased = pointee; - while let ty::Adt(adt, args) = erased.kind() - && matches!( - library::Std::of(self.t.tcx, adt.did()), - Some(library::Std::Pin | library::Std::Box) - ) { - erased = args.type_at(0); - } - let shared = match erased.kind() { - ty::Adt(adt, _) => matches!( - library::Std::of(self.t.tcx, adt.did()), - Some(library::Std::Arc | library::Std::Waker | library::Std::Context | library::Std::MutexGuard) - ), - ty::Ref(..) | ty::Coroutine(..) => true, - _ => false, - }; - match self.t.object_kind(pointee) { - Some(ObjectKind::Class) if shared => { - self.t.err( - span, - format!("replacing the `{pointee}` behind a reference, whose JS object is shared or private"), - ); - } - Some(ObjectKind::Class) => { - let e = Expr::ident("Object").member("assign").call(vec![target, value]); - self.push(out, StmtKind::Expr(e), span); - } - Some(ObjectKind::Bytes) => { - let e = target.member("set").call(vec![value]); - self.push(out, StmtKind::Expr(e), span); - } - _ => { - self.t - .err(span, format!("an assignment through a reference to `{pointee}`")); - } - } - return; - } - self.push(out, StmtKind::Expr(target.assign(value)), span); - } - - fn assign_op( - &mut self, - op: rustc_middle::mir::AssignOp, - lhs: ExprId, - rhs: ExprId, - span: Span, - out: &mut Vec, - ) { - // The value evaluates first, so it is saved before the place reads it again or - // runs statements of its own. - let mut value = self.operand(rhs, out); - let mut pre = Vec::new(); - let target = self.place(lhs, &mut pre); - if (!pre.is_empty() || !value.is_path()) && !value.is_constant() { - value = self.spill(value, "value", out); - } - out.extend(pre); - if !target.is_path() && !matches!(target, Expr::Index(..)) { - self.t.err(span, "a compound assignment to a computed place"); - return; - } - let lty = self.ty_of(lhs); - let rty = self.ty_of(rhs); - let op = rustc_middle::mir::BinOp::from(op); - let lhs_value = super::num::Operand { - expr: target.clone(), - value: None, - }; - let rhs_value = super::num::Operand { - expr: value, - value: None, - }; - let result = super::num::binary(self, op, lhs_value, rhs_value, lty, rty, span); - self.push(out, StmtKind::Expr(target.assign(result)), span); - } - - // Expressions - - /// Lower `id` as an operand: its value, copied if it is a `Copy` aggregate read - /// from a place, so a later write to either side does not reach the other. - pub fn operand(&mut self, id: ExprId, out: &mut Vec) -> Expr { - self.expr(id, out) - } - - /// Lower operands left to right, saving earlier ones that a later one's statements - /// could change. - pub fn operands(&mut self, ids: &[ExprId], out: &mut Vec) -> Vec { - let mut values: Vec = Vec::with_capacity(ids.len()); - // Whether an earlier operand is a value that drops, which a later `.await` would - // hold where no scope drops it if the future is cancelled. - let mut holds = false; - for &id in ids { - let mut pre = Vec::new(); - let yields = self.yields; - let value = self.operand(id, &mut pre); - if holds && self.yields != yields { - self.t.err( - self.span(id), - "an `.await` in an operand after one that drops, which is not supported yet: bind the awaited value first", - ); - } - holds |= self.t.drops(self.ty_of(id)); - self.after(&mut values, pre, out); - values.push(value); - } - values - } - - /// Emit `pre`, the statements of an operand that evaluates after `earlier`, saving - /// `earlier` first if there are any, so they cannot change it. - pub fn after(&mut self, earlier: &mut [Expr], pre: Vec, out: &mut Vec) { - if !pre.is_empty() { - for value in earlier.iter_mut().filter(|v| !v.is_constant()) { - let saved = std::mem::replace(value, Expr::undefined()); - *value = self.spill(saved, "arg", out); - } - } - out.extend(pre); - } - - /// Whether `id` names a place, rather than making a temporary value. - pub fn is_place(&self, id: ExprId) -> bool { - match &self.thir[id].kind { - ExprKind::Scope { value, .. } | ExprKind::PlaceTypeAscription { source: value, .. } => { - self.is_place(*value) - } - ExprKind::VarRef { .. } | ExprKind::UpvarRef { .. } | ExprKind::Field { .. } | ExprKind::Index { .. } => { - true - } - // What a `Box` made in place points at is part of that temporary. - ExprKind::Deref { arg } => matches!(self.ty_of(*arg).kind(), ty::Ref(..)) || self.is_place(*arg), - _ => false, + /// A name no other binding in the function has. + pub fn fresh(&mut self, base: &str) -> String { + let base = escape(base); + let mut name = base.clone(); + let mut n = 2; + while !self.names.insert(name.clone()) { + name = format!("{base}{n}"); + n += 1; } + name } - /// Whether `id` makes a temporary that drops, which only a statement could drop. - fn temporary_drops(&mut self, id: ExprId) -> bool { - !self.is_place(id) && self.t.drops(self.ty_of(id)) - } - - /// Whether lowering `id` for its value moves it out of a place that drops it. - pub fn moves(&mut self, id: ExprId) -> bool { - let ty = self.ty_of(id); - self.is_place(id) && !self.t.is_copy(ty) && self.t.drops(ty) + pub fn spill(&mut self, value: Expr, base: &str, out: &mut Vec) -> Expr { + let name = self.fresh(base); + out.push(StmtKind::decl(false, name.clone(), None, Some(value)).at(None)); + Expr::ident(name) } - /// Whether a block binds a variable that drops, so its value can't outlive it. - fn block_owns(&mut self, id: BlockId) -> bool { - let thir: &'a Thir<'tcx> = self.thir; - let mut owns = false; - for &stmt in &thir[id].stmts { - if let thir::StmtKind::Let { - pattern, initializer, .. - } = &thir[stmt].kind - { - // A `ref` binding keeps a temporary alive to the end of the block. - if let PatKind::Binding { - mode, subpattern: None, .. - } = pattern.kind - && mode.0 != rustc_hir::ByRef::No - && let Some(init) = *initializer - && !self.is_place(init) - { - owns |= self.t.drops(self.ty_of(init)); - } - pattern.walk_always(|p| { - if let PatKind::Binding { mode, ty, .. } = p.kind - && mode.0 == rustc_hir::ByRef::No - { - owns |= self.t.drops(self.t.subst(self.args, ty)); - } - }); - } + /// `From::from(value)`, converting a `from` into a `to`. + pub fn convert(&mut self, value: Expr, from: Ty<'tcx>, to: Ty<'tcx>, span: Span, out: &mut Vec) -> Expr { + if from == to { + return value; } - owns + let tcx = self.t.tcx; + let Some(from_trait) = tcx.get_diagnostic_item(rustc_span::sym::From) else { + return self.err(span, "no `From` trait"); + }; + let Some(from_fn) = tcx + .associated_items(from_trait) + .in_definition_order() + .find(|i| i.is_fn()) + else { + return self.err(span, "no `From::from`"); + }; + let args = tcx.mk_args(&[to.into(), from.into()]); + self.call_def(from_fn.def_id, args, vec![value], span, out) } pub fn needs_copy(&self, ty: Ty<'tcx>) -> bool { @@ -2022,312 +95,6 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { } } - pub(super) fn ref_binding(&mut self, by_ref: rustc_hir::ByRef, ty: Ty<'tcx>, span: Span) { - if let rustc_hir::ByRef::Yes(_, rustc_ast::Mutability::Mut) = by_ref { - let pointee = match ty.kind() { - ty::Ref(_, inner, _) => *inner, - _ => ty, - }; - if self.t.object_kind(pointee).is_none() { - self.t.err( - span, - format!("a `ref mut` binding to `{pointee}`, which is no object a reference can change"), - ); - } - } - } - - /// Lower `id` for its value. - pub fn expr(&mut self, id: ExprId, out: &mut Vec) -> Expr { - self.visit(id); - let e = &self.thir[id]; - let span = e.span; - let ty = self.ty_of(id); - if self.t.ignored_macro(span) { - if !ty.is_unit() { - return self.err(span, "an ignored macro must evaluate to `()`"); - } - return Expr::undefined(); - } - if self.is_format_args(id) { - return self.format_args(id, out); - } - match &e.kind { - ExprKind::Scope { value, .. } => match self.scoped_loop(*value) { - Some(_) => self.via_temp(id, ty, span, out), - None => self.expr(*value, out), - }, - ExprKind::ValueTypeAscription { source, .. } | ExprKind::ValueExpr { source } => self.expr(*source, out), - // The temp is never assigned: control never gets past the source. - ExprKind::NeverToAny { .. } => self.via_temp(id, ty, span, out), - // A block of type `!` without a value, such as `panic!(..)`, goes through a temp. - ExprKind::Block { block } - if !self.thir[*block].targeted_by_break - && !self.block_owns(*block) - && (self.thir[*block].expr.is_some() || !ty.is_never()) => - { - let block = &self.thir[*block]; - for &stmt in &block.stmts { - self.stmt_item(stmt, out); - } - match block.expr { - Some(expr) => self.expr(expr, out), - None => Expr::undefined(), - } - } - ExprKind::If { - cond, then, else_opt, .. - } if self.simple(*then) && else_opt.is_some_and(|e| self.simple(e)) && !self.has_let(*cond) => { - let c = self.expr(*cond, out); - let mut pre = Vec::new(); - let a = self.expr(*then, &mut pre); - let b = self.expr(else_opt.unwrap(), &mut pre); - if !pre.is_empty() { - out.extend(pre); - return self.err(span, "an `if` that was simple and became not"); - } - Expr::Cond(Box::new(c), Box::new(a), Box::new(b)) - } - ExprKind::Match { - scrutinee, - match_source: MatchSource::TryDesugar(_), - .. - } => self.try_(*scrutinee, span, out), - // A scrutinee that diverges, such as `match return x {}`, has no value to pass. - ExprKind::Match { scrutinee, arms, .. } if arms.is_empty() && self.ty_of(*scrutinee).is_never() => { - self.stmt(*scrutinee, Dest::Discard, out); - Expr::undefined() - } - // A value of a type without values: native code never gets here. - ExprKind::Match { scrutinee, arms, .. } if arms.is_empty() => { - let value = self.operand(*scrutinee, out); - Expr::rt("unreachable", vec![value]) - } - ExprKind::Match { .. } if self.ternary_match(id) => self.ternary(id, out), - ExprKind::Block { .. } | ExprKind::If { .. } | ExprKind::Match { .. } | ExprKind::Loop { .. } => { - self.via_temp(id, ty, span, out) - } - ExprKind::Call { - ty: fn_ty, - fun, - args, - fn_span, - .. - } => { - let call = self.call(*fn_ty, *fun, args, *fn_span, out); - match self.t.loc(span) { - Some(loc) => Expr::Located(loc, Box::new(call)), - None => call, - } - } - // A place of type `!`, as in a generic instantiated at `!`, which native code never - // reads: `tsc` sees that through `rt.unreachable`. - ExprKind::VarRef { .. } - | ExprKind::UpvarRef { .. } - | ExprKind::Field { .. } - | ExprKind::Index { .. } - | ExprKind::Deref { .. } - | ExprKind::PlaceTypeAscription { .. } - if ty.is_never() => - { - let place = self.place(id, out); - Expr::rt("unreachable", vec![place]) - } - ExprKind::VarRef { .. } - | ExprKind::UpvarRef { .. } - | ExprKind::Field { .. } - | ExprKind::Index { .. } - | ExprKind::Deref { .. } - | ExprKind::PlaceTypeAscription { .. } => { - if let ExprKind::Index { lhs, index } = &e.kind { - let base = self.place(*lhs, out); - let base = self.path(base, *lhs, out); - let index_ty = self.ty_of(*lhs); - let i = self.operand(*index, out); - let value = match self.const_index(index_ty, *index) { - true => base.index(i), - false => Expr::rt("at", vec![base, i]), - }; - return self.copied(value, ty); - } - if matches!(self.ty_of(id).kind(), ty::FnDef(..)) - && let ExprKind::VarRef { .. } | ExprKind::UpvarRef { .. } = e.kind - { - let ty::FnDef(def_id, args) = *ty.kind() else { - unreachable!() - }; - return self.fn_value(def_id, args.skip_binder(), span); - } - if self.moves(id) { - let place = self.place(id, out); - return self.move_out(place, span, out); - } - let value = self.place(id, out); - self.copied(value, ty) - } - ExprKind::Borrow { borrow_kind, arg } => { - if self.temporary_drops(*arg) { - return self.err(span, "a borrow of a temporary that drops: bind it to a variable first"); - } - if let BorrowKind::Mut { .. } = borrow_kind { - let pointee = self.ty_of(*arg); - if self.t.object_kind(pointee).is_none() - && !matches!(pointee.kind(), ty::Ref(_, _, rustc_ast::Mutability::Mut)) - { - return self.err( - span, - format!("a mutable reference to `{pointee}`, which is no object it can change in place"), - ); - } - } - self.place(*arg, out) - } - ExprKind::RawBorrow { .. } => self.err(span, "raw pointers are not supported"), - ExprKind::Binary { op, lhs, rhs } => { - let (lty, rty) = (self.ty_of(*lhs), self.ty_of(*rhs)); - let values = self.operands(&[*lhs, *rhs], out); - let [l, r] = <[Expr; 2]>::try_from(values).unwrap(); - let l = super::num::Operand { - expr: l, - value: self.const_int(*lhs), - }; - let r = super::num::Operand { - expr: r, - value: self.const_int(*rhs), - }; - super::num::binary(self, *op, l, r, lty, rty, span) - } - ExprKind::LogicalOp { op, lhs, rhs } => { - let l = self.expr(*lhs, out); - let mut pre = Vec::new(); - let r = self.expr(*rhs, &mut pre); - let js = match op { - thir::LogicalOp::And => "&&", - thir::LogicalOp::Or => "||", - }; - if pre.is_empty() { - return l.binary(js, r); - } - // The right side needs statements: run them only when it is evaluated. - let name = self.fresh("cond"); - out.push(StmtKind::decl(true, name.clone(), Some(Type::Builtin("boolean")), Some(l)).at(None)); - pre.push(StmtKind::Expr(Expr::ident(&name).assign(r)).at(None)); - let cond = match op { - thir::LogicalOp::And => Expr::ident(&name), - thir::LogicalOp::Or => Expr::ident(&name).not(), - }; - out.push( - StmtKind::If { - cond, - then: pre, - els: Vec::new(), - } - .at(None), - ); - Expr::ident(name) - } - ExprKind::Unary { op, arg } => { - let aty = self.ty_of(*arg); - let value = self.operand(*arg, out); - super::num::unary(self, *op, value, aty, span) - } - ExprKind::Cast { source } => { - let from = self.ty_of(*source); - let value = self.operand(*source, out); - let operand = super::num::Operand { - expr: value, - value: self.const_int(*source), - }; - super::num::cast(self, operand, from, ty, span) - } - ExprKind::PointerCoercion { cast, source, .. } => match cast { - // `&T` to `&dyn Debug`: a function writing the value. - PointerCoercion::Unsize if let Some(tr) = self.fmt_object(ty) => { - let source_ty = self.ty_of(*source); - let value = self.operand(*source, out); - self.fmt_value(tr, source_ty, value, span, out) - } - PointerCoercion::Unsize if self.trait_object(ty) => self.err(span, format!("a coercion to `{ty}`")), - PointerCoercion::Unsize | PointerCoercion::ReifyFnPointer(_) | PointerCoercion::ClosureFnPointer(_) => { - self.expr(*source, out) - } - _ => self.err(span, format!("unsupported pointer coercion {cast:?}")), - }, - ExprKind::Literal { .. } - | ExprKind::NonHirLiteral { .. } - | ExprKind::ZstLiteral { .. } - | ExprKind::NamedConst { .. } - | ExprKind::ConstParam { .. } - | ExprKind::ConstBlock { .. } => self.constant(id), - ExprKind::Tuple { fields } if fields.is_empty() => Expr::undefined(), - ExprKind::Tuple { fields } => { - let values = self.operands(fields, out); - // TypeScript widens an array literal to an array of the union. - let ts_ty = self.t.ty(ty, span); - Expr::As(Box::new(Expr::Array(values)), ts_ty) - } - ExprKind::Array { fields } => { - let values = self.operands(fields, out); - match ty.kind() { - ty::Array(elem, _) if matches!(elem.kind(), ty::Uint(ty::UintTy::U8)) => { - Expr::ident("Uint8Array").member("of").call(values) - } - _ => Expr::Array(values), - } - } - ExprKind::Repeat { value, count } => { - let n = match count.try_to_target_usize(self.t.tcx) { - Some(n) => n, - None => return self.err(span, "an array length that is not a constant"), - }; - let elem_ty = self.ty_of(*value); - // `[v; 0]` drops `v` at once, which no element of the array would. - if self.t.drops(elem_ty) { - return self.err( - span, - "an array repeat of a value that drops, which is not supported yet", - ); - } - let v = self.operand(*value, out); - match elem_ty.kind() { - ty::Uint(ty::UintTy::U8) => { - let array = Expr::rt("bytes", vec![Expr::lit(n.to_string())]); - match &v { - Expr::Lit(text) if text == "0" => array, - _ => array.member("fill").call(vec![v]), - } - } - _ => { - let v = self.path(v, *value, out); - let item = self.copied(v, elem_ty); - let item_ty = self.t.ty(elem_ty, span); - Expr::ident("Array").member("from").call(vec![ - Expr::Object(vec![(Key::Name("length".into()), Expr::lit(n.to_string()))]), - Expr::Arrow(Vec::new(), item_ty, vec![StmtKind::Return(Some(item.typed())).at(None)]), - ]) - } - } - } - ExprKind::Adt(adt) => self.adt_expr(adt, ty, span, out), - ExprKind::Closure(closure) => self.closure(closure.closure_id, span, out), - ExprKind::Assign { .. } - | ExprKind::AssignOp { .. } - | ExprKind::Break { .. } - | ExprKind::Continue { .. } - | ExprKind::Return { .. } => { - self.stmt(id, Dest::Discard, out); - Expr::undefined() - } - ExprKind::Let { .. } => self.err(span, "a `let` outside an `if` condition"), - ExprKind::Yield { value } => { - self.stmt(*value, Dest::Discard, out); - self.yields += 1; - Expr::Yield - } - kind => self.err(span, format!("unsupported expression: {}", kind_name(kind))), - } - } - /// `value`, copied if `ty` is a `Copy` aggregate. pub fn copied(&mut self, value: Expr, ty: Ty<'tcx>) -> Expr { match self.needs_copy(ty) { @@ -2336,565 +103,12 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { } } - /// Whether indexing a `ty` at `index` is in bounds by construction: a constant index - /// into an array long enough. - fn const_index(&self, ty: Ty<'tcx>, index: ExprId) -> bool { - let ty::Array(_, len) = ty.peel_refs().kind() else { - return false; - }; - let (Some(len), Some(i)) = (len.try_to_target_usize(self.t.tcx), self.const_int(index)) else { - return false; - }; - i >= 0 && (i as u64) < len - } - - /// `id` assigned to a new variable, which a value of type `!` leaves unassigned: control - /// never gets past it. - fn via_temp(&mut self, id: ExprId, ty: Ty<'tcx>, span: Span, out: &mut Vec) -> Expr { - if ty.is_unit() { - self.stmt(id, Dest::Discard, out); - return Expr::undefined(); - } - let name = self.temp_for(id); - let ts_ty = self.t.ty(ty, span); - out.push(StmtKind::decl(true, name.clone(), Some(ts_ty), None).at(None)); - self.stmt(id, Dest::Assign(name.clone()), out); - Expr::ident(name) - } - - /// A `match` of simple arms as a chain of `?:`. - fn ternary(&mut self, id: ExprId, out: &mut Vec) -> Expr { - let ExprKind::Match { scrutinee, arms, .. } = &self.thir[self.strip(id)].kind else { - unreachable!() - }; - let thir: &'a Thir<'tcx> = self.thir; - // Its arms bind nothing, so a temporary that drops is left for nothing to drop. - if self.temporary_drops(*scrutinee) { - return self.err( - self.span(id), - "a `match` on a temporary that drops, which it doesn't move out of whole", - ); - } - let reads: usize = arms - .iter() - .take(arms.len().saturating_sub(1)) - .map(|&arm| self.test_reads(&thir[arm].pattern)) - .sum(); - let (scrut, _) = self.scrutinee(*scrutinee, reads.min(2), out); - let mut chain: Vec<(Option, Expr)> = Vec::new(); - for &arm in arms.iter() { - let arm = &self.thir[arm]; - let test = self.pat_test(&arm.pattern, &scrut); - let mut pre = Vec::new(); - let value = self.expr(arm.body, &mut pre); - out.extend(pre); - chain.push((test, value)); - } - let (_, mut result) = chain.pop().unwrap(); - while let Some((test, value)) = chain.pop() { - result = match (test, value, result) { - (None, value, _) => value, - (Some(test), Expr::Lit(a), Expr::Lit(b)) if a == "true" && b == "false" => test, - (Some(test), Expr::Lit(a), Expr::Lit(b)) if a == "false" && b == "true" => test.not(), - (Some(test), value, result) => Expr::Cond(Box::new(test), Box::new(value), Box::new(result)), - }; - } - result - } - - /// Lower `id` as a place: no copy is made of what it names. - pub fn place(&mut self, id: ExprId, out: &mut Vec) -> Expr { - self.visit(id); - let e = &self.thir[id]; - let span = e.span; - match &e.kind { - ExprKind::Scope { value, .. } | ExprKind::PlaceTypeAscription { source: value, .. } => { - self.place(*value, out) - } - ExprKind::VarRef { id: var } => self.local(var.0, span), - ExprKind::UpvarRef { var_hir_id, .. } => self.local(var_hir_id.0, span), - // Reading through a `Box` that drops reads its pointee: the box stays where it is. - ExprKind::Deref { arg } if self.is_place(*arg) && self.t.drops(self.ty_of(*arg)) => self.place(*arg, out), - ExprKind::Deref { arg } => self.expr(*arg, out), - ExprKind::Field { - lhs, - variant_index, - name, - } => { - if self.temporary_drops(*lhs) { - return self.err(span, "a field of a temporary that drops: bind it to a variable first"); - } - // A field of a tuple made in place, `(a, b).0`: its other fields still run. - if let ExprKind::Tuple { fields } = &self.thir[self.strip(*lhs)].kind { - let fields = fields.clone(); - let mut values = self.operands(&fields, out); - let index = name.index(); - let later_effects = values[index + 1..].iter().any(|v| !v.is_path()); - let mut field = std::mem::replace(&mut values[index], Expr::undefined()); - if later_effects && !field.is_constant() { - field = self.spill(field, "field", out); - } - for (i, value) in values.into_iter().enumerate() { - if i != index && !value.is_path() { - out.push(StmtKind::Expr(value).at(None)); - } - } - return field; - } - let base = self.place(*lhs, out); - let lty = self.ty_of(*lhs); - self.project(base, lty, *variant_index, *name, span) - } - ExprKind::Index { lhs, index } => { - if self.temporary_drops(*lhs) { - return self.err( - span, - "an index into a temporary that drops: bind it to a variable first", - ); - } - let base = self.place(*lhs, out); - let base = self.path(base, *lhs, out); - let lty = self.ty_of(*lhs); - let i = self.operand(*index, out); - match self.const_index(lty, *index) { - true => base.index(i), - false => { - let i = match i.is_path() { - true => i, - false => self.spill(i, "index", out), - }; - base.clone().index(Expr::rt("idx", vec![base, i])) - } - } - } - _ => self.expr(id, out), - } - } - - /// A field of `base`, a `ty`. - pub fn project( - &mut self, - base: Expr, - ty: Ty<'tcx>, - variant: rustc_abi::VariantIdx, - field: rustc_abi::FieldIdx, - span: Span, - ) -> Expr { - let ty = ty.peel_refs(); - match ty.kind() { - ty::Tuple(_) => base.index(Expr::lit(field.index().to_string())), - ty::Adt(adt, _) => match library::Std::of(self.t.tcx, adt.did()) { - Some(library::Std::Option | library::Std::Poll) => base, - Some(library::Std::Result) => match variant.index() { - 0 => base.member("value"), - _ => base.member("error"), - }, - Some(library::Std::Box | library::Std::Entry) => base, - Some(library::Std::Range) => base.member(adt.non_enum_variant().fields[field].name.as_str()), - None if adt.did().is_local() => { - let info = self.t.adt(*adt, span); - match info.repr { - AdtRepr::Struct { fields, .. } => base.field(fields[field.index()]), - AdtRepr::Union | AdtRepr::Tags => { - let def = &adt.variant(variant).fields[field]; - base.member(super::field_name(def.name.as_str(), field.index())) - } - } - } - _ => self.err(span, format!("a field of `{ty}`")), - }, - _ => self.err(span, format!("a field of `{ty}`")), - } - } - - /// A struct expression's fields by index, in the order they evaluate: those written, - /// then those `..base` fills, read from the base after it. - pub fn written( - &mut self, - adt: &thir::AdtExpr<'tcx>, - ty: Ty<'tcx>, - span: Span, - out: &mut Vec, - ) -> Vec<(usize, Expr)> { - let ids: Vec = adt.fields.iter().map(|f| f.expr).collect(); - let mut values = self.operands(&ids, out); - let base = match &adt.base { - thir::AdtExprBase::None => None, - thir::AdtExprBase::Base(fru) if self.t.drops(self.ty_of(fru.base)) => { - self.t.err(span, "struct update syntax from a value that drops"); - None - } - thir::AdtExprBase::Base(fru) => { - // The base is read after the fields, so earlier fields are saved first. - let mut pre = Vec::new(); - let base = self.operand(fru.base, &mut pre); - if !pre.is_empty() || !base.is_path() { - for value in values.iter_mut() { - if !value.is_constant() { - let saved = std::mem::replace(value, Expr::undefined()); - *value = self.spill(saved, "field", out); - } - } - } - out.extend(pre); - Some(self.path(base, fru.base, out)) - } - thir::AdtExprBase::DefaultFields(_) => { - self.t.err(span, "default field values are not supported"); - None - } - }; - let mut written: Vec<(usize, Expr)> = adt.fields.iter().map(|f| f.name.index()).zip(values).collect(); - if let Some(base) = base { - let variant = adt.adt_def.variant(adt.variant_index); - for (i, field) in variant.fields.iter_enumerated() { - if adt.fields.iter().any(|f| f.name == i) { - continue; - } - let field_ty = self.subst(field.ty(self.t.tcx, adt.args).skip_norm_wip()); - let value = self.project(base.clone(), ty, adt.variant_index, i, span); - written.push((i.index(), self.copied(value, field_ty))); - } - } - written - } - - fn adt_expr(&mut self, adt: &thir::AdtExpr<'tcx>, ty: Ty<'tcx>, span: Span, out: &mut Vec) -> Expr { - let tcx = self.t.tcx; - let def = adt.adt_def; - let variant = def.variant(adt.variant_index); - let written = self.written(adt, ty, span, out); - if let Some(std) = library::Std::of(tcx, def.did()) { - let mut values: Vec = self.declared(written, out).into_iter().map(|(_, v)| v).collect(); - return match (std, adt.variant_index.index()) { - (library::Std::Option, 0) | (library::Std::Poll, 1) => match std { - library::Std::Poll => Expr::Rt("Pending".into()), - _ => Expr::undefined(), - }, - (library::Std::Option | library::Std::Poll, _) => values.pop().unwrap(), - (library::Std::Result, 0) => Expr::rt("Ok", values), - (library::Std::Result, _) => Expr::rt("Err", values), - (library::Std::FmtError, _) => Expr::New(Box::new(Expr::Rt("FmtError".into())), Vec::new()), - (library::Std::Ordering, _) => super::collections::ordering_variant(adt.variant_index), - (library::Std::RangeTo, _) => Expr::Object(vec![(Key::Name("end".into()), values.pop().unwrap())]), - (library::Std::RangeFrom, _) => Expr::Object(vec![(Key::Name("start".into()), values.pop().unwrap())]), - (library::Std::RangeFull, _) => Expr::undefined(), - (library::Std::Range, _) => { - // A wide range steps past 2^53 through its type. - let ty::Adt(_, gargs) = ty.kind() else { - unreachable!("a range is a struct") - }; - if let Some(int) = super::num::Int::of(gargs.type_at(0)) - && int.big() - { - values.push(int.func("step")); - } - Expr::New(Box::new(Expr::Rt("Range".into())), values) - } - (library::Std::AssertKind, _) => match variant.name.as_str() { - "Eq" => Expr::Str("==".into()), - "Ne" => Expr::Str("!=".into()), - _ => self.err(span, format!("constructing `{ty}`")), - }, - _ => self.err(span, format!("constructing `{ty}`")), - }; - } - if !def.did().is_local() { - return self.err(span, format!("constructing `{ty}` from another crate")); - } - let info = self.t.adt(def, span); - match info.repr { - AdtRepr::Struct { ctor, fields } => { - let written: Vec<(usize, Expr)> = written - .into_iter() - .map(|(i, value)| { - ( - i, - field_arg(tcx, &variant.fields[rustc_abi::FieldIdx::from_usize(i)], value), - ) - }) - .collect(); - match ctor { - ts::Ctor::Unit => self.t.construct(info.sym, &ts::Ctor::Unit, &fields, Vec::new()), - // A class takes its named fields as an object, which evaluates them as written. - ts::Ctor::Named if !self.t.plain(info.sym) => { - let props = written.into_iter().map(|(i, v)| (Key::Field(fields[i]), v)).collect(); - Expr::New(Box::new(Expr::Sym(info.sym)), vec![Expr::Object(props)]) - } - // A plain object's properties go in declaration order, so every value of the - // struct shares one shape. - _ => { - let args = self.declared(written, out).into_iter().map(|(_, v)| v).collect(); - self.t.construct(info.sym, &ctor, &fields, args) - } - } - } - AdtRepr::Tags => { - let ts_ty = self.t.ty(ty, span); - Expr::As(Box::new(Expr::Str(variant.name.to_string())), ts_ty) - } - AdtRepr::Union => { - let mut props = vec![(Key::Name("tag".into()), Expr::Str(variant.name.to_string()))]; - for (i, value) in self.declared(written, out) { - let name = super::field_name(variant.fields[rustc_abi::FieldIdx::from_usize(i)].name.as_str(), i); - props.push((Key::Name(name), value)); - } - let ts_ty = self.t.ty(ty, span); - Expr::As(Box::new(Expr::Object(props)), ts_ty) - } - } - } - - /// A closure as an arrow function, or an `async` body as a future around a generator. - /// - /// The generator is a function of its own, taking its upvars as parameters: a - /// generator function made per call costs V8 a prototype object and a new shape for - /// each generator, about 25 times what one made once does. - fn closure(&mut self, local: rustc_hir::def_id::LocalDefId, span: Span, out: &mut Vec) -> Expr { - let tcx = self.t.tcx; - let Some((thir, body)) = self.t.body(local) else { - return self.err(span, "no body for a closure"); - }; - let closure_ty = self.subst(tcx.type_of(local).instantiate_identity().skip_norm_wip()); - let (ret, coroutine) = match closure_ty.kind() { - ty::Closure(_, args) => ( - tcx.instantiate_bound_regions_with_erased(args.as_closure().sig()) - .output(), - false, - ), - ty::Coroutine(_, args) if tcx.coroutine_is_async(local.to_def_id()) => { - (args.as_coroutine().return_ty(), true) - } - _ => return self.err(span, format!("a closure of type `{closure_ty}`")), - }; - if coroutine && self.t.erases_to(ret).pending { - self.t.err( - span, - format!("an async body returning `{ret}` is not supported: its `Ready` could be pending"), - ); - } - // An async fn's body is this block alone, which rustc starts by moving each argument - // into a local: the function gives its arguments up whole, and those locals drop - // them. A block moves what it owns out of its place, as any move does, and drops it. - let fn_body = matches!( - tcx.coroutine_kind(local), - Some(rustc_hir::CoroutineKind::Desugared(_, rustc_hir::CoroutineSource::Fn)) - ); - // A generator's upvars, each a parameter: its name, its value here, its type, and - // whether the future owns it and so drops it. - let mut upvars: Vec<(String, Expr, Ty<'tcx>, bool)> = Vec::new(); - for capture in tcx.closure_captures(local) { - let var = capture.get_root_variable(); - let ty = self.subst(capture.place.ty()); - let by_value = matches!(capture.info.capture_kind, ty::UpvarCapture::ByValue); - let mutable = matches!(self.locals.get(&var), Some(Local::Name { mutable: true, .. })); - // A copy captured by `move` would be shared in JS: refuse one that can change. - if !coroutine && by_value && mutable && self.t.is_copy(ty) { - self.t - .err(capture.get_path_span(tcx), "a closure that copies a mutable variable"); - } - if !coroutine { - if by_value && self.t.drops(ty) { - self.t.err( - capture.get_path_span(tcx), - "a closure that captures a value that drops, which is not supported yet", - ); - } - continue; - } - if !capture.place.projections.is_empty() { - self.t.err( - capture.get_path_span(tcx), - "an async body that captures part of a variable", - ); - continue; - } - // Its generator takes the value: a change through the borrow would change a copy. - if let ty::UpvarCapture::ByRef(kind) = capture.info.capture_kind - && kind != ty::BorrowKind::Immutable - { - if self.t.object_kind(ty).is_none() { - self.t.err( - capture.get_path_span(tcx), - format!("an async body that borrows `{ty}` mutably, which is no object it can change in place"), - ); - continue; - } - self.borrowed.insert(var); - } - let Some(Local::Name { name, .. }) = self.locals.get(&var).cloned() else { - self.t - .err(capture.get_path_span(tcx), "an async body capturing a function item"); - continue; - }; - let owns = by_value && self.t.drops(ty); - let place = Expr::ident(&name); - let value = match (owns, fn_body) { - (true, true) => { - self.disown(&name); - place - } - (true, false) => self.move_out(place, capture.get_path_span(tcx), out), - // A `Copy` aggregate taken by value is the future's own, as JS would share it. - (false, _) if by_value => self.copied(place, ty), - (false, _) => place, - }; - upvars.push((name, value, ty, owns)); - } - let saved_thir = std::mem::replace(&mut self.thir, thir); - self.read.extend(reads(tcx, thir)); - let saved_breakables = std::mem::take(&mut self.breakables); - let saved_ret = std::mem::replace(&mut self.ret, ret); - let saved_done = std::mem::replace(&mut self.done, false); - let mut body_stmts = Vec::new(); - let mut params = Vec::new(); - self.open_scope(); - // Upvars drop in capture order, after the locals: the first is the innermost. - for (name, _, ty, owns) in upvars.iter().rev() { - if *owns && !fn_body { - self.own(name, *ty); - } - } - // The first parameter is the closure's environment; a coroutine's second is the - // context each poll resumes it with. - for param in thir.params.iter().skip(1) { - let name = match ¶m.pat { - Some(pat) => self.param(pat, &mut body_stmts), - None => self.fresh("arg"), - }; - let ty = self.subst(param.ty); - let ty = self.t.ty(ty, span); - params.push(Param { name, ty: Some(ty) }); - } - let dest = match ret.is_unit() || ret.is_never() { - true => Dest::Discard, - false => Dest::Return, - }; - self.stmt(body, dest, &mut body_stmts); - self.close_scope(&mut body_stmts, 0, span); - let ret_ty = self.t.ret_ty(ret, span); - self.thir = saved_thir; - self.breakables = saved_breakables; - self.ret = saved_ret; - self.done = saved_done; - if !coroutine { - return Expr::Arrow(params, ret_ty, body_stmts); - } - - // `rt.future(body, drop, ...upvars)`: the body and what drops the upvars if it - // never runs, each a function of the upvars. - let parent = tcx.typeck_root_def_id(local.to_def_id()); - let base = camel(tcx.item_name(parent).as_str()); - let mut drops = Vec::new(); - for (name, _, ty, owns) in &upvars { - if *owns && let Some(dropped) = self.t.drop_value(Expr::ident(name), *ty, span) { - drops.push(StmtKind::Expr(dropped).at(None)); - } - } - let upvar_params: Vec = upvars - .iter() - .map(|(name, _, ty, _)| Param { - name: name.clone(), - ty: Some(self.t.ty(*ty, span)), - }) - .collect(); - params.extend(upvar_params.iter().cloned()); - let body_fn = self.hoist(parent, format!("{base}Body"), params, ret_ty, body_stmts, true, span); - // The drop reads only the upvars it drops: TypeScript lets the rest go unread as `_`s. - let drop_params = upvars - .iter() - .zip(upvar_params) - .map(|((_, _, _, owns), param)| match owns { - true => param, - false => Param { - name: format!("_{}", param.name), - ..param - }, - }) - .collect(); - let drop_fn = match drops.is_empty() { - true => Expr::undefined(), - false => self.hoist( - parent, - format!("{base}Drop"), - drop_params, - Type::Builtin("void"), - drops, - false, - span, - ), - }; - let mut args = vec![body_fn, drop_fn]; - args.extend(upvars.into_iter().map(|(_, value, _, _)| value)); - Expr::rt("future", args) - } - - /// A module-level function in `parent`'s module, by the name `base` and the suffix of - /// the instance of `parent` it is part of. - #[expect(clippy::too_many_arguments, reason = "a function's parts")] - fn hoist( - &mut self, - parent: rustc_hir::def_id::DefId, - base: String, - params: Vec, - ret: Type, - body: Vec, - generator: bool, - span: Span, - ) -> Expr { - let order = self.t.order(span); - let sym = self.t.program.sym(crate::program::Symbol { - module: self.t.module_of(parent), - base, - suffix: self.t.suffix(Instance::new_raw(parent, self.args)), - owner: None, - kind: SymKind::Function, - order, - instance: String::new(), - name: String::new(), - alias: None, - }); - let loc = self.t.loc(span); - self.t.program.items.push(ts::Item::Function(ts::Function { - sym, - params, - ret, - body, - loc, - doc: None, - generator, - })); - Expr::Sym(sym) - } - - // Calls - - fn call(&mut self, fn_ty: Ty<'tcx>, fun: ExprId, args: &[ExprId], span: Span, out: &mut Vec) -> Expr { - let fn_ty = self.subst(fn_ty); - match *fn_ty.kind() { - ty::FnDef(def_id, gargs) => { - // A function item is a type: evaluating `fun` only runs its effects. - if !self.simple(fun) { - self.stmt(fun, Dest::Discard, out); - } - self.call_def(def_id, gargs.skip_binder(), Args::Thir(args), span, out) - } - ty::FnPtr(..) => { - let ids: Vec = std::iter::once(fun).chain(args.iter().copied()).collect(); - let mut values = self.operands(&ids, out); - let f = values.remove(0); - f.call(values) - } - _ => self.err(span, format!("a call through `{fn_ty}`")), - } - } - /// A call of `def_id` with `gargs`, from wherever it resolves. pub fn call_def( &mut self, def_id: rustc_hir::def_id::DefId, gargs: GenericArgsRef<'tcx>, - args: Args<'_>, + args: Vec, span: Span, out: &mut Vec, ) -> Expr { @@ -2903,46 +117,20 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { // A tuple struct or variant's constructor, called or passed as a value. if let rustc_hir::def::DefKind::Ctor(..) = tcx.def_kind(def_id) { - return self.ctor(def_id, gargs, args, span, out); - } - - // Calling a closure or function value: `FnOnce::call_once(f, (args,))`. - if let Some(trait_id) = tcx.trait_of_assoc(def_id) - && tcx.is_fn_trait(trait_id) - { - let callee_ty = gargs.type_at(0); - let Args::Thir(ids) = args else { - return self.err(span, "a closure call with lowered arguments"); - }; - let tupled = self.strip(ids[1]); - let ExprKind::Tuple { fields } = &self.thir[tupled].kind else { - return self.err(span, "a closure call whose arguments are not a tuple"); - }; - let fields = fields.clone(); - if let ty::FnDef(inner, inner_args) = *callee_ty.peel_refs().kind() { - return self.call_def(inner, inner_args.skip_binder(), Args::Thir(&fields), span, out); - } - let mut all = vec![ids[0]]; - all.extend(fields.iter()); - let mut values = self.operands(&all, out); - let f = values.remove(0); - return f.call(values); + return self.ctor(def_id, gargs, args, span); } let instance = match Instance::try_resolve(tcx, self.t.typing_env_pub(), def_id, gargs) { Ok(Some(instance)) => instance, // A trait method of a type parameter: each instance resolves it. - Ok(None) if self.t.polymorphic() && gargs.has_param() => { - self.args(args, out); - return Expr::undefined(); - } + Ok(None) if self.t.polymorphic() && gargs.has_param() => return Expr::undefined(), _ => return self.err(span, format!("`{}` does not resolve", tcx.def_path_str(def_id))), }; // An `async` body's `Future::poll`, which its future has itself. if let ty::InstanceKind::Item(did) = instance.def && tcx.is_coroutine(did) { - let mut values = self.args(args, out); + let mut values = args; let future = values.remove(0); return future.member("poll").call(values); } @@ -2950,7 +138,7 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { && did.is_local() { let sym = self.t.instance(instance); - let values: Vec = self.args(args, out).into_iter().map(Expr::typed).collect(); + let values: Vec = args.into_iter().map(Expr::typed).collect(); let call = Expr::Sym(sym).call(values); // The crate's own `next` returns an item or `rt.DONE`, and its caller an `Option`. if super::iter::is_next(tcx, did) { @@ -2965,30 +153,12 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { args: gargs, span, }; - let ids = match &args { - Args::Thir(ids) => *ids, - Args::Values(_) => &[], - }; match library::call(self, &call, args, out) { Some(e) => e, - None => { - // Refused, but what the arguments refuse is reported too. The mapping may - // have lowered some already: lowering them twice would double the work at - // each level of a nested call. - let unvisited: Vec = ids.iter().copied().filter(|&id| !self.visited(id)).collect(); - self.operands(&unvisited, out); - self.err( - span, - format!("unsupported call to `{}`", tcx.def_path_str_with_args(def_id, gargs)), - ) - } - } - } - - pub fn args(&mut self, args: Args<'_>, out: &mut Vec) -> Vec { - match args { - Args::Thir(ids) => self.operands(ids, out), - Args::Values(values) => values, + None => self.err( + span, + format!("unsupported call to `{}`", tcx.def_path_str_with_args(def_id, gargs)), + ), } } @@ -2996,12 +166,11 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { &mut self, def_id: rustc_hir::def_id::DefId, gargs: GenericArgsRef<'tcx>, - args: Args<'_>, + args: Vec, span: Span, - out: &mut Vec, ) -> Expr { let tcx = self.t.tcx; - let values = self.args(args, out); + let values = args; let parent = tcx.parent(def_id); let (adt_id, variant) = match tcx.def_kind(parent) { rustc_hir::def::DefKind::Variant => ( @@ -3069,7 +238,7 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { return Expr::Sym(self.t.instance(instance)); } let mut body = Vec::new(); - let call = self.call_def(def_id, gargs, Args::Values(values), span, &mut body); + let call = self.call_def(def_id, gargs, values, span, &mut body); body.push(StmtKind::Return(Some(call.typed())).at(None)); let params = names .into_iter() @@ -3082,152 +251,6 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { let ret = self.t.ret_ty(sig.output(), span); Expr::Arrow(params, ret, body) } - - /// The integer a literal operand has, folding constant arithmetic. - pub fn const_int(&self, id: ExprId) -> Option { - match &self.thir[id].kind { - ExprKind::Scope { value, .. } => self.const_int(*value), - ExprKind::Literal { lit, neg } => match lit.node { - rustc_ast::LitKind::Int(n, _) => { - let n = n.get() as i128; - Some(if *neg { -n } else { n }) - } - _ => None, - }, - ExprKind::NonHirLiteral { lit, .. } => { - let ty = self.ty_of(id); - let int = super::num::Int::of(ty)?; - let size = rustc_abi::Size::from_bits(int.bits); - Some(match int.signed { - true => lit.to_int(size), - false => lit.to_uint(size) as i128, - }) - } - ExprKind::Binary { op, lhs, rhs } => { - let ty = self.ty_of(id); - let int = super::num::Int::of(ty)?; - super::num::fold(*op, self.const_int(*lhs)?, self.const_int(*rhs)?, int) - } - _ => None, - } - } -} - -/// A range of `ty` as a `for` loop iterates it: counting in a number, or as the runtime's -/// range of a wide integer, which steps past 2^53 into limbs. -fn range_of(ty: Ty<'_>, start: Expr, end: Expr, inclusive: bool) -> Iterable { - let ty::Adt(_, args) = ty.kind() else { - unreachable!("a range is a struct") - }; - match super::num::Int::of(args.type_at(0)) { - Some(int) if int.big() => { - let class = if inclusive { "RangeInclusive" } else { "Range" }; - Iterable::Of(Expr::New( - Box::new(Expr::Rt(class.into())), - vec![start, end, int.func("step")], - )) - } - _ => Iterable::Range { start, end, inclusive }, - } -} - -enum Iterable { - Range { - start: Expr, - end: Expr, - inclusive: bool, - }, - /// A JS array or `Uint8Array`, which `for ... of` iterates. - Of(Expr), - /// An iterator, by its `next`: an item or `rt.DONE`. - Next(Expr), -} - -/// The variables `thir` reads, those its closures capture included. -fn reads<'tcx>(tcx: ty::TyCtxt<'tcx>, thir: &Thir<'tcx>) -> FxHashSet { - let mut read = FxHashSet::default(); - for expr in thir.exprs.iter() { - match &expr.kind { - ExprKind::VarRef { id } => { - read.insert(id.0); - } - ExprKind::UpvarRef { var_hir_id, .. } => { - read.insert(var_hir_id.0); - } - ExprKind::Closure(closure) => { - read.extend( - tcx.closure_captures(closure.closure_id) - .iter() - .map(|capture| capture.get_root_variable()), - ); - } - _ => {} - } - } - read -} - -/// Whether `ty` is a closure or function pointer that never returns, whose binding `tsc` -/// sees a call to diverge only through a declared type. -fn diverges_when_called(ty: Ty<'_>) -> bool { - let output = match ty.peel_refs().kind() { - ty::Closure(_, args) => args.as_closure().sig().output(), - ty::FnPtr(sig, header) => sig.with(*header).output(), - _ => return false, - }; - output.skip_binder().is_never() -} - -/// Whether a declaration's initializer is one TypeScript can't type on its own. -fn needs_annotation(value: &Expr) -> bool { - match value { - Expr::Array(items) => items.is_empty(), - Expr::Lit(text) => text == "undefined", - Expr::Arrow(..) => false, - Expr::Located(_, e) => needs_annotation(e), - _ => false, - } -} - -/// Whether matching `pat` moves its whole value into a binding, or matches only a variant -/// with nothing in it: either way nothing is left to drop. -fn takes_all(pat: &Pat<'_>) -> bool { - match &pat.kind { - PatKind::Binding { - mode, subpattern: None, .. - } => mode.0 == rustc_hir::ByRef::No, - // `Some(..)` names no field, which then stays in the temporary. - PatKind::Variant { - adt_def, - variant_index, - subpatterns, - .. - } => { - subpatterns.len() == adt_def.variant(*variant_index).fields.len() - && subpatterns.iter().all(|f| takes_all(&f.pattern)) - } - _ => false, - } -} - -pub fn has_bindings(pat: &Pat<'_>) -> bool { - bindings(pat) > 0 -} - -/// How many bindings `pat` makes, each reading the scrutinee once. -fn bindings(pat: &Pat<'_>) -> usize { - let mut count = 0; - pat.walk_always(|p| { - if let PatKind::Binding { .. } = p.kind { - count += 1; - } - }); - count -} - -fn kind_name(kind: &ExprKind<'_>) -> String { - let debug = format!("{kind:?}"); - debug.split([' ', '(', '{']).next().unwrap_or("?").to_string() } /// A field's value as a class's constructor takes it: without an outer `as` where the diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index e8adb4e22..80a1cac78 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -11,20 +11,20 @@ use rustc_middle::ty::{self, Instance, Ty}; use rustc_span::Span; use super::body::Body; -use super::library::{self, Args, Call, Std}; +use super::library::{self, Call, Std}; use super::num::Int; use crate::ts::{Expr, Stmt}; /// A call of a standard library function on these types, or its arguments back if it is /// none of theirs. -pub fn call<'tcx, 'x>( +pub fn call<'tcx>( b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, owner: &str, name: &str, - args: Args<'x>, + mut args: Vec, out: &mut Vec, -) -> Result, Args<'x>> { +) -> Result, Vec> { let tcx = b.t.tcx; let span = call.span; let self_ty = call.args.types().next(); @@ -45,7 +45,7 @@ pub fn call<'tcx, 'x>( return Err(args); } let f = cmp_fn(b, t, span); - return Ok(Some(f.call(b.args(args, out)))); + return Ok(Some(f.call(args))); } ("Hash", "hash", ..) if let Some(t) = self_ty => { let t = peel(b, t); @@ -55,20 +55,20 @@ pub fn call<'tcx, 'x>( return Err(args); }; let f = hash_fn(b, t, hasher, span); - return Ok(Some(f.call(b.args(args, out)))); + return Ok(Some(f.call(args))); } ("PartialEq", "eq" | "ne", ..) if let Some(t) = self_ty => { let t = peel(b, t); if !matches!(t.kind(), ty::Tuple(tys) if !tys.is_empty()) && b.t.std_of(t) != Some(Std::Ordering) { return Err(args); } - let eq = eq_fn(b, t, span).call(b.args(args, out)); + let eq = eq_fn(b, t, span).call(args); return Ok(Some(if name == "eq" { eq } else { eq.not() })); } ("Hasher", _, Some(Std::Hasher), _) => return Ok(Some(hasher_call(b, name, args, span, out))), // The discriminant derived `Hash` and `Ord` read of an enum. ("intrinsics", "discriminant_value", ..) if let Some(t) = self_ty => { - let value = b.args(args, out).pop(); + let value = args.pop(); return Ok(value.map(|value| discriminant(b, t, value, span))); } _ => return Err(args), @@ -90,10 +90,10 @@ pub fn call<'tcx, 'x>( } 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, out), + Std::BTreeMap | Std::BTreeSet => btree(b, coll, call, owner, name, args), Std::VecDeque => deque(b, coll, call, owner, name, args, out), - Std::Entry => entry(b, coll, name, args, span, out), - Std::Ordering => ordering(b, name, args, span, out), + Std::Entry => entry(b, coll, name, args, span), + Std::Ordering => ordering(name, args), Std::Hasher if matches!(name, "new" | "default") => Some(Expr::rt("hasher", vec![])), _ => return Err(args), }; @@ -217,14 +217,14 @@ fn hash<'tcx>( call: &Call<'tcx>, owner: &str, name: &str, - args: Args<'_>, + args: Vec, out: &mut Vec, ) -> Option { let span = call.span; let set = b.t.std_of(coll) == Some(Std::HashSet); let key = arg(coll, 0); let value = if set { None } else { Some(arg(coll, 1)) }; - let mut values = b.args(args, out); + let mut values = args; let e = match (owner, name) { (_, "new" | "with_capacity") | ("Default", "default") => { discard(values, out); @@ -358,14 +358,13 @@ fn btree<'tcx>( call: &Call<'tcx>, owner: &str, name: &str, - args: Args<'_>, - out: &mut Vec, + args: Vec, ) -> Option { let span = call.span; let set = b.t.std_of(coll) == Some(Std::BTreeSet); let key = arg(coll, 0); let value = if set { None } else { Some(arg(coll, 1)) }; - let mut values = b.args(args, out); + let mut values = args; let last = |mut values: Vec| { values.push(Expr::lit("true")); values @@ -446,12 +445,12 @@ fn deque<'tcx>( call: &Call<'tcx>, owner: &str, name: &str, - args: Args<'_>, + args: Vec, out: &mut Vec, ) -> Option { let span = call.span; let item = arg(coll, 0); - let mut values = b.args(args, out); + let mut values = args; let back = |mut values: Vec| { values.push(Expr::lit("true")); values @@ -533,16 +532,9 @@ fn extend_source<'tcx>( } /// A method of an `Entry`, `OccupiedEntry`, or `VacantEntry`. -fn entry<'tcx>( - b: &mut Body<'_, '_, 'tcx>, - coll: Ty<'tcx>, - name: &str, - args: Args<'_>, - span: Span, - out: &mut Vec, -) -> Option { +fn entry<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, name: &str, args: Vec, span: Span) -> Option { let value = arg(coll, 1); - let mut values = b.args(args, out); + let mut values = args; let e = match name { "or_insert" => Expr::rt("entryOrInsert", values), // A vacant entry's. @@ -588,9 +580,7 @@ pub fn ordering_variant(index: rustc_abi::VariantIdx) -> Expr { } /// `Ordering`'s methods, on its discriminant. -fn ordering(b: &mut Body<'_, '_, '_>, name: &str, args: Args<'_>, span: Span, out: &mut Vec) -> Option { - let _ = span; - let mut values = b.args(args, out); +fn ordering(name: &str, mut values: Vec) -> Option { let zero = || Expr::lit("0"); let e = match name { "is_eq" => values.pop()?.binary("===", zero()), @@ -611,8 +601,8 @@ fn ordering(b: &mut Body<'_, '_, '_>, name: &str, args: Args<'_>, span: Span, ou } /// `Hasher`'s methods: writing an integer or a string, and `finish`. -fn hasher_call(b: &mut Body<'_, '_, '_>, name: &str, args: Args<'_>, span: Span, out: &mut Vec) -> Expr { - let mut values = b.args(args, out); +fn hasher_call(b: &mut Body<'_, '_, '_>, name: &str, args: Vec, span: Span, out: &mut Vec) -> Expr { + let mut values = args; // The runtime takes the value first, so a hasher that is not a path evaluates first. if let [state, value] = values.as_mut_slice() && !state.is_path() diff --git a/ts/src/lower/consts.rs b/ts/src/lower/consts.rs index 3b1efd081..1e562445f 100644 --- a/ts/src/lower/consts.rs +++ b/ts/src/lower/consts.rs @@ -1,9 +1,7 @@ -//! Literals and constants. A named constant is evaluated by rustc and written as its -//! value at each use, as Rust inlines it. +//! Constants: rustc evaluates each, and its value is written at each use, as Rust +//! inlines it. -use rustc_middle::mir::interpret::GlobalId; -use rustc_middle::thir::{ExprId, ExprKind}; -use rustc_middle::ty::{self, Instance, Ty, ValTree}; +use rustc_middle::ty::{self, Ty, ValTree}; use rustc_span::Span; use super::AdtRepr; @@ -13,121 +11,6 @@ use super::num::Int; use crate::ts::{Expr, Key}; impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { - /// A literal or constant expression. - pub fn constant(&mut self, id: ExprId) -> Expr { - let tcx = self.t.tcx; - let e = &self.thir[id]; - let span = e.span; - let ty = self.ty_of(id); - match &e.kind { - ExprKind::Literal { lit, neg } => match lit.node { - rustc_ast::LitKind::Int(n, _) => { - let Some(int) = Int::of(ty) else { - return self.err(span, format!("an integer literal of type `{ty}`")); - }; - let value = n.get() as i128; - let value = if *neg { -value } else { value }; - match self.literal_text(span, *neg) { - Some(text) => int.spelled(text, value), - None => int.lit(value), - } - } - rustc_ast::LitKind::Bool(b) => Expr::lit(b.to_string()), - rustc_ast::LitKind::Str(s, _) => Expr::Str(s.to_string()), - rustc_ast::LitKind::Byte(b) => Expr::lit(b.to_string()), - rustc_ast::LitKind::ByteStr(ref bytes, _) => { - let items = bytes.as_byte_str().iter().map(|b| Expr::lit(b.to_string())).collect(); - Expr::ident("Uint8Array").member("of").call(items) - } - _ => self.err(span, format!("unsupported literal of type `{ty}`")), - }, - ExprKind::NonHirLiteral { lit, .. } => match (ty.kind(), Int::of(ty)) { - (ty::Bool, _) => Expr::lit((lit.to_bits_unchecked() != 0).to_string()), - (_, Some(int)) => { - let size = rustc_abi::Size::from_bits(int.bits); - let value = match int.signed { - true => lit.to_int(size), - false => lit.to_uint(size) as i128, - }; - int.lit(value) - } - _ => self.err(span, format!("a literal of type `{ty}`")), - }, - ExprKind::ZstLiteral { .. } => match *ty.kind() { - ty::FnDef(def_id, args) => self.fn_value(def_id, args.skip_binder(), span), - ty::Tuple(tys) if tys.is_empty() => Expr::undefined(), - ty::Adt(adt, _) if adt.is_struct() && adt.did().is_local() => { - let info = self.t.adt(adt, span); - self.t.construct(info.sym, &crate::ts::Ctor::Unit, &[], Vec::new()) - } - _ => self.err(span, format!("a value of type `{ty}`")), - }, - ExprKind::NamedConst { def_id, args, .. } => { - let args = self.subst(*args); - let env = self.t.typing_env_pub(); - let instance = match Instance::try_resolve(tcx, env, *def_id, args) { - Ok(Some(instance)) => instance, - _ => return self.err(span, "a constant that does not resolve"), - }; - let cid = GlobalId { - instance, - promoted: None, - }; - match tcx.const_eval_global_id_for_typeck(env, cid, span) { - Ok(Ok(valtree)) => self.value(ty, valtree, span), - Ok(Err(_)) => self.err(span, format!("a constant of type `{ty}`, which has no value tree")), - Err(_) => self.err(span, "a constant that failed to evaluate"), - } - } - ExprKind::ConstParam { .. } | ExprKind::ConstBlock { .. } => { - self.err(span, "const generics and const blocks in expressions are not supported") - } - _ => unreachable!(), - } - } - - /// A literal as the source spells it, when that is also valid JS. - fn literal_text(&self, span: Span, neg: bool) -> Option { - if span.from_expansion() { - return None; - } - let text = self.t.tcx.sess.source_map().span_to_snippet(span).ok()?; - let text = text.trim_start_matches('-').trim(); - let (prefix, digits) = match text.get(..2) { - Some("0x" | "0o" | "0b") => text.split_at(2), - _ => ("", text), - }; - let radix = match prefix { - "0x" => 16, - "0o" => 8, - "0b" => 2, - _ => 10, - }; - // Drop a type suffix, which hex digits can't be confused with. - let end = digits - .find(|c: char| c != '_' && !c.is_digit(radix)) - .unwrap_or(digits.len()); - let digits = &digits[..end]; - // JS allows `_` only between two digits. - let chars: Vec = digits.chars().collect(); - let mut cleaned = String::new(); - for (i, &c) in chars.iter().enumerate() { - if c == '_' { - let between = i > 0 && chars[i - 1] != '_' && chars.get(i + 1).is_some_and(|n| *n != '_'); - if !between { - continue; - } - } - cleaned.push(c); - } - let cleaned = cleaned.trim_matches('_'); - if cleaned.is_empty() || cleaned.contains("__") { - return None; - } - let sign = if neg { "-" } else { "" }; - Some(format!("{sign}{prefix}{cleaned}")) - } - /// A constant's value tree as a JS value of type `ty`. pub fn value(&mut self, ty: Ty<'tcx>, valtree: ValTree<'tcx>, span: Span) -> Expr { let tcx = self.t.tcx; @@ -217,6 +100,17 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { (Std::Option, _) => values.pop().unwrap(), (Std::Result, 0) => Expr::rt("Ok", values), (Std::Result, _) => Expr::rt("Err", values), + // `start..=end`, not yet stepped past its end. + (Std::RangeInclusive, _) + if values.len() == 3 && matches!(&values[2], Expr::Lit(l) if l == "false") => + { + values.pop(); + let ty::Adt(_, args) = ty.kind() else { + unreachable!("matched above") + }; + values.extend(crate::lower::num::Int::of(args.type_at(0)).map(|int| int.func("step"))); + Expr::New(Box::new(Expr::Rt("RangeInclusive".into())), values) + } (Std::Ordering, _) => super::collections::ordering_variant(variant), _ => self.err(span, format!("a constant of type `{ty}`")), }; diff --git a/ts/src/lower/drop.rs b/ts/src/lower/drop.rs index a449416f6..bceda7068 100644 --- a/ts/src/lower/drop.rs +++ b/ts/src/lower/drop.rs @@ -2,25 +2,17 @@ //! //! A type drops if dropping it does something JS can see: runs a `Drop` impl, counts an //! `Arc` down, or drops a waker. Such a value has `[Symbol.dispose]`, which a class gets -//! as drop glue: its `Drop` impl, then each field in order. A variable drops at the end -//! of its scope through a `finally`, so an early exit, a panic, or a cancelled future -//! drops it too. A move leaves `undefined` in the place it left, which drops as nothing, -//! so a variable moved on only some paths still drops on the others. +//! as drop glue: its `Drop` impl, then each field in order. Where each value drops is +//! MIR's: drop elaboration put a terminator at each drop, with a flag wherever a value is +//! moved on some paths only. use rustc_middle::ty::{self, AdtDef, Instance, Ty, TypeVisitableExt}; use rustc_span::Span; -use super::body::Body; use super::library::Std; use super::{Adt, AdtRepr, Translator}; use crate::program::{SymKind, Symbol}; -use crate::ts::{self, Expr, Stmt, StmtKind, Target, Type}; - -/// A variable its scope drops when it ends. -pub struct Owned<'tcx> { - pub name: String, - pub ty: Ty<'tcx>, -} +use crate::ts::{self, Expr, Stmt, StmtKind, Type}; impl<'a, 'tcx> Translator<'a, 'tcx> { /// Whether dropping a `ty` does something JS can see. @@ -158,13 +150,18 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { ty::Coroutine(..) | ty::Param(_) => true, _ => false, }; - // A MIR lowering drops an enum or tuple by the glue rustc builds for it. - if !supported - && self.mir - && let Some(sym) = super::mir::glue::shim(self, ty, span) - { + // An enum or tuple drops by the glue rustc builds for it. + if !supported && let Some(sym) = super::mir::glue::shim(self, ty, span) { return Some(super::mir::glue::call(sym, value)); } + if !supported && let ty::Closure(..) = ty.kind() { + // Its captures live in an arrow function's scope, where nothing outside can drop them. + self.err( + span, + "dropping a closure that owns a value that drops, which is not supported yet", + ); + return None; + } if !supported { self.err(span, format!("dropping `{ty}`, which is not supported yet")); return None; @@ -241,123 +238,6 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { body, loc: None, doc: None, - generator: false, }); } } - -impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { - /// Start a scope: the variables bound until it closes drop when it does. - pub fn open_scope(&mut self) { - self.scopes.push(Vec::new()); - } - - /// Drop `name`, a `ty`, when the innermost scope closes, if JS would see it drop. - pub fn own(&mut self, name: &str, ty: Ty<'tcx>) { - if !self.t.drops(ty) { - return; - } - if let Some(scope) = self.scopes.last_mut() { - scope.push(Owned { - name: name.to_string(), - ty, - }); - } - } - - /// Stop dropping `name` here: it moved somewhere that drops it itself. - pub fn disown(&mut self, name: &str) { - for scope in &mut self.scopes { - scope.retain(|owned| owned.name != name); - } - } - - /// Whether the innermost scope drops anything yet. - pub fn scope_owns(&self) -> bool { - self.scopes.last().is_some_and(|scope| !scope.is_empty()) - } - - /// Close the innermost scope, whose statements are `out[start..]`: each variable it - /// drops is dropped in a `finally` around the statements after its declaration, the - /// last declared innermost, or around them all for a parameter. - pub fn close_scope(&mut self, out: &mut Vec, start: usize, span: Span) { - let owned = self.scopes.pop().unwrap_or_default(); - for owned in owned.into_iter().rev() { - let Some(dropped) = self.t.drop_value(Expr::ident(&owned.name), owned.ty, span) else { - continue; - }; - let moved = self.moved.contains(&owned.name); - let mut at = start; - for (i, stmt) in out.iter_mut().enumerate().skip(start) { - if let StmtKind::Decl { - mutable, target, init, .. - } = &mut stmt.kind - && declares(target, &owned.name) - { - *mutable |= moved; - // The `finally` may run before anything assigns it. - init.get_or_insert_with(|| Expr::lit("undefined!")); - at = i + 1; - break; - } - } - // What the declaration moved from is cleared before anything can throw. - while out.get(at).is_some_and(clears) { - at += 1; - } - let body = out.split_off(at); - let dropped = StmtKind::Expr(dropped).at(None); - match body.is_empty() { - true => out.push(dropped), - false => out.push( - StmtKind::Try { - body, - finally: vec![dropped], - } - .at(None), - ), - } - } - } - - /// The value of the place `place`, a `ty` that drops, moved out: the place is left - /// `undefined`, so whatever drops it later drops nothing. - pub fn move_out(&mut self, place: Expr, span: Span, out: &mut Vec) -> Expr { - let base = match &place { - Expr::Ident(name) => name.clone(), - _ => "moved".into(), - }; - match &place { - Expr::Ident(name) => { - self.moved.insert(name.clone()); - } - Expr::Member(..) if place.is_path() => {} - _ => return self.err(span, "a move out of a place that is no variable or field"), - } - let name = self.fresh(&base); - out.push(StmtKind::decl(false, name.clone(), None, Some(place.clone())).at(None)); - self.clear(place, out); - Expr::ident(name) - } - - /// Leave `undefined` in `place`, whose value moved. - pub fn clear(&mut self, place: Expr, out: &mut Vec) { - if let Expr::Ident(name) = &place { - self.moved.insert(name.clone()); - } - out.push(StmtKind::Expr(place.assign(Expr::lit("undefined!"))).at(None)); - } -} - -/// Whether `stmt` leaves a moved-out place `undefined`. -fn clears(stmt: &Stmt) -> bool { - matches!(&stmt.kind, StmtKind::Expr(Expr::Assign(_, value)) if matches!(&**value, Expr::Lit(text) if text == "undefined!")) -} - -/// Whether `target` declares `name`. -fn declares(target: &Target, name: &str) -> bool { - match target { - Target::Name(n) => n == name, - Target::Array(items) => items.iter().flatten().any(|t| declares(t, name)), - } -} diff --git a/ts/src/lower/fmt.rs b/ts/src/lower/fmt.rs index 693ac4229..065fadbed 100644 --- a/ts/src/lower/fmt.rs +++ b/ts/src/lower/fmt.rs @@ -6,12 +6,11 @@ //! call goes to the impl of the value's type directly, as monomorphization allows. use rustc_hir::def_id::DefId; -use rustc_middle::thir::{ExprId, ExprKind, StmtKind}; use rustc_middle::ty::{self, Ty, TyCtxt}; use rustc_span::Span; use super::body::Body; -use super::library::{self, Args, Std}; +use super::library::{self, Std}; use super::num::Int; use crate::ts::{Expr, Key, Param, Stmt, Type}; @@ -66,8 +65,25 @@ impl Trait { } } -const UNEXPECTED: &str = "an unexpected `format_args!` lowering"; -pub const FROM_ARGUMENT: &str = "a width or precision from an argument, as in `{:1$}`,"; +/// The trait a `format_args!` argument's constructor, `Argument::new_display` and the +/// like, writes its value by, or the construct outside the subset that it is. +pub fn argument(name: &str) -> Result { + match name { + "new_display" => Ok(Trait::Display), + "new_debug" => Ok(Trait::Debug), + "new_lower_hex" => Ok(Trait::LowerHex), + "new_upper_hex" => Ok(Trait::UpperHex), + "from_usize" => Err(FROM_ARGUMENT), + "new_octal" => Err("`Octal` formatting, as in `{:o}`,"), + "new_binary" => Err("`Binary` formatting, as in `{:b}`,"), + "new_lower_exp" => Err("`LowerExp` formatting, as in `{:e}`,"), + "new_upper_exp" => Err("`UpperExp` formatting, as in `{:E}`,"), + "new_pointer" => Err("`Pointer` formatting, as in `{:p}`,"), + _ => Err("an unexpected `format_args!` lowering"), + } +} + +const FROM_ARGUMENT: &str = "a width or precision from an argument, as in `{:1$}`,"; /// A formatter's type, for the parameters of the functions written here. fn formatter() -> Type { @@ -75,26 +91,6 @@ fn formatter() -> Type { } impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { - /// Whether `id` is what `format_args!` lowers to: `Arguments::from_str(s)`, or a block - /// of two `super let`s ending in `unsafe { Arguments::new(template, &args) }`. - pub fn is_format_args(&self, id: ExprId) -> bool { - let calls = |id: ExprId, names: &[&str]| match &self.thir[self.strip(id)].kind { - ExprKind::Call { ty, .. } => self - .callee(*ty) - .is_some_and(|(owner, name)| owner == "Arguments" && names.contains(&name.as_str())), - _ => false, - }; - let tail = |id: ExprId| match &self.thir[self.strip(id)].kind { - ExprKind::Block { block } => self.thir[*block].expr, - _ => None, - }; - let block = match &self.thir[self.strip(id)].kind { - ExprKind::Block { block } => &self.thir[*block], - _ => return calls(id, &["from_str", "from_str_nonconst"]), - }; - block.stmts.len() == 2 && block.expr.and_then(tail).is_some_and(|call| calls(call, &["new"])) - } - /// The formatting trait of a `&dyn Debug` or the like. pub fn fmt_object(&self, ty: Ty<'tcx>) -> Option { let ty::Ref(_, inner, rustc_ast::Mutability::Not) = ty.kind() else { @@ -112,142 +108,6 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { .is_some_and(|pointee| matches!(pointee.kind(), ty::Dynamic(..))) } - /// The `owner::name` key of a call's callee in std. - fn callee(&self, fn_ty: Ty<'tcx>) -> Option<(String, String)> { - match *self.subst(fn_ty).kind() { - ty::FnDef(def_id, _) => library::key(self.t.tcx, def_id), - _ => None, - } - } - - /// A `fmt::Arguments`, from what `format_args!` lowers to: an array of literal pieces - /// and functions writing each placeholder's value. - pub fn format_args(&mut self, id: ExprId, out: &mut Vec) -> Expr { - let span = self.span(id); - match self.arguments(id, out) { - Ok(parts) => Expr::Array(parts), - Err(msg) if msg == UNEXPECTED => self.err(span, msg), - Err(msg) => self.err(span, format!("{msg} is not supported")), - } - } - - /// The parts of a `format_args!`, or the construct that is outside the subset. - fn arguments(&mut self, id: ExprId, out: &mut Vec) -> Result, String> { - let id = self.strip(id); - let thir = self.thir; - let block = match &thir[id].kind { - // A template without placeholders. - ExprKind::Call { args, .. } if args.len() == 1 => return Ok(vec![self.operand(args[0], out)]), - ExprKind::Block { block } => &thir[*block], - _ => return Err(UNEXPECTED.into()), - }; - // `super let args = (&a, &b); super let args = [Argument::new_display(args.0), ..];` - let [values, arguments] = block.stmts[..] else { - return Err(UNEXPECTED.into()); - }; - let binding = |stmt: rustc_middle::thir::StmtId| match &thir[stmt].kind { - StmtKind::Let { - pattern, - initializer: Some(init), - .. - } => match pattern.kind { - rustc_middle::thir::PatKind::Binding { var, .. } => Some((var, *init)), - _ => None, - }, - _ => None, - }; - let ((values_var, values), (_, arguments)) = binding(values).zip(binding(arguments)).ok_or(UNEXPECTED)?; - let ExprKind::Tuple { fields } = &thir[self.strip(values)].kind else { - return Err(UNEXPECTED.into()); - }; - // Each value is evaluated once, in order, before anything is written. - let mut values = self.operands(fields, out); - for value in &mut values { - if !value.is_path() { - let saved = std::mem::replace(value, Expr::undefined()); - *value = self.spill(saved, "arg", out); - } - } - let ExprKind::Array { fields: arguments } = &thir[self.strip(arguments)].kind else { - return Err(UNEXPECTED.into()); - }; - let mut placeholders = Vec::new(); - for &argument in arguments.iter() { - let ExprKind::Call { ty, args, .. } = &thir[self.strip(argument)].kind else { - return Err(UNEXPECTED.into()); - }; - let ty::FnDef(def_id, gargs) = *self.subst(*ty).kind() else { - return Err(UNEXPECTED.into()); - }; - let tr = match self.t.tcx.item_name(def_id).as_str() { - "new_display" => Trait::Display, - "new_debug" => Trait::Debug, - "new_lower_hex" => Trait::LowerHex, - "new_upper_hex" => Trait::UpperHex, - "from_usize" => return Err(FROM_ARGUMENT.into()), - "new_octal" => return Err("`Octal` formatting, as in `{:o}`,".into()), - "new_binary" => return Err("`Binary` formatting, as in `{:b}`,".into()), - "new_lower_exp" => return Err("`LowerExp` formatting, as in `{:e}`,".into()), - "new_upper_exp" => return Err("`UpperExp` formatting, as in `{:E}`,".into()), - "new_pointer" => return Err("`Pointer` formatting, as in `{:p}`,".into()), - _ => return Err(UNEXPECTED.into()), - }; - let field = self.tuple_field(args[0], values_var).ok_or(UNEXPECTED)?; - let ty = self.subst(gargs.skip_binder().types().next().ok_or(UNEXPECTED)?); - placeholders.push((tr, field, ty)); - } - // `unsafe { Arguments::new(template, &args) }` - let call = match &thir[self.strip(block.expr.ok_or(UNEXPECTED)?)].kind { - ExprKind::Block { block } => thir[*block].expr.ok_or(UNEXPECTED)?, - _ => return Err(UNEXPECTED.into()), - }; - let ExprKind::Call { args, .. } = &thir[self.strip(call)].kind else { - return Err(UNEXPECTED.into()); - }; - let template = self.byte_str(args[0]).ok_or(UNEXPECTED)?; - let span = self.span(id); - let mut parts = Vec::new(); - for piece in decode(&template)? { - match piece { - Piece::Lit(s) => parts.push(Expr::Str(s)), - Piece::Arg { index, spec } => { - let &(tr, field, ty) = placeholders.get(index).ok_or(UNEXPECTED)?; - let value = values.get(field).ok_or(UNEXPECTED)?.clone(); - let value = self.fmt_value(tr, ty, value, span, out); - parts.push(match spec.object() { - Some(spec) => Expr::rt("fmtSpec", vec![spec, value]), - None => value, - }); - } - } - } - Ok(parts) - } - - /// The index of `args.N`, a field of the tuple `var`, behind borrows and derefs. - fn tuple_field(&self, id: ExprId, var: rustc_middle::thir::LocalVarId) -> Option { - match &self.thir[self.strip(id)].kind { - ExprKind::Borrow { arg, .. } | ExprKind::Deref { arg } => self.tuple_field(*arg, var), - ExprKind::Field { lhs, name, .. } => match self.thir[self.strip(*lhs)].kind { - ExprKind::VarRef { id } if id == var => Some(name.index()), - _ => None, - }, - _ => None, - } - } - - /// The bytes of a byte string literal, behind borrows and derefs. - fn byte_str(&self, id: ExprId) -> Option> { - match &self.thir[self.strip(id)].kind { - ExprKind::Borrow { arg, .. } | ExprKind::Deref { arg } => self.byte_str(*arg), - ExprKind::Literal { lit, .. } => match &lit.node { - rustc_ast::LitKind::ByteStr(bytes, _) => Some(bytes.as_byte_str().to_vec()), - _ => None, - }, - _ => None, - } - } - /// `value`, a `ty`, written by `tr` to `f`, through the impl for `ty`. pub fn fmt_call(&mut self, tr: Trait, ty: Ty<'tcx>, value: Expr, f: Expr, span: Span) -> Expr { let tcx = self.t.tcx; @@ -256,7 +116,7 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { }; let args = tcx.mk_args(&[ty.into()]); let mut pre = Vec::new(); - let call = self.call_def(method, args, Args::Values(vec![value, f]), span, &mut pre); + let call = self.call_def(method, args, vec![value, f], span, &mut pre); match pre.is_empty() { true => call, false => self.err(span, format!("`{}` of `{ty}` needs statements", tr.name())), diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index 214bcdfb6..7562fc765 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -10,9 +10,9 @@ use rustc_span::Span; use super::Translator; use super::body::Body; -use super::library::{self, Args, Call, Std}; +use super::library::{self, Call, Std}; use super::num::Int; -use crate::ts::{Expr, Param, Stmt, Type}; +use crate::ts::{Expr, Param, Type}; /// `Iterator::next`, and the trait's `Item`. fn trait_items(tcx: ty::TyCtxt<'_>) -> Option<(DefId, DefId)> { @@ -185,8 +185,7 @@ pub fn call<'tcx>( call: &Call<'tcx>, owner: &str, name: &str, - args: Args<'_>, - out: &mut Vec, + mut args: Vec, ) -> Option { let tcx = b.t.tcx; let span = call.span; @@ -198,14 +197,14 @@ pub fn call<'tcx>( // Where iterators come from. match (owner, name) { ("slice", "iter" | "iter_mut") => { - return Some(Expr::rt("iterSlice", b.args(args, out))); + return Some(Expr::rt("iterSlice", args)); } ("Option", "iter" | "iter_mut") => { option_ok(b, targ(0)?, span); - return Some(Expr::rt("iterOption", b.args(args, out))); + return Some(Expr::rt("iterOption", args)); } ("IntoIterator", "into_iter") => { - let value = b.args(args, out).pop()?; + let value = args.pop()?; return into_iter(b, targ(0)?, value, span); } _ => {} @@ -213,10 +212,10 @@ pub fn call<'tcx>( match path.as_slice() { ["iter", "sources", "once", "once"] => { no_drops(b, targ(0)?, span); - return Some(Expr::rt("iterOnce", b.args(args, out))); + return Some(Expr::rt("iterOnce", args)); } ["iter", "sources", "empty", "empty"] => return Some(Expr::rt("iterEmpty", Vec::new())), - ["iter", "sources", "from_fn", "from_fn"] => return Some(Expr::rt("iterFromFn", b.args(args, out))), + ["iter", "sources", "from_fn", "from_fn"] => return Some(Expr::rt("iterFromFn", args)), _ => {} } @@ -229,7 +228,7 @@ pub fn call<'tcx>( if Std::of(tcx, adt.did()) != Some(Std::Vec) { return None; } - let [v, items] = <[Expr; 2]>::try_from(b.args(args, out)).ok()?; + let [v, items] = <[Expr; 2]>::try_from(args).ok()?; let mut items = into_iter(b, source, items, span)?; // `Extend<&T>` copies each element. if item != vec_args.type_at(0) && b.needs_copy(vec_args.type_at(0)) { @@ -256,7 +255,7 @@ pub fn call<'tcx>( if name != "by_ref" && !(name == "next" && own_next(b, self_ty).is_some()) { no_drops(b, item, span); } - let mut values = b.args(args, out).into_iter(); + let mut values = args.into_iter(); let recv = values.next()?; let rest: Vec = values.collect(); diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index 5f40d2a4f..1d26195be 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -6,11 +6,10 @@ //! function by its module (`mem::take`). use rustc_hir::def_id::DefId; -use rustc_middle::thir::{ExprId, ExprKind}; use rustc_middle::ty::{self, GenericArgsRef, Instance, Ty, TyCtxt}; use rustc_span::Span; -use super::body::{Body, Dest}; +use super::body::Body; use super::fmt; use super::num::{self, Int, Operand}; use crate::ts::{Expr, Stmt, StmtKind}; @@ -239,12 +238,6 @@ pub fn inherent_std(tcx: TyCtxt<'_>, def_id: DefId) -> Option { } } -/// A call's arguments: still THIR, or already lowered. -pub enum Args<'x> { - Thir(&'x [ExprId]), - Values(Vec), -} - pub struct Call<'tcx> { /// The function as written, before resolving a trait method to its impl. pub def_id: DefId, @@ -318,7 +311,7 @@ pub fn key(tcx: TyCtxt<'_>, def_id: DefId) -> Option<(String, String)> { Some((owner, name)) } -pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, out: &mut Vec) -> Option { +pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Vec, out: &mut Vec) -> Option { let tcx = b.t.tcx; // thiserror's `Display` derive reads each field through `AsDisplay`, which is the // field itself for anything but a path. @@ -326,7 +319,7 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, && tcx.item_name(call.def_id).as_str() == "as_display" && matches!(targ(call.args, 0).kind(), ty::Ref(..)) { - return b.args(args, out).pop(); + return args.into_iter().next_back(); } if !is_std(tcx, call.def_id) { return None; @@ -334,11 +327,11 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, let (owner, name) = key(tcx, call.def_id)?; let span = call.span; let gargs = call.args; - let args = match super::task::call(b, call, &owner, &name, args, out) { + let args = match super::task::call(b, call, &owner, &name, args) { Ok(e) => return e, Err(args) => args, }; - let args = match super::collections::call(b, call, &owner, &name, args, out) { + let mut args = match super::collections::call(b, call, &owner, &name, args, out) { Ok(e) => return e, Err(args) => args, }; @@ -363,21 +356,10 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, "wrapping_sub" => "wrappingSub", _ => return None, }; - if let ("from_be_bytes", Args::Thir([bytes])) = (name.as_str(), &args) { - return Some(from_be_bytes(b, int, *bytes, out)); - } - let values = b.args(args, out); - return Some(int.method(method, values)); + return Some(int.method(method, args)); } let self_ty = || gargs.types().next(); - let elem = |t: Ty<'tcx>| -> Option> { - match t.peel_refs().kind() { - ty::Slice(e) | ty::Array(e, _) => Some(*e), - ty::Adt(adt, args) if Std::of(tcx, adt.did()) == Some(Std::Vec) => Some(args.type_at(0)), - _ => None, - } - }; let is_u8 = |t: Ty<'tcx>| matches!(t.kind(), ty::Uint(ty::UintTy::U8)); let range = matches!(inherent_std(tcx, call.def_id), Some(Std::Range | Std::RangeInclusive)); // A range of integers, whose comparisons and clones JS makes as Rust does. @@ -393,7 +375,7 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, // Conversions. ("From", "from") => { let (to, from) = (targ(gargs, 0), targ(gargs, 1)); - let mut values = b.args(args, out); + let mut values = args; let value = values.pop()?; if to == from { return Some(value); @@ -411,7 +393,7 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, } ("Into", "into") => { let (from, to) = (targ(gargs, 0), targ(gargs, 1)); - let mut values = b.args(args, out); + let mut values = args; let value = values.pop()?; b.convert(value, from, to, span, out) } @@ -420,7 +402,7 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, let (Some(int), Some(_)) = (Int::of(to), Int::of(from)) else { return None; }; - let values = b.args(args, out); + let values = args; int.method("tryFrom", values) } @@ -441,23 +423,12 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, _ => rustc_middle::mir::BinOp::Shr, }; let (lty, rty) = (targ(gargs, 0), targ(gargs, 1)); - let consts = match &args { - Args::Thir(ids) => (b.const_int(ids[0]), b.const_int(ids[1])), - Args::Values(_) => (None, None), - }; - let values = b.args(args, out); - let [l, r] = <[Expr; 2]>::try_from(values).ok()?; + let [l, r] = <[Expr; 2]>::try_from(args).ok()?; num::binary( b, op, - Operand { - expr: l, - value: consts.0, - }, - Operand { - expr: r, - value: consts.1, - }, + Operand { expr: l, value: None }, + Operand { expr: r, value: None }, lty, rty, span, @@ -474,7 +445,7 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, "gt" => ">", _ => ">=", }; - let values = b.args(args, out); + let values = args; let [l, r] = <[Expr; 2]>::try_from(values).ok()?; match Int::of(targ(gargs, 0).peel_refs()) { Some(int) => int.compare(js, l, r), @@ -482,7 +453,7 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, } } ("Ord", "max" | "min") if let Some(int) = Int::of(targ(gargs, 0)) => { - let values = b.args(args, out); + let values = args; match int.big() { true => int.method(name.as_str(), values), false => Expr::rt(if name == "max" { "max" } else { "min" }, values), @@ -490,7 +461,7 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, } ("Clone", "clone") => { let ty = targ(gargs, 0); - let values = b.args(args, out); + let values = args; let value = values.into_iter().next()?; match ty.kind() { ty::Adt(adt, args) if Std::of(tcx, adt.did()) == Some(Std::Vec) && is_u8(args.type_at(0)) => { @@ -507,37 +478,30 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, ("Default", "default") => default_value(b, targ(gargs, 0))?, // Options. - ("Option", "map") => rt2(b, args, out, "option", "map"), - ("Option", "map_or") => rt2(b, args, out, "option", "mapOr"), - ("Option", "unwrap_or") => rt2(b, args, out, "option", "unwrapOr"), - ("Option", "ok_or") => rt2(b, args, out, "option", "okOr"), - ("Option", "unwrap") => rt2(b, args, out, "option", "unwrap"), - ("Option", "expect") => rt2(b, args, out, "option", "expect"), - ("Option", "is_some") => b.args(args, out).pop()?.binary("!==", Expr::undefined()), - ("Option", "is_none") => b.args(args, out).pop()?.binary("===", Expr::undefined()), - ("Option", "as_ref" | "as_mut") => b.args(args, out).pop()?, + ("Option", "map") => rt2(args, "option", "map"), + ("Option", "map_or") => rt2(args, "option", "mapOr"), + ("Option", "unwrap_or") => rt2(args, "option", "unwrapOr"), + ("Option", "ok_or") => rt2(args, "option", "okOr"), + ("Option", "unwrap") => rt2(args, "option", "unwrap"), + ("Option", "expect") => rt2(args, "option", "expect"), + ("Option", "is_some") => args.pop()?.binary("!==", Expr::undefined()), + ("Option", "is_none") => args.pop()?.binary("===", Expr::undefined()), + ("Option", "as_ref" | "as_mut") => args.pop()?, ("Option", "copied" | "cloned") => { let inner = targ(gargs, 0); - let value = b.args(args, out).pop()?; + let value = args.pop()?; b.copied(value, inner) } - ("Option", "take") => { - let Args::Thir(ids) = args else { - return None; - }; - let place = borrowed_place(b, ids[0], out)?; - swap_out(b, place, Expr::undefined(), "taken", out) - } // Results. - ("Result", "map") => rt2(b, args, out, "result", "map"), - ("Result", "map_err") => rt2(b, args, out, "result", "mapErr"), - ("Result", "and_then") => rt2(b, args, out, "result", "andThen"), - ("Result", "inspect_err") => rt2(b, args, out, "result", "inspectErr"), - ("Result", "is_ok") => b.args(args, out).pop()?.member("ok"), - ("Result", "is_err") => b.args(args, out).pop()?.member("ok").not(), - ("Result", "ok") => rt2(b, args, out, "result", "ok"), - ("Result", "err") => rt2(b, args, out, "result", "err"), + ("Result", "map") => rt2(args, "result", "map"), + ("Result", "map_err") => rt2(args, "result", "mapErr"), + ("Result", "and_then") => rt2(args, "result", "andThen"), + ("Result", "inspect_err") => rt2(args, "result", "inspectErr"), + ("Result", "is_ok") => args.pop()?.member("ok"), + ("Result", "is_err") => args.pop()?.member("ok").not(), + ("Result", "ok") => rt2(args, "result", "ok"), + ("Result", "err") => rt2(args, "result", "err"), // Their panics show the other side with its `Debug`. ("Result", "unwrap" | "expect" | "unwrap_err") => { let (method, shown) = match name.as_str() { @@ -545,16 +509,16 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, "expect" => ("expect", targ(gargs, 1)), _ => ("unwrapErr", targ(gargs, 0)), }; - let mut values = b.args(args, out); + let mut values = args; values.push(b.fmt_fn(fmt::Trait::Debug, shown, span)); Expr::rt_of("result", method).call(values) } - ("Result", "unwrap_or") => rt2(b, args, out, "result", "unwrapOr"), + ("Result", "unwrap_or") => rt2(args, "result", "unwrapOr"), // Ranges, which are their own iterators. // An integer range wraps within its type's bounds where std's `nth` does. ("RangeInclusive", "new") if range => { - let mut values = b.args(args, out); + let mut values = args; values.extend(self_ty().and_then(Int::of).map(|int| int.func("step"))); Expr::New(Box::new(Expr::Rt("RangeInclusive".into())), values) } @@ -563,53 +527,32 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, if range && (matches!(name.as_str(), "start" | "end") || self_ty().and_then(Int::of).is_some()) => { let of = range_of(inherent_std(tcx, call.def_id)?)?; - Expr::rt_of(of, &super::camel(&name)).call(b.args(args, out)) + Expr::rt_of(of, &super::camel(&name)).call(args) } ("bool", "then_some") => { - let values = b.args(args, out); + let values = args; Expr::rt("thenSome", values) } // Slices. - ("slice", "len") => b.args(args, out).pop()?.member("length"), - ("slice", "is_empty") => b.args(args, out).pop()?.member("length").binary("===", Expr::lit("0")), - ("slice", "split_first") => rt2(b, args, out, "slice", "splitFirst"), - ("slice", "split_at") => rt2(b, args, out, "slice", "splitAt"), - ("slice", "split_at_checked") => rt2(b, args, out, "slice", "splitAtChecked"), - ("slice", "first") => rt2(b, args, out, "slice", "first"), - ("slice", "get") if Int::of(targ(gargs, 1)).is_some() => rt2(b, args, out, "slice", "get"), + ("slice", "len") => args.pop()?.member("length"), + ("slice", "is_empty") => args.pop()?.member("length").binary("===", Expr::lit("0")), + ("slice", "split_first") => rt2(args, "slice", "splitFirst"), + ("slice", "split_at") => rt2(args, "slice", "splitAt"), + ("slice", "split_at_checked") => rt2(args, "slice", "splitAtChecked"), + ("slice", "first") => rt2(args, "slice", "first"), + ("slice", "get") if Int::of(targ(gargs, 1)).is_some() => rt2(args, "slice", "get"), ("slice", "split_first_chunk") => { let n = gargs.consts().next()?.try_to_target_usize(tcx)?; - let mut values = b.args(args, out); + let mut values = args; values.push(Expr::lit(n.to_string())); Expr::rt("sliceSplitFirstChunk", values) } - ("slice", "copy_from_slice") if is_u8(targ(gargs, 0)) => rt2(b, args, out, "slice", "copyFromSlice"), - ("slice", "copy_within") if is_u8(targ(gargs, 0)) => { - let Args::Thir(ids) = args else { - return None; - }; - let mut s = [b.operand(ids[0], out)]; - let (start, end) = range_bounds(b, &mut s, ids[1], out)?; - let [s] = s; - let (s, end) = match end { - Some(end) => (s, end), - None => { - let s = path(b, s, "slice", out); - (s.clone(), s.member("length")) - } - }; - let mut pre = Vec::new(); - let dest = b.operand(ids[2], &mut pre); - let mut values = vec![s, start, end]; - b.after(&mut values, pre, out); - values.push(dest); - Expr::rt("sliceCopyWithin", values) - } + ("slice", "copy_from_slice") if is_u8(targ(gargs, 0)) => rt2(args, "slice", "copyFromSlice"), ("slice", "to_vec") => { let elem = targ(gargs, 0); - let values = b.args(args, out); + let values = args; match is_u8(elem) { true => Expr::rt("sliceToByteVec", values), false if b.t.is_copy(elem) => Expr::rt("sliceToVec", values), @@ -619,16 +562,16 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, ("slice", "into_vec") => { // `vec![..]`: `<[T]>::into_vec(box_new([..]))`. let elem = targ(gargs, 0); - let value = b.args(args, out).pop()?; + let value = args.pop()?; match is_u8(elem) { true => Expr::rt("byteVecFrom", vec![value]), false => value, } } - ("boxed", "box_new") | ("Box", "new") => b.args(args, out).pop()?, + ("boxed", "box_new") | ("Box", "new") => args.pop()?, ("vec", "from_elem") => { let elem = targ(gargs, 0); - let values = b.args(args, out); + let values = args; match is_u8(elem) { true => Expr::rt("byteVecOf", values), false if b.t.is_copy(elem) => { @@ -658,14 +601,11 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, false => Expr::Array(Vec::new()), }, ("Vec", "with_capacity") => match is_u8(targ(gargs, 0)) { - true => Expr::New(Box::new(Expr::Rt("ByteVec".into())), b.args(args, out)), - false => { - b.args(args, out); - Expr::Array(Vec::new()) - } + true => Expr::New(Box::new(Expr::Rt("ByteVec".into())), args), + false => Expr::Array(Vec::new()), }, ("Vec", "push") => { - let mut values = b.args(args, out); + let mut values = args; match is_u8(targ(gargs, 0)) { true => Expr::rt("byteVecPush", values), false => { @@ -675,21 +615,21 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, } } ("Vec", "pop") => match is_u8(targ(gargs, 0)) { - true => Expr::rt("byteVecPop", b.args(args, out)), - false => b.args(args, out).pop()?.method("pop", vec![]), + true => Expr::rt("byteVecPop", args), + false => args.pop()?.method("pop", vec![]), }, - ("Vec", "len") => b.args(args, out).pop()?.member("length"), - ("Vec", "is_empty") => b.args(args, out).pop()?.member("length").binary("===", Expr::lit("0")), - ("Vec", "truncate") if is_u8(targ(gargs, 0)) => Expr::rt("byteVecTruncate", b.args(args, out)), - ("Vec", "clear") if is_u8(targ(gargs, 0)) => Expr::rt("byteVecClear", b.args(args, out)), - ("Vec", "extend_from_slice") if is_u8(targ(gargs, 0)) => Expr::rt("byteVecExtendFromSlice", b.args(args, out)), + ("Vec", "len") => args.pop()?.member("length"), + ("Vec", "is_empty") => args.pop()?.member("length").binary("===", Expr::lit("0")), + ("Vec", "truncate") if is_u8(targ(gargs, 0)) => Expr::rt("byteVecTruncate", args), + ("Vec", "clear") if is_u8(targ(gargs, 0)) => Expr::rt("byteVecClear", args), + ("Vec", "extend_from_slice") if is_u8(targ(gargs, 0)) => Expr::rt("byteVecExtendFromSlice", args), ("Vec", "as_slice" | "as_mut_slice") => { - let v = b.args(args, out).pop()?; + let v = args.pop()?; vec_view(v, targ(gargs, 0)) } ("Deref", "deref") | ("DerefMut", "deref_mut") => { let ty = targ(gargs, 0); - let v = b.args(args, out).pop()?; + let v = args.pop()?; match ty.kind() { ty::Adt(adt, _) => match Std::of(tcx, adt.did()) { Some(Std::Vec) => vec_view(v, ty), @@ -699,100 +639,29 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, _ => return None, } } - ("Index", "index") | ("IndexMut", "index_mut") => { - let Args::Thir(ids) = args else { - return None; - }; - let container = targ(gargs, 0); - let index_ty = targ(gargs, 1); - let elem_ty = elem(container)?; - let base = b.operand(ids[0], out); - let base = match container.kind() { - ty::Adt(..) => vec_view(base, container), - _ => base, - }; - match Int::of(index_ty) { - Some(_) => { - let mut pre = Vec::new(); - let i = b.operand(ids[1], &mut pre); - let mut base = [base]; - b.after(&mut base, pre, out); - let [base] = base; - match name.as_str() { - "index" => Expr::rt("at", vec![base, i]), - _ => { - let base = path(b, base, "slice", out); - let i = path(b, i, "index", out); - base.clone().index(Expr::rt("idx", vec![base, i])) - } - } - } - None => { - if name == "index_mut" && !is_u8(elem_ty) { - // A JS array has no views, so a mutable subslice would be a copy. - return None; - } - let mut base = [base]; - let (start, end) = range_bounds(b, &mut base, ids[1], out)?; - let [base] = base; - let mut values = vec![base, start]; - values.extend(end); - Expr::rt("sliceRange", values) - } - } - } // Strings. - ("String" | "str", "as_bytes") => Expr::rt("stringAsBytes", b.args(args, out)), - ("String", "from_utf8") => Expr::rt("stringFromUtf8", b.args(args, out)), - ("String" | "str", "len") => Expr::rt("stringLen", b.args(args, out)), - ("String", "as_str") => b.args(args, out).pop()?, + ("String" | "str", "as_bytes") => Expr::rt("stringAsBytes", args), + ("String", "from_utf8") => Expr::rt("stringFromUtf8", args), + ("String" | "str", "len") => Expr::rt("stringLen", args), + ("String", "as_str") => args.pop()?, ("String", "new") => Expr::Str(String::new()), ("ToString", "to_string") | ("ToOwned", "to_owned") if matches!(self_ty()?.peel_refs().kind(), ty::Str) => { - b.args(args, out).pop()? - } - - // Moving out of a place. - ("mem", "take") => { - let Args::Thir(ids) = args else { - return None; - }; - let ty = targ(gargs, 0); - let place = borrowed_place(b, ids[0], out)?; - let default = default_value(b, ty)?; - swap_out(b, place, default, "taken", out) - } - ("mem", "replace") => { - let Args::Thir(ids) = args else { - return None; - }; - let place = borrowed_place(b, ids[0], out)?; - let value = b.operand(ids[1], out); - swap_out(b, place, value, "old", out) - } - ("mem", "swap") => { - let Args::Thir(ids) = args else { - return None; - }; - let a = borrowed_place(b, ids[0], out)?; - let c = borrowed_place(b, ids[1], out)?; - let old = swap_out(b, a.clone(), c.clone(), "swapped", out); - out.push(StmtKind::Expr(c.assign(old)).at(None)); - Expr::undefined() + args.pop()? } // Panics, which format their message as std does. ("panicking", "panic_fmt") => { - let message = b.args(args, out).pop()?; + let message = args.pop()?; match literal(&message) { Some(s) => Expr::rt("panic", vec![Expr::Str(s)]), None => Expr::rt("panicFmt", vec![message]), } } - ("panicking", "panic") | ("rt", "begin_panic") => Expr::rt("panic", b.args(args, out)), + ("panicking", "panic") | ("rt", "begin_panic") => Expr::rt("panic", args), ("panicking", "panic_explicit") => Expr::rt("panic", vec![Expr::Str("explicit panic".into())]), ("panicking", "panic_display" | "unreachable_display") => { - let value = b.args(args, out).pop()?; + let value = args.pop()?; let value = b.fmt_value(fmt::Trait::Display, targ(gargs, 0), value, span, out); let mut message = vec![value]; if name == "unreachable_display" { @@ -802,7 +671,7 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, } // `assert_eq!` and `assert_ne!`: the operator, both sides, and any message. ("panicking", "assert_failed") => { - let [kind, left, right, message] = <[Expr; 4]>::try_from(b.args(args, out)).ok()?; + let [kind, left, right, message] = <[Expr; 4]>::try_from(args).ok()?; let left = b.fmt_value(fmt::Trait::Debug, targ(gargs, 0), left, span, out); let right = b.fmt_value(fmt::Trait::Debug, targ(gargs, 1), right, span, out); let mut values = vec![kind, left, right]; @@ -813,9 +682,9 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, } // Formatting. - ("hint", "must_use") => b.args(args, out).pop()?, + ("hint", "must_use") => args.pop()?, ("fmt", "format") => { - let parts = b.args(args, out).pop()?; + let parts = args.pop()?; match literal(&parts) { Some(s) => Expr::Str(s), None => Expr::rt("fmtFormat", vec![parts]), @@ -823,12 +692,12 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, } ("Display" | "Debug" | "LowerHex" | "UpperHex", "fmt") => { let tr = fmt::Trait::of(tcx, tcx.trait_of_assoc(call.def_id)?)?; - let [value, f] = <[Expr; 2]>::try_from(b.args(args, out)).ok()?; + let [value, f] = <[Expr; 2]>::try_from(args).ok()?; fmt::std_impl(b, tr, targ(gargs, 0), value, f, span, out)? } ("ToString", "to_string") => { let ty = targ(gargs, 0); - let value = b.args(args, out).pop()?; + let value = args.pop()?; match ty.kind() { ty::Adt(adt, _) if Std::of(tcx, adt.did()) == Some(Std::String) => value, _ => { @@ -838,7 +707,7 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, } } ("Formatter", "write_fmt") => { - let [f, parts] = <[Expr; 2]>::try_from(b.args(args, out)).ok()?; + let [f, parts] = <[Expr; 2]>::try_from(args).ok()?; match literal(&parts) { Some(s) => Expr::rt("fmtWriteStr", vec![f, Expr::Str(s)]), None => Expr::rt("fmtWriteFmt", vec![f, parts]), @@ -854,13 +723,13 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, "DebugTuple" => "debugTuple", _ => "debugList", }; - Expr::rt_of(of, &super::camel(&name)).call(b.args(args, out)) + Expr::rt_of(of, &super::camel(&name)).call(args) } // Derived `Debug`: `debug_struct_field2_finish(f, name, "a", &a, "b", &b)`. - ("Formatter", "debug_struct_fields_finish") => Expr::rt("fmtDebugStructFields", b.args(args, out)), - ("Formatter", "debug_tuple_fields_finish") => Expr::rt("fmtDebugTupleFields", b.args(args, out)), + ("Formatter", "debug_struct_fields_finish") => Expr::rt("fmtDebugStructFields", args), + ("Formatter", "debug_tuple_fields_finish") => Expr::rt("fmtDebugTupleFields", args), ("Formatter", n) if n.starts_with("debug_struct_field") || n.starts_with("debug_tuple_field") => { - let mut values = b.args(args, out).into_iter(); + let mut values = args.into_iter(); let (f, type_name) = (values.next()?, values.next()?); let structure = n.starts_with("debug_struct"); let (of, start) = match structure { @@ -878,16 +747,7 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, } Expr::rt_of(of, "finish").call(vec![builder]) } - ("DebugList", "entries") => { - let Args::Thir(ids) = args else { - return None; - }; - let list = b.operand(ids[0], out); - let items = items(b, ids[1], out)?; - let debug = b.fmt_fn(fmt::Trait::Debug, targ(gargs, 0), span); - Expr::rt("debugListEntries", vec![list, items, debug]) - } - _ => return super::iter::call(b, call, &owner, &name, args, out), + _ => return super::iter::call(b, call, &owner, &name, args), }; if let Some(ty) = dropping { return Some(b.err( @@ -898,22 +758,6 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, Some(e) } -/// `int::from_be_bytes(bytes)`. A number from an array written in place is its bytes -/// shifted and or-ed, with no array made. Otherwise the runtime reads the array the -/// argument names, uncopied, since the read neither keeps nor changes it. -fn from_be_bytes<'tcx>(b: &mut Body<'_, '_, 'tcx>, int: Int, bytes: ExprId, out: &mut Vec) -> Expr { - let thir = b.thir; - let fields = match &thir[b.strip(bytes)].kind { - ExprKind::Array { fields } if !int.big() => fields, - _ => { - let value = b.place(bytes, out); - return int.method("fromBeBytes", vec![value]); - } - }; - let values = b.operands(fields, out); - be_word(int, values) -} - /// A number from its big-endian bytes, each a value: shifted and or-ed. pub fn be_word(int: Int, values: Vec) -> Expr { let last = values.len() - 1; @@ -952,9 +796,8 @@ pub fn targ<'tcx>(gargs: GenericArgsRef<'tcx>, n: usize) -> Ty<'tcx> { } /// `rt.(args)`. -fn rt2<'tcx>(b: &mut Body<'_, '_, 'tcx>, args: Args<'_>, out: &mut Vec, of: &str, name: &str) -> Expr { - let values = b.args(args, out); - Expr::rt_of(of, name).call(values) +fn rt2(args: Vec, of: &str, name: &str) -> Expr { + Expr::rt_of(of, name).call(args) } /// What the runtime's functions of a std range type start with. @@ -1011,95 +854,6 @@ impl MethodCall for Expr { } } -fn path<'tcx>(b: &mut Body<'_, '_, 'tcx>, value: Expr, base: &str, out: &mut Vec) -> Expr { - if value.is_path() { - return value; - } - let name = b.fresh(base); - out.push(StmtKind::decl(false, name.clone(), None, Some(value)).at(None)); - Expr::ident(name) -} - -/// The start and optional end of a range written in place: `a..b`, `..b`, `a..`, `..`. -/// `earlier` are the operands evaluated before it, spilled if the range needs statements. -fn range_bounds<'tcx>( - b: &mut Body<'_, '_, 'tcx>, - earlier: &mut [Expr], - id: ExprId, - out: &mut Vec, -) -> Option<(Expr, Option)> { - let tcx = b.t.tcx; - let written = id; - let id = b.strip(id); - let ty = b.ty_of(id); - let ty::Adt(adt, _) = ty.kind() else { - return None; - }; - let name = tcx.item_name(adt.did()).to_string(); - let mut pre = Vec::new(); - let mut values: Vec = match &b.thir[id].kind { - // `..` has no bounds, but what makes it still runs. - _ if name == "RangeFull" => { - b.stmt(written, Dest::Discard, &mut pre); - Vec::new() - } - ExprKind::Adt(range) => { - b.visit(written); - let values = b.written(range, ty, b.thir[id].span, &mut pre); - b.declared(values, &mut pre).into_iter().map(|(_, v)| v).collect() - } - _ => return None, - }; - b.after(earlier, pre, out); - match name.as_str() { - "Range" => { - let end = values.pop()?; - let start = values.pop()?; - Some((start, Some(end))) - } - "RangeTo" => Some((Expr::lit("0"), values.pop())), - "RangeFrom" => Some((values.pop()?, None)), - "RangeFull" => Some((Expr::lit("0"), None)), - _ => None, - } -} - -/// The place behind `&mut place`, as an assignable path. -fn borrowed_place<'tcx>(b: &mut Body<'_, '_, 'tcx>, id: ExprId, out: &mut Vec) -> Option { - let written = id; - let id = b.strip(id); - let ExprKind::Borrow { mut arg, .. } = b.thir[id].kind else { - return None; - }; - // A reborrow, `&mut *&mut place`. - while let ExprKind::Deref { arg: inner } = b.thir[b.strip(arg)].kind - && let ExprKind::Borrow { arg: place, .. } = b.thir[b.strip(inner)].kind - { - arg = place; - } - // The path to `*r` is `r` itself: assigning it would rebind the reference. - if let ExprKind::Deref { arg: pointer } = b.thir[b.strip(arg)].kind - && matches!(b.ty_of(pointer).kind(), ty::Ref(..)) - { - let pointee = b.ty_of(arg); - return Some(b.err( - b.thir[arg].span, - format!("replacing the value behind a reference to `{pointee}`"), - )); - } - b.visit(written); - let place = b.place(arg, out); - place.is_path().then_some(place) -} - -/// The value at `place`, after setting `place` to `value`. -pub fn swap_out<'tcx>(b: &mut Body<'_, '_, 'tcx>, place: Expr, value: Expr, base: &str, out: &mut Vec) -> Expr { - let name = b.fresh(base); - out.push(StmtKind::decl(false, name.clone(), None, Some(place.clone())).at(None)); - out.push(StmtKind::Expr(place.assign(value)).at(None)); - Expr::ident(name) -} - /// `Default::default()` for a standard type. pub fn default_value<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>) -> Option { let tcx = b.t.tcx; @@ -1140,38 +894,3 @@ pub fn literal(parts: &Expr) -> Option { }) .collect() } - -/// The slice `id` iterates if it is `<[T]>::iter(slice)`, which iterates as the JS array -/// or `Uint8Array` itself does. -pub fn iterated_slice(b: &Body<'_, '_, '_>, id: ExprId) -> Option { - let ExprKind::Call { ty: fn_ty, args, .. } = &b.thir[b.strip(id)].kind else { - return None; - }; - let ty::FnDef(iter, _) = *b.subst(*fn_ty).kind() else { - return None; - }; - (key(b.t.tcx, iter) == Some(("slice".into(), "iter".into()))).then(|| args[0]) -} - -/// What an `IntoIterator` iterates, as an iterable JS value: a slice, array, or `Vec` -/// itself, by value or by reference, or else an `rt.Iter`. -fn items<'tcx>(b: &mut Body<'_, '_, 'tcx>, id: ExprId, out: &mut Vec) -> Option { - let tcx = b.t.tcx; - if let Some(slice) = iterated_slice(b, id) { - b.visit(id); - return Some(b.operand(slice, out)); - } - let id = b.strip(id); - let ty = b.ty_of(id); - match ty.peel_refs().kind() { - ty::Slice(_) | ty::Array(..) => Some(b.operand(id, out)), - ty::Adt(adt, _) if Std::of(tcx, adt.did()) == Some(Std::Vec) => { - let v = b.operand(id, out); - Some(vec_view(v, ty)) - } - _ => { - let value = b.operand(id, out); - super::iter::into_iter(b, ty, value, b.span(id)) - } - } -} diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index ddab459e2..4643883a1 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -10,7 +10,7 @@ use rustc_span::{Span, Spanned}; use super::{Fx, Slot}; use crate::lower::fmt::{self, Piece}; -use crate::lower::library::{self, Args, Std}; +use crate::lower::library::{self, Std}; use crate::lower::num::Int; use crate::ts::{Expr, Stmt, StmtKind}; @@ -39,15 +39,29 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { { let name = name.to_string(); self.assigned[dest.local] = true; - self.range_next(name, recv, &mut pre); + let stepped = match &args[0].node { + Operand::Copy(p) | Operand::Move(p) => { + p.as_local().is_some_and(|b| self.stepped_borrows.contains_key(&b)) + } + Operand::Constant(_) | Operand::RuntimeChecks(_) => false, + }; + let read = self.uses[dest.local] > 1; + let held = self.range_next(name, recv, stepped, read, &mut pre); self.emit(pre, None, false, out); + if let Some((flag, more)) = held { + self.hold_flag(flag, more); + } return; } if let Some(name) = self.var(dest.local) { let name = name.to_string(); self.next_names.insert(name); } - (crate::lower::iter::next(self.b, iter_ty, recv), true) + if self.stepped_array(&args[0].node) { + (self.stepped_next(&recv), true) + } else { + (crate::lower::iter::next(self.b, iter_ty, recv), true) + } } ty::FnDef(def_id, gargs) => match self.intercept(def_id, gargs.skip_binder(), args, dest, span, &mut pre) { Some(Some(done)) => done, @@ -65,6 +79,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } _ => (self.err(span, format!("a call through `{fn_ty}`")), true), }; + let value = match dest.as_local() { + Some(local) if self.stepped.contains(&local) => self.stepped_make(value, span), + _ => value, + }; let value = match self.b.t.loc(span) { Some(loc) if effect => Expr::Located(loc, Box::new(value)), _ => value, @@ -150,9 +168,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } }; if let ty::FnDef(inner, inner_args) = *callee_ty.peel_refs().kind() { - return self - .b - .call_def(inner, inner_args.skip_binder(), Args::Values(values), span, out); + return self.b.call_def(inner, inner_args.skip_binder(), values, span, out); } let f = self.operand(&callee.node, span, out); return f.call(values); @@ -168,7 +184,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } } let values = self.operands(args, span, out); - self.b.call_def(def_id, gargs, Args::Values(values), span, out) + self.b.call_def(def_id, gargs, values, span, out) } /// Refuse a `&mut` to a value JS copies, passed on whole to code that could write @@ -272,23 +288,26 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { // `format_args!`, as MIR builds it: each argument a function writing its value, // and a template of literal pieces and placeholders. ("Argument", name) if name.starts_with("new_") || name == "from_usize" => { - let tr = match name { - "new_display" => fmt::Trait::Display, - "new_debug" => fmt::Trait::Debug, - "new_lower_hex" => fmt::Trait::LowerHex, - "new_upper_hex" => fmt::Trait::UpperHex, - "from_usize" => { - self.err(span, format!("{} is not supported", fmt::FROM_ARGUMENT)); - return done(Expr::undefined(), false); - } - other => { - self.err(span, format!("formatting by `{other}` is not supported")); + let tr = match fmt::argument(name) { + Ok(tr) => tr, + Err(construct) => { + self.err(span, format!("{construct} is not supported")); return done(Expr::undefined(), false); } }; let ty = targ(0)?; let value = self.operand(&args[0].node, span, out); - let value = self.path(value, "arg", out); + // The function reads it later, in a closure, where TypeScript no longer + // narrows a member of a union: a member is read now, into a name. + let value = match value { + Expr::Member(..) | Expr::Index(..) => { + let name = self.b.fresh("arg"); + let stmt = StmtKind::decl(false, name.clone(), None, Some(value)).at(None); + self.emit(vec![stmt], None, false, out); + Expr::ident(name) + } + value => self.path(value, "arg", out), + }; done(self.b.fmt_value(tr, ty, value, span, out), false) } ("Arguments", "from_str" | "from_str_nonconst") => { @@ -361,20 +380,42 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let to = targ(0)?; let residual = targ(1)?; let value = self.operand(&args[0].node, span, out); - match (self.b.t.std_of(to), to.kind(), residual.kind()) { + // What a `Result` residual goes into: a `Result`, or one that is ready, which + // is the same value. + let result = match (self.b.t.std_of(to), to.kind()) { + (Some(Std::Result), _) => Some(to), + (Some(Std::Poll), ty::Adt(_, poll_args)) => { + let inner = poll_args.type_at(0); + (self.b.t.std_of(inner) == Some(Std::Result)).then_some(inner) + } + _ => None, + }; + match (self.b.t.std_of(to), result.map(|r| r.kind()), residual.kind()) { (Some(Std::Option), ..) => done(Expr::undefined(), false), - (Some(Std::Result), ty::Adt(_, to_args), ty::Adt(_, from_args)) => { + (_, Some(ty::Adt(_, to_args)), ty::Adt(_, from_args)) + if self.b.t.std_of(residual) == Some(Std::Result) => + { let (from, to) = (from_args.type_at(1), to_args.type_at(1)); if from == to { return done(value, false); } - let value = self.path(value, "residual", out); - // The residual is an `Err`. - let err = crate::ts::Type::Object(vec![ - ("ok".into(), crate::ts::Type::Builtin("false")), - ("error".into(), self.b.t.ty(from, span)), - ]); - let error = Expr::As(Box::new(value), err).member("error"); + let error = match value { + // Made in place: its error. + Expr::Call(f, mut items) + if matches!(&*f, Expr::Rt(n) if n == "Err") && items.len() == 1 => + { + items.pop().expect("checked above") + } + value => { + let value = self.path(value, "residual", out); + // The residual is an `Err`. + let err = crate::ts::Type::Object(vec![ + ("ok".into(), crate::ts::Type::Builtin("false")), + ("error".into(), self.b.t.ty(from, span)), + ]); + Expr::As(Box::new(value), err).member("error") + } + }; let converted = self.b.convert(error, from, to, span, out); done(Expr::rt("Err", vec![converted]), true) } @@ -432,12 +473,34 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { /// `name = recv.next()` of a range of numbers, stepped in place rather than through /// `rt.Range`'s generic steps, into the item alone and a flag for whether there was /// one: a number that is sometimes `rt.DONE` is slower in V8. Past the end, `name` is - /// left as it was, since only `Some` reads it. - fn range_next(&mut self, name: String, recv: Expr, out: &mut Vec) { - let range = self.path(recv, "range", out); - let start = range.clone().member("start"); + /// left as it was, since only `Some` reads it. A range only `next` reads (`stepped`) + /// steps past its end too, so the flag is one comparison, to hold back for the switch + /// that reads it; it assigns `name` only if something reads it (`read`). + fn range_next( + &mut self, + name: String, + recv: Expr, + stepped: bool, + read: bool, + out: &mut Vec, + ) -> Option<(String, Expr)> { + let range = match recv { + Expr::Object(_) => recv, + recv => self.path(recv, "range", out), + }; + let start = super::step::stepped_field(&range, "start"); + let end = super::step::stepped_field(&range, "end"); let flag = self.b.fresh(&format!("{name}Some")); - let more = start.clone().binary("<", range.member("end")); + self.range_flags.insert(name.clone(), flag.clone()); + if stepped { + let step = Expr::Postfix(Box::new(start), "++"); + let item = match read { + true => Expr::ident(&name).assign(step), + false => step, + }; + return Some((flag, item.binary("<", end))); + } + let more = start.clone().binary("<", end); out.push(StmtKind::Expr(Expr::ident(&flag).assign(more)).at(None)); let step = Expr::ident(&name).assign(Expr::Postfix(Box::new(start), "++")); out.push( @@ -448,7 +511,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } .at(None), ); - self.range_flags.insert(name, flag); + None } /// The value at `place`, after setting `place` to `value`. diff --git a/ts/src/lower/mir/cfg.rs b/ts/src/lower/mir/cfg.rs index 8ccd718b9..6802fc6a6 100644 --- a/ts/src/lower/mir/cfg.rs +++ b/ts/src/lower/mir/cfg.rs @@ -395,10 +395,6 @@ pub fn simplify(stmts: &mut Vec) { cases.iter_mut().for_each(|(_, body)| simplify(body)); simplify(default); } - StmtKind::Try { body, finally } => { - simplify(body); - simplify(finally); - } StmtKind::Catch { body, handler, .. } => { simplify(body); simplify(handler); @@ -478,13 +474,23 @@ fn strip_tail(stmts: &mut Vec, jump: &StmtKind) { strip_tail(els, jump); } StmtKind::Block { body, .. } => strip_tail(body, jump), + // Falling off the `try` goes past its `catch`. + StmtKind::Catch { body, .. } => strip_tail(body, jump), _ => {} } } +/// Drop the `return;`s a function returning nothing ends with. +pub fn strip_return(stmts: &mut Vec) { + strip_tail(stmts, &StmtKind::Return(None)); + simplify(stmts); + simplify(stmts); +} + fn same_jump(a: &StmtKind, b: &StmtKind) -> bool { match (a, b) { (StmtKind::Break(x), StmtKind::Break(y)) | (StmtKind::Continue(x), StmtKind::Continue(y)) => x == y, + (StmtKind::Return(None), StmtKind::Return(None)) => true, _ => false, } } @@ -494,11 +500,7 @@ fn targets(stmts: &[Stmt], label: &str) -> bool { stmts.iter().any(|stmt| match &stmt.kind { StmtKind::Break(Some(l)) | StmtKind::Continue(Some(l)) => l == label, StmtKind::If { then, els, .. } => targets(then, label) || targets(els, label), - StmtKind::Block { body, .. } - | StmtKind::While { body, .. } - | StmtKind::ForRange { body, .. } - | StmtKind::ForOf { body, .. } => targets(body, label), - StmtKind::Try { body, finally } => targets(body, label) || targets(finally, label), + StmtKind::Block { body, .. } | StmtKind::While { body, .. } => targets(body, label), StmtKind::Catch { body, handler, .. } => targets(body, label) || targets(handler, label), StmtKind::Switch { cases, default, .. } => { cases.iter().any(|(_, body)| targets(body, label)) || targets(default, label) diff --git a/ts/src/lower/mir/coroutine.rs b/ts/src/lower/mir/coroutine.rs index f8292873f..f1b1acbb7 100644 --- a/ts/src/lower/mir/coroutine.rs +++ b/ts/src/lower/mir/coroutine.rs @@ -154,7 +154,7 @@ pub fn info<'tcx>(t: &mut Translator<'_, 'tcx>, def_id: DefId, args: GenericArgs }); if let Some(mir) = super::instance_mir(t, instance, span) { let ret = mir.return_ty(); - let mut b = Body::detached(t, args, ret); + let mut b = Body::new(t, args); let mut fx = Fx::new(&mut b, &mir, Env::Coroutine, span); let params = fx.params(); let body = fx.lower(); @@ -167,7 +167,6 @@ pub fn info<'tcx>(t: &mut Translator<'_, 'tcx>, def_id: DefId, args: GenericArgs body, loc, doc: None, - generator: false, }); } // `[Symbol.dispose]`: the drop, by the state it is in. @@ -190,7 +189,7 @@ pub fn info<'tcx>(t: &mut Translator<'_, 'tcx>, def_id: DefId, args: GenericArgs t.typing_env_pub(), EarlyBinder::bind(tcx, drop), ); - let mut b = Body::detached(t, args, tcx.types.unit); + let mut b = Body::new(t, args); let mut fx = Fx::new(&mut b, &mir, Env::Coroutine, span); fx.lower() } @@ -203,7 +202,6 @@ pub fn info<'tcx>(t: &mut Translator<'_, 'tcx>, def_id: DefId, args: GenericArgs body, loc: None, doc: None, - generator: false, }); info } diff --git a/ts/src/lower/mir/glue.rs b/ts/src/lower/mir/glue.rs index 3d45b028f..68288bbca 100644 --- a/ts/src/lower/mir/glue.rs +++ b/ts/src/lower/mir/glue.rs @@ -21,7 +21,7 @@ pub fn shim<'tcx>(t: &mut Translator<'_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Opt return None; } let structural = match ty.kind() { - ty::Tuple(_) | ty::Closure(..) => true, + ty::Tuple(_) => true, ty::Adt(adt, _) => adt.is_enum(), _ => false, }; @@ -45,7 +45,7 @@ pub fn shim<'tcx>(t: &mut Translator<'_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Opt let body = tcx.instance_mir(instance.def).clone(); let mir = instance.instantiate_mir_and_normalize_erasing_regions(tcx, t.typing_env_pub(), EarlyBinder::bind(tcx, body)); - let mut b = Body::detached(t, instance.args, tcx.types.unit); + let mut b = Body::new(t, instance.args); let mut fx = Fx::new(&mut b, &mir, Env::Shim, span); let params = fx.params(); let body = fx.lower(); @@ -64,7 +64,6 @@ pub fn shim<'tcx>(t: &mut Translator<'_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Opt body, loc: None, doc: None, - generator: false, })); Some(sym) } diff --git a/ts/src/lower/mir/mod.rs b/ts/src/lower/mir/mod.rs index 04d48a18d..184fb279c 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -1,4 +1,4 @@ -//! Function bodies from MIR: the spike's prototype, beside the THIR lowering in `body`. +//! Function bodies, from MIR. //! //! MIR is each body's control-flow graph after borrow checking. Every drop is a //! terminator where drop elaboration put it, with a flag wherever a value is moved on @@ -7,8 +7,8 @@ //! with each temporary that is assigned once and read once folded back into the //! expression that reads it, unless that would reorder an effect. //! -//! Library calls go through the THIR lowering's mappings, which take their arguments -//! lowered: a detached `Body` holds the names, and its translator everything else. +//! Library calls go through the mappings in `library`, which take their arguments +//! lowered: a `Body` holds the names, and its translator everything else. mod call; mod cfg; @@ -16,6 +16,7 @@ pub mod coroutine; pub mod glue; mod place; mod rvalue; +mod step; mod unwind; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; @@ -41,7 +42,7 @@ pub fn function<'a, 'tcx>(t: &mut Translator<'a, 'tcx>, instance: Instance<'tcx> super::iter::check_impl(t, def_id); } let ret_ty = mir.return_ty(); - let mut b = Body::detached(t, instance.args, ret_ty); + let mut b = Body::new(t, instance.args); let mut fx = Fx::new(&mut b, &mir, Env::Plain, span); let params = fx.params(); let body = fx.lower(); @@ -56,7 +57,6 @@ pub fn function<'a, 'tcx>(t: &mut Translator<'a, 'tcx>, instance: Instance<'tcx> body, loc: None, doc: None, - generator: false, }) } @@ -137,6 +137,10 @@ pub struct Fx<'m, 'b, 'a, 'tcx> { mutated: IndexVec, /// The names of borrowed locals. shared: FxHashSet, + /// The names of locals whose own value nothing changes: a tuple, array, or enum or + /// struct of their own, never changed in place nor borrowed, so a call can't change + /// what their fields hold. + frozen_names: FxHashSet, /// `(value, overflowed)` pairs of checked arithmetic, whose `.1` is false once the value /// is made, which panics where the assert would. checked: FxHashSet, @@ -184,6 +188,23 @@ pub struct Fx<'m, 'b, 'a, 'tcx> { range_nexts: FxHashSet, /// Their names, and their flags' names, which a switch on their variant tests. range_flags: FxHashMap, + /// Iterators over an array stepped in place, by `step`. + stepped: FxHashSet, + /// The borrows `next` steps them by, and what each borrows. + stepped_borrows: FxHashMap, + /// The two variables each holds its fields in, by `step`. + stepped_vars: FxHashMap, + /// Those moved into another, which shares its variables. + stepped_into: FxHashMap, + /// Statements that change nothing: a swap through a temporary nothing else names, as + /// an async body moves its context at each `await`. + noops: FxHashSet<(BasicBlock, usize)>, + /// The lengths a bounds check compares with, of the slices whose `rt.idx` it is. + idx_of: FxHashMap>, + /// Each block's one predecessor, if it has one. + sole_pred: FxHashMap, + /// What the cleanup variable holds as each block lowered so far leaves. + unwind_out: FxHashMap>, /// The halves a `|` joins into a `u64`, by the local of the shift that is its left side. halves: FxHashMap, &'m Operand<'tcx>)>, /// Temporaries of those joins, whose assignments go unlowered. @@ -206,6 +227,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { borrowed: IndexVec::from_elem_n(false, n), mutated: IndexVec::from_elem_n(false, n), shared: FxHashSet::default(), + frozen_names: FxHashSet::default(), checked: FxHashSet::default(), pending: Vec::new(), order: 0, @@ -230,6 +252,14 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { next_names: FxHashSet::default(), range_nexts: FxHashSet::default(), range_flags: FxHashMap::default(), + stepped: FxHashSet::default(), + stepped_borrows: FxHashMap::default(), + stepped_vars: FxHashMap::default(), + stepped_into: FxHashMap::default(), + noops: FxHashSet::default(), + sole_pred: FxHashMap::default(), + idx_of: FxHashMap::default(), + unwind_out: FxHashMap::default(), halves: FxHashMap::default(), joined: FxHashSet::default(), }; @@ -245,6 +275,8 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { /// Count each local's reads and assignments, and decide how each lowers. fn analyze(&mut self) { let mir = self.mir; + self.find_noops(); + let mut bounds = Vec::new(); for (bb, data) in mir.basic_blocks.iter_enumerated() { if data.statements.iter().all(|s| { matches!( @@ -256,6 +288,9 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { self.unreachable.insert(bb); } for (i, stmt) in data.statements.iter().enumerate() { + if self.noops.contains(&(bb, i)) { + continue; + } match &stmt.kind { StatementKind::Assign(assign) => { let (place, rvalue) = &**assign; @@ -312,25 +347,44 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { // The assert after checked arithmetic reads `.1`, which lowering folds away. let folded = matches!(cond, Operand::Move(p) | Operand::Copy(p) if p.projection.len() == 1 && self.checked.contains(&p.local)); - if !folded && !redundant(msg) { + if let mir::AssertKind::BoundsCheck { len, index } = &**msg { + // Counted once every length's definition is known. + bounds.push((cond, len, index)); + } else if !folded && !redundant(msg) { self.operand_use(cond); - // Only a bounds check's message shows its operands. - if let mir::AssertKind::BoundsCheck { len, index } = &**msg { - self.operand_use(len); - self.operand_use(index); - } } } _ => {} } } + // A bounds check of a slice's length is `rt.idx` of the slice; others test their + // condition, and show their operands. + for (cond, len, index) in bounds { + if let Operand::Copy(l) | Operand::Move(l) = len + && let Some(l) = l.as_local() + && let Some(Rvalue::UnaryOp(mir::UnOp::PtrMetadata, Operand::Copy(slice) | Operand::Move(slice))) = + self.def_rvalue(l) + && self.stable(*slice) + { + self.idx_of.insert(l, *slice); + self.place_use(*slice); + self.operand_use(index); + continue; + } + self.operand_use(cond); + self.operand_use(len); + self.operand_use(index); + } + self.drop_unread(); self.find_next_results(); + self.find_stepped(); + self.unborrow_passed(); self.find_halves(); for local in mir.local_decls.indices() { let ty = mir.local_decls[local].ty; let slot = if self.zero_sized(ty) { Slot::Unit - } else if let Some(value) = self.unit_struct(local, ty) { + } else if let Some(value) = self.unassigned(local, ty) { Slot::Alias(Some(value)) } else if self.alias(local) { Slot::Alias(None) @@ -366,9 +420,143 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { if self.borrowed[local] { self.shared.insert(name.clone()); } + if self.stepped.contains(&local) { + self.name_stepped(local, &base); + } + let owned = match mir.local_decls[local].ty.kind() { + ty::Tuple(_) | ty::Array(..) => true, + ty::Adt(adt, _) => { + adt.did().is_local() + || matches!( + crate::lower::library::Std::of(self.tcx, adt.did()), + Some(crate::lower::library::Std::Option | crate::lower::library::Std::Result) + ) + } + _ => false, + }; + if owned && !self.is_arg(local) && !self.borrowed[local] && !self.mutated[local] { + self.frozen_names.insert(name.clone()); + } self.slots[local] = Slot::Var(name); } } + self.share_stepped(); + } + + /// Uncount the reads of what computes a local nothing reads without doing anything + /// else, as the test of an assert a runtime function checks for itself is. + fn drop_unread(&mut self) { + let mir = self.mir; + let mut computed: IndexVec>> = + IndexVec::from_elem_n(Vec::new(), mir.local_decls.len()); + let mut pure = IndexVec::from_elem_n(true, mir.local_decls.len()); + for (bb, data) in mir.basic_blocks.iter_enumerated() { + for (i, stmt) in data.statements.iter().enumerate() { + if self.noops.contains(&(bb, i)) { + continue; + } + if let StatementKind::Assign(assign) = &stmt.kind + && let Some(local) = assign.0.as_local() + { + match &assign.1 { + // One that can throw is lowered even unread, so it keeps its reads. + r @ (Rvalue::BinaryOp(..) | Rvalue::UnaryOp(..) | Rvalue::Use(..)) + if !rvalue::effect(r, self) => + { + computed[local].push(r) + } + _ => pure[local] = false, + } + } + } + if let TerminatorKind::Call { destination, .. } = &data.terminator().kind { + pure[destination.local] = false; + } + } + let mut work: Vec = mir.local_decls.indices().collect(); + while let Some(local) = work.pop() { + if self.uses[local] != 0 || !pure[local] || self.is_arg(local) || local == mir::RETURN_PLACE { + continue; + } + for rvalue in std::mem::take(&mut computed[local]) { + let ops: Vec<&Operand<'tcx>> = match rvalue { + Rvalue::BinaryOp(_, ops) => vec![&ops.0, &ops.1], + Rvalue::UnaryOp(_, op) | Rvalue::Use(op, _) => vec![op], + _ => unreachable!("collected above"), + }; + for op in ops { + if let Operand::Copy(p) | Operand::Move(p) = op { + self.uses[p.local] -= 1; + for elem in p.projection { + if let mir::ProjectionElem::Index(index) = elem { + self.uses[index] -= 1; + } + } + work.push(p.local); + } + } + } + } + } + + /// A local nothing changes whose one read is a shared borrow, itself read once, is + /// read once where the borrow is: it folds like a local nothing borrows, as an array + /// made to pass as a slice does. + fn unborrow_passed(&mut self) { + let mir = self.mir; + for data in mir.basic_blocks.iter() { + for stmt in &data.statements { + if let StatementKind::Assign(assign) = &stmt.kind + && let (to, Rvalue::Ref(_, mir::BorrowKind::Shared, from)) = &**assign + && let Some(to) = to.as_local() + && let Some(from) = from.as_local() + && self.borrowed[from] + && !self.mutated[from] + && self.uses[from] == 1 + && self.defs[to] == 1 + && self.uses[to] == 1 + && !self.borrowed[to] + { + self.borrowed[from] = false; + } + } + } + } + + /// Find the swaps `t = move x; x = move t;` through a `t` nothing else names. + fn find_noops(&mut self) { + use rustc_middle::mir::visit::{PlaceContext, Visitor}; + struct Mentions(IndexVec); + impl<'tcx> Visitor<'tcx> for Mentions { + fn visit_local(&mut self, local: Local, cx: PlaceContext, _: mir::Location) { + if !matches!(cx, PlaceContext::NonUse(_)) { + self.0[local] += 1; + } + } + } + let mir = self.mir; + let mut mentions = Mentions(IndexVec::from_elem_n(0, mir.local_decls.len())); + mentions.visit_body(mir); + let moved = |stmt: &mir::Statement<'tcx>| match &stmt.kind { + StatementKind::Assign(assign) => match &assign.1 { + Rvalue::Use(Operand::Move(from), _) => Some((assign.0.as_local()?, from.as_local()?)), + _ => None, + }, + _ => None, + }; + for (bb, data) in mir.basic_blocks.iter_enumerated() { + for (i, pair) in data.statements.windows(2).enumerate() { + if let (Some((t, x)), Some((x2, t2))) = (moved(&pair[0]), moved(&pair[1])) + && x == x2 + && t == t2 + && t != x + && mentions.0[t] == 2 + { + self.noops.insert((bb, i)); + self.noops.insert((bb, i + 1)); + } + } + } } fn def(&mut self, place: Place<'tcx>) { @@ -448,12 +636,20 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } } - /// A struct of no fields that nothing assigns, which MIR leaves unassigned since it - /// holds nothing: JS needs it made. - fn unit_struct(&mut self, local: Local, ty: Ty<'tcx>) -> Option { + /// A struct of no fields or an empty array that nothing assigns, which MIR leaves + /// unassigned since it holds nothing: JS needs it made. + fn unassigned(&mut self, local: Local, ty: Ty<'tcx>) -> Option { if self.defs[local] != 0 || self.is_arg(local) || local == mir::RETURN_PLACE { return None; } + if let ty::Array(elem, len) = ty.kind() + && len.try_to_target_usize(self.tcx) == Some(0) + { + return Some(match elem.kind() { + ty::Uint(ty::UintTy::U8) => Expr::ident("Uint8Array").member("of").call(Vec::new()), + _ => Expr::As(Box::new(Expr::Array(Vec::new())), self.b.t.ty(ty, self.span)), + }); + } let ty::Adt(adt, _) = ty.kind() else { return None; }; @@ -487,6 +683,16 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let Some(rvalue) = self.def_rvalue(local) else { return false; }; + if self.context_of_arg(local) { + return true; + } + // A number or a flag assigned once from a constant: the constant. + if let Rvalue::Use(Operand::Constant(_), _) = rvalue + && !self.mutated[local] + { + let ty = mir.local_decls[local].ty; + return ty.is_bool() || crate::lower::num::Int::of(ty).is_some_and(|i| !i.big()); + } match (mir.local_decls[local].ty.kind(), rvalue) { // A borrow: borrow checking keeps the place as it is but through the borrow, // unless the path to it goes through a reference held in a field or element, @@ -528,6 +734,33 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } } + /// Whether `local` is the task's context an async body is resumed with, as it passes it + /// on: a parameter nothing assigns, or a local assigned it once, in another type that + /// is the context in JS too. + fn context_of_arg(&self, local: Local) -> bool { + if self.borrowed[local] || self.mutated[local] || !rvalue::context_like(self, self.mir.local_decls[local].ty) { + return false; + } + if self.is_arg(local) { + return self.defs[local] == 0; + } + if self.defs[local] != 1 { + return false; + } + let from = match self.def_rvalue(local) { + Some( + Rvalue::Use(Operand::Copy(p) | Operand::Move(p), _) + | Rvalue::Cast(mir::CastKind::Transmute, Operand::Copy(p) | Operand::Move(p), _), + ) => p, + Some(Rvalue::Aggregate(_, ops)) if ops.len() == 1 => match &ops[rustc_abi::FieldIdx::ZERO] { + Operand::Copy(p) | Operand::Move(p) => p, + Operand::Constant(_) | Operand::RuntimeChecks(_) => return false, + }, + _ => return false, + }; + from.as_local().is_some_and(|from| self.context_of_arg(from)) + } + /// Whether `place` is a field of a closure's environment, which stays put for the call. fn env_field(&self, place: Place<'tcx>) -> bool { matches!(self.env, Env::Closure(_)) @@ -819,6 +1052,20 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { .collect(), }; } + let mut preds: Vec> = vec![Vec::new(); n]; + for (from, tos) in succs.iter().enumerate() { + for &to in tos { + preds[to].push(from); + } + } + for (to, from) in preds.iter().enumerate() { + if let [from] = from[..] + && from != to + { + self.sole_pred + .insert(BasicBlock::from_usize(to), BasicBlock::from_usize(from)); + } + } let graph = cfg::Graph { succs }; let mut labels = self.labels; let body = cfg::structure(&graph, self, &mut labels); @@ -830,7 +1077,15 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { if self.is_arg(local) || !self.assigned[local] { continue; } - if let Slot::Var(name) = self.slots[local].clone() { + if let Some(vars) = self.stepped_vars.get(&local).cloned() { + // Declared once, by the local that shares them. + if self.stepped_root(local) != local { + continue; + } + for (name, ty) in vars.into_iter().zip(self.stepped_tys(local)) { + out.push(StmtKind::Declare { name, ty }.at(None)); + } + } else if let Slot::Var(name) = self.slots[local].clone() { let ty = self.decl_ty(local); out.push(StmtKind::Declare { name, ty }.at(None)); } @@ -849,7 +1104,13 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { out.extend(entry); out.extend(body); drop_self_assignments(&mut out); + let mut caught = Vec::new(); + handler_reads(&out, &mut caught); + return_in_place(&mut out, &caught.into_iter().collect()); prune_unread(&mut out); + if self.zero_sized(self.mir.local_decls[mir::RETURN_PLACE].ty) { + cfg::strip_return(&mut out); + } out } @@ -944,9 +1205,12 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { TerminatorKind::Goto { target, .. } => vec![*target], // An unreachable default is no edge: the last value takes its place. TerminatorKind::SwitchInt { targets, .. } => { - let mut all = targets.all_targets().to_vec(); - if self.unreachable.contains(&targets.otherwise()) && all.len() > 1 { - all.pop(); + let (arms, default) = self.switch_targets(targets); + let mut all: Vec = Vec::new(); + for bb in arms.into_iter().map(|(_, bb)| bb).chain([default]) { + if !all.contains(&bb) { + all.push(bb); + } } all } @@ -964,6 +1228,51 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { // Locals + /// A switch's arms and default, each past blocks that do nothing but go on, without + /// the arms that go where the default does. An unreachable default leaves the last + /// arm as the default. + fn switch_targets(&self, targets: &mir::SwitchTargets) -> (Vec<(u128, BasicBlock)>, BasicBlock) { + let mut arms: Vec<(u128, BasicBlock)> = targets.iter().collect(); + let mut default = targets.otherwise(); + if self.unreachable.contains(&default) + && let Some((_, last)) = arms.pop() + { + default = last; + } + let default = self.forward(default); + let returns = |bb: BasicBlock| matches!(self.mir.basic_blocks[bb].terminator().kind, TerminatorKind::Return); + arms.retain_mut(|(_, target)| { + *target = self.forward(*target); + *target != default && !(returns(*target) && returns(default) && self.empty(*target) && self.empty(default)) + }); + (arms, default) + } + + /// Whether `bb` has no statement that does anything. + fn empty(&self, bb: BasicBlock) -> bool { + self.mir.basic_blocks[bb].statements.iter().enumerate().all(|(i, s)| { + matches!( + s.kind, + StatementKind::StorageDead(_) | StatementKind::StorageLive(_) | StatementKind::Nop + ) || self.noops.contains(&(bb, i)) + }) + } + + /// Where `bb` goes, past blocks that do nothing but go on. + fn forward(&self, mut bb: BasicBlock) -> BasicBlock { + for _ in 0..self.mir.basic_blocks.len() { + let data = &self.mir.basic_blocks[bb]; + let TerminatorKind::Goto { target, .. } = data.terminator().kind else { + return bb; + }; + if !self.empty(bb) || data.is_cleanup || self.redirect.contains_key(&bb) { + return bb; + } + bb = target; + } + bb + } + /// The JS name of a local held in a variable. fn var(&self, local: Local) -> Option<&str> { match &self.slots[local] { @@ -1038,6 +1347,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { None => seen_memory |= self.shared.contains(name.as_str()), }, Read::Memory => seen_memory = true, + Read::Field(name) => seen_memory |= !self.frozen_names.contains(name.as_str()), Read::Effect => seen_effect = true, } } @@ -1175,6 +1485,25 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { }); } + /// Hold back `value`, the assignment of the flag `flag`, to fold into the switch that + /// reads it. + fn hold_flag(&mut self, flag: String, value: Expr) { + self.order += 1; + let mut reads = Vec::new(); + reads_of(&value, &mut reads); + self.pending.push(Pending { + name: flag, + value, + order: self.order, + effect: true, + memory: true, + parts: None, + reads, + copy: false, + decl: false, + }); + } + /// The parts of the pending aggregate `local`, each held back in its place, so the /// expression that reads them keeps what they do and read in order. fn take_parts(&mut self, op: &Operand<'tcx>) -> Option> { @@ -1204,6 +1533,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let effect = events.iter().any(|r| matches!(r, Read::Effect)); let memory = events.iter().any(|r| match r { Read::Memory => true, + Read::Field(name) => !self.frozen_names.contains(name.as_str()), Read::Ident(name, _) => self.shared.contains(name.as_str()), Read::Effect => false, }); @@ -1244,6 +1574,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { parts: Option>, out: &mut Vec, ) { + if self.stepped_vars.contains_key(&local) { + self.set_stepped(local, value, out); + return; + } match self.slots[local].clone() { Slot::Var(name) => { if self.uses[local] == 0 { @@ -1300,12 +1634,21 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { fn block(&mut self, bb: BasicBlock, out: &mut Vec) -> Exit { let mir = self.mir; let data = &mir.basic_blocks[bb]; + // Entered only from its one predecessor, with the cleanup that left it. + if let Some(unwind) = &mut self.unwind + && let Some(from) = self.sole_pred.get(&bb) + && let Some(&known) = self.unwind_out.get(from) + { + unwind.known = known; + } self.set_unwind(data.terminator(), out); - for stmt in &data.statements { - if !self.in_ignored(stmt.source_info.span) { + for (i, stmt) in data.statements.iter().enumerate() { + if !self.in_ignored(stmt.source_info.span) && !self.noops.contains(&(bb, i)) { self.statement(stmt, out); } } + let known = self.unwind.as_ref().and_then(|u| u.known); + self.unwind_out.insert(bb, known); if let Some(&to) = self.redirect.get(&bb) { return Exit::Goto(to.as_usize()); } @@ -1358,9 +1701,18 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { Rvalue::CopyForDeref(p) => self.place_expr(*p, span, out), Rvalue::Use(Operand::Copy(p) | Operand::Move(p), _) => self.place_expr(*p, span, out), Rvalue::Cast(_, Operand::Copy(p) | Operand::Move(p), _) => self.place_expr(*p, span, out), + Rvalue::Use(op @ Operand::Constant(_), _) => self.operand(op, span, out), + // The task's context, wrapped. + Rvalue::Aggregate(_, ops) => match &ops[rustc_abi::FieldIdx::ZERO] { + Operand::Copy(p) | Operand::Move(p) => self.place_expr(*p, span, out), + _ => unreachable!("checked by context_of_arg"), + }, _ => unreachable!("an alias is a borrow or a copy of one"), }; - self.materialize(&target, out); + // Read once, it folds in what it reads that is held back, like any other read. + if self.uses[local] > 1 { + self.materialize(&target, out); + } self.slots[local] = Slot::Alias(Some(target)); return; } @@ -1398,6 +1750,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { self.force_share = true; } let value = self.rvalue(rvalue, place, span, &mut pre); + let value = match (value, place.as_local()) { + (Some(value), Some(local)) if self.stepped.contains(&local) => Some(self.stepped_make(value, span)), + (value, _) => value, + }; self.into_frozen = false; self.force_share = false; self.copy_on_flush = shares; @@ -1564,23 +1920,25 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } fn switch(&mut self, discr: &Operand<'tcx>, targets: &mir::SwitchTargets, span: Span, out: &mut Vec) -> Exit { - let mut arms: Vec<(u128, BasicBlock)> = targets.iter().collect(); - let mut default = targets.otherwise(); - // An unreachable default leaves the last value as the default. - if self.unreachable.contains(&default) - && let Some((_, last)) = arms.pop() - { - default = last; - } + let (arms, default) = self.switch_targets(targets); let discr_local = match discr { Operand::Copy(p) | Operand::Move(p) => p.as_local(), _ => None, }; let tests: Vec<(Expr, BasicBlock)> = match discr_local.map(|l| self.slots[l].clone()) { - Some(Slot::Discr(Some((scrut, ty)))) => arms - .iter() - .map(|&(value, target)| (self.variant_test(&scrut, ty, value, span), target)) - .collect(), + Some(Slot::Discr(Some((scrut, ty)))) => { + let tests: Vec = arms + .iter() + .map(|&(value, _)| self.variant_test(&scrut, ty, value, span)) + .collect(); + // What one test reads that is held back folds into it; of several, all but + // the first may not run. + let conds = match tests.len() { + 1 => self.fold_exprs(Vec::new(), tests, false, out), + _ => tests, + }; + conds.into_iter().zip(arms.iter().map(|&(_, t)| t)).collect() + } _ => { let ty = discr.ty(&self.mir.local_decls, self.tcx); let mut pre = Vec::new(); @@ -1653,6 +2011,17 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { if redundant(msg) { return; } + if let mir::AssertKind::BoundsCheck { len, index } = msg + && let Operand::Copy(l) | Operand::Move(l) = len + && let Some(&slice) = l.as_local().and_then(|l| self.idx_of.get(&l)) + { + let mut pre = Vec::new(); + let slice = self.place_expr(slice, span, &mut pre); + let index = self.operand(index, span, &mut pre); + pre.push(StmtKind::Expr(Expr::rt("idx", vec![slice, index])).at(self.b.t.loc(span))); + self.emit(pre, None, false, out); + return; + } let mut pre = Vec::new(); let value = self.operand(cond, span, &mut pre); let mut exprs = vec![value]; @@ -1816,6 +2185,8 @@ enum Read { Ident(String, bool), /// Memory: a member or an element. Memory, + /// A member or an element of a local's own value, by its name. + Field(String), /// A call, which may do anything. Effect, } @@ -1837,22 +2208,30 @@ fn scan_stmt(stmt: &Stmt, reads: &mut Vec, lazy: bool) { } } +/// A read of a member or element of `base`. +fn field(base: &Expr) -> Read { + match base { + Expr::Ident(name) => Read::Field(name.clone()), + _ => Read::Memory, + } +} + fn scan(e: &Expr, reads: &mut Vec, lazy: bool) { match e { Expr::Ident(name) => reads.push(Read::Ident(name.clone(), lazy)), - Expr::This | Expr::Sym(_) | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) | Expr::Yield => {} + Expr::This | Expr::Sym(_) | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) => {} Expr::Array(items) => items.iter().for_each(|e| scan(e, reads, lazy)), Expr::Object(props) => props.iter().for_each(|(_, e)| scan(e, reads, lazy)), // The runtime's and the program's own items never change. Expr::Member(base, _) if matches!(&**base, Expr::Rt(_) | Expr::Sym(_)) => {} Expr::Member(base, _) => { scan(base, reads, lazy); - reads.push(Read::Memory); + reads.push(field(base)); } Expr::Index(base, index) => { scan(base, reads, lazy); scan(index, reads, lazy); - reads.push(Read::Memory); + reads.push(field(base)); } Expr::Call(f, args) | Expr::New(f, args) => { // A method's lookup reads no data the arguments could change: only its receiver. @@ -1879,9 +2258,16 @@ fn scan(e: &Expr, reads: &mut Vec, lazy: bool) { scan(b, reads, true); } Expr::Assign(target, value) => { - // A variable assigned is not read; a place's base and index are, before the value. - if !matches!(**target, Expr::Ident(_)) { - scan(target, reads, lazy); + // A variable assigned is not read; a place's base and index are, before the value, + // but not the place itself. + match &**target { + Expr::Ident(_) => {} + Expr::Member(base, _) => scan(base, reads, lazy), + Expr::Index(base, index) => { + scan(base, reads, lazy); + scan(index, reads, lazy); + } + target => scan(target, reads, lazy), } scan(value, reads, lazy); reads.push(Read::Effect); @@ -1907,7 +2293,7 @@ fn subst(e: &mut Expr, name: &str, value: &Expr) -> bool { *e = value.clone(); true } - Expr::Ident(_) | Expr::This | Expr::Sym(_) | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) | Expr::Yield => false, + Expr::Ident(_) | Expr::This | Expr::Sym(_) | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) => false, Expr::Array(items) => items.iter_mut().any(|e| subst(e, name, value)), Expr::Object(props) => props.iter_mut().any(|(_, e)| subst(e, name, value)), Expr::Member(base, _) => subst(base, name, value), @@ -1968,17 +2354,7 @@ fn scan_reads(stmt: &Stmt, out: &mut Vec) { } default.iter().for_each(|s| scan_reads(s, out)); } - StmtKind::Try { body, finally } => body.iter().chain(finally).for_each(|s| scan_reads(s, out)), StmtKind::Catch { body, handler, .. } => body.iter().chain(handler).for_each(|s| scan_reads(s, out)), - StmtKind::ForRange { start, end, body, .. } => { - reads_of(start, out); - reads_of(end, out); - body.iter().for_each(|s| scan_reads(s, out)); - } - StmtKind::ForOf { iter, body, .. } => { - reads_of(iter, out); - body.iter().for_each(|s| scan_reads(s, out)); - } _ => {} } } @@ -1986,7 +2362,7 @@ fn scan_reads(stmt: &Stmt, out: &mut Vec) { fn reads_of(e: &Expr, out: &mut Vec) { match e { Expr::Ident(name) => out.push(name.clone()), - Expr::This | Expr::Sym(_) | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) | Expr::Yield => {} + Expr::This | Expr::Sym(_) | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) => {} Expr::Array(items) => items.iter().for_each(|e| reads_of(e, out)), Expr::Object(props) => props.iter().for_each(|(_, e)| reads_of(e, out)), Expr::Member(base, _) => reads_of(base, out), @@ -2042,10 +2418,6 @@ fn strip_assignments(stmts: &mut Vec, unread: &FxHashSet) { cases.iter_mut().for_each(|(_, body)| strip_assignments(body, unread)); strip_assignments(default, unread); } - StmtKind::Try { body, finally } => { - strip_assignments(body, unread); - strip_assignments(finally, unread); - } StmtKind::Catch { body, handler, .. } => { strip_assignments(body, unread); strip_assignments(handler, unread); @@ -2194,10 +2566,6 @@ fn drop_self_assignments(stmts: &mut Vec) { cases.iter_mut().for_each(|(_, body)| drop_self_assignments(body)); drop_self_assignments(default); } - StmtKind::Try { body, finally } => { - drop_self_assignments(body); - drop_self_assignments(finally); - } StmtKind::Catch { body, handler, .. } => { drop_self_assignments(body); drop_self_assignments(handler); @@ -2207,6 +2575,172 @@ fn drop_self_assignments(stmts: &mut Vec) { } } +/// Return values in place throughout `stmts`, given the names cleanups read. +fn return_in_place(stmts: &mut Vec, caught: &FxHashSet) { + sink_return(stmts); + for stmt in stmts.iter_mut() { + match &mut stmt.kind { + StmtKind::If { then, els, .. } => { + return_in_place(then, caught); + return_in_place(els, caught); + } + StmtKind::While { body, .. } | StmtKind::Block { body, .. } => return_in_place(body, caught), + StmtKind::Switch { cases, default, .. } => { + cases.iter_mut().for_each(|(_, body)| return_in_place(body, caught)); + return_in_place(default, caught); + } + StmtKind::Catch { body, handler, .. } => { + return_in_place(body, caught); + return_in_place(handler, caught); + } + _ => {} + } + } + while return_assigned(stmts, caught) {} +} + +/// `x = v; ...; return x;` at the end of `stmts` as `...; return v;`, where moving `v` +/// past the statements between changes nothing (there are none, or `v` is a constant or a +/// name none of them assigns) and no cleanup reads `x`; whether it was. +fn return_assigned(stmts: &mut Vec, caught: &FxHashSet) -> bool { + let Some(Stmt { + kind: StmtKind::Return(Some(Expr::Ident(name))), + .. + }) = stmts.last() + else { + return false; + }; + // A cleanup reading it would run after its assignment, were the statements between to + // throw. + if caught.contains(name) { + return false; + } + let name = name.clone(); + let assigns = |e: &Expr, to: &str| matches!(e, Expr::Assign(t, _) if matches!(&**t, Expr::Ident(n) if n == to)); + let mut at = None; + for i in (0..stmts.len() - 1).rev() { + let StmtKind::Expr(e) = &stmts[i].kind else { + return false; + }; + if assigns(e, &name) { + at = Some(i); + break; + } + let mut reads = Vec::new(); + reads_of(e, &mut reads); + if reads.contains(&name) { + return false; + } + } + let Some(at) = at else { + return false; + }; + let StmtKind::Expr(Expr::Assign(_, value)) = &stmts[at].kind else { + unreachable!("found above") + }; + let between = &stmts[at + 1..stmts.len() - 1]; + let moves = between.is_empty() + || value.is_constant() + || matches!(&**value, Expr::Ident(n) if between.iter().all(|s| !matches!(&s.kind, StmtKind::Expr(e) if assigns(e, n)))); + if !moves { + return false; + } + let StmtKind::Expr(Expr::Assign(_, value)) = stmts.remove(at).kind else { + unreachable!("found above") + }; + let last = stmts.last_mut().expect("the return"); + last.kind = StmtKind::Return(Some(*value)); + true +} + +/// The names read in each catch handler in `stmts`. +fn handler_reads(stmts: &[Stmt], out: &mut Vec) { + for stmt in stmts { + match &stmt.kind { + StmtKind::If { then, els, .. } => { + handler_reads(then, out); + handler_reads(els, out); + } + StmtKind::While { body, .. } | StmtKind::Block { body, .. } => handler_reads(body, out), + StmtKind::Switch { cases, default, .. } => { + cases.iter().for_each(|(_, body)| handler_reads(body, out)); + handler_reads(default, out); + } + StmtKind::Catch { body, handler, .. } => { + handler_reads(body, out); + handler.iter().for_each(|s| scan_reads(s, out)); + } + _ => {} + } + } +} + +/// Move a `return x;` that follows an `if` or a labeled block into each way out of it, so +/// each can return what it assigns `x` in place. +fn sink_return(stmts: &mut Vec) { + while stmts.len() >= 2 + && matches!( + stmts.last().map(|s| &s.kind), + Some(StmtKind::Return(Some(Expr::Ident(_)))) + ) { + let ret = stmts.pop().expect("checked above"); + let last = stmts.last_mut().expect("checked above"); + match &mut last.kind { + StmtKind::If { then, els, .. } => { + for branch in [then, els] { + if !crate::ts::diverges(branch) { + branch.push(ret.clone()); + } + } + return; + } + StmtKind::Block { + label: Some(label), + body, + } => { + let label = label.clone(); + breaks_to_return(body, &label, &ret); + if !crate::ts::diverges(body) { + body.push(ret); + } + let StmtKind::Block { body, .. } = stmts.pop().expect("checked above").kind else { + unreachable!("matched above") + }; + stmts.extend(body); + } + _ => { + stmts.push(ret); + return; + } + } + } +} + +/// Replace each `break label;` in `stmts` with `ret`. +fn breaks_to_return(stmts: &mut [Stmt], label: &str, ret: &Stmt) { + for stmt in stmts.iter_mut() { + match &mut stmt.kind { + StmtKind::Break(Some(l)) if l == label => *stmt = ret.clone(), + StmtKind::If { then, els, .. } => { + breaks_to_return(then, label, ret); + breaks_to_return(els, label, ret); + } + StmtKind::While { body, .. } | StmtKind::Block { body, .. } => breaks_to_return(body, label, ret), + StmtKind::Switch { cases, default, .. } => { + cases + .iter_mut() + .for_each(|(_, body)| breaks_to_return(body, label, ret)); + breaks_to_return(default, label, ret); + } + StmtKind::Catch { body, handler, .. } => { + breaks_to_return(body, label, ret); + breaks_to_return(handler, label, ret); + } + _ => {} + } + } +} + /// Whether evaluating `e` does nothing at all: a path, or a literal made of them. fn inert(e: &Expr) -> bool { match e { diff --git a/ts/src/lower/mir/place.rs b/ts/src/lower/mir/place.rs index a849356da..d56ae15cc 100644 --- a/ts/src/lower/mir/place.rs +++ b/ts/src/lower/mir/place.rs @@ -26,6 +26,9 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { Env::Plain | Env::Shim => {} } } + if let Some(value) = self.stepped_value(local) { + return value; + } match &self.slots[local] { Slot::Var(name) => Expr::ident(name), // A value of type `!`, as a generic instantiated at `!` reads: native code never diff --git a/ts/src/lower/mir/rvalue.rs b/ts/src/lower/mir/rvalue.rs index e30a5926a..cacb25f66 100644 --- a/ts/src/lower/mir/rvalue.rs +++ b/ts/src/lower/mir/rvalue.rs @@ -447,7 +447,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { /// Whether a `ty`'s JS value is the task's context: `&mut Context`, or the `ResumeTy` and /// `NonNull` an async body passes it in. -fn context_like<'tcx>(fx: &Fx<'_, '_, '_, 'tcx>, ty: Ty<'tcx>) -> bool { +pub(super) fn context_like<'tcx>(fx: &Fx<'_, '_, '_, 'tcx>, ty: Ty<'tcx>) -> bool { let tcx = fx.tcx; match ty.kind() { ty::Ref(_, inner, _) => context_like(fx, *inner), diff --git a/ts/src/lower/mir/step.rs b/ts/src/lower/mir/step.rs new file mode 100644 index 000000000..773174e46 --- /dev/null +++ b/ts/src/lower/mir/step.rs @@ -0,0 +1,328 @@ +//! Iterators stepped in place: a slice's or a `Vec`'s iterator, or a range of numbers, +//! that only `next` reads, as a `for` loop's is, is two variables, of the array and an +//! index or of the bounds, rather than an `rt.Iter`, which a bundler can't shake its +//! adaptors from. Variables, not an object of both: V8 took up to 1.25x as long over a +//! `BTreeMap` stepping an object's fields. + +use rustc_data_structures::fx::{FxHashMap, FxHashSet}; +use rustc_middle::mir::{self, Local, Operand, Rvalue, StatementKind, TerminatorKind}; +use rustc_middle::ty::{self, Ty, TyCtxt}; + +use super::Fx; +use crate::lower::library::{self, Std}; +use crate::ts::{Expr, Key, Stmt, StmtKind, Type}; + +/// The item type of a slice's or a `Vec`'s iterator, if `ty` is one. +fn array_iter<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option> { + let ty::Adt(adt, args) = ty.kind() else { + return None; + }; + let path = library::std_path(tcx, adt.did()); + let path: Vec<&str> = path.iter().map(String::as_str).collect(); + match path.as_slice() { + ["slice", "iter", "Iter" | "IterMut"] | ["vec", "into_iter", "IntoIter"] => args.types().next(), + _ => None, + } +} + +/// Whether `ty` is what such an iterator is made from: a slice, an array, or a `Vec`. +fn array<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { + match ty.peel_refs().kind() { + ty::Slice(_) | ty::Array(..) => true, + ty::Adt(adt, _) => Std::of(tcx, adt.did()) == Some(Std::Vec), + _ => false, + } +} + +impl<'tcx> Fx<'_, '_, '_, 'tcx> { + /// Find the iterators to step in place: each made by a call from an array, or moved + /// from another, and otherwise only borrowed for `next` into a protocol local and + /// dropped. Each borrow is read only as `next`'s receiver. + pub(super) fn find_stepped(&mut self) { + let mir = self.mir; + let tcx = self.tcx; + let mut iters: Vec = mir + .local_decls + .indices() + .filter(|&l| !self.is_arg(l) && l != mir::RETURN_PLACE && self.defs[l] == 1) + .filter(|&l| { + let ty = mir.local_decls[l].ty; + array_iter(tcx, ty).is_some() || super::small_range(tcx, ty) + }) + .collect(); + if iters.is_empty() { + return; + } + // What each reads that is allowed: borrows for `next`, drops, moves into another. + let mut reads: FxHashMap = FxHashMap::default(); + let mut made = FxHashSet::default(); + let mut moves: Vec<(Local, Local)> = Vec::new(); + let mut borrows: FxHashMap = FxHashMap::default(); + let mut next_reads: FxHashMap = FxHashMap::default(); + for data in mir.basic_blocks.iter() { + for stmt in &data.statements { + let StatementKind::Assign(assign) = &stmt.kind else { + continue; + }; + let (place, rvalue) = &**assign; + match rvalue { + Rvalue::Ref(_, mir::BorrowKind::Mut { .. }, from) if from.as_local().is_some() => { + let from = from.as_local().unwrap(); + *reads.entry(from).or_default() += 1; + if let Some(to) = place.as_local() { + borrows.insert(to, from); + } + } + Rvalue::Use(Operand::Move(from), _) if from.as_local().is_some() => { + let from = from.as_local().unwrap(); + *reads.entry(from).or_default() += 1; + if let Some(to) = place.as_local() { + moves.push((from, to)); + } + } + Rvalue::Aggregate(..) if let Some(to) = place.as_local() => { + made.insert(to); + } + _ => {} + } + } + match &data.terminator().kind { + TerminatorKind::Drop { place, .. } if let Some(local) = place.as_local() => { + *reads.entry(local).or_default() += 1; + } + TerminatorKind::Call { + func, + args, + destination, + .. + } => { + let ty::FnDef(def_id, _) = *func.ty(&mir.local_decls, tcx).kind() else { + continue; + }; + let maker = library::key(tcx, def_id).is_some_and(|(o, n)| { + matches!( + (o.as_str(), n.as_str()), + ("IntoIterator", "into_iter") | ("slice", "iter" | "iter_mut") + ) + }); + if maker + && let Some(to) = destination.as_local() + && let [arg] = &**args + { + match &arg.node { + // A range is its own iterator. + Operand::Move(from) + if let Some(from) = from.as_local() + && super::small_range(tcx, mir.local_decls[from].ty) => + { + *reads.entry(from).or_default() += 1; + moves.push((from, to)); + } + op if array(tcx, op.ty(&mir.local_decls, tcx)) => { + made.insert(to); + } + _ => {} + } + } + if crate::lower::iter::is_next(tcx, def_id) + && destination.as_local().is_some_and(|l| self.next_results.contains(&l)) + && let [arg] = &**args + && let Operand::Copy(p) | Operand::Move(p) = &arg.node + && let Some(recv) = p.as_local() + { + *next_reads.entry(recv).or_default() += 1; + } + } + _ => {} + } + } + // A borrow only `next` reads, assigned once and borrowed by nothing. + let stepping = |fx: &Self, borrow: Local| { + fx.defs[borrow] == 1 + && !fx.borrowed[borrow] + && next_reads.get(&borrow).copied().unwrap_or(0) == fx.uses[borrow] + }; + let mut ok: FxHashSet = iters.drain(..).collect(); + ok.retain(|&l| reads.get(&l).copied().unwrap_or(0) == self.uses[l]); + ok.retain(|&l| made.contains(&l) || moves.iter().any(|&(_, to)| to == l)); + ok.retain(|&l| borrows.iter().all(|(&b, &from)| from != l || stepping(self, b))); + // A move joins two iterators that must both step in place, or neither. + loop { + let before = ok.len(); + for &(from, to) in &moves { + if ok.contains(&from) != ok.contains(&to) { + ok.remove(&from); + ok.remove(&to); + } + } + if ok.len() == before { + break; + } + } + for (b, from) in borrows { + if ok.contains(&from) { + self.stepped_borrows.insert(b, from); + } + } + // One moved into another and read nowhere else shares its variables: the other is + // assigned only by the move, so neither is live while the other is. + for &(from, to) in &moves { + if ok.contains(&from) && self.uses[from] == 1 { + self.stepped_into.insert(from, to); + } + } + self.stepped = ok; + } + + /// The local whose variables `local` holds its fields in: the last it is moved into. + pub(super) fn stepped_root(&self, mut local: Local) -> Local { + while let Some(&to) = self.stepped_into.get(&local) { + local = to; + } + local + } + + /// The array iterator a `next` receiver `op` borrows, if it steps in place. A range's + /// `next` steps one in place anyway. + pub(super) fn stepped_array(&self, op: &Operand<'tcx>) -> bool { + let (Operand::Copy(p) | Operand::Move(p)) = op else { + return false; + }; + p.as_local() + .and_then(|b| self.stepped_borrows.get(&b)) + .is_some_and(|&l| array_iter(self.tcx, self.mir.local_decls[l].ty).is_some()) + } + + /// The keys of `local`'s fields: its array and index, or its bounds. + fn stepped_keys(&self, local: Local) -> [&'static str; 2] { + match array_iter(self.tcx, self.mir.local_decls[local].ty) { + Some(_) => ["s", "i"], + None => ["start", "end"], + } + } + + /// Name the two variables `local` holds its fields in, unless it shares another's. A + /// read of either counts as one of memory, since `next` changes them in place. + pub(super) fn name_stepped(&mut self, local: Local, base: &str) { + if self.stepped_root(local) != local { + return; + } + let vars = self.stepped_keys(local).map(|key| { + let mut suffix = key.to_string(); + suffix[..1].make_ascii_uppercase(); + let name = self.b.fresh(&format!("{base}{suffix}")); + self.shared.insert(name.clone()); + name + }); + self.stepped_vars.insert(local, vars); + } + + /// Give each stepped local that shares its variables those of the local it shares. + pub(super) fn share_stepped(&mut self) { + for &local in &self.stepped { + let root = self.stepped_root(local); + if root != local { + let vars = self.stepped_vars[&root].clone(); + self.stepped_vars.insert(local, vars); + } + } + } + + /// `local` read whole, if it is stepped in place: an object of its variables, which + /// [`Self::set_stepped`] and [`stepped_field`] take apart again. + pub(super) fn stepped_value(&self, local: Local) -> Option { + let vars = self.stepped_vars.get(&local)?; + let keys = self.stepped_keys(local); + let fields = keys.into_iter().zip(vars); + Some(Expr::Object( + fields.map(|(k, v)| (Key::Name(k.into()), Expr::ident(v))).collect(), + )) + } + + /// Assign `local`'s variables the fields of `value`, as [`Self::stepped_make`] made it. + pub(super) fn set_stepped(&mut self, local: Local, value: Expr, out: &mut Vec) { + let value = match value { + Expr::Located(_, value) => *value, + value => value, + }; + // Anything else is refused already. + let Expr::Object(fields) = value else { + return; + }; + self.assigned[local] = true; + let vars = self.stepped_vars[&local].clone(); + for ((_, value), var) in fields.into_iter().zip(vars) { + // A move from a local that shares the variables. + if matches!(&value, Expr::Ident(name) if *name == var) { + continue; + } + let stmt = StmtKind::Expr(Expr::ident(&var).assign(value)).at(None); + self.emit(vec![stmt], Some(&var), false, out); + } + } + + /// An iterator stepped in place, from the `rt.Iter` its mapping makes: `{ s, i: 0 }` + /// from `rt.iterSlice(s)`, 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]| { + Expr::Object(fields.into_iter().map(|(k, v)| (Key::Name(k.into()), v)).collect()) + }; + match value { + Expr::Call(f, mut args) if rt(&f, "iterSlice") && args.len() == 1 => { + object([("s", args.pop().unwrap()), ("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)]) + } + Expr::Object(_) => value, + // Refused already. + Expr::Lit(lit) if lit == "undefined" => Expr::undefined(), + _ => self.err(span, "an iterator stepped in place that its mapping didn't make"), + } + } + + /// The next item of `it`, stepped in place, or `rt.DONE`. + pub(super) fn stepped_next(&self, it: &Expr) -> Expr { + let s = stepped_field(it, "s"); + let i = stepped_field(it, "i"); + Expr::Cond( + Box::new(i.clone().binary("<", s.clone().member("length"))), + Box::new(s.index(Expr::Postfix(Box::new(i), "++"))), + Box::new(Expr::Rt("DONE".into())), + ) + } + + /// The types of a stepped local's variables: its array and index, or its bounds. + pub(super) fn stepped_tys(&mut self, local: Local) -> [Type; 2] { + let ty = self.mir.local_decls[local].ty; + match array_iter(self.tcx, ty) { + Some(item) => [ + self.b.t.ty(Ty::new_slice(self.tcx, item), self.span), + Type::Builtin("number"), + ], + None => { + let ty::Adt(_, args) = ty.kind() else { + unreachable!("a range is a struct") + }; + let bound = self.b.t.ty(args.type_at(0), self.span); + [bound.clone(), bound] + } + } + } +} + +/// The field `key` of an iterator stepped in place: its variable, from the object +/// [`Fx::stepped_value`] reads it as. +pub(super) fn stepped_field(it: &Expr, key: &str) -> Expr { + match it { + Expr::Object(fields) => fields + .iter() + .find(|(k, _)| matches!(k, Key::Name(n) if n == key)) + .map(|(_, v)| v.clone()) + .expect("a stepped iterator's field"), + it => it.clone().member(key), + } +} diff --git a/ts/src/lower/mod.rs b/ts/src/lower/mod.rs index c5091c3f9..9fe8dd16c 100644 --- a/ts/src/lower/mod.rs +++ b/ts/src/lower/mod.rs @@ -14,14 +14,12 @@ mod iter; mod library; mod mir; mod num; -mod pat; mod task; use std::collections::VecDeque; use rustc_hir::def::{DefKind, Res}; use rustc_hir::def_id::{DefId, LocalDefId}; -use rustc_middle::thir::{ExprId, Thir}; use rustc_middle::ty::{ self, AdtDef, EarlyBinder, GenericArgsRef, Instance, InstanceKind, Ty, TyCtxt, TypeVisitableExt, TypingEnv, }; @@ -32,38 +30,9 @@ use crate::config::Config; use crate::program::{Program, Source, SymKind, Symbol}; use crate::ts::{self, Ctor, FieldId, Item, Loc, SymId, Type}; -/// Each function's THIR, copied before borrow checking steals it. -pub struct Bodies<'tcx> { - map: rustc_data_structures::fx::FxHashMap, ExprId)>, - /// No body: what a MIR lowering's library calls see, which pass their arguments lowered. - empty: Thir<'tcx>, -} - -impl<'tcx> Bodies<'tcx> { - pub fn collect(tcx: TyCtxt<'tcx>) -> Self { - let mut map = rustc_data_structures::fx::FxHashMap::default(); - for def_id in tcx.hir_body_owners() { - if !matches!(tcx.def_kind(def_id), DefKind::Fn | DefKind::AssocFn | DefKind::Closure) { - continue; - } - let Ok((thir, expr)) = tcx.thir_body(def_id) else { - continue; - }; - // Constant evaluation during type checking may have built this body's MIR - // already; translating it then fails with a span instead. - if !thir.is_stolen() { - map.insert(def_id, (thir.borrow().clone(), expr)); - } - } - let empty = Thir::new(rustc_middle::thir::BodyTy::Const(tcx.types.unit)); - Self { map, empty } - } -} - /// Translate what the config's roots reach, or `None` after reporting why not. -pub fn translate<'tcx>(tcx: TyCtxt<'tcx>, config: &Config, bodies: &Bodies<'tcx>, mir: bool) -> Option { - let mut t = Translator::new(tcx, config, bodies, None)?; - t.mir = mir; +pub fn translate<'tcx>(tcx: TyCtxt<'tcx>, config: &Config) -> Option { + let mut t = Translator::new(tcx, config, None)?; for root in &config.roots { t.root(root); } @@ -80,9 +49,8 @@ pub fn translate<'tcx>(tcx: TyCtxt<'tcx>, config: &Config, bodies: &Bodies<'tcx> /// Every construct translation refuses in the crate, reached from each of its items /// as if each were a root. -pub fn census<'tcx>(tcx: TyCtxt<'tcx>, config: &Config, bodies: &Bodies<'tcx>, mir: bool) -> Option { - let mut t = Translator::new(tcx, config, bodies, Some(Vec::new()))?; - t.mir = mir; +pub fn census<'tcx>(tcx: TyCtxt<'tcx>, config: &Config) -> Option { + let mut t = Translator::new(tcx, config, Some(Vec::new()))?; for def_id in tcx.hir_crate_items(()).definitions() { if matches!(tcx.def_kind(def_id), DefKind::Struct | DefKind::Enum | DefKind::Union) { t.adt(tcx.adt_def(def_id), tcx.def_span(def_id)); @@ -155,7 +123,6 @@ pub fn census<'tcx>(tcx: TyCtxt<'tcx>, config: &Config, bodies: &Bodies<'tcx>, m pub struct Translator<'a, 'tcx> { pub tcx: TyCtxt<'tcx>, - bodies: &'a Bodies<'tcx>, config: &'a Config, pub program: Program, instances: rustc_data_structures::fx::FxHashMap, SymId>, @@ -176,11 +143,9 @@ pub struct Translator<'a, 'tcx> { drops_cycle: bool, /// The classes given drop glue. glued: rustc_data_structures::fx::FxHashSet, - /// Whether bodies lower from MIR, the spike's prototype, rather than THIR. - pub mir: bool, - /// The drop glue made from each type's drop shim, by a MIR lowering. + /// The drop glue made from each type's drop shim. pub drop_shims: rustc_data_structures::fx::FxHashMap, SymId>, - /// The class of each coroutine instance a MIR lowering made. + /// The class of each coroutine instance. pub coroutines: rustc_data_structures::fx::FxHashMap, mir::coroutine::Info<'tcx>>, } @@ -220,12 +185,7 @@ pub struct Erased { } impl<'a, 'tcx> Translator<'a, 'tcx> { - fn new( - tcx: TyCtxt<'tcx>, - config: &'a Config, - bodies: &'a Bodies<'tcx>, - refusals: Option>, - ) -> Option { + fn new(tcx: TyCtxt<'tcx>, config: &'a Config, refusals: Option>) -> Option { if tcx.data_layout.pointer_size().bits() != 32 { tcx.dcx().err( "rust2-ts: translation needs a 32-bit target, such as wasm32-unknown-unknown, so usize is a number", @@ -234,7 +194,6 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } Some(Self { tcx, - bodies, config, program: Program::default(), instances: Default::default(), @@ -248,7 +207,6 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { drops_open: Default::default(), drops_cycle: false, glued: Default::default(), - mir: false, coroutines: Default::default(), drop_shims: Default::default(), }) @@ -319,11 +277,6 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { self.typing_env() } - /// A closure's THIR and body expression. - pub fn body(&self, def_id: LocalDefId) -> Option<(&'a Thir<'tcx>, ExprId)> { - self.bodies.map.get(&def_id).map(|(thir, expr)| (thir, *expr)) - } - fn root(&mut self, path: &str) { let Some(def_id) = self.config_item(path) else { return; @@ -1117,27 +1070,11 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { self.err(span, format!("unsupported function `{}`", tcx.def_path_str(def_id))); return; }; - let Some(local) = def_id.as_local() else { + if !def_id.is_local() { self.err(span, format!("`{}` is from another crate", tcx.def_path_str(def_id))); return; - }; - let function = match self.mir { - true => mir::function(self, instance), - false => { - let Some((thir, expr)) = self.bodies.map.get(&local) else { - self.err( - span, - format!( - "no body for `{}`: constant evaluation consumed it", - tcx.def_path_str(def_id) - ), - ); - return; - }; - body::function(self, instance, thir, *expr) - } - }; - let Some(mut function) = function else { + } + let Some(mut function) = mir::function(self, instance) else { return; }; function.sym = sym; @@ -1176,22 +1113,6 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } None } - - /// Whether invocations of the macro that made `span` are left out. - pub fn ignored_macro(&self, mut span: Span) -> bool { - // Walk out through the macros this one was expanded inside. - while span.from_expansion() { - let data = span.ctxt().outer_expn_data(); - if let Some(def_id) = data.macro_def_id { - let path = self.tcx.def_path_str(def_id); - if self.config.ignore_macros.contains(&path) { - return true; - } - } - span = data.call_site; - } - false - } } /// A short name for a type, to tell instances apart. diff --git a/ts/src/lower/num.rs b/ts/src/lower/num.rs index 866a41655..a573df464 100644 --- a/ts/src/lower/num.rs +++ b/ts/src/lower/num.rs @@ -104,7 +104,7 @@ impl Int { /// A literal of this type spelled `text`, JS number digits of `value`. A wide value /// past 2^53 is limbs, made from a bigint: `rt.u64Of(0xffffffffffffffffn)`. - pub fn spelled(self, text: String, value: i128) -> Expr { + fn spelled(self, text: String, value: i128) -> Expr { let safe = (1 - (1i128 << 53)..(1 << 53)).contains(&value) && (self.signed || value >= 0); match safe { true => Expr::lit(text), diff --git a/ts/src/lower/pat.rs b/ts/src/lower/pat.rs deleted file mode 100644 index c48f8150a..000000000 --- a/ts/src/lower/pat.rs +++ /dev/null @@ -1,313 +0,0 @@ -//! Patterns: a test of whether a value matches, and the bindings it makes. -//! -//! Both read the scrutinee through a path, a name or member chain that is free to -//! evaluate more than once. - -use rustc_middle::thir::{Pat, PatKind, PatRangeBoundary}; -use rustc_middle::ty::{self, Ty}; - -use super::AdtRepr; -use super::body::Body; -use super::library::Std; -use super::num::Int; -use crate::ts::{Expr, Stmt, StmtKind}; - -impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { - /// The test `scrut` must pass to match `pat`, or `None` if it always matches. - pub fn pat_test(&mut self, pat: &Pat<'tcx>, scrut: &Expr) -> Option { - let ty = self.subst(pat.ty); - match &pat.kind { - PatKind::Wild | PatKind::Missing => None, - PatKind::Binding { subpattern, .. } => subpattern.as_ref().and_then(|p| self.pat_test(p, scrut)), - PatKind::Deref { subpattern, .. } => self.pat_test(subpattern, scrut), - PatKind::Leaf { subpatterns } => { - let tests: Vec = subpatterns - .iter() - .filter_map(|f| { - let field = self.project(scrut.clone(), ty, rustc_abi::FIRST_VARIANT, f.field, pat.span); - self.pat_test(&f.pattern, &field) - }) - .collect(); - all(tests) - } - PatKind::Variant { - adt_def, - variant_index, - subpatterns, - .. - } => { - let mut tests = Vec::new(); - match Std::of(self.t.tcx, adt_def.did()) { - Some(Std::Option) => tests.push(match variant_index.index() { - 0 => scrut.clone().binary("===", Expr::undefined()), - _ => scrut.clone().binary("!==", Expr::undefined()), - }), - Some(Std::Poll) => tests.push(match variant_index.index() { - 0 => scrut.clone().binary("!==", Expr::Rt("Pending".into())), - _ => scrut.clone().binary("===", Expr::Rt("Pending".into())), - }), - Some(Std::Result) => tests.push(match variant_index.index() { - 0 => scrut.clone().member("ok"), - _ => scrut.clone().member("ok").not(), - }), - Some(Std::Entry) => { - tests.push(super::collections::entry_test(*adt_def, *variant_index, scrut.clone())) - } - Some(Std::Ordering) => tests.push( - scrut - .clone() - .binary("===", super::collections::ordering_variant(*variant_index)), - ), - None if adt_def.did().is_local() => { - let info = self.t.adt(*adt_def, pat.span); - let name = Expr::Str(adt_def.variant(*variant_index).name.to_string()); - match info.repr { - AdtRepr::Tags => tests.push(scrut.clone().binary("===", name)), - AdtRepr::Union => tests.push(scrut.clone().member("tag").binary("===", name)), - AdtRepr::Struct { .. } => {} - } - } - _ => { - self.t.err(pat.span, format!("a pattern on `{ty}`")); - return None; - } - } - for f in subpatterns { - let field = self.project(scrut.clone(), ty, *variant_index, f.field, pat.span); - if let Some(test) = self.pat_test(&f.pattern, &field) { - tests.push(test); - } - } - all(tests) - } - PatKind::Constant { value } => { - let constant = self.value(value.ty, value.valtree, pat.span); - match (&constant, ty.peel_refs().kind()) { - (Expr::Lit(t), ty::Bool) if t == "true" => Some(scrut.clone()), - (Expr::Lit(t), ty::Bool) if t == "false" => Some(scrut.clone().not()), - (_, ty::Int(_) | ty::Uint(_)) => { - Some(Int::of(ty.peel_refs()).unwrap().compare("===", scrut.clone(), constant)) - } - (_, ty::Bool | ty::Str) => Some(scrut.clone().binary("===", constant)), - _ => { - self.t.err(pat.span, format!("a constant pattern of type `{ty}`")); - None - } - } - } - PatKind::Range(range) => { - let mut tests = Vec::new(); - let compare = |op: &'static str, l: Expr, r: Expr| match Int::of(range.ty) { - Some(int) => int.compare(op, l, r), - None => l.binary(op, r), - }; - if let PatRangeBoundary::Finite(lo) = range.lo { - let lo = self.value(range.ty, lo, pat.span); - tests.push(compare("<=", lo, scrut.clone())); - } - if let PatRangeBoundary::Finite(hi) = range.hi { - let hi = self.value(range.ty, hi, pat.span); - let op = match range.end { - rustc_hir::RangeEnd::Included => "<=", - rustc_hir::RangeEnd::Excluded => "<", - }; - tests.push(compare(op, scrut.clone(), hi)); - } - all(tests) - } - PatKind::Slice { prefix, slice, suffix } | PatKind::Array { prefix, slice, suffix } => { - let mut tests = Vec::new(); - let fixed = matches!(pat.kind, PatKind::Array { .. }); - let n = prefix.len() + suffix.len(); - if !fixed { - let op = if slice.is_some() { ">=" } else { "===" }; - tests.push(scrut.clone().member("length").binary(op, Expr::lit(n.to_string()))); - } - for (i, p) in prefix.iter().enumerate() { - let elem = scrut.clone().index(Expr::lit(i.to_string())); - if let Some(test) = self.pat_test(p, &elem) { - tests.push(test); - } - } - for (i, p) in suffix.iter().enumerate() { - let elem = self.suffix_elem(scrut, ty, suffix.len() - i); - if let Some(test) = self.pat_test(p, &elem) { - tests.push(test); - } - } - if let Some(p) = slice - && let Some(_) = self.pat_test(p, scrut) - { - self.t.err(p.span, "a refutable pattern on a slice's rest"); - } - all(tests) - } - PatKind::Or { pats } => { - let mut tests = Vec::new(); - for p in pats.iter() { - if super::body::has_bindings(p) { - self.t.err(pat.span, "an or-pattern with bindings"); - return None; - } - tests.push(self.pat_test(p, scrut)?); - } - tests.into_iter().reduce(|a, b| a.binary("||", b)) - } - _ => { - self.t.err(pat.span, "unsupported pattern"); - None - } - } - } - - /// The element `from_end` places before the end of the slice `scrut`. - fn suffix_elem(&mut self, scrut: &Expr, ty: Ty<'tcx>, from_end: usize) -> Expr { - match ty.peel_refs().kind() { - ty::Array(_, len) if let Some(len) = len.try_to_target_usize(self.t.tcx) => { - scrut.clone().index(Expr::lit((len as usize - from_end).to_string())) - } - _ => scrut.clone().index( - scrut - .clone() - .member("length") - .binary("-", Expr::lit(from_end.to_string())), - ), - } - } - - /// Declare the bindings `pat` makes from `scrut`. An `owned` scrutinee is a - /// temporary, so a `Copy` value binds without a copy. - pub fn pat_bind(&mut self, pat: &Pat<'tcx>, scrut: &Expr, owned: bool, out: &mut Vec) { - let ty = self.subst(pat.ty); - match &pat.kind { - PatKind::Wild | PatKind::Missing | PatKind::Constant { .. } | PatKind::Range(_) => {} - // Bindings in alternatives are refused by `pat_test`; binding the first - // alternative's keeps that one error from cascading. - PatKind::Or { pats } => self.pat_bind(&pats[0], scrut, owned, out), - PatKind::Binding { - name, - var, - mode, - subpattern, - .. - } => { - let by_value = mode.0 == rustc_hir::ByRef::No; - if !by_value { - self.ref_binding(mode.0, ty, pat.span); - } - // A value that drops moves into its binding, read or not. - let moves = by_value && !self.t.is_copy(ty) && self.t.drops(ty); - // Binding has no effect in JS, and TypeScript refuses an unread local. - if subpattern.is_none() && !self.is_read(*var) && !moves { - return; - } - let mutable = mode.1 == rustc_ast::Mutability::Mut; - let value = match by_value && !owned { - true => self.copied(scrut.clone(), ty), - false => scrut.clone(), - }; - let name = self.bind_var(*var, *name, mutable, ty, pat.span, by_value); - let annotate = mutable.then(|| self.t.ty(ty, pat.span)); - out.push(StmtKind::decl(mutable, name, annotate, Some(value)).at(None)); - // Out of a place, which is left `undefined`. - if moves && !owned { - self.clear(scrut.clone(), out); - } - if let Some(sub) = subpattern { - self.pat_bind(sub, scrut, owned, out); - } - } - PatKind::Deref { subpattern, .. } => self.pat_bind(subpattern, scrut, false, out), - PatKind::Leaf { subpatterns } => { - for f in subpatterns { - let field = self.project(scrut.clone(), ty, rustc_abi::FIRST_VARIANT, f.field, pat.span); - self.pat_bind(&f.pattern, &field, owned, out); - } - } - PatKind::Variant { - variant_index, - subpatterns, - .. - } => { - // A payload changed in place would change every copy of a `Copy` enum, - // which JS shares. - let copy_enum = self.t.is_copy(ty.peel_refs()); - for f in subpatterns { - if copy_enum && binds_mut_ref(&f.pattern) { - self.t.err(f.pattern.span, "a `ref mut` binding into a `Copy` enum"); - } - let field = self.project(scrut.clone(), ty, *variant_index, f.field, pat.span); - self.pat_bind(&f.pattern, &field, owned, out); - } - } - PatKind::Slice { prefix, slice, suffix } | PatKind::Array { prefix, slice, suffix } => { - for (i, p) in prefix.iter().enumerate() { - let elem = scrut.clone().index(Expr::lit(i.to_string())); - self.pat_bind(p, &elem, owned, out); - } - for (i, p) in suffix.iter().enumerate() { - let elem = self.suffix_elem(scrut, ty, suffix.len() - i); - self.pat_bind(p, &elem, owned, out); - } - if let Some(p) = slice { - let start = Expr::lit(prefix.len().to_string()); - let end = match ty.peel_refs().kind() { - ty::Array(_, len) if let Some(len) = len.try_to_target_usize(self.t.tcx) => { - Expr::lit((len as usize - suffix.len()).to_string()) - } - _ => scrut - .clone() - .member("length") - .binary("-", Expr::lit(suffix.len().to_string())), - }; - let elem = match ty.peel_refs().kind() { - ty::Array(elem, _) | ty::Slice(elem) => *elem, - _ => { - self.t.err(pat.span, format!("a slice pattern on `{ty}`")); - return; - } - }; - let method = match elem.kind() { - ty::Uint(ty::UintTy::U8) => "subarray", - _ => "slice", - }; - if method == "slice" && binds_mut_ref(p) { - self.t.err( - p.span, - format!("a mutable borrow of a subslice of `{elem}`, which JS would copy, having no views"), - ); - } - // Its copy of the elements would drop them, and so would the place they stay in. - let rest_ty = self.subst(p.ty); - if !owned && !matches!(rest_ty.kind(), ty::Ref(..)) && self.t.drops(rest_ty) { - self.t.err( - p.span, - "a rest pattern that moves values that drop out of a place, which is not supported yet", - ); - } - let rest = scrut.clone().member(method).call(vec![start, end]); - self.pat_bind(p, &rest, true, out); - } - } - _ => { - self.t.err(pat.span, "unsupported pattern"); - } - } - } -} - -fn all(tests: Vec) -> Option { - tests.into_iter().reduce(Expr::and) -} - -fn binds_mut_ref(pat: &Pat<'_>) -> bool { - let mut found = false; - pat.walk_always(|p| { - if let PatKind::Binding { mode, .. } = p.kind - && let rustc_hir::ByRef::Yes(_, rustc_ast::Mutability::Mut) = mode.0 - { - found = true; - } - }); - found -} diff --git a/ts/src/lower/task.rs b/ts/src/lower/task.rs index d3466a295..f7f2a34e1 100644 --- a/ts/src/lower/task.rs +++ b/ts/src/lower/task.rs @@ -4,19 +4,18 @@ use rustc_middle::ty::{self, Ty}; use super::body::Body; -use super::library::{Args, Call, Std}; -use crate::ts::{Expr, Stmt}; +use super::library::{Call, Std}; +use crate::ts::Expr; /// A call of a standard library function on these types, or its arguments back if it is /// none of theirs. `Ok(None)` refuses it. -pub fn call<'tcx, 'x>( +pub fn call<'tcx>( b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, owner: &str, name: &str, - args: Args<'x>, - out: &mut Vec, -) -> Result, Args<'x>> { + args: Vec, +) -> Result, Vec> { let tcx = b.t.tcx; let std_of = |ty: Ty<'tcx>| match ty.peel_refs().kind() { ty::Adt(adt, _) => Std::of(tcx, adt.did()), @@ -25,47 +24,47 @@ pub fn call<'tcx, 'x>( let self_ty = call.args.types().next(); let self_std = self_ty.and_then(std_of); let e = match (owner, name) { - ("Arc", "new") => Expr::New(Box::new(Expr::Rt("Arc".into())), b.args(args, out)), - ("Arc", "downgrade") => Expr::New(Box::new(Expr::Rt("Weak".into())), b.args(args, out)), - ("Arc", "strong_count") => first(b, args, out).member("strong"), + ("Arc", "new") => Expr::New(Box::new(Expr::Rt("Arc".into())), args), + ("Arc", "downgrade") => Expr::New(Box::new(Expr::Rt("Weak".into())), args), + ("Arc", "strong_count") => first(args).member("strong"), ("Arc", "ptr_eq") => { - let [l, r] = two(b, args, out); + let [l, r] = two(args); l.binary("===", r) } - ("Weak", "upgrade") => Expr::rt("weakUpgrade", b.args(args, out)), - ("Weak", "strong_count") => first(b, args, out).member("arc").member("strong"), + ("Weak", "upgrade") => Expr::rt("weakUpgrade", args), + ("Weak", "strong_count") => first(args).member("arc").member("strong"), ("Weak", "ptr_eq") => { - let [l, r] = two(b, args, out); + let [l, r] = two(args); l.member("arc").binary("===", r.member("arc")) } - ("Clone", "clone") if self_std == Some(Std::Arc) => Expr::rt("arcClone", b.args(args, out)), - ("Clone", "clone") if self_std == Some(Std::Weak) => Expr::rt("weakClone", b.args(args, out)), + ("Clone", "clone") if self_std == Some(Std::Arc) => Expr::rt("arcClone", args), + ("Clone", "clone") if self_std == Some(Std::Weak) => Expr::rt("weakClone", args), // A waker is the executor's, whose `clone` is its own. - ("Clone", "clone") if self_std == Some(Std::Waker) => first(b, args, out).member("clone").call(vec![]), + ("Clone", "clone") if self_std == Some(Std::Waker) => first(args).member("clone").call(vec![]), ("Deref", "deref") | ("DerefMut", "deref_mut") => match self_std { - Some(Std::Arc | Std::Mutex | Std::MutexGuard) => first(b, args, out).member("value"), - Some(Std::Pin) => first(b, args, out), + Some(Std::Arc | Std::Mutex | Std::MutexGuard) => first(args).member("value"), + Some(Std::Pin) => first(args), _ => return Err(args), }, - ("Mutex", "new") => Expr::New(Box::new(Expr::Rt("Mutex".into())), b.args(args, out)), + ("Mutex", "new") => Expr::New(Box::new(Expr::Rt("Mutex".into())), args), // The mutex is its own guard, and a lock never fails on one thread. - ("Mutex", "lock") => first(b, args, out), + ("Mutex", "lock") => first(args), ("Result", "unwrap" | "expect") if call.args.types().nth(1).and_then(std_of) == Some(Std::PoisonError) => { - first(b, args, out) + first(args) } - ("Waker", "wake_by_ref") => first(b, args, out).member("wakeByRef").call(vec![]), - ("Waker", "wake") => first(b, args, out).member("wake").call(vec![]), + ("Waker", "wake_by_ref") => first(args).member("wakeByRef").call(vec![]), + ("Waker", "wake") => first(args).member("wake").call(vec![]), ("Waker", "will_wake") => { - let [l, r] = two(b, args, out); + let [l, r] = two(args); l.member("willWake").call(vec![r]) } ("Context", "waker" | "from_waker") | ("Pin", "new" | "new_unchecked" | "as_mut" | "get_mut" | "get_unchecked_mut") | ("future", "get_context") - | ("IntoFuture", "into_future") => first(b, args, out), + | ("IntoFuture", "into_future") => first(args), ("mem", "drop") => { let ty = call.args.type_at(0); - let value = first(b, args, out); + let value = first(args); match b.t.drop_value(value.clone(), ty, call.span) { Some(dropped) => dropped, None if value.is_path() => Expr::undefined(), @@ -77,12 +76,12 @@ pub fn call<'tcx, 'x>( Ok(Some(e)) } -fn first<'tcx>(b: &mut Body<'_, '_, 'tcx>, args: Args<'_>, out: &mut Vec) -> Expr { - b.args(args, out).into_iter().next().unwrap_or_else(Expr::undefined) +fn first(args: Vec) -> Expr { + args.into_iter().next().unwrap_or_else(Expr::undefined) } -fn two<'tcx>(b: &mut Body<'_, '_, 'tcx>, args: Args<'_>, out: &mut Vec) -> [Expr; 2] { - let mut values = b.args(args, out).into_iter(); +fn two(args: Vec) -> [Expr; 2] { + let mut values = args.into_iter(); [ values.next().unwrap_or_else(Expr::undefined), values.next().unwrap_or_else(Expr::undefined), diff --git a/ts/src/print.rs b/ts/src/print.rs index 653e2e378..c2a6e8216 100644 --- a/ts/src/print.rs +++ b/ts/src/print.rs @@ -7,7 +7,7 @@ use std::path::{Component, Path, PathBuf}; use oxc_sourcemap::SourceMapBuilder; use crate::program::{HEADER, ModPath, Program, SymKind, is_type_module, module_file}; -use crate::ts::{Ctor, Expr, FieldInit, Function, Item, Key, Loc, Param, Stmt, StmtKind, SymId, Target, Type}; +use crate::ts::{Ctor, Expr, FieldInit, Function, Item, Key, Loc, Param, Stmt, StmtKind, SymId, Type}; pub struct Printed { pub code: String, @@ -317,20 +317,7 @@ impl Refs { self.expr(program, cond); self.stmts(program, body); } - StmtKind::ForRange { start, end, body, .. } => { - self.expr(program, start); - self.expr(program, end); - self.stmts(program, body); - } - StmtKind::ForOf { iter, body, .. } => { - self.expr(program, iter); - self.stmts(program, body); - } StmtKind::Block { body, .. } => self.stmts(program, body), - StmtKind::Try { body, finally } => { - self.stmts(program, body); - self.stmts(program, finally); - } StmtKind::Catch { body, handler, .. } => { self.stmts(program, body); self.stmts(program, handler); @@ -354,7 +341,7 @@ impl Refs { fn expr(&mut self, program: &Program, e: &Expr) { match e { - Expr::Ident(_) | Expr::This | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) | Expr::Yield => {} + Expr::Ident(_) | Expr::This | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) => {} Expr::Sym(id) => self.use_sym(program, *id, true), Expr::Array(es) => es.iter().for_each(|e| self.expr(program, e)), Expr::Object(props) => props.iter().for_each(|(_, e)| self.expr(program, e)), @@ -597,21 +584,16 @@ impl Printer<'_> { self.start(); self.mark(f.loc); let name = self.program.syms[f.sym].name.clone(); - let star = if f.generator { "*" } else { "" }; match (module, &self.program.syms[f.sym].alias) { (true, Some(alias)) => { self.aliases.push((name.clone(), alias.clone())); - self.write(&format!("function{star} {name}(")); + self.write(&format!("function {name}(")); } - (true, None) => self.write(&format!("export function{star} {name}(")), - (false, _) => self.write(&format!("{star}{name}(")), + (true, None) => self.write(&format!("export function {name}(")), + (false, _) => self.write(&format!("{name}(")), } self.params(&f.params); - let mut ret = self.ty(&f.ret); - if f.generator { - self.uses_rt = true; - ret = format!("Generator"); - } + let ret = self.ty(&f.ret); self.write(&format!("): {ret} {{\n")); self.block_body(&f.body); self.start(); @@ -645,27 +627,6 @@ impl Printer<'_> { self.renames.get(name).map_or(name, String::as_str) } - fn target(&mut self, target: &Target) { - match target { - Target::Name(name) => { - let name = self.local(name).to_string(); - self.write(&name); - } - Target::Array(items) => { - self.write("["); - for (i, item) in items.iter().enumerate() { - if i > 0 { - self.write(", "); - } - if let Some(item) = item { - self.target(item); - } - } - self.write("]"); - } - } - } - fn params(&mut self, params: &[Param]) { for (i, param) in params.iter().enumerate() { if i > 0 { @@ -709,12 +670,13 @@ impl Printer<'_> { } StmtKind::Decl { mutable, - target, + name, ty, init, } => { self.write(if *mutable { "let " } else { "const " }); - self.target(target); + let name = self.local(name).to_string(); + self.write(&name); if let Some(ty) = ty { let ty = self.ty(ty); self.write(&format!(": {ty}")); @@ -777,41 +739,6 @@ impl Printer<'_> { self.start(); self.write("}\n"); } - StmtKind::ForRange { - label, - name, - start, - end, - inclusive, - body, - } => { - self.label(label); - let name = self.local(name).to_string(); - self.write(&format!("for (let {name} = ")); - self.expr(start, 2); - let op = if *inclusive { "<=" } else { "<" }; - self.write(&format!("; {name} {op} ")); - self.expr(end, 13); - self.write(&format!("; {name}++) {{\n")); - self.block_body(body); - self.start(); - self.write("}\n"); - } - StmtKind::ForOf { - label, - name, - iter, - body, - } => { - self.label(label); - let name = self.local(name).to_string(); - self.write(&format!("for (const {name} of ")); - self.expr(iter, 2); - self.write(") {\n"); - self.block_body(body); - self.start(); - self.write("}\n"); - } StmtKind::Block { label, body } => { self.label(label); self.write("{\n"); @@ -819,15 +746,6 @@ impl Printer<'_> { self.start(); self.write("}\n"); } - StmtKind::Try { body, finally } => { - self.write("try {\n"); - self.block_body(body); - self.start(); - self.write("} finally {\n"); - self.block_body(finally); - self.start(); - self.write("}\n"); - } StmtKind::Catch { body, name, handler } => { self.write("try {\n"); self.block_body(body); @@ -1013,7 +931,6 @@ impl Printer<'_> { self.write("}"); } } - Expr::Yield => self.write("yield"), Expr::Lambda(params, body) => { self.write("("); self.params(params); @@ -1171,7 +1088,7 @@ fn binary_prec(op: &str) -> u8 { fn prec(e: &Expr) -> u8 { match e { - Expr::Assign(..) | Expr::Arrow(..) | Expr::Lambda(..) | Expr::Yield => 3, + Expr::Assign(..) | Expr::Arrow(..) | Expr::Lambda(..) => 3, Expr::Cond(..) => 4, Expr::Binary(_, op, _) => binary_prec(op), Expr::As(..) => 12, @@ -1209,8 +1126,8 @@ pub fn quote(s: &str) -> String { fn collect_locals(stmts: &[Stmt], out: &mut Vec) { for stmt in stmts { match &stmt.kind { - StmtKind::Decl { target, init, .. } => { - collect_target(target, out); + StmtKind::Decl { name, init, .. } => { + out.push(name.clone()); if let Some(init) = init { collect_expr_locals(init, out); } @@ -1225,24 +1142,7 @@ fn collect_locals(stmts: &[Stmt], out: &mut Vec) { collect_expr_locals(cond, out); collect_locals(body, out); } - StmtKind::ForRange { - name, start, end, body, .. - } => { - out.push(name.clone()); - collect_expr_locals(start, out); - collect_expr_locals(end, out); - collect_locals(body, out); - } - StmtKind::ForOf { name, iter, body, .. } => { - out.push(name.clone()); - collect_expr_locals(iter, out); - collect_locals(body, out); - } StmtKind::Block { body, .. } => collect_locals(body, out), - StmtKind::Try { body, finally } => { - collect_locals(body, out); - collect_locals(finally, out); - } StmtKind::Catch { body, name, handler } => { collect_locals(body, out); out.push(name.clone()); @@ -1265,13 +1165,6 @@ fn collect_locals(stmts: &[Stmt], out: &mut Vec) { } } -fn collect_target(target: &Target, out: &mut Vec) { - match target { - Target::Name(name) => out.push(name.clone()), - Target::Array(items) => items.iter().flatten().for_each(|t| collect_target(t, out)), - } -} - fn collect_expr_locals(e: &Expr, out: &mut Vec) { match e { Expr::Arrow(params, _, body) => { @@ -1300,6 +1193,6 @@ fn collect_expr_locals(e: &Expr, out: &mut Vec) { collect_expr_locals(b, out); collect_expr_locals(c, out); } - Expr::Ident(_) | Expr::This | Expr::Sym(_) | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) | Expr::Yield => {} + Expr::Ident(_) | Expr::This | Expr::Sym(_) | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) => {} } } diff --git a/ts/src/ts.rs b/ts/src/ts.rs index 6b7e04881..4d7ee48c9 100644 --- a/ts/src/ts.rs +++ b/ts/src/ts.rs @@ -50,8 +50,6 @@ pub enum Expr { /// `e as T`: a literal whose type TypeScript would widen, or an integer cast to /// another integer type with the same value. As(Box, Type), - /// `yield`, which a generator resumes from with the next `rt.Context`. - Yield, Located(Loc, Box), } @@ -124,10 +122,6 @@ impl Expr { } } - pub fn and(self, rhs: Expr) -> Self { - self.binary("&&", rhs) - } - /// This without an outer `as`, where the context already gives the type. pub fn typed(self) -> Self { match self { @@ -186,7 +180,7 @@ pub enum StmtKind { Expr(Expr), Decl { mutable: bool, - target: Target, + name: String, ty: Option, init: Option, }, @@ -201,32 +195,12 @@ pub enum StmtKind { cond: Expr, body: Vec, }, - /// `for (let name = start; name < end; name++)`, or `<=` if `inclusive`. - ForRange { - label: Option, - name: String, - start: Expr, - end: Expr, - inclusive: bool, - body: Vec, - }, - ForOf { - label: Option, - name: String, - iter: Expr, - body: Vec, - }, Block { label: Option, body: Vec, }, Break(Option), Continue(Option), - /// `try { body } finally { finally }`: what `finally` drops is dropped on every exit. - Try { - body: Vec, - finally: Vec, - }, /// `try { body } catch (name) { handler }`. Catch { body: Vec, @@ -263,28 +237,20 @@ impl StmtKind { }; Self::Decl { mutable, - target: Target::Name(name.into()), + name: name.into(), ty, init, } } } -/// What a declaration binds: a name, or an array destructured into names. -#[derive(Clone, Debug)] -pub enum Target { - Name(String), - /// `[a, , [b, c]]`; `None` skips an element. - Array(Vec>), -} - impl Stmt { /// Whether control never reaches the statement after this one. pub fn diverges(&self) -> bool { match &self.kind { StmtKind::Return(_) | StmtKind::Break(_) | StmtKind::Continue(_) | StmtKind::Throw(_) => true, StmtKind::If { then, els, .. } => diverges(then) && diverges(els), - StmtKind::Block { label: None, body } | StmtKind::Try { body, .. } => diverges(body), + StmtKind::Block { label: None, body } => diverges(body), StmtKind::While { label, cond: Expr::Lit(cond), @@ -304,61 +270,16 @@ fn breaks_out(stmts: &[Stmt], label: Option<&str>, nested: bool) -> bool { StmtKind::Break(Some(target)) => Some(target.as_str()) == label, StmtKind::If { then, els, .. } => breaks_out(then, label, nested) || breaks_out(els, label, nested), StmtKind::Block { body, .. } => breaks_out(body, label, nested), - StmtKind::Try { body, finally } => breaks_out(body, label, nested) || breaks_out(finally, label, nested), StmtKind::Catch { body, handler, .. } => breaks_out(body, label, nested) || breaks_out(handler, label, nested), // An unlabeled `break` in a case leaves the switch. StmtKind::Switch { cases, default, .. } => { cases.iter().any(|(_, body)| breaks_out(body, label, true)) || breaks_out(default, label, true) } - StmtKind::While { body, .. } | StmtKind::ForRange { body, .. } | StmtKind::ForOf { body, .. } => { - breaks_out(body, label, true) - } + StmtKind::While { body, .. } => breaks_out(body, label, true), _ => false, }) } -/// Whether `stmts` name the local `name` anywhere, their closures included. -pub fn mentions(stmts: &[Stmt], name: &str) -> bool { - let expr = |e: &Expr| e.mentions(name); - stmts.iter().any(|stmt| match &stmt.kind { - StmtKind::Expr(e) | StmtKind::Return(Some(e)) | StmtKind::Throw(e) => expr(e), - StmtKind::Decl { init, .. } => init.as_ref().is_some_and(expr), - StmtKind::Catch { body, handler, .. } => mentions(body, name) || mentions(handler, name), - StmtKind::Switch { - disc, cases, default, .. - } => { - expr(disc) || cases.iter().any(|(test, body)| expr(test) || mentions(body, name)) || mentions(default, name) - } - StmtKind::Declare { .. } => false, - StmtKind::If { cond, then, els } => expr(cond) || mentions(then, name) || mentions(els, name), - StmtKind::While { cond, body, .. } => expr(cond) || mentions(body, name), - StmtKind::ForRange { start, end, body, .. } => expr(start) || expr(end) || mentions(body, name), - StmtKind::ForOf { iter, body, .. } => expr(iter) || mentions(body, name), - StmtKind::Block { body, .. } => mentions(body, name), - StmtKind::Try { body, finally } => mentions(body, name) || mentions(finally, name), - StmtKind::Return(None) | StmtKind::Break(_) | StmtKind::Continue(_) => false, - }) -} - -impl Expr { - fn mentions(&self, name: &str) -> bool { - match self { - Self::Ident(ident) => ident == name, - Self::This | Self::Sym(_) | Self::Rt(_) | Self::Lit(_) | Self::Str(_) | Self::Yield => false, - Self::Array(es) => es.iter().any(|e| e.mentions(name)), - Self::Object(props) => props.iter().any(|(_, e)| e.mentions(name)), - Self::Member(e, _) | Self::Unary(_, e) | Self::Postfix(e, _) | Self::Located(_, e) | Self::As(e, _) => { - e.mentions(name) - } - Self::Index(a, b) | Self::Binary(a, _, b) | Self::Assign(a, b) => a.mentions(name) || b.mentions(name), - Self::Call(f, args) | Self::New(f, args) => f.mentions(name) || args.iter().any(|e| e.mentions(name)), - Self::Cond(a, b, c) => a.mentions(name) || b.mentions(name) || c.mentions(name), - Self::Arrow(_, _, body) => mentions(body, name), - Self::Lambda(_, body) => body.mentions(name), - } - } -} - /// Whether control never falls off the end of `stmts`. pub fn diverges(stmts: &[Stmt]) -> bool { stmts.last().is_some_and(Stmt::diverges) @@ -391,9 +312,6 @@ pub struct Function { pub body: Vec, pub loc: Option, pub doc: Option, - /// An async body, run as a generator: `function*`, returning `Generator`. - pub generator: bool, } #[derive(Clone, Debug)] diff --git a/ts/tests/differential.ts b/ts/tests/differential.ts index 208b377b4..e23d70c1c 100644 --- a/ts/tests/differential.ts +++ b/ts/tests/differential.ts @@ -129,7 +129,7 @@ if (wideArg === "wide") { const u = i % 3 === 0 ? x : values[(i * 7) % values.length]; const v = values[(i * 13 + 5) % values.length]; const shift = shifts[i++ % shifts.length]; - for (let kind = 0; kind < 24; kind++) { + for (let kind = 0; kind < 25; kind++) { for (const op of [3, 9]) cases.push(Uint8Array.of(op, kind, ...be(x), ...be(y), shift)); for (const op of [4, 10]) cases.push(Uint8Array.of(op, kind, ...be(x), ...be(y), ...be(u), ...be(v), shift)); } diff --git a/ts/tests/fixtures.rs b/ts/tests/fixtures.rs index 4e86fa754..3f9dda273 100644 --- a/ts/tests/fixtures.rs +++ b/ts/tests/fixtures.rs @@ -56,25 +56,6 @@ fn translated(name: &str) -> PathBuf { out } -/// Run the driver on a fixture with bodies lowered from MIR, the spike's prototype. -fn translate_mir(name: &str) -> (PathBuf, Output) { - let out = scratch().join(name).join("mir"); - let config = fixture(name).join("ts.toml"); - let args: [&std::ffi::OsStr; 4] = ["--out".as_ref(), out.as_ref(), "--lower".as_ref(), "mir".as_ref()]; - let output = driver(name, &config, &args, "mir"); - (out, output) -} - -fn translated_mir(name: &str) -> PathBuf { - let (out, output) = translate_mir(name); - assert!( - output.status.success(), - "translating {name} from MIR failed:\n{}", - String::from_utf8_lossy(&output.stderr) - ); - out -} - /// The generated TypeScript, by path relative to `dir`, without the runtime. fn sources(dir: &Path) -> Vec<(PathBuf, String)> { let mut files = Vec::new(); @@ -271,7 +252,6 @@ fn shake(out: &Path) { "Err", "Ok", "Panic", - "at", "checked", "clamp", "idx", @@ -299,14 +279,6 @@ fn shake(out: &Path) { } } -/// The codec with bodies lowered from MIR: the same differential test, without a snapshot. -#[test] -fn codec_mir() { - let out = translated_mir("codec"); - typecheck(&out); - differential("codec-fixture", &out, "harness.ts", 20_000, &[]); -} - /// Adding a root changes only the output of what it reaches: everything else keeps its /// text and order, though translation reaches it in another order. #[test] @@ -390,13 +362,6 @@ fn lang() { lang_differential(&out); } -/// The language fixture with bodies lowered from MIR. -#[test] -fn lang_mir() { - let out = translated_mir("lang"); - lang_differential(&out); -} - fn lang_differential(out: &Path) { // Hand-written callers, type-checked against the output they call: one runs it, and // one mixes integer types, which `tsc` must refuse. @@ -416,13 +381,6 @@ fn task() { task_differential(&out); } -/// Futures and drops with bodies lowered from MIR: each async body a state machine. -#[test] -fn task_mir() { - let out = translated_mir("task"); - task_differential(&out); -} - fn task_differential(out: &Path) { let harness = manifest_dir().join("tests").join("task.ts").display().to_string(); let text = format!( @@ -485,18 +443,11 @@ fn unwinding(out: &Path, entry: &str, scripts: u32) { #[test] fn reject() { let (out, output) = translate("reject"); - rejected(&out, &output, "expected.txt"); -} - -/// What lowering from MIR refuses in the same fixture. -#[test] -fn reject_mir() { - let (out, output) = translate_mir("reject"); - rejected(&out, &output, "expected-mir.txt"); + rejected(&out, &output); } -/// The errors of a failed translation, each with where it points, against `expected`. -fn rejected(out: &Path, output: &Output, expected: &str) { +/// The errors of a failed translation, each with where it points, against `expected.txt`. +fn rejected(out: &Path, output: &Output) { assert!(!output.status.success(), "translating reject succeeded"); assert!(!out.join("lib.ts").exists(), "a failed translation wrote output"); let stderr = String::from_utf8_lossy(&output.stderr); @@ -512,7 +463,7 @@ fn rejected(out: &Path, output: &Output, expected: &str) { got.push('\n'); } } - let path = fixture("reject").join(expected); + let path = fixture("reject").join("expected.txt"); if std::env::var_os("UPDATE_EXPECT").is_some() { std::fs::write(&path, &got).unwrap(); return;