diff --git a/quest/m2/ts-byte-views/README.md b/quest/m2/ts-byte-views/README.md index bc527cf2d..6a946afb1 100644 --- a/quest/m2/ts-byte-views/README.md +++ b/quest/m2/ts-byte-views/README.md @@ -17,7 +17,7 @@ kept them as `(data, start, length)` made Chrome's varint decode 2.3-2.9x and fr Decided with the maintainer on 2026-10-27: scalar-replace values built of byte slices, scalars, tuples, `Option`, `Result`, and `ControlFlow`, materializing an object only where -one escapes, in three pieces that each land and measure alone (the children below). +one escapes, in pieces that each land and measure alone (the children below). The precedents are `stepped` iterators, `range_nexts`, and `place_opts`, which a general pass could later absorb. @@ -30,6 +30,5 @@ Public API: the translator's output for byte slices. ## Required -- [Byte slices passed as parts](/quest/m2/ts-byte-views/arguments.md) - a function takes a slice's parts as arguments -- [Byte slices returned](/quest/m2/ts-byte-views/returns.md) - a function returns a split's parts without an object +- [Byte slices passed and returned as parts](/quest/m2/ts-byte-views/returns.md) - a function takes a slice's parts and returns a split's parts without an object - [Byte slices in fields](/quest/m2/ts-byte-views/fields.md) - a private slice field is three fields diff --git a/quest/m2/ts-byte-views/arguments.md b/quest/m2/ts-byte-views/arguments.md deleted file mode 100644 index 4b8776fbc..000000000 --- a/quest/m2/ts-byte-views/arguments.md +++ /dev/null @@ -1,22 +0,0 @@ -# [M] Byte slices passed as parts - -## Goal - -A translated function that takes a byte slice outside the API boundary takes its parts -(`data`, `start`, `length`) as arguments instead of an `rt.ByteSlice`, and Chrome's varint -and frame decode on `just ts bench` are faster than `main`, with every differential test -passing. - -## Plan - -Decided with the maintainer on 2026-10-27, from -[#138](https://github.com/moq-dev/rust2/pull/138): its per-function scratch return made -Chrome slower than `main` (varint quic/1B 12.0 to 15.2 ns, frames 3B-reads 152 to 208 ns), -since V8 already removes most of `main`'s temporaries once it inlines. A hand edit that -also passed slices as parts looked 20-40% faster on varint and 30% on frames lite-06, but -18% slower on group lite-06, on an overloaded host, so measure on a quiet one first. - -- Only functions outside the API boundary that are never used as a value, as for returns. -- Report each workload in Chrome, Firefox, Node, and Bun; Chrome decides. - -Public API: the translator's output for byte slices. diff --git a/quest/m2/ts-byte-views/fields.md b/quest/m2/ts-byte-views/fields.md index 9ad7dbdb3..883128d39 100644 --- a/quest/m2/ts-byte-views/fields.md +++ b/quest/m2/ts-byte-views/fields.md @@ -26,4 +26,4 @@ three `#private` fields. ## Required -- [Byte slices returned](/quest/m2/ts-byte-views/returns.md) - the measurement this one builds on +- [Byte slices passed and returned as parts](/quest/m2/ts-byte-views/returns.md) - the measurement this one builds on diff --git a/quest/m2/ts-byte-views/returns.md b/quest/m2/ts-byte-views/returns.md index 07167df9b..1024b011f 100644 --- a/quest/m2/ts-byte-views/returns.md +++ b/quest/m2/ts-byte-views/returns.md @@ -1,34 +1,81 @@ -# [M] Byte slices returned +# [L] Byte slices passed and returned as parts ## Goal -A translated function that returns a value built of byte slices and scalars, such as -`Result<(&[u8], T), E>`, hands its parts to the caller without an object, and Chrome's -varint and frame decode on `just ts bench` are faster than with slices passed as parts -alone, with every differential test passing. +A translated function outside the API boundary takes each byte slice parameter as its parts +(`data`, `start`, `length`), and one that returns a `Result` of byte slices and scalars, such +as `Result<(u64, &[u8]), E>`, returns the error or `undefined`, with its payload in a +module-level out slot. Chrome's varint and frame decode on `just ts bench` are faster than +`main`, no workload is meaningfully slower in any engine, and every differential test passes. ## Plan -The [epic's](/quest/m2/ts-byte-views/README.md) hand edit measured Chrome 1.84x on varint -decode and 1.65x on frames with locals and returns, against [#120](https://github.com/moq-dev/rust2/pull/120). +Decided with the maintainer on 2026-10-28: this absorbs passing slices as parts, which +[#160](https://github.com/moq-dev/rust2/pull/160) implemented. Alone, parts gain nothing in +Chrome, since V8 already removes a slice object that doesn't escape once it inlines, and +Node's varint decode is 11-15% slower. They land only with the return ABI ("e1"). +[#138](https://github.com/moq-dev/rust2/pull/138)'s per-function scratch measured slower +than `main`: copying between scratches when one function returns another's result cost the +most. One out slot per payload type, which a forwarded result already fills, avoids that. -Decided with the maintainer on 2026-10-27, from -[#138](https://github.com/moq-dev/rust2/pull/138): remeasure after -[arguments as parts](/quest/m2/ts-byte-views/arguments.md). #138 built a per-function -scratch object (the function returns which variant it made and writes the parts into its -module-level scratch), and it measured slower than `main` in Chrome (varint quic/1B 12.0 -to 15.2 ns, frames 3B-reads 152 to 208 ns). One shared scratch per return type, reading -only the branch taken, measured about even; module `let`s measured 0.93x. Its branch keeps -the code. Pick the ABI only if it beats arguments alone. - -- Only functions outside the API boundary that are never used as a value: not roots, fn - pointers, or closures. -- The callee writes its scratch at the JS `return`, after its MIR drops ran, so a `Drop` - that re-enters cannot overwrite it; the caller reads it at once, and temporary folding - never delays that read. +- Only functions outside the API boundary: not roots or closures. A function used as a + value is wrapped in an arrow that rebuilds the `Result`. +- The callee writes its slot at the JS `return`, after its MIR drops ran; the caller reads + it at once, before any other call. +- Start the slot's number fields as `undefined`, not `0`. Such a field holds any value once + a small integer is written (V8's `--trace-generalization`), so a write of a number that is + no small integer, as an 8-byte varint is, boxes a new one into an old object. A field + that starts as `0` stays a double written in place, but a slot that held one such number + converts every small one read after: on Chrome, `p_0` starting at `0` took QUIC and + leading-ones 8-byte varints from 1.13x and 1.24x `main`'s time to 0.88x and 1.06x, and + frame decode from 0.83x and 0.67x to 0.90x and 0.76x (2026-10-29, interleaved, a busy + host). Starting the starts and lengths at `0` changed nothing. +- Measured by hand edits of the codec's translation against `main`, Chrome first (2026-10-28, + on a busy host, so confirm on a quiet one): with the slot's fields tagged, Chrome's varint + and frame decode were each about 1.25x faster and group decode 1.06x, Node 1.33x and + 1.40x, Firefox 1.21x and 1.10x, Bun even and 1.12x. Leading-ones varints of 8 bytes + measured 0.84x, within that run's noise. +- Decided with the maintainer on 2026-10-28: the translator writes the slot ("e1e"), its + fields starting as `undefined`. Land only if Chrome's varint and frame decode both beat + `main` on a quiet host, with the A/A route under 5% at the median and the max. +- Std's functions keep returning their `Result` whole, as their callers take it apart + already. A slot sits beside the first function in source order that writes it, so its + place doesn't depend on the order translation reaches them. `?`'s `Err` assigns a + result held as its parts, so a function with early returns writes the slot at each. +- Measured from the translator's own output on 2026-10-29, four `just ts bench` runs against + `main` at ccd52a0e. Chrome took 0.79-0.81 of `main`'s time on varint decode and 0.79-0.81 + on frame decode, and Node 0.68-0.78 and 0.71-0.72. No run's Chrome A/A came under 5% at the + max: 5.5%, 61%, 16%, and 5.1%, with medians of 0.6-2.0%. It doesn't land on those runs. +- Open: Chrome's `time/u64` conversions took 1.11-1.17x `main`'s time in all four runs, with + that workload's A/A within 4%, and `btree/` 1.08-1.28x in three of them. Swapping which + route is `translated` kept `main` faster, so it isn't the route's place in the run. Their + functions translate to the same text on both, and a harness of their own, running every + workload in a fixed or shuffled order, timed them within 3% of `main`. So the gap is in + how the bench drives them, not in their translation. Find which before landing. +- Leading-ones varints of 8 bytes took 1.06-1.24x `main`'s time: `read_leading_ones` is too + big to inline, so each call boxes its value into the slot (above), where `main` returned + a new array. Returning the `Ok`'s first number, rather than writing it to the slot, would + avoid both the box and the conversion: an ABI change for the maintainer to weigh. +- Measured again on 2026-10-29 evening, other agents held, against `main` at ccd52a0e. CI + jobs on the host's runners started during both deciding runs, and neither met the A/A + rule: Chrome's was 4.0% at the median and 28% at the max, then 0.9% and 7.0%. Chrome took + 0.81x and 0.79x `main`'s time on varint decode, 1.01x and 0.81x on frame decode, 1.02x and + 1.03x on group decode, 1.18x and 0.84x on `btree/`, and 1.08x on `time/` conversions in + both. Node took 0.68-0.74x on varint and 0.71x on frame decode. +- Timed alone, `time/` and `btree/` on the bench still put `time/u64` at 1.12-1.18x `main`, + with the A/A within 6%, so the other workloads don't cause it. `btree/` swung from + 1.12-1.26x to 0.85-0.94x. One bench run under `--trace-turbo-inlining` showed this + branch's `rescale` deopting 1,892 times, from Turbofan code compiled on stack replacement + before the `put_u64` calls after its loop had run, where `main`'s deopted 28 times; but + under `--trace-deopt` alone it deopted 4 and 7 times, so that loop came from the tracing. +- `rescale`'s only change from `main` is its `take_u64` calls: `take_u64` takes its slice + as parts but makes it an `rt.ByteSlice` on entry, so each caller holding one splits it + for the callee to make it again. That breaks this file's rule that nothing is made more + often than before, but at 5 objects per 1024 conversions it can't be 8%. Not passing as + parts a parameter its body makes on entry needs each callee's analysis before its + callers are lowered. A hand edit of that (all outputs equal) deopted 0 and 1 times. +- Parked as a draft until the host is quiet, with its runners frozen. Then run the + deciding bench, judged on family geomeans, and time the `take_u64` hand edit beside + this branch, to see whether the call's shape is `time/`'s gap. Public API: the translator's output for byte slices. - -## Required - -- [Byte slices passed as parts](/quest/m2/ts-byte-views/arguments.md) - the measured win, landed first diff --git a/ts/MIGRATE.md b/ts/MIGRATE.md index e1a7ecdb1..f32e271fd 100644 --- a/ts/MIGRATE.md +++ b/ts/MIGRATE.md @@ -2,6 +2,15 @@ ## Unreleased +- A function the config's roots don't name takes each `&[u8]` or `&[u8; N]` parameter + whose object its body never makes as its `data`, `start`, and `length`: + `read(buf, form)` is `read(buf.data, buf.start, buf.length, form)`. A caller takes + which from the output. One that returns a `Result` of byte slices + and scalars returns its error or `undefined`, and leaves the `Ok`'s parts in a + module-level slot, such as `sliceOut`. If the `Ok`'s first part is a number, it returns + that, or `undefined` for an error, and leaves the rest, or the error as `err`, in the + slot, such as `readOut`. A root still takes an `rt.ByteSlice` and returns + the `Result`. - `rt.btreeCollect` takes whether it sorts and the keys' `!ne` after the entries, and `rt.btreeCollectKeys` the keys' `PartialOrd::lt` and `!ne`, as in `rt.btreeCollect(m, entries, true, Key.eq$cmp_PartialEq)`; neither takes a test for keys diff --git a/ts/README.md b/ts/README.md index 0d9bf44a2..27002c650 100644 --- a/ts/README.md +++ b/ts/README.md @@ -678,8 +678,35 @@ they need. often than before stays one. `just ts bench` measured the codec's varint decode at 0.49 times the objects' time in Chrome, 0.57 in Firefox, 0.64 in Node, and 0.56 in Bun at the geometric mean, and frame decode at 0.61, 0.56, 0.70, and 0.61, with the A/A route - within 0.04 and encode no slower. A parameter, a return, and a field are still a - `ByteSlice` ([byte slices without objects](/quest/m2/ts-byte-views/README.md)). + within 0.04 and encode no slower. A field is still a `ByteSlice`, as is a return but + for the `Result`s below ([byte slices without objects](/quest/m2/ts-byte-views/README.md)). +- A function only translated code calls takes each `&[u8]` or `&[u8; N]` parameter as + three, its `data`, `start`, and `length`, which its body holds as that local's parts: + not a root, which the outside calls, a closure, or an `async fn`. One whose object the + body would make anyway, to borrow it, to pass it to a function taking it whole, or at + all, it takes whole: as parts, the callee would just make the object instead of the caller. + That made Chrome's `btree/` workloads 1.06x `main`'s time through a helper that + rebuilt the slice it was passed. What a body makes depends on what its callees take, so + the functions a call reaches settle together, recursion included, each dropping the + slices it would make until none does. The function as a value is an arrow that takes + the slice whole. `just ts bench` measured parts + no faster than passing the slice whole, since V8 already removes what an inlined call + doesn't keep: Chrome's varint decode at 0.98-0.99 times the time and frame decode at + 1.01-1.05 over two runs, with the A/A route within 0.05, Firefox and Bun within their + noise, and Node's varint decode at 1.11-1.15. +- A function of the crate's that only translated code calls and that returns a `Result` + of byte slices and scalars, such as `Result<(u64, &[u8]), E>`, whose error is one JS + value that is never `undefined`, writes the `Ok`'s parts into a module-level slot and returns the error or + `undefined`. The slot is shared by every function returning that payload type, named + for the first of them in source order with its suffix, as `readOut` or `leadOut$u16`. + The function writes it at its JS `return`, after its drops, and its caller reads it at + once, so one that returns another's result as is returns the call. The slot's fields + start as `undefined`, so V8 keeps them tagged. When the `Ok`'s first part is a number, + the function returns that, or `undefined` for an error, and writes the error into the + slot instead: V8 boxes a number past 2^31 that a function too big to inline writes into + the long-lived slot, which made Chrome's 8-byte leading-ones varints 1.06-1.09x `main`'s + time. A slice's bytes stay in the slot, since returning them gave back frame decode. The + function as a value is an arrow that rebuilds the `Result`. - A `BTreeMap` is a B+ tree of up to 64 keys a node, O(log n) as std's B-tree is: its leaves hold the keys and values and link to their neighbors, which iterators walk from either end, and its branches hold each child's lower bound. A node's slots shift in a diff --git a/ts/fixtures/codec/expected/coding/decode.Decoder.ts b/ts/fixtures/codec/expected/coding/decode.Decoder.ts index bd732b59d..18a6a3454 100644 --- a/ts/fixtures/codec/expected/coding/decode.Decoder.ts +++ b/ts/fixtures/codec/expected/coding/decode.Decoder.ts @@ -2,7 +2,7 @@ import * as rt from "../rt.ts"; import * as DecodeError from "../coding/decode.DecodeError.ts"; -import { read } from "../coding/varint.ts"; +import { read, readOut } from "../coding/varint.ts"; import type * as Form from "../coding/varint.Form.ts"; import { mapErr$06mnjtr as result_mapErr$06mnjtr, inspectErr$156koiv } from "../core/result.ts"; import type * as Control from "../stats.Control.ts"; @@ -61,15 +61,20 @@ export function isEmpty(self: Decoder): boolean { } /** Read `len` raw bytes. */ -export function slice(self: Decoder, len: rt.usize): rt.Result { +export function slice(self: Decoder, len: rt.usize): DecodeError.DecodeError | undefined { const slice: rt.ByteSlice = self.buf; if (len <= slice.length) { self.buf = new rt.ByteSlice(slice.data, slice.start + len, slice.length - len); - return rt.Ok(new rt.ByteSlice(slice.data, slice.start, len)); + sliceOut.pData = slice.data; + sliceOut.pStart = slice.start; + sliceOut.pLen = len; + return undefined; } - return rt.Err(short(self, len)); + return short(self, len); } +export const sliceOut: { pData: Uint8Array; pStart: number; pLen: number } = { pData: undefined as never, pStart: undefined as never, pLen: undefined as never }; + /** Read every remaining byte. */ export function rest(self: Decoder): rt.ByteSlice { const taken = self.buf; @@ -79,33 +84,48 @@ export function rest(self: Decoder): rt.ByteSlice { /** 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 _4: rt.Result = slice(self, len); - if (_4.ok) { - return rt.Ok(new_(_4.value, self.form)); + const err: DecodeError.DecodeError | undefined = slice(self, len); + const part: Uint8Array = sliceOut.pData; + const part2: number = sliceOut.pStart; + const part3: number = sliceOut.pLen; + if (err === undefined) { + return rt.Ok(new_(new rt.ByteSlice(part, part2, part3), self.form)); } - return _4; + return rt.Err(err as DecodeError.DecodeError); } /** Read a single byte. */ export function u8(self: Decoder): rt.Result { - const _3: rt.Result = slice(self, 1); - if (_3.ok) { - rt.idx(_3.value, 0); - return rt.Ok(_3.value.data[_3.value.start]); + const err: DecodeError.DecodeError | undefined = slice(self, 1); + const part: Uint8Array = sliceOut.pData; + const part2: number = sliceOut.pStart; + const part3: number = sliceOut.pLen; + if (err === undefined) { + if (0 >= part3) { + rt.panic("index out of bounds: the len is " + part3 + " but the index is " + 0); + } + return rt.Ok(part[part2]); } - return _3; + return rt.Err(err as DecodeError.DecodeError); } /** Read a big-endian `u16`. */ export function u16(self: Decoder): rt.Result { - const _2: rt.Result = slice(self, 2); - if (_2.ok) { - rt.idx(_2.value, 0); - const _9: rt.u8 = _2.value.data[_2.value.start]; - rt.idx(_2.value, 1); - return rt.Ok((_9 << 8) | _2.value.data[_2.value.start + 1]); + const err: DecodeError.DecodeError | undefined = slice(self, 2); + const part: Uint8Array = sliceOut.pData; + const part2: number = sliceOut.pStart; + const part3: number = sliceOut.pLen; + if (err === undefined) { + if (0 >= part3) { + rt.panic("index out of bounds: the len is " + part3 + " but the index is " + 0); + } + const _9: rt.u8 = part[part2]; + if (1 >= part3) { + rt.panic("index out of bounds: the len is " + part3 + " but the index is " + 1); + } + return rt.Ok((_9 << 8) | part[part2 + 1]); } - return _2; + return rt.Err(err as DecodeError.DecodeError); } /** Read a byte that must be 0 or 1. */ @@ -127,15 +147,20 @@ export function bool(self: Decoder): rt.Result /** Read a varint. */ export function varint(self: Decoder): rt.Result { let _0!: rt.Result; - const _2: rt.Result<[rt.u64, rt.ByteSlice], DecodeError.DecodeError> = read(self.buf, self.form); - if (_2.ok) { - const value: rt.u64 = _2.value[0]; - self.buf = _2.value[1]; + const _13: rt.ByteSlice = self.buf; + const part: rt.u64 | undefined = read(_13.data, _13.start, _13.length, self.form); + const err2: DecodeError.DecodeError | undefined = part === undefined ? readOut.err as DecodeError.DecodeError : undefined; + const part2: Uint8Array = readOut.p_1Data; + const part3: number = readOut.p_1Start; + const part4: number = readOut.p_1Len; + if (err2 === undefined) { + const value: rt.u64 = part as rt.u64; + self.buf = new rt.ByteSlice(part2, part3, part4); _0 = rt.Ok(value); - } else if (_2.error.tag === "Short") { + } else if ((err2 as DecodeError.DecodeError).tag === "Short") { _0 = rt.Err(short(self, rt.usizeAdd(self.buf.length, 1))); } else { - _0 = _2 as rt.Result; + _0 = rt.Err(err2 as DecodeError.DecodeError); } return _0; } @@ -150,7 +175,8 @@ export function varintOpt(self: Decoder): rt.Result { +export function bytes(self: Decoder): DecodeError.DecodeError | undefined { + let _0!: rt.Result; const start: rt.ByteSlice = self.buf; const _6: rt.Result = varint(self); if (_6.ok) { @@ -158,26 +184,45 @@ export function bytes(self: Decoder): rt.Result { + const err: DecodeError.DecodeError | undefined = slice(self, _3.value); + const part: Uint8Array = sliceOut.pData; + const part2: number = sliceOut.pStart; + const part3: number = sliceOut.pLen; + const _15: (a0: DecodeError.DecodeError) => undefined = (_22: DecodeError.DecodeError): undefined => { self.buf = start; - }); + }; + _0 = inspectErr$156koiv((err !== undefined ? rt.Err(err as DecodeError.DecodeError) : rt.Ok(new rt.ByteSlice(part, part2, part3))) as rt.Result, _15); + } else { + _0 = _3; } - return _3; + } else { + _0 = _6; + } + const result: rt.Result = _0; + if (!result.ok) { + return result.error; } - return _6; + const slice_: rt.ByteSlice = result.value; + sliceOut.pData = slice_.data; + sliceOut.pStart = slice_.start; + sliceOut.pLen = slice_.length; + return undefined; } /** Read a varint length, then that many bytes of UTF-8. */ export function string(self: Decoder): rt.Result { - const _5: rt.Result = bytes(self); - if (_5.ok) { - const _2: rt.Result = rt.stringFromUtf8(rt.byteSliceToByteVec(_5.value)); + const err: DecodeError.DecodeError | undefined = bytes(self); + const part: Uint8Array = sliceOut.pData; + const part2: number = sliceOut.pStart; + const part3: number = sliceOut.pLen; + if (err === undefined) { + const _2: rt.Result = rt.stringFromUtf8(rt.byteSliceToByteVec(new rt.ByteSlice(part, part2, part3))); if (_2.ok) { return rt.Ok(_2.value); } return rt.Err(DecodeError.from$convert_From_string_FromUtf8Error((_2 as { ok: false; error: rt.FromUtf8Error }).error)); } - return _5; + return rt.Err(err as DecodeError.DecodeError); } export { new_ as new }; diff --git a/ts/fixtures/codec/expected/coding/varint.ts b/ts/fixtures/codec/expected/coding/varint.ts index 7ff15c5d0..0149bc5d3 100644 --- a/ts/fixtures/codec/expected/coding/varint.ts +++ b/ts/fixtures/codec/expected/coding/varint.ts @@ -191,129 +191,163 @@ export function writeLeadingOnes(value: rt.u64, out: rt.ByteVec): void { } /** Decode a varint in `form` from the front of `buf`, returning it and the rest of `buf`. */ -export function read(buf: rt.ByteSlice, form: Form.Form): rt.Result<[rt.u64, rt.ByteSlice], DecodeError.DecodeError> { +export function read(bufData: Uint8Array, bufStart: number, bufLen: number, form: Form.Form): rt.u64 | undefined { if (form.tag === "Quic") { - return readQuic(buf); + return readQuic(bufData, bufStart, bufLen); } - return readLeadingOnes(buf, form.seven); + return readLeadingOnes(bufData, bufStart, bufLen, form.seven); } -export function readQuic(buf: rt.ByteSlice): rt.Result<[rt.u64, rt.ByteSlice], DecodeError.DecodeError> { - if (buf.length !== 0) { - const first: rt.u8 = buf.data[buf.start]; +export const readOut: { err: unknown; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { err: undefined, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; + +export function readQuic(bufData: Uint8Array, bufStart: number, bufLen: number): rt.u64 | undefined { + if (bufLen !== 0) { + const first: rt.u8 = bufData[bufStart]; if (!(first < 64)) { if (!(first < 128)) { if (!(first < 192)) { - if (buf.length >= 8) { - return rt.Ok([fromHalves((((buf.data[buf.start] & 63) << 24) | (buf.data[buf.start + 1] << 16) | (buf.data[buf.start + 2] << 8) | buf.data[buf.start + 3]) >>> 0, ((buf.data[buf.start + 4] << 24) | (buf.data[buf.start + 5] << 16) | (buf.data[buf.start + 6] << 8) | buf.data[buf.start + 7]) >>> 0), new rt.ByteSlice(buf.data, buf.start + 8, buf.length - 8)] as [rt.u64, rt.ByteSlice]); + if (bufLen >= 8) { + const _61_0: rt.u64 = fromHalves((((bufData[bufStart] & 63) << 24) | (bufData[bufStart + 1] << 16) | (bufData[bufStart + 2] << 8) | bufData[bufStart + 3]) >>> 0, ((bufData[bufStart + 4] << 24) | (bufData[bufStart + 5] << 16) | (bufData[bufStart + 6] << 8) | bufData[bufStart + 7]) >>> 0); + readOut.p_1Data = bufData; + readOut.p_1Start = bufStart + 8; + readOut.p_1Len = bufLen - 8; + return _61_0; } - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + readOut.err = { tag: "Short" } as DecodeError.DecodeError; + return undefined; } - if (buf.length >= 4) { - return rt.Ok([(((buf.data[buf.start] & 63) << 24) | (buf.data[buf.start + 1] << 16) | (buf.data[buf.start + 2] << 8) | buf.data[buf.start + 3]) >>> 0 as rt.u64, new rt.ByteSlice(buf.data, buf.start + 4, buf.length - 4)] as [rt.u64, rt.ByteSlice]); + if (bufLen >= 4) { + const _40_0: rt.u64 = (((bufData[bufStart] & 63) << 24) | (bufData[bufStart + 1] << 16) | (bufData[bufStart + 2] << 8) | bufData[bufStart + 3]) >>> 0 as rt.u64; + readOut.p_1Data = bufData; + readOut.p_1Start = bufStart + 4; + readOut.p_1Len = bufLen - 4; + return _40_0; } - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + readOut.err = { tag: "Short" } as DecodeError.DecodeError; + return undefined; } - if (buf.length >= 2) { - return rt.Ok([(((buf.data[buf.start] & 63) << 8) | buf.data[buf.start + 1]) as rt.u64, new rt.ByteSlice(buf.data, buf.start + 2, buf.length - 2)] as [rt.u64, rt.ByteSlice]); + if (bufLen >= 2) { + const _21_0: rt.u64 = (((bufData[bufStart] & 63) << 8) | bufData[bufStart + 1]) as rt.u64; + readOut.p_1Data = bufData; + readOut.p_1Start = bufStart + 2; + readOut.p_1Len = bufLen - 2; + return _21_0; } - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + readOut.err = { tag: "Short" } as DecodeError.DecodeError; + return undefined; } - return rt.Ok([first as rt.u64, new rt.ByteSlice(buf.data, buf.start + 1, buf.length - 1)] as [rt.u64, rt.ByteSlice]); + readOut.p_1Data = bufData; + readOut.p_1Start = bufStart + 1; + readOut.p_1Len = bufLen - 1; + return first as rt.u64; } - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + readOut.err = { tag: "Short" } as DecodeError.DecodeError; + return undefined; } -export function readLeadingOnes(buf: rt.ByteSlice, seven: boolean): rt.Result<[rt.u64, rt.ByteSlice], DecodeError.DecodeError> { +export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: number, seven: boolean): rt.u64 | undefined { let _8_0!: rt.u64; let _8_1Data!: Uint8Array; let _8_1Start!: number; let _8_1Len!: number; - if (buf.length !== 0) { - const first: rt.u8 = buf.data[buf.start]; + if (bufLen !== 0) { + const first: rt.u8 = bufData[bufStart]; const _9: rt.u32 = rt.u8LeadingOnes(first); if (_9 === 0) { _8_0 = first as rt.u64; - _8_1Data = buf.data; - _8_1Start = buf.start + 1; - _8_1Len = buf.length - 1; + _8_1Data = bufData; + _8_1Start = bufStart + 1; + _8_1Len = bufLen - 1; } else if (_9 === 1) { - if (buf.length >= 2) { - _8_0 = (((buf.data[buf.start] & 63) << 8) | buf.data[buf.start + 1]) as rt.u64; - _8_1Data = buf.data; - _8_1Start = buf.start + 2; - _8_1Len = buf.length - 2; + if (bufLen >= 2) { + _8_0 = (((bufData[bufStart] & 63) << 8) | bufData[bufStart + 1]) as rt.u64; + _8_1Data = bufData; + _8_1Start = bufStart + 2; + _8_1Len = bufLen - 2; } else { - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + readOut.err = { tag: "Short" } as DecodeError.DecodeError; + return undefined; } } else if (_9 === 2) { - if (buf.length >= 3) { - _8_0 = (((buf.data[buf.start] & 31) << 16) | (buf.data[buf.start + 1] << 8) | buf.data[buf.start + 2]) as rt.u64; - _8_1Data = buf.data; - _8_1Start = buf.start + 3; - _8_1Len = buf.length - 3; + if (bufLen >= 3) { + _8_0 = (((bufData[bufStart] & 31) << 16) | (bufData[bufStart + 1] << 8) | bufData[bufStart + 2]) as rt.u64; + _8_1Data = bufData; + _8_1Start = bufStart + 3; + _8_1Len = bufLen - 3; } else { - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + readOut.err = { tag: "Short" } as DecodeError.DecodeError; + return undefined; } } else if (_9 === 3) { - if (buf.length >= 4) { - _8_0 = (((buf.data[buf.start] & 15) << 24) | (buf.data[buf.start + 1] << 16) | (buf.data[buf.start + 2] << 8) | buf.data[buf.start + 3]) >>> 0 as rt.u64; - _8_1Data = buf.data; - _8_1Start = buf.start + 4; - _8_1Len = buf.length - 4; + if (bufLen >= 4) { + _8_0 = (((bufData[bufStart] & 15) << 24) | (bufData[bufStart + 1] << 16) | (bufData[bufStart + 2] << 8) | bufData[bufStart + 3]) >>> 0 as rt.u64; + _8_1Data = bufData; + _8_1Start = bufStart + 4; + _8_1Len = bufLen - 4; } else { - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + readOut.err = { tag: "Short" } as DecodeError.DecodeError; + return undefined; } } else if (_9 === 4) { - if (buf.length >= 5) { - _8_0 = fromHalves(((buf.data[buf.start] & 7)) as rt.u32, ((buf.data[buf.start + 1] << 24) | (buf.data[buf.start + 2] << 16) | (buf.data[buf.start + 3] << 8) | buf.data[buf.start + 4]) >>> 0); - _8_1Data = buf.data; - _8_1Start = buf.start + 5; - _8_1Len = buf.length - 5; + if (bufLen >= 5) { + _8_0 = fromHalves(((bufData[bufStart] & 7)) as rt.u32, ((bufData[bufStart + 1] << 24) | (bufData[bufStart + 2] << 16) | (bufData[bufStart + 3] << 8) | bufData[bufStart + 4]) >>> 0); + _8_1Data = bufData; + _8_1Start = bufStart + 5; + _8_1Len = bufLen - 5; } else { - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + readOut.err = { tag: "Short" } as DecodeError.DecodeError; + return undefined; } } else if (_9 === 5) { - if (buf.length >= 6) { - _8_0 = fromHalves(((buf.data[buf.start] & 3) << 8) | buf.data[buf.start + 1], ((buf.data[buf.start + 2] << 24) | (buf.data[buf.start + 3] << 16) | (buf.data[buf.start + 4] << 8) | buf.data[buf.start + 5]) >>> 0); - _8_1Data = buf.data; - _8_1Start = buf.start + 6; - _8_1Len = buf.length - 6; + if (bufLen >= 6) { + _8_0 = fromHalves(((bufData[bufStart] & 3) << 8) | bufData[bufStart + 1], ((bufData[bufStart + 2] << 24) | (bufData[bufStart + 3] << 16) | (bufData[bufStart + 4] << 8) | bufData[bufStart + 5]) >>> 0); + _8_1Data = bufData; + _8_1Start = bufStart + 6; + _8_1Len = bufLen - 6; } else { - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + readOut.err = { tag: "Short" } as DecodeError.DecodeError; + return undefined; } } else if (_9 === 6) { if (!seven) { - return rt.Err({ tag: "InvalidValue" } as DecodeError.DecodeError); + readOut.err = { tag: "InvalidValue" } as DecodeError.DecodeError; + return undefined; } - if (buf.length >= 7) { - _8_0 = fromHalves(((buf.data[buf.start] & 1) << 16) | (buf.data[buf.start + 1] << 8) | buf.data[buf.start + 2], ((buf.data[buf.start + 3] << 24) | (buf.data[buf.start + 4] << 16) | (buf.data[buf.start + 5] << 8) | buf.data[buf.start + 6]) >>> 0); - _8_1Data = buf.data; - _8_1Start = buf.start + 7; - _8_1Len = buf.length - 7; + if (bufLen >= 7) { + _8_0 = fromHalves(((bufData[bufStart] & 1) << 16) | (bufData[bufStart + 1] << 8) | bufData[bufStart + 2], ((bufData[bufStart + 3] << 24) | (bufData[bufStart + 4] << 16) | (bufData[bufStart + 5] << 8) | bufData[bufStart + 6]) >>> 0); + _8_1Data = bufData; + _8_1Start = bufStart + 7; + _8_1Len = bufLen - 7; } else { - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + readOut.err = { tag: "Short" } as DecodeError.DecodeError; + return undefined; } } else if (_9 === 7) { - if (buf.length >= 8) { - _8_0 = fromHalves((buf.data[buf.start + 1] << 16) | (buf.data[buf.start + 2] << 8) | buf.data[buf.start + 3], ((buf.data[buf.start + 4] << 24) | (buf.data[buf.start + 5] << 16) | (buf.data[buf.start + 6] << 8) | buf.data[buf.start + 7]) >>> 0); - _8_1Data = buf.data; - _8_1Start = buf.start + 8; - _8_1Len = buf.length - 8; + if (bufLen >= 8) { + _8_0 = fromHalves((bufData[bufStart + 1] << 16) | (bufData[bufStart + 2] << 8) | bufData[bufStart + 3], ((bufData[bufStart + 4] << 24) | (bufData[bufStart + 5] << 16) | (bufData[bufStart + 6] << 8) | bufData[bufStart + 7]) >>> 0); + _8_1Data = bufData; + _8_1Start = bufStart + 8; + _8_1Len = bufLen - 8; } else { - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + readOut.err = { tag: "Short" } as DecodeError.DecodeError; + return undefined; } - } else if (buf.length >= 9) { - _8_0 = fromHalves(((buf.data[buf.start + 1] << 24) | (buf.data[buf.start + 2] << 16) | (buf.data[buf.start + 3] << 8) | buf.data[buf.start + 4]) >>> 0, ((buf.data[buf.start + 5] << 24) | (buf.data[buf.start + 6] << 16) | (buf.data[buf.start + 7] << 8) | buf.data[buf.start + 8]) >>> 0); - _8_1Data = buf.data; - _8_1Start = buf.start + 9; - _8_1Len = buf.length - 9; + } else if (bufLen >= 9) { + _8_0 = fromHalves(((bufData[bufStart + 1] << 24) | (bufData[bufStart + 2] << 16) | (bufData[bufStart + 3] << 8) | bufData[bufStart + 4]) >>> 0, ((bufData[bufStart + 5] << 24) | (bufData[bufStart + 6] << 16) | (bufData[bufStart + 7] << 8) | bufData[bufStart + 8]) >>> 0); + _8_1Data = bufData; + _8_1Start = bufStart + 9; + _8_1Len = bufLen - 9; } else { - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + readOut.err = { tag: "Short" } as DecodeError.DecodeError; + return undefined; } - return rt.Ok([_8_0, new rt.ByteSlice(_8_1Data, _8_1Start, _8_1Len)] as [rt.u64, rt.ByteSlice]); + readOut.p_1Data = _8_1Data; + readOut.p_1Start = _8_1Start; + readOut.p_1Len = _8_1Len; + return _8_0; } - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + readOut.err = { tag: "Short" } as DecodeError.DecodeError; + return undefined; } /** diff --git a/ts/fixtures/codec/expected/harness.ts b/ts/fixtures/codec/expected/harness.ts index 92ecb977c..9387c42a1 100644 --- a/ts/fixtures/codec/expected/harness.ts +++ b/ts/fixtures/codec/expected/harness.ts @@ -21,7 +21,21 @@ import type * as lite_version_Version from "./lite/version.Version.ts"; * moves no other. */ export function cases(): Array<(a0: rt.ByteSlice, a1: rt.ByteVec) => undefined> { - return [decodeScript as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined, encodeScript as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined, zigzag as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined, sizes as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined, roundtrip$coding_version_Versions as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined, roundtripLite$lite_group_Group as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined, roundtripLite$lite_probe_Probe as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined, encodeMessages as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined, errors as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined]; + return [(a0: rt.ByteSlice, a1: rt.ByteVec): undefined => { + decodeScript(a0.data, a0.start, a0.length, a1); + }, (a02: rt.ByteSlice, a12: rt.ByteVec): undefined => { + encodeScript(a02.data, a02.start, a02.length, a12); + }, zigzag as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined, sizes as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined, (a05: rt.ByteSlice, a15: rt.ByteVec): undefined => { + roundtrip$coding_version_Versions(a05.data, a05.start, a05.length, a15); + }, (a06: rt.ByteSlice, a16: rt.ByteVec): undefined => { + roundtripLite$lite_group_Group(a06.data, a06.start, a06.length, a16); + }, (a07: rt.ByteSlice, a17: rt.ByteVec): undefined => { + roundtripLite$lite_probe_Probe(a07.data, a07.start, a07.length, a17); + }, (a08: rt.ByteSlice, a18: rt.ByteVec): undefined => { + encodeMessages(a08.data, a08.start, a08.length, a18); + }, (a09: rt.ByteSlice, a19: rt.ByteVec): undefined => { + errors(a09.data, a09.start, a09.length, a19); + }]; } /** Run one case. */ @@ -181,16 +195,16 @@ export function encodeError(out: rt.ByteVec, err: EncodeError.EncodeError): void * Read primitives as a script says until one fails: the script is the first * `data[1]` bytes after the form selector, and the wire is everything after it. */ -export function decodeScript(data: rt.ByteSlice, out: rt.ByteVec): void { - if (data.length !== 0) { - const selector: rt.u8 = data.data[data.start]; - if (data.length - 1 !== 0) { - const mid: number = rt.min(data.length - 2, data.data[data.start + 1] as rt.usize); - if (mid > data.length - 2) { +export function decodeScript(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + if (dataLen !== 0) { + const selector: rt.u8 = dataData[dataStart]; + if (dataLen - 1 !== 0) { + const mid: number = rt.min(dataLen - 2, dataData[dataStart + 1] as rt.usize); + if (mid > dataLen - 2) { rt.panic("mid > len"); } - const r: Decoder.Decoder = Decoder.new(new rt.ByteSlice(data.data, data.start + 2 + mid, data.length - 2 - mid), form(selector)); - for (const _21 of rt.byteSliceView(new rt.ByteSlice(data.data, data.start + 2, mid))) { + const r: Decoder.Decoder = Decoder.new(new rt.ByteSlice(dataData, dataStart + 2 + mid, dataLen - 2 - mid), form(selector)); + for (const _21 of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart + 2, mid))) { const _26: rt.Result = decodeStep(r, _21, out); if (_26.ok) { rt.byteVecPush(out, 0); @@ -251,12 +265,15 @@ export function decodeStep(r: Decoder.Decoder, step: rt.u8, out: rt.ByteVec): rt return _31; } } else if (_5 === 5) { - const _40: rt.Result = Decoder.bytes(r); - if (_40.ok) { - putUsize(out, _40.value.length); - rt.byteVecExtendFromSlice(out, _40.value); + const err2: DecodeError.DecodeError | undefined = Decoder.bytes(r); + const part4: Uint8Array = Decoder.sliceOut.pData; + const part5: number = Decoder.sliceOut.pStart; + const part6: number = Decoder.sliceOut.pLen; + if (err2 === undefined) { + putUsize(out, part6); + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part4, part5, part6)); } else { - return _40; + return rt.Err(err2 as DecodeError.DecodeError); } } else if (_5 === 6) { const _49: rt.Result = Decoder.string(r); @@ -266,11 +283,14 @@ export function decodeStep(r: Decoder.Decoder, step: rt.u8, out: rt.ByteVec): rt return _49; } } else if (_5 === 7) { - const _57: rt.Result = Decoder.slice(r, rt.u8Div(step, 10) as rt.usize); - if (_57.ok) { - rt.byteVecExtendFromSlice(out, _57.value); + const err: DecodeError.DecodeError | undefined = Decoder.slice(r, rt.u8Div(step, 10) as rt.usize); + const part: Uint8Array = Decoder.sliceOut.pData; + const part2: number = Decoder.sliceOut.pStart; + const part3: number = Decoder.sliceOut.pLen; + if (err === undefined) { + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part, part2, part3)); } else { - return _57; + return rt.Err(err as DecodeError.DecodeError); } } else if (_5 === 8) { const _67: rt.Result = Decoder.sub(r, rt.u8Div(step, 10) as rt.usize); @@ -293,23 +313,23 @@ 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: rt.ByteSlice, out: rt.ByteVec): void { +export function encodeScript(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let result!: rt.Result; let _47!: rt.u64 | undefined; let _74!: Prefix.Prefix; - if (data.length !== 0) { - const selector: rt.u8 = data.data[data.start]; - if (data.length - 1 !== 0) { - const mid: number = rt.min(data.length - 2, data.data[data.start + 1] as rt.usize); - if (mid > data.length - 2) { + if (dataLen !== 0) { + const selector: rt.u8 = dataData[dataStart]; + if (dataLen - 1 !== 0) { + const mid: number = rt.min(dataLen - 2, dataData[dataStart + 1] as rt.usize); + if (mid > dataLen - 2) { rt.panic("mid > len"); } - let values: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + 2 + mid, data.length - 2 - mid); + let values: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 2 + mid, dataLen - 2 - mid); const buf: rt.ByteVec = new rt.ByteVec(); const _20: Form.Form = form(selector); const w: Encoder.Encoder = Encoder.new(buf, _20); const prefixes: Prefix.Prefix[] = []; - for (const step of rt.byteSliceView(new rt.ByteSlice(data.data, data.start + 2, mid))) { + for (const step of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart + 2, mid))) { const _30: [rt.u64, rt.ByteSlice] = takeU64(values); const value: rt.u64 = _30[0]; values = _30[1]; @@ -415,10 +435,10 @@ export function sizes(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Decode a `T` from the wire, then encode what came out. */ -export function roundtrip$coding_version_Versions(data: rt.ByteSlice, out: rt.ByteVec): void { - if (data.length !== 0) { - const form_: Form.Form = form(data.data[data.start]); - const _8: rt.Result<[Versions.Versions, rt.usize], DecodeError.DecodeError> = Versions.decodeSlice$coding_decode_Decode_coding_varint_Form(new rt.ByteSlice(data.data, data.start + 1, data.length - 1), form_); +export function roundtrip$coding_version_Versions(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + if (dataLen !== 0) { + const form_: Form.Form = form(dataData[dataStart]); + const _8: rt.Result<[Versions.Versions, rt.usize], DecodeError.DecodeError> = Versions.decodeSlice$coding_decode_Decode_coding_varint_Form(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1), form_); if (_8.ok) { const value: Versions.Versions = _8.value[0]; putUsize(out, _8.value[1]); @@ -436,10 +456,10 @@ export function roundtrip$coding_version_Versions(data: rt.ByteSlice, out: rt.By } /** [`roundtrip`] for a lite message, size-prefixed at a lite version. */ -export function roundtripLite$lite_group_Group(data: rt.ByteSlice, out: rt.ByteVec): void { - if (data.length !== 0) { - const version: lite_version_Version.Version = liteVersion(data.data[data.start]); - const _8: rt.Result<[Group.Group, rt.usize], DecodeError.DecodeError> = Group.decodeSlice$coding_decode_Decode_lite_version_Version(new rt.ByteSlice(data.data, data.start + 1, data.length - 1), version); +export function roundtripLite$lite_group_Group(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + if (dataLen !== 0) { + const version: lite_version_Version.Version = liteVersion(dataData[dataStart]); + const _8: rt.Result<[Group.Group, rt.usize], DecodeError.DecodeError> = Group.decodeSlice$coding_decode_Decode_lite_version_Version(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1), version); if (_8.ok) { const value: Group.Group = _8.value[0]; putUsize(out, _8.value[1]); @@ -458,10 +478,10 @@ export function roundtripLite$lite_group_Group(data: rt.ByteSlice, out: rt.ByteV } /** [`roundtrip`] for a lite message, size-prefixed at a lite version. */ -export function roundtripLite$lite_probe_Probe(data: rt.ByteSlice, out: rt.ByteVec): void { - if (data.length !== 0) { - const version: lite_version_Version.Version = liteVersion(data.data[data.start]); - const _8: rt.Result<[Probe.Probe, rt.usize], DecodeError.DecodeError> = Probe.decodeSlice$coding_decode_Decode_lite_version_Version(new rt.ByteSlice(data.data, data.start + 1, data.length - 1), version); +export function roundtripLite$lite_probe_Probe(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + if (dataLen !== 0) { + const version: lite_version_Version.Version = liteVersion(dataData[dataStart]); + const _8: rt.Result<[Probe.Probe, rt.usize], DecodeError.DecodeError> = Probe.decodeSlice$coding_decode_Decode_lite_version_Version(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1), version); if (_8.ok) { const value: Probe.Probe = _8.value[0]; putUsize(out, _8.value[1]); @@ -480,10 +500,10 @@ export function roundtripLite$lite_probe_Probe(data: rt.ByteSlice, out: rt.ByteV } /** Encode messages built from the data, at a lite version. */ -export function encodeMessages(data: rt.ByteSlice, out: rt.ByteVec): void { - if (data.length !== 0) { - const version: lite_version_Version.Version = liteVersion(data.data[data.start]); - const _10: [rt.u64, rt.ByteSlice] = takeU64(new rt.ByteSlice(data.data, data.start + 1, data.length - 1)); +export function encodeMessages(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + if (dataLen !== 0) { + const version: lite_version_Version.Version = liteVersion(dataData[dataStart]); + const _10: [rt.u64, rt.ByteSlice] = takeU64(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)); const subscribe: rt.u64 = _10[0]; const _13: [rt.u64, rt.ByteSlice] = takeU64(_10[1]); const sequence: rt.u64 = _13[0]; @@ -535,12 +555,12 @@ export function encodeMessage$lite_probe_Probe(msg: Probe.Probe, version: lite_v } /** Each error the codec can return, built from the data, as callers see it. */ -export function errors(data: rt.ByteSlice, out: rt.ByteVec): void { +export function errors(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let err!: DecodeError.DecodeError; b0: { - if (data.length !== 0) { - const selector: rt.u8 = data.data[data.start]; - const data2: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + 1, data.length - 1); + if (dataLen !== 0) { + const selector: rt.u8 = dataData[dataStart]; + const data2: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); const value: rt.u64 = takeU64(data2)[0]; const _10: rt.u8 = rt.u8Rem(selector, 8); if (_10 === 0) { diff --git a/ts/fixtures/crates/expected/crates_dep.ts b/ts/fixtures/crates/expected/crates_dep.ts index fc41d09c2..428eb8db3 100644 --- a/ts/fixtures/crates/expected/crates_dep.ts +++ b/ts/fixtures/crates/expected/crates_dep.ts @@ -24,16 +24,18 @@ export function heaviest$harness_Item(items: Item.Item[]): Item.Item | undefined } /** The first byte of `bytes`. */ -export function first(bytes: rt.ByteSlice): rt.u8 { - if (!(bytes.length === 0)) { - return read(bytes); +export function first(bytesData: Uint8Array, bytesStart: number, bytesLen: number): rt.u8 { + if (!(bytesLen === 0)) { + return read(bytesData, bytesStart, bytesLen); } rt.panicFmt(["no first byte"]); } -export function read(bytes: rt.ByteSlice): rt.u8 { - rt.idx(bytes, 0); - return bytes.data[bytes.start]; +export function read(bytesData: Uint8Array, bytesStart: number, bytesLen: number): rt.u8 { + if (0 >= bytesLen) { + rt.panic("index out of bounds: the len is " + bytesLen + " but the index is " + 0); + } + return bytesData[bytesStart]; } /** Provided, and overridden by one impl. */ diff --git a/ts/fixtures/crates/expected/harness.ts b/ts/fixtures/crates/expected/harness.ts index 692189bcf..476480ace 100644 --- a/ts/fixtures/crates/expected/harness.ts +++ b/ts/fixtures/crates/expected/harness.ts @@ -77,7 +77,7 @@ export function run(input: rt.ByteSlice): rt.ByteVec { const filled: rt.i16[] = copy$array_i16(kept); Slots.fill(Slots.withBase(kept[0]), filled); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(kept[0] & 0xff, kept[1] & 0xff, filled[0] & 0xff, filled[1] & 0xff)), undefined, true); - const _181: rt.u8 = first(input); + const _181: rt.u8 = first(input.data, input.start, input.length); rt.byteVecPush(out, _181); const _184: rt.u8 = last.last(input); rt.byteVecPush(out, _184); diff --git a/ts/fixtures/lang/expected/args.Scale.ts b/ts/fixtures/lang/expected/args.Scale.ts new file mode 100644 index 000000000..e9e62c3c7 --- /dev/null +++ b/ts/fixtures/lang/expected/args.Scale.ts @@ -0,0 +1,15 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; + +export interface Scale { + _0: rt.u8; +} + +export function weigh$args_Weigh(self: Scale, data: rt.ByteSlice): rt.u8 { + return rt.iterFold(rt.iterSlice(rt.byteSliceView(data)), self._0, (a: rt.u8, b: rt.u8): rt.u8 => { + return rt.u8WrappingAdd(a, b ^ 90); + }); +} + +//# sourceMappingURL=args.Scale.ts.map diff --git a/ts/fixtures/lang/expected/args.ts b/ts/fixtures/lang/expected/args.ts new file mode 100644 index 000000000..aa5376bef --- /dev/null +++ b/ts/fixtures/lang/expected/args.ts @@ -0,0 +1,243 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import * as args_Scale from "./args.Scale.ts"; +import { map$0waqle9 as option_map$0waqle9, map$1yogfym as option_map$1yogfym, mapOr$0dk8jdr as option_mapOr$0dk8jdr } from "./core/option.ts"; + +/** A use that needs the slice itself. */ +export function opaque(s: rt.ByteSlice): rt.u8 { + return rt.iterFold(rt.iterSlice(rt.byteSliceView(s)), s.length & 0xff, (a: rt.u8, b: rt.u8): rt.u8 => { + return rt.u8WrappingAdd(a ^ (a >> 3), b); + }); +} + +/** A parameter reassigned from its own tail. */ +export function sum(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { + let sum: rt.u8 = 0; + while (true) { + const _4Data: Uint8Array = dataData; + const _4Start: number = dataStart; + const _4Len: number = dataLen; + if (_4Len !== 0) { + sum = rt.u8WrappingAdd(sum, _4Data[_4Start]); + dataData = _4Data; + dataStart = _4Start + 1; + dataLen = _4Len - 1; + } else { + return sum; + } + } +} + +/** A parameter only measured. */ +export function len(_dataData: Uint8Array, _dataStart: number, dataLen: number): rt.usize { + return dataLen; +} + +/** A parameter borrowed, which takes it whole. */ +export function byRef(data: rt.ByteSlice): rt.usize { + return lenOf(data); +} + +export function lenOf(data: rt.ByteSlice): rt.usize { + return data.length; +} + +/** A parameter made whole in a loop, which takes it whole. */ +export function kept(data: rt.ByteSlice, n: rt.u8): rt.ByteSlice[] { + const all: rt.ByteSlice[] = []; + const _6: rt.u8 = rt.u8Rem(n, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _6; + while (true) { + if (!(iterStart++ < iterEnd)) { + return all; + } + all.push(data); + } +} + +/** A reference to an array of bytes. */ +export function word(w: rt.ByteSlice): rt.u32 { + return ((w.data[w.start] << 24) | (w.data[w.start + 1] << 16) | (w.data[w.start + 2] << 8) | w.data[w.start + 3]) >>> 0; +} + +/** Two slices, perhaps the same. */ +export function both(a: rt.ByteSlice, bData: Uint8Array, bStart: number, bLen: number): rt.u8 { + return opaque(a) ^ (len(bData, bStart, bLen) & 0xff); +} + +/** A recursive count of the bytes before a zero. */ +export function depth(data: rt.ByteSlice): rt.u8 { + const _2: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(data); + if (_2 !== undefined) { + if (_2[0] !== 0) { + return rt.u8Add(1, depth(_2[1])); + } + } + return 0; +} + +/** Passed along to one that takes it whole, so taken whole too. */ +export function relay(data: rt.ByteSlice): rt.u8 { + return opaque(data); +} + +/** Passed along to one that takes its parts, so taken as parts too. */ +export function relaySum(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { + return sum(dataData, dataStart, dataLen); +} + +/** Recursive, and made whole at the bottom, so taken whole all the way down. */ +export function lastRun(data: rt.ByteSlice): rt.u8 { + const _2: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(data); + if (_2 !== undefined) { + if (_2[0] !== 0) { + return lastRun(_2[1]); + } + } + return opaque(data); +} + +/** Mutually recursive, each reading bytes, so both take parts. */ +export function evens(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { + if (dataLen === 0) { + return 0; + } + return rt.u8WrappingAdd(dataData[dataStart], odds(dataData, dataStart + 1, dataLen - 1)); +} + +export function odds(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { + if (dataLen === 0) { + return 0; + } + return evens(dataData, dataStart + 1, dataLen - 1); +} + +/** Mutually recursive, where `ping` makes its slice whole and `pong` only splits its own. */ +export function ping(data: rt.ByteSlice): rt.u8 { + const _2: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(data); + if (_2 !== undefined) { + if (rt.u8Rem(_2[0], 3) !== 0) { + return pong(_2[1].data, _2[1].start, _2[1].length); + } + } + return opaque(data); +} + +export function pong(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { + if (dataLen === 0) { + return 0; + } + return dataData[dataStart] ^ ping(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)); +} + +/** A slice chosen by a call that does something. */ +export function pick(out: rt.ByteVec, data: rt.ByteSlice): rt.ByteSlice { + rt.byteVecPush(out, 187); + return rt.byteSliceRange(data, rt.usizeDiv(data.length, 2)); +} + +export function code(out: rt.ByteVec, n: rt.u8): rt.u8 { + rt.byteVecPush(out, 238); + return n; +} + +export function pair(n: rt.u8, s: rt.ByteSlice): rt.u8 { + return n ^ opaque(s); +} + +export function weigh$args_Scale(w: args_Scale.Scale, data: rt.ByteSlice): rt.u8 { + return args_Scale.weigh$args_Weigh(w, data); +} + +export function args(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + let f!: (a0: rt.ByteSlice) => rt.u8; + const _4: rt.u8 = rt.u8Rem(kind, 8); + if (_4 === 0) { + rt.byteVecPush(out, sum(data.data, data.start, data.length)); + rt.byteVecPush(out, len(data.data, data.start, data.length) & 0xff); + rt.byteVecPush(out, byRef(data) & 0xff); + rt.byteVecPush(out, rt.iterFold(rt.iterMap(rt.iterSlice(kept(data, kind)), (s: rt.ByteSlice): rt.u8 => { + return opaque(s); + }), 0, (a05: rt.u8, a1: rt.u8): rt.u8 => { + return rt.u8WrappingAdd(a05, a1); + })); + } else if (_4 === 1) { + if (data.length >= 4) { + const w: rt.ByteSlice = new rt.ByteSlice(data.data, data.start, 4); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32WrappingAdd(word(w), 1)))); + rt.byteVecPush(out, both(new rt.ByteSlice(data.data, data.start + 4, data.length - 4), data.data, data.start + 4, data.length - 4)); + rt.byteVecPush(out, both(w, data.data, data.start + 4, data.length - 4)); + } + rt.byteVecPush(out, depth(rt.byteSliceRange(data, 0, rt.min(data.length, 64)))); + } else if (_4 === 2) { + rt.iterExtendBytes(out, rt.iterOption(option_map$0waqle9(option_map$1yogfym((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, (_2: [rt.u8, rt.ByteSlice]): rt.ByteSlice => { + return _2[1]; + }), opaque)), undefined, true); + if (!(rt.usizeRem(data.length, 2) === 0)) { + f = (a03: rt.ByteSlice): rt.u8 => { + return sum(a03.data, a03.start, a03.length); + }; + } else { + f = opaque; + } + rt.byteVecPush(out, f(data)); + rt.byteVecPush(out, option_mapOr$0dk8jdr(option_map$1yogfym((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, (_22: [rt.u8, rt.ByteSlice]): rt.ByteSlice => { + return _22[1]; + }), 0, (a04: rt.ByteSlice): rt.usize => { + return len(a04.data, a04.start, a04.length); + }) & 0xff); + } else if (_4 === 3) { + rt.byteVecPush(out, pair(code(out, 1), pick(out, data))); + } else if (_4 === 4) { + const seen: rt.ByteVec = new rt.ByteVec(); + const note: (a0: rt.u8) => undefined = (b2: rt.u8): undefined => { + rt.byteVecPush(seen, b2 ^ opaque(data)); + }; + const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 3); + while (true) { + const _70: rt.u8 | rt.Done = iter.next(); + if (_70 === rt.DONE) { + break; + } + note(_70); + } + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(seen)); + } else if (_4 === 6) { + const data2: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(data.length, 64)); + rt.byteVecPush(out, relay(data2)); + rt.byteVecPush(out, relaySum(data2.data, data2.start, data2.length)); + rt.byteVecPush(out, lastRun(data2)); + rt.byteVecPush(out, evens(data2.data, data2.start, data2.length)); + rt.byteVecPush(out, ping(data2)); + rt.byteVecPush(out, pong(data2.data, data2.start, data2.length)); + } else if (_4 === 7) { + const mid: number = rt.usizeDiv(data.length, 2); + if (mid > data.length) { + rt.panic("mid > len"); + } + const mid2: number = rt.usizeDiv(data.length, 2); + if (mid2 > data.length) { + rt.panic("mid > len"); + } + const halves: rt.ByteSlice[] = [new rt.ByteSlice(data.data, data.start, mid), new rt.ByteSlice(data.data, data.start + mid2, data.length - mid2)]; + const iter2: rt.Iter = rt.iterSlice(halves); + while (true) { + const _111: rt.ByteSlice | rt.Done = iter2.next(); + if (_111 === rt.DONE) { + break; + } + const _138: rt.ByteSlice = _111; + rt.byteVecPush(out, sum(_138.data, _138.start, _138.length)); + rt.byteVecPush(out, relay(_111)); + } + rt.byteVecPush(out, relaySum(halves[1].data, halves[1].start, halves[1].length)); + rt.byteVecPush(out, sum(data.data, data.start, data.length)); + } else { + rt.byteVecPush(out, weigh$args_Scale({ _0: kind }, data)); + rt.byteVecPush(out, args_Scale.weigh$args_Weigh({ _0: 3 }, rt.byteSliceRange(data, rt.min(data.length, 2)))); + } +} + +//# sourceMappingURL=args.ts.map diff --git a/ts/fixtures/lang/expected/cells.ts b/ts/fixtures/lang/expected/cells.ts index 765af876b..33a9aaa93 100644 --- a/ts/fixtures/lang/expected/cells.ts +++ b/ts/fixtures/lang/expected/cells.ts @@ -4,22 +4,22 @@ import * as rt from "./rt.ts"; import { thenSome$0d5am30 } from "./core/bool.ts"; /** Steps of an operation and an operand on one cell, each putting what it read. */ -export function cellOption(data: rt.ByteSlice, out: rt.ByteVec): void { +export function cellOption(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { const make: (a0: rt.u8) => rt.u8 | undefined = maybe; const put: (a0: rt.ByteVec, a1: rt.u8 | undefined) => undefined = putMaybe as (a0: rt.ByteVec, a1: rt.u8 | undefined) => undefined; let cell: rt.OnceCell = new rt.OnceCell(rt.None); - let dataData: Uint8Array = data.data; - let dataStart: number = data.start; - let dataLen: number = data.length; - while (dataLen >= 2) { - const op: rt.u8 = dataData[dataStart]; - const v: rt.u8 = dataData[dataStart + 1]; - const restData: Uint8Array = dataData; - const restStart: number = dataStart + 2; - const restLen: number = dataLen - 2; - dataData = restData; - dataStart = restStart; - dataLen = restLen; + let dataData2: Uint8Array = dataData; + let dataStart2: number = dataStart; + let dataLen2: number = dataLen; + while (dataLen2 >= 2) { + const op: rt.u8 = dataData2[dataStart2]; + const v: rt.u8 = dataData2[dataStart2 + 1]; + const restData: Uint8Array = dataData2; + const restStart: number = dataStart2 + 2; + const restLen: number = dataLen2 - 2; + dataData2 = restData; + dataStart2 = restStart; + dataLen2 = restLen; const op2: rt.u8 = op; const v2: rt.u8 = v; const _18: rt.u8 = rt.u8Rem(op2, 9); @@ -102,7 +102,7 @@ export function cellOption(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Steps of an operation and an operand on one cell, each putting what it read. */ -export function cellString(data: rt.ByteSlice, out: rt.ByteVec): void { +export function cellString(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { const make: (a0: rt.u8) => string = (v3: rt.u8): string => { return rt.fmtToString((f: rt.Formatter) => rt.u8Display(v3, f)); }; @@ -110,18 +110,18 @@ export function cellString(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(t6)); }; let cell: rt.OnceCell = new rt.OnceCell(undefined); - let dataData: Uint8Array = data.data; - let dataStart: number = data.start; - let dataLen: number = data.length; - while (dataLen >= 2) { - const op: rt.u8 = dataData[dataStart]; - const v: rt.u8 = dataData[dataStart + 1]; - const restData: Uint8Array = dataData; - const restStart: number = dataStart + 2; - const restLen: number = dataLen - 2; - dataData = restData; - dataStart = restStart; - dataLen = restLen; + let dataData2: Uint8Array = dataData; + let dataStart2: number = dataStart; + let dataLen2: number = dataLen; + while (dataLen2 >= 2) { + const op: rt.u8 = dataData2[dataStart2]; + const v: rt.u8 = dataData2[dataStart2 + 1]; + const restData: Uint8Array = dataData2; + const restStart: number = dataStart2 + 2; + const restLen: number = dataLen2 - 2; + dataData2 = restData; + dataStart2 = restStart; + dataLen2 = restLen; const op2: rt.u8 = op; const v2: rt.u8 = v; const _18: rt.u8 = rt.u8Rem(op2, 9); @@ -204,24 +204,24 @@ export function cellString(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Steps of an operation and an operand on one cell, each putting what it read. */ -export function cellU64(data: rt.ByteSlice, out: rt.ByteVec): void { +export function cellU64(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { const make: (a0: rt.u8) => rt.u64 = wide; const put: (a0: rt.ByteVec, a1: rt.u64) => undefined = (out2: rt.ByteVec, t6: rt.u64): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u64ToBeBytes(t6))); }; let cell: rt.OnceCell = new rt.OnceCell(undefined); - let dataData: Uint8Array = data.data; - let dataStart: number = data.start; - let dataLen: number = data.length; - while (dataLen >= 2) { - const op: rt.u8 = dataData[dataStart]; - const v: rt.u8 = dataData[dataStart + 1]; - const restData: Uint8Array = dataData; - const restStart: number = dataStart + 2; - const restLen: number = dataLen - 2; - dataData = restData; - dataStart = restStart; - dataLen = restLen; + let dataData2: Uint8Array = dataData; + let dataStart2: number = dataStart; + let dataLen2: number = dataLen; + while (dataLen2 >= 2) { + const op: rt.u8 = dataData2[dataStart2]; + const v: rt.u8 = dataData2[dataStart2 + 1]; + const restData: Uint8Array = dataData2; + const restStart: number = dataStart2 + 2; + const restLen: number = dataLen2 - 2; + dataData2 = restData; + dataStart2 = restStart; + dataLen2 = restLen; const op2: rt.u8 = op; const v2: rt.u8 = v; const _18: rt.u8 = rt.u8Rem(op2, 9); @@ -304,7 +304,7 @@ export function cellU64(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Steps of an operation and an operand on one cell, each putting what it read. */ -export function cellU8(data: rt.ByteSlice, out: rt.ByteVec): void { +export function cellU8(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { const make: (a0: rt.u8) => rt.u8 = (v3: rt.u8): rt.u8 => { return v3; }; @@ -312,18 +312,18 @@ export function cellU8(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out2, t6); }; let cell: rt.OnceCell = new rt.OnceCell(undefined); - let dataData: Uint8Array = data.data; - let dataStart: number = data.start; - let dataLen: number = data.length; - while (dataLen >= 2) { - const op: rt.u8 = dataData[dataStart]; - const v: rt.u8 = dataData[dataStart + 1]; - const restData: Uint8Array = dataData; - const restStart: number = dataStart + 2; - const restLen: number = dataLen - 2; - dataData = restData; - dataStart = restStart; - dataLen = restLen; + let dataData2: Uint8Array = dataData; + let dataStart2: number = dataStart; + let dataLen2: number = dataLen; + while (dataLen2 >= 2) { + const op: rt.u8 = dataData2[dataStart2]; + const v: rt.u8 = dataData2[dataStart2 + 1]; + const restData: Uint8Array = dataData2; + const restStart: number = dataStart2 + 2; + const restLen: number = dataLen2 - 2; + dataData2 = restData; + dataStart2 = restStart; + dataLen2 = restLen; const op2: rt.u8 = op; const v2: rt.u8 = v; const _18: rt.u8 = rt.u8Rem(op2, 9); @@ -406,24 +406,24 @@ export function cellU8(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Steps of an operation and an operand on one cell, each putting what it read. */ -export function cellUnit(data: rt.ByteSlice, out: rt.ByteVec): void { +export function cellUnit(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { const make: (a0: rt.u8) => undefined = (_2: rt.u8): undefined => {}; const put: (a0: rt.ByteVec, a1: undefined) => undefined = (out2: rt.ByteVec, _3: undefined): undefined => { rt.byteVecPush(out2, 170); }; let cell: rt.OnceCell = new rt.OnceCell(rt.None); - let dataData: Uint8Array = data.data; - let dataStart: number = data.start; - let dataLen: number = data.length; - while (dataLen >= 2) { - const op: rt.u8 = dataData[dataStart]; - const v: rt.u8 = dataData[dataStart + 1]; - const restData: Uint8Array = dataData; - const restStart: number = dataStart + 2; - const restLen: number = dataLen - 2; - dataData = restData; - dataStart = restStart; - dataLen = restLen; + let dataData2: Uint8Array = dataData; + let dataStart2: number = dataStart; + let dataLen2: number = dataLen; + while (dataLen2 >= 2) { + const op: rt.u8 = dataData2[dataStart2]; + const v: rt.u8 = dataData2[dataStart2 + 1]; + const restData: Uint8Array = dataData2; + const restStart: number = dataStart2 + 2; + const restLen: number = dataLen2 - 2; + dataData2 = restData; + dataStart2 = restStart; + dataLen2 = restLen; const op2: rt.u8 = op; const v2: rt.u8 = v; const _18: rt.u8 = rt.u8Rem(op2, 9); @@ -506,27 +506,47 @@ export function cellUnit(data: rt.ByteSlice, out: rt.ByteVec): void { /** Steps on the cell and value type `kind` picks. */ export function cells(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const cases: Array<(a0: rt.ByteSlice, a1: rt.ByteVec) => undefined> = [cellU8 as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined, lockU8 as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined, cellU64 as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined, lockU64 as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined, cellOption as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined, lockOption as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined, cellUnit as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined, lockUnit as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined, cellString as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined, lockString as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined]; + const cases: Array<(a0: rt.ByteSlice, a1: rt.ByteVec) => undefined> = [(a0: rt.ByteSlice, a1: rt.ByteVec): undefined => { + cellU8(a0.data, a0.start, a0.length, a1); + }, (a02: rt.ByteSlice, a12: rt.ByteVec): undefined => { + lockU8(a02.data, a02.start, a02.length, a12); + }, (a03: rt.ByteSlice, a13: rt.ByteVec): undefined => { + cellU64(a03.data, a03.start, a03.length, a13); + }, (a04: rt.ByteSlice, a14: rt.ByteVec): undefined => { + lockU64(a04.data, a04.start, a04.length, a14); + }, (a05: rt.ByteSlice, a15: rt.ByteVec): undefined => { + cellOption(a05.data, a05.start, a05.length, a15); + }, (a06: rt.ByteSlice, a16: rt.ByteVec): undefined => { + lockOption(a06.data, a06.start, a06.length, a16); + }, (a07: rt.ByteSlice, a17: rt.ByteVec): undefined => { + cellUnit(a07.data, a07.start, a07.length, a17); + }, (a08: rt.ByteSlice, a18: rt.ByteVec): undefined => { + lockUnit(a08.data, a08.start, a08.length, a18); + }, (a09: rt.ByteSlice, a19: rt.ByteVec): undefined => { + cellString(a09.data, a09.start, a09.length, a19); + }, (a010: rt.ByteSlice, a110: rt.ByteVec): undefined => { + lockString(a010.data, a010.start, a010.length, a110); + }]; cases[rt.idx(cases, rt.usizeRem(kind as rt.usize, cases.length))](data, out); } /** Steps of an operation and an operand on one cell, each putting what it read. */ -export function lockOption(data: rt.ByteSlice, out: rt.ByteVec): void { +export function lockOption(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { const make: (a0: rt.u8) => rt.u8 | undefined = maybe; const put: (a0: rt.ByteVec, a1: rt.u8 | undefined) => undefined = putMaybe as (a0: rt.ByteVec, a1: rt.u8 | undefined) => undefined; let cell: rt.OnceLock = new rt.OnceLock(rt.None); - let dataData: Uint8Array = data.data; - let dataStart: number = data.start; - let dataLen: number = data.length; - while (dataLen >= 2) { - const op: rt.u8 = dataData[dataStart]; - const v: rt.u8 = dataData[dataStart + 1]; - const restData: Uint8Array = dataData; - const restStart: number = dataStart + 2; - const restLen: number = dataLen - 2; - dataData = restData; - dataStart = restStart; - dataLen = restLen; + let dataData2: Uint8Array = dataData; + let dataStart2: number = dataStart; + let dataLen2: number = dataLen; + while (dataLen2 >= 2) { + const op: rt.u8 = dataData2[dataStart2]; + const v: rt.u8 = dataData2[dataStart2 + 1]; + const restData: Uint8Array = dataData2; + const restStart: number = dataStart2 + 2; + const restLen: number = dataLen2 - 2; + dataData2 = restData; + dataStart2 = restStart; + dataLen2 = restLen; const op2: rt.u8 = op; const v2: rt.u8 = v; const _18: rt.u8 = rt.u8Rem(op2, 9); @@ -609,7 +629,7 @@ export function lockOption(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Steps of an operation and an operand on one cell, each putting what it read. */ -export function lockString(data: rt.ByteSlice, out: rt.ByteVec): void { +export function lockString(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { const make: (a0: rt.u8) => string = (v3: rt.u8): string => { return rt.fmtToString((f: rt.Formatter) => rt.u8Display(v3, f)); }; @@ -617,18 +637,18 @@ export function lockString(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(t6)); }; let cell: rt.OnceLock = new rt.OnceLock(undefined); - let dataData: Uint8Array = data.data; - let dataStart: number = data.start; - let dataLen: number = data.length; - while (dataLen >= 2) { - const op: rt.u8 = dataData[dataStart]; - const v: rt.u8 = dataData[dataStart + 1]; - const restData: Uint8Array = dataData; - const restStart: number = dataStart + 2; - const restLen: number = dataLen - 2; - dataData = restData; - dataStart = restStart; - dataLen = restLen; + let dataData2: Uint8Array = dataData; + let dataStart2: number = dataStart; + let dataLen2: number = dataLen; + while (dataLen2 >= 2) { + const op: rt.u8 = dataData2[dataStart2]; + const v: rt.u8 = dataData2[dataStart2 + 1]; + const restData: Uint8Array = dataData2; + const restStart: number = dataStart2 + 2; + const restLen: number = dataLen2 - 2; + dataData2 = restData; + dataStart2 = restStart; + dataLen2 = restLen; const op2: rt.u8 = op; const v2: rt.u8 = v; const _18: rt.u8 = rt.u8Rem(op2, 9); @@ -711,24 +731,24 @@ export function lockString(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Steps of an operation and an operand on one cell, each putting what it read. */ -export function lockU64(data: rt.ByteSlice, out: rt.ByteVec): void { +export function lockU64(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { const make: (a0: rt.u8) => rt.u64 = wide; const put: (a0: rt.ByteVec, a1: rt.u64) => undefined = (out2: rt.ByteVec, t6: rt.u64): undefined => { rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u64ToBeBytes(t6))); }; let cell: rt.OnceLock = new rt.OnceLock(undefined); - let dataData: Uint8Array = data.data; - let dataStart: number = data.start; - let dataLen: number = data.length; - while (dataLen >= 2) { - const op: rt.u8 = dataData[dataStart]; - const v: rt.u8 = dataData[dataStart + 1]; - const restData: Uint8Array = dataData; - const restStart: number = dataStart + 2; - const restLen: number = dataLen - 2; - dataData = restData; - dataStart = restStart; - dataLen = restLen; + let dataData2: Uint8Array = dataData; + let dataStart2: number = dataStart; + let dataLen2: number = dataLen; + while (dataLen2 >= 2) { + const op: rt.u8 = dataData2[dataStart2]; + const v: rt.u8 = dataData2[dataStart2 + 1]; + const restData: Uint8Array = dataData2; + const restStart: number = dataStart2 + 2; + const restLen: number = dataLen2 - 2; + dataData2 = restData; + dataStart2 = restStart; + dataLen2 = restLen; const op2: rt.u8 = op; const v2: rt.u8 = v; const _18: rt.u8 = rt.u8Rem(op2, 9); @@ -811,7 +831,7 @@ export function lockU64(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Steps of an operation and an operand on one cell, each putting what it read. */ -export function lockU8(data: rt.ByteSlice, out: rt.ByteVec): void { +export function lockU8(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { const make: (a0: rt.u8) => rt.u8 = (v3: rt.u8): rt.u8 => { return v3; }; @@ -819,18 +839,18 @@ export function lockU8(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out2, t6); }; let cell: rt.OnceLock = new rt.OnceLock(undefined); - let dataData: Uint8Array = data.data; - let dataStart: number = data.start; - let dataLen: number = data.length; - while (dataLen >= 2) { - const op: rt.u8 = dataData[dataStart]; - const v: rt.u8 = dataData[dataStart + 1]; - const restData: Uint8Array = dataData; - const restStart: number = dataStart + 2; - const restLen: number = dataLen - 2; - dataData = restData; - dataStart = restStart; - dataLen = restLen; + let dataData2: Uint8Array = dataData; + let dataStart2: number = dataStart; + let dataLen2: number = dataLen; + while (dataLen2 >= 2) { + const op: rt.u8 = dataData2[dataStart2]; + const v: rt.u8 = dataData2[dataStart2 + 1]; + const restData: Uint8Array = dataData2; + const restStart: number = dataStart2 + 2; + const restLen: number = dataLen2 - 2; + dataData2 = restData; + dataStart2 = restStart; + dataLen2 = restLen; const op2: rt.u8 = op; const v2: rt.u8 = v; const _18: rt.u8 = rt.u8Rem(op2, 9); @@ -913,24 +933,24 @@ export function lockU8(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Steps of an operation and an operand on one cell, each putting what it read. */ -export function lockUnit(data: rt.ByteSlice, out: rt.ByteVec): void { +export function lockUnit(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { const make: (a0: rt.u8) => undefined = (_2: rt.u8): undefined => {}; const put: (a0: rt.ByteVec, a1: undefined) => undefined = (out2: rt.ByteVec, _3: undefined): undefined => { rt.byteVecPush(out2, 170); }; let cell: rt.OnceLock = new rt.OnceLock(rt.None); - let dataData: Uint8Array = data.data; - let dataStart: number = data.start; - let dataLen: number = data.length; - while (dataLen >= 2) { - const op: rt.u8 = dataData[dataStart]; - const v: rt.u8 = dataData[dataStart + 1]; - const restData: Uint8Array = dataData; - const restStart: number = dataStart + 2; - const restLen: number = dataLen - 2; - dataData = restData; - dataStart = restStart; - dataLen = restLen; + let dataData2: Uint8Array = dataData; + let dataStart2: number = dataStart; + let dataLen2: number = dataLen; + while (dataLen2 >= 2) { + const op: rt.u8 = dataData2[dataStart2]; + const v: rt.u8 = dataData2[dataStart2 + 1]; + const restData: Uint8Array = dataData2; + const restStart: number = dataStart2 + 2; + const restLen: number = dataLen2 - 2; + dataData2 = restData; + dataStart2 = restStart; + dataLen2 = restLen; const op2: rt.u8 = op; const v2: rt.u8 = v; const _18: rt.u8 = rt.u8Rem(op2, 9); diff --git a/ts/fixtures/lang/expected/chunks.ts b/ts/fixtures/lang/expected/chunks.ts index 0557a2040..04bbaca58 100644 --- a/ts/fixtures/lang/expected/chunks.ts +++ b/ts/fixtures/lang/expected/chunks.ts @@ -2,19 +2,30 @@ import * as rt from "./rt.ts"; import type * as Header from "./chunks.Header.ts"; -import { mapOr$1jgrjsu as option_mapOr$1jgrjsu, okOr$0jslmu4 as option_okOr$0jslmu4 } from "./core/option.ts"; +import { mapOr$1jgrjsu as option_mapOr$1jgrjsu } from "./core/option.ts"; -export function header(data: rt.ByteSlice): Header.Header | undefined { - if (data.length >= 2) { - return { tag: new rt.ByteSlice(data.data, data.start, 2), rest: new rt.ByteSlice(data.data, data.start + 2, data.length - 2) }; +export function header(dataData: Uint8Array, dataStart: number, dataLen: number): Header.Header | undefined { + if (dataLen >= 2) { + return { tag: new rt.ByteSlice(dataData, dataStart, 2), rest: new rt.ByteSlice(dataData, dataStart + 2, dataLen - 2) }; } return undefined; } -export function take4(data: rt.ByteSlice): rt.Result<[rt.ByteSlice, rt.ByteSlice], rt.u8> { - return option_okOr$0jslmu4((data.length >= 4 ? [new rt.ByteSlice(data.data, data.start, 4), new rt.ByteSlice(data.data, data.start + 4, data.length - 4)] as [rt.ByteSlice, rt.ByteSlice] : undefined) as [rt.ByteSlice, rt.ByteSlice] | undefined, data.length & 0xff); +export function take4(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 | undefined { + if (!(dataLen >= 4)) { + return dataLen & 0xff; + } + take4Out.p_0Data = dataData; + take4Out.p_0Start = dataStart; + take4Out.p_0Len = 4; + take4Out.p_1Data = dataData; + take4Out.p_1Start = dataStart + 4; + take4Out.p_1Len = dataLen - 4; + return undefined; } +export const take4Out: { p_0Data: Uint8Array; p_0Start: number; p_0Len: number; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { p_0Data: undefined as never, p_0Start: undefined as never, p_0Len: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; + export function word(chunk: rt.ByteSlice): rt.u32 { return ((chunk.data[chunk.start] << 24) | (chunk.data[chunk.start + 1] << 16) | (chunk.data[chunk.start + 2] << 8) | chunk.data[chunk.start + 3]) >>> 0; } @@ -42,30 +53,36 @@ export function bump(chunk: rt.ByteSlice): void { chunk.data[chunk.start + 1] = chunk.data[chunk.start + 1] ^ 255; } -export function ends(chunk: rt.ByteSlice): [rt.u8, rt.ByteSlice, rt.u8] { - return [chunk.data[chunk.start], new rt.ByteSlice(chunk.data, chunk.start + 1, 2), chunk.data[chunk.start + 3]] as [rt.u8, rt.ByteSlice, rt.u8]; +export function ends(chunkData: Uint8Array, chunkStart: number, _chunkLen: number): [rt.u8, rt.ByteSlice, rt.u8] { + return [chunkData[chunkStart], new rt.ByteSlice(chunkData, chunkStart + 1, 2), chunkData[chunkStart + 3]] as [rt.u8, rt.ByteSlice, rt.u8]; } export function chunks(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let chosen2!: rt.ByteSlice; const _4: rt.u8 = rt.u8Rem(kind, 6); if (_4 === 0) { - const _6: Header.Header | undefined = header(data); + const _6: Header.Header | undefined = header(data.data, data.start, data.length); if (_6 !== undefined) { const h: Header.Header = _6; rt.byteVecExtendFromSlice(out, h.tag); rt.byteVecPush(out, h.tag.data[h.tag.start + 1]); rt.byteVecPush(out, h.rest.length & 0xff); } - const _18: rt.Result<[rt.ByteSlice, rt.ByteSlice], rt.u8> = take4(data); - if (_18.ok) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(word(_18.value[0])))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes((((_18.value[0].data[_18.value[0].start + 1] << 8) | _18.value[0].data[_18.value[0].start + 2]) << 16) >> 16))); - const _42: [rt.u8, rt.ByteSlice, rt.u8] = ends(_18.value[0]); + const err: rt.u8 | undefined = take4(data.data, data.start, data.length); + const part3: Uint8Array = take4Out.p_0Data; + const part4: number = take4Out.p_0Start; + const part5: number = take4Out.p_0Len; + const part6: Uint8Array = take4Out.p_1Data; + const part7: number = take4Out.p_1Start; + const part8: number = take4Out.p_1Len; + if (err === undefined) { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(word(new rt.ByteSlice(part3, part4, part5))))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes((((part3[part4 + 1] << 8) | part3[part4 + 2]) << 16) >> 16))); + const _42: [rt.u8, rt.ByteSlice, rt.u8] = ends(part3, part4, part5); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_42[0], _42[2], _42[1].data[_42[1].start], _42[1].data[_42[1].start + 1], _42[1].length & 0xff))); - rt.byteVecExtendFromSlice(out, _18.value[1]); + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part6, part7, part8)); } else { - rt.byteVecPush(out, _18.error); + rt.byteVecPush(out, err as rt.u8); } } else if (_4 === 1) { const buf: Uint8Array = rt.bytes(4); @@ -135,8 +152,8 @@ export function chunks(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(chosen2), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(lit), f, rt.u8Debug)]; rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1]]))); if (data.length >= 3) { - const chunk: rt.ByteSlice = new rt.ByteSlice(data.data, data.start, 3); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(chunk), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(chunk), f, rt.u8Debug)]; + const chunk2: rt.ByteSlice = new rt.ByteSlice(data.data, data.start, 3); + const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(chunk2), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(chunk2), f, rt.u8Debug)]; rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); } } else if (_4 === 4) { @@ -177,26 +194,26 @@ export function chunks(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return p2.data[p2.start + 1]; })), undefined, true); } else { - let restData2: Uint8Array = data.data; - let restStart2: number = data.start; - let restLen2: number = data.length; + let restData3: Uint8Array = data.data; + let restStart3: number = data.start; + let restLen3: number = data.length; let sum: rt.u32 = 0; while (true) { - const _261Data: Uint8Array = restData2; - const _261Start: number = restStart2; - const _261Len: number = restLen2; + const _261Data: Uint8Array = restData3; + const _261Start: number = restStart3; + const _261Len: number = restLen3; if (_261Len >= 3) { sum = rt.u32WrappingAdd((((sum << 5) >>> 0) | (sum >>> 27)) >>> 0, ((_261Data[_261Start] << 8) | _261Data[_261Start + 2]) as rt.u32); rt.byteVecPush(out, _261Data[_261Start + 1]); - restData2 = _261Data; - restStart2 = _261Start + 3; - restLen2 = _261Len - 3; + restData3 = _261Data; + restStart3 = _261Start + 3; + restLen3 = _261Len - 3; } else { break; } } rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(sum))); - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(restData2, restStart2, restLen2)); + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(restData3, restStart3, restLen3)); } } diff --git a/ts/fixtures/lang/expected/collections.ts b/ts/fixtures/lang/expected/collections.ts index 707a1791d..ca4d5a865 100644 --- a/ts/fixtures/lang/expected/collections.ts +++ b/ts/fixtures/lang/expected/collections.ts @@ -3539,12 +3539,12 @@ export function eq$cmp_PartialEq_collections_Right_u8(self: rt.u8, other: Right. return rt.u16Rem(self as rt.u16, 4) === rt.u16Rem(other._0, 4); } -export function eq$cmp_PartialEq_collections_Right_array2_u8(self: rt.ByteSlice, other: Right.Right): boolean { - return rt.u16Rem(rt.u16Add(self.data[self.start] as rt.u16, self.data[self.start + 1] as rt.u16), 4) === rt.u16Rem(other._0, 4); +export function eq$cmp_PartialEq_collections_Right_array2_u8(selfData: Uint8Array, selfStart: number, _selfLen: number, other: Right.Right): boolean { + return rt.u16Rem(rt.u16Add(selfData[selfStart] as rt.u16, selfData[selfStart + 1] as rt.u16), 4) === rt.u16Rem(other._0, 4); } -export function partialCmp$cmp_PartialOrd_collections_Right_array2_u8(self: rt.ByteSlice, other: Right.Right): rt.Ordering | undefined { - return rt.cmp(rt.u16Rem(rt.u16Add(self.data[self.start] as rt.u16, self.data[self.start + 1] as rt.u16), 4), rt.u16Rem(other._0, 4)); +export function partialCmp$cmp_PartialOrd_collections_Right_array2_u8(selfData: Uint8Array, selfStart: number, _selfLen: number, other: Right.Right): rt.Ordering | undefined { + return rt.cmp(rt.u16Rem(rt.u16Add(selfData[selfStart] as rt.u16, selfData[selfStart + 1] as rt.u16), 4), rt.u16Rem(other._0, 4)); } /** @@ -3675,7 +3675,9 @@ export function unlikeEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi const _148: Uint8Array[] = rt.sliceRange(pairs, 0); const _150: Right.Right[] = rt.sliceRange(rights_, 0, rt.min(pairs.length, rights_.length)); putEq(rt.eqSeq((a23: Uint8Array, b20: Right.Right): boolean => { - return eq$cmp_PartialEq_collections_Right_array2_u8(rt.byteSliceFrom(a23), b20); + return ((a018: rt.ByteSlice, a118: Right.Right): boolean => { + return eq$cmp_PartialEq_collections_Right_array2_u8(a018.data, a018.start, a018.length, a118); + })(rt.byteSliceFrom(a23), b20); })(_148, _150), log, out); const _162: Left.Left[][] = [lefts(), lefts()]; const _169: Right.Right[][] = [rights_, rt.sliceRange(rights_, 0)]; @@ -4606,9 +4608,13 @@ export function unlikeCompares(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec) return Uint8Array.of(_35, c.data[c.start + 1]); }), undefined, 2, true); putEq(rt.iterEq(rt.iterCopied(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray), rt.iterSlice(rights_()), (a: Uint8Array, b3: Right.Right): boolean => { - return eq$cmp_PartialEq_collections_Right_array2_u8(rt.byteSliceFrom(a), b3); + return ((a09: rt.ByteSlice, a19: Right.Right): boolean => { + return eq$cmp_PartialEq_collections_Right_array2_u8(a09.data, a09.start, a09.length, a19); + })(rt.byteSliceFrom(a), b3); + }, true), log, out); + putEq(rt.iterEq(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.iterSlice(theirs), (a010: rt.ByteSlice, a110: Right.Right): boolean => { + return eq$cmp_PartialEq_collections_Right_array2_u8(a010.data, a010.start, a010.length, a110); }, true), log, out); - putEq(rt.iterEq(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.iterSlice(theirs), eq$cmp_PartialEq_collections_Right_array2_u8, true), log, out); const part3 = rt.iterCmp(rt.iterSlice(mine), rt.iterSlice(theirs), Left.partialCmp$cmp_PartialOrd_collections_Right); _9(part3, log, out); const part5 = rt.iterCmp(rt.iterSlice(lefts()), rt.iterSlice(rights_()), Left.partialCmp$cmp_PartialOrd_collections_Right); @@ -4616,10 +4622,14 @@ export function unlikeCompares(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec) putEq(rt.iterLt(rt.iterSlice(lefts()), rt.iterSlice(rights_()), Left.partialCmp$cmp_PartialOrd_collections_Right), log, out); putEq(rt.iterGe(rt.iterSlice(mine), rt.iterSlice(theirs), Left.partialCmp$cmp_PartialOrd_collections_Right), log, out); const part7 = rt.iterCmp(rt.iterCopied(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray), rt.iterSlice(rights_()), (a2: Uint8Array, b4: Right.Right): rt.Ordering | undefined => { - return partialCmp$cmp_PartialOrd_collections_Right_array2_u8(rt.byteSliceFrom(a2), b4); + return ((a015: rt.ByteSlice, a115: Right.Right): rt.Ordering | undefined => { + return partialCmp$cmp_PartialOrd_collections_Right_array2_u8(a015.data, a015.start, a015.length, a115); + })(rt.byteSliceFrom(a2), b4); }); _9(part7, log, out); - const part9 = rt.iterCmp(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.iterSlice(theirs), partialCmp$cmp_PartialOrd_collections_Right_array2_u8); + const part9 = rt.iterCmp(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.iterSlice(theirs), (a016: rt.ByteSlice, a116: Right.Right): rt.Ordering | undefined => { + return partialCmp$cmp_PartialOrd_collections_Right_array2_u8(a016.data, a016.start, a016.length, a116); + }); _9(part9, log, out); } diff --git a/ts/fixtures/lang/expected/core/bool.ts b/ts/fixtures/lang/expected/core/bool.ts index ed5bddc77..05a78782b 100644 --- a/ts/fixtures/lang/expected/core/bool.ts +++ b/ts/fixtures/lang/expected/core/bool.ts @@ -230,6 +230,13 @@ export function then$18np55d(self: boolean, f: () => Way.Way | undefined): Way.W return f(); } +export function then$0w2ymju(self: boolean, f: () => rt.ByteSlice): rt.ByteSlice | undefined { + if (!self) { + return undefined; + } + return f(); +} + export function then$0havnzo(self: boolean, f: () => string): string | undefined { if (!self) { return undefined; diff --git a/ts/fixtures/lang/expected/core/num.ts b/ts/fixtures/lang/expected/core/num.ts index b1baa1375..73e77f237 100644 --- a/ts/fixtures/lang/expected/core/num.ts +++ b/ts/fixtures/lang/expected/core/num.ts @@ -3,39 +3,39 @@ import * as rt from "../rt.ts"; import { toDigit$01k9ewn } from "../core/char/methods.ts"; -export function canNotOverflow$01xawbo(radix: rt.u32, isSignedTy: boolean, digits: rt.ByteSlice): boolean { +export function canNotOverflow$0q497dn(radix: rt.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { if (!(radix <= 16)) { return false; } - return digits.length <= rt.usizeSub(rt.usizeMul(16, 2), isSignedTy ? 1 : 0); + return digitsLen <= rt.usizeSub(rt.usizeMul(16, 2), isSignedTy ? 1 : 0); } -export function canNotOverflow$0omqc31(radix: rt.u32, isSignedTy: boolean, digits: rt.ByteSlice): boolean { +export function canNotOverflow$1wu8g18(radix: rt.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { if (!(radix <= 16)) { return false; } - return digits.length <= rt.usizeSub(rt.usizeMul(2, 2), isSignedTy ? 1 : 0); + return digitsLen <= rt.usizeSub(rt.usizeMul(2, 2), isSignedTy ? 1 : 0); } -export function canNotOverflow$1ldhufq(radix: rt.u32, isSignedTy: boolean, digits: rt.ByteSlice): boolean { +export function canNotOverflow$0uown4l(radix: rt.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { if (!(radix <= 16)) { return false; } - return digits.length <= rt.usizeSub(rt.usizeMul(4, 2), isSignedTy ? 1 : 0); + return digitsLen <= rt.usizeSub(rt.usizeMul(4, 2), isSignedTy ? 1 : 0); } -export function canNotOverflow$0ywqfa7(radix: rt.u32, isSignedTy: boolean, digits: rt.ByteSlice): boolean { +export function canNotOverflow$03q1vv8(radix: rt.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { if (!(radix <= 16)) { return false; } - return digits.length <= rt.usizeSub(rt.usizeMul(8, 2), isSignedTy ? 1 : 0); + return digitsLen <= rt.usizeSub(rt.usizeMul(8, 2), isSignedTy ? 1 : 0); } -export function canNotOverflow$01utshh(radix: rt.u32, isSignedTy: boolean, digits: rt.ByteSlice): boolean { +export function canNotOverflow$0aqh4yo(radix: rt.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { if (!(radix <= 16)) { return false; } - return digits.length <= rt.usizeSub(rt.usizeMul(1, 2), isSignedTy ? 1 : 0); + return digitsLen <= rt.usizeSub(rt.usizeMul(1, 2), isSignedTy ? 1 : 0); } export function fromAsciiBytesRadixPanic(radix: rt.u32): never { @@ -51,7 +51,7 @@ export function runtime$0bn0geu(radix: rt.u32): never { rt.panicFmt(["from_ascii_bytes_radix: radix must lie in the range `[2, 36]` - found ", args2[0]]); } -export function fromAsciiBytesRadixImpl$1fi5krg(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0xhcrxt(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -98,7 +98,7 @@ export function fromAsciiBytesRadixImpl$1fi5krg(src: rt.ByteSlice, radix: rt.u32 let digitsLen: number = _12_1Len; let result: rt.i128 = 0; b5: { - if (!canNotOverflow$01xawbo(radix, isSignedTy, new rt.ByteSlice(digitsData, digitsStart, digitsLen))) { + if (!canNotOverflow$0q497dn(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { @@ -203,7 +203,7 @@ export function fromAsciiBytesRadixImpl$1fi5krg(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$0vxnyo2(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0jbbuu8(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -250,7 +250,7 @@ export function fromAsciiBytesRadixImpl$0vxnyo2(src: rt.ByteSlice, radix: rt.u32 let digitsLen: number = _12_1Len; let result: rt.i16 = 0; b5: { - if (!canNotOverflow$0omqc31(radix, isSignedTy, new rt.ByteSlice(digitsData, digitsStart, digitsLen))) { + if (!canNotOverflow$1wu8g18(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { @@ -355,7 +355,7 @@ export function fromAsciiBytesRadixImpl$0vxnyo2(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$084mvn4(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0p2idzk(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -402,7 +402,7 @@ export function fromAsciiBytesRadixImpl$084mvn4(src: rt.ByteSlice, radix: rt.u32 let digitsLen: number = _12_1Len; let result: rt.i32 = 0; b5: { - if (!canNotOverflow$1ldhufq(radix, isSignedTy, new rt.ByteSlice(digitsData, digitsStart, digitsLen))) { + if (!canNotOverflow$0uown4l(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { @@ -507,7 +507,7 @@ export function fromAsciiBytesRadixImpl$084mvn4(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$1txa8fg(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$01tfvb9(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -554,7 +554,7 @@ export function fromAsciiBytesRadixImpl$1txa8fg(src: rt.ByteSlice, radix: rt.u32 let digitsLen: number = _12_1Len; let result: rt.i64 = 0; b5: { - if (!canNotOverflow$0ywqfa7(radix, isSignedTy, new rt.ByteSlice(digitsData, digitsStart, digitsLen))) { + if (!canNotOverflow$03q1vv8(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { @@ -659,7 +659,7 @@ export function fromAsciiBytesRadixImpl$1txa8fg(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$0jjf32b(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$18og5o1(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -706,7 +706,7 @@ export function fromAsciiBytesRadixImpl$0jjf32b(src: rt.ByteSlice, radix: rt.u32 let digitsLen: number = _12_1Len; let result: rt.i8 = 0; b5: { - if (!canNotOverflow$01utshh(radix, isSignedTy, new rt.ByteSlice(digitsData, digitsStart, digitsLen))) { + if (!canNotOverflow$0aqh4yo(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { @@ -811,7 +811,7 @@ export function fromAsciiBytesRadixImpl$0jjf32b(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$0z6zuq3(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$05ylgyc(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -858,7 +858,7 @@ export function fromAsciiBytesRadixImpl$0z6zuq3(src: rt.ByteSlice, radix: rt.u32 let digitsLen: number = _12_1Len; let result: rt.isize = 0; b5: { - if (!canNotOverflow$1ldhufq(radix, isSignedTy, new rt.ByteSlice(digitsData, digitsStart, digitsLen))) { + if (!canNotOverflow$0uown4l(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { @@ -963,55 +963,55 @@ export function fromAsciiBytesRadixImpl$0z6zuq3(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromStr$1ej7fl2(src: string): rt.Result { - return fromStrRadix$1cxc8v7(src, 10); +export function fromStr$0zyj6he(src: string): rt.Result { + return fromStrRadix$0366bau(src, 10); } -export function fromStr$076yg1t(src: string): rt.Result { - return fromStrRadix$0w5k2s7(src, 10); +export function fromStr$17ewwma(src: string): rt.Result { + return fromStrRadix$02mhuxs(src, 10); } -export function fromStr$1dxzqb4(src: string): rt.Result { - return fromStrRadix$1a42la1(src, 10); +export function fromStr$0zhqfgx(src: string): rt.Result { + return fromStrRadix$1bgm1z0(src, 10); } -export function fromStr$09oey6q(src: string): rt.Result { - return fromStrRadix$0olne29(src, 10); +export function fromStr$116mp4t(src: string): rt.Result { + return fromStrRadix$11y6fsf(src, 10); } -export function fromStr$1m3wp28(src: string): rt.Result { - return fromStrRadix$0snhnv5(src, 10); +export function fromStr$0ovlgjd(src: string): rt.Result { + return fromStrRadix$0s9rspw(src, 10); } -export function fromStr$1gsa29j(src: string): rt.Result { - return fromStrRadix$1mq18rn(src, 10); +export function fromStr$1grmucc(src: string): rt.Result { + return fromStrRadix$1473bi0(src, 10); } -export function fromStrRadix$1cxc8v7(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$1fi5krg(rt.stringAsBytes(src), radix); +export function fromStrRadix$0366bau(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0xhcrxt(rt.stringAsBytes(src), radix); } -export function fromStrRadix$0w5k2s7(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0vxnyo2(rt.stringAsBytes(src), radix); +export function fromStrRadix$02mhuxs(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0jbbuu8(rt.stringAsBytes(src), radix); } -export function fromStrRadix$1a42la1(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$084mvn4(rt.stringAsBytes(src), radix); +export function fromStrRadix$1bgm1z0(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0p2idzk(rt.stringAsBytes(src), radix); } -export function fromStrRadix$0olne29(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$1txa8fg(rt.stringAsBytes(src), radix); +export function fromStrRadix$11y6fsf(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$01tfvb9(rt.stringAsBytes(src), radix); } -export function fromStrRadix$0snhnv5(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0jjf32b(rt.stringAsBytes(src), radix); +export function fromStrRadix$0s9rspw(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$18og5o1(rt.stringAsBytes(src), radix); } -export function fromStrRadix$1mq18rn(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0z6zuq3(rt.stringAsBytes(src), radix); +export function fromStrRadix$1473bi0(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$05ylgyc(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$0upyfqu(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0r1q6uy(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -1058,7 +1058,7 @@ export function fromAsciiBytesRadixImpl$0upyfqu(src: rt.ByteSlice, radix: rt.u32 let digitsLen: number = _12_1Len; let result: rt.u128 = 0; b5: { - if (!canNotOverflow$01xawbo(radix, isSignedTy, new rt.ByteSlice(digitsData, digitsStart, digitsLen))) { + if (!canNotOverflow$0q497dn(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { @@ -1163,7 +1163,7 @@ export function fromAsciiBytesRadixImpl$0upyfqu(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$02by984(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$1ukmfx2(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -1210,7 +1210,7 @@ export function fromAsciiBytesRadixImpl$02by984(src: rt.ByteSlice, radix: rt.u32 let digitsLen: number = _12_1Len; let result: rt.u16 = 0; b5: { - if (!canNotOverflow$0omqc31(radix, isSignedTy, new rt.ByteSlice(digitsData, digitsStart, digitsLen))) { + if (!canNotOverflow$1wu8g18(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { @@ -1315,7 +1315,7 @@ export function fromAsciiBytesRadixImpl$02by984(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$1wmuzvm(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0ax4wbr(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -1362,7 +1362,7 @@ export function fromAsciiBytesRadixImpl$1wmuzvm(src: rt.ByteSlice, radix: rt.u32 let digitsLen: number = _12_1Len; let result: rt.u32 = 0; b5: { - if (!canNotOverflow$1ldhufq(radix, isSignedTy, new rt.ByteSlice(digitsData, digitsStart, digitsLen))) { + if (!canNotOverflow$0uown4l(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { @@ -1467,7 +1467,7 @@ export function fromAsciiBytesRadixImpl$1wmuzvm(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$1qf6fna(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$02xpj41(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -1514,7 +1514,7 @@ export function fromAsciiBytesRadixImpl$1qf6fna(src: rt.ByteSlice, radix: rt.u32 let digitsLen: number = _12_1Len; let result: rt.u64 = 0; b5: { - if (!canNotOverflow$0ywqfa7(radix, isSignedTy, new rt.ByteSlice(digitsData, digitsStart, digitsLen))) { + if (!canNotOverflow$03q1vv8(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { @@ -1619,7 +1619,7 @@ export function fromAsciiBytesRadixImpl$1qf6fna(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$0kv3dtn(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$1n9fygl(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -1666,7 +1666,7 @@ export function fromAsciiBytesRadixImpl$0kv3dtn(src: rt.ByteSlice, radix: rt.u32 let digitsLen: number = _12_1Len; let result: rt.u8 = 0; b5: { - if (!canNotOverflow$01utshh(radix, isSignedTy, new rt.ByteSlice(digitsData, digitsStart, digitsLen))) { + if (!canNotOverflow$0aqh4yo(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { @@ -1771,7 +1771,7 @@ export function fromAsciiBytesRadixImpl$0kv3dtn(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$1z1297b(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$00hojjd(src: rt.ByteSlice, radix: rt.u32): rt.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -1818,7 +1818,7 @@ export function fromAsciiBytesRadixImpl$1z1297b(src: rt.ByteSlice, radix: rt.u32 let digitsLen: number = _12_1Len; let result: rt.usize = 0; b5: { - if (!canNotOverflow$1ldhufq(radix, isSignedTy, new rt.ByteSlice(digitsData, digitsStart, digitsLen))) { + if (!canNotOverflow$0uown4l(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { @@ -1923,52 +1923,52 @@ export function fromAsciiBytesRadixImpl$1z1297b(src: rt.ByteSlice, radix: rt.u32 fromAsciiBytesRadixPanic(radix); } -export function fromStr$0pnvd2c(src: string): rt.Result { - return fromStrRadix$1549erz(src, 10); +export function fromStr$0qvzsmz(src: string): rt.Result { + return fromStrRadix$0g0g31i(src, 10); } -export function fromStr$1bigolo(src: string): rt.Result { - return fromStrRadix$1x7yq9g(src, 10); +export function fromStr$0yqu2i9(src: string): rt.Result { + return fromStrRadix$1ku3myt(src, 10); } -export function fromStr$1uzmhcw(src: string): rt.Result { - return fromStrRadix$1gamglm(src, 10); +export function fromStr$08wf09w(src: string): rt.Result { + return fromStrRadix$05zvwcf(src, 10); } -export function fromStr$05sn9io(src: string): rt.Result { - return fromStrRadix$0bx9j5d(src, 10); +export function fromStr$1ypcnp8(src: string): rt.Result { + return fromStrRadix$1gp4jqq(src, 10); } -export function fromStr$0kn8g72(src: string): rt.Result { - return fromStrRadix$1ys3fwo(src, 10); +export function fromStr$1hq0zfa(src: string): rt.Result { + return fromStrRadix$0nj08um(src, 10); } -export function fromStr$0qgw0pl(src: string): rt.Result { - return fromStrRadix$09ykvvv(src, 10); +export function fromStr$10ypyht(src: string): rt.Result { + return fromStrRadix$0tjqkb6(src, 10); } -export function fromStrRadix$1549erz(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0upyfqu(rt.stringAsBytes(src), radix); +export function fromStrRadix$0g0g31i(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0r1q6uy(rt.stringAsBytes(src), radix); } -export function fromStrRadix$1x7yq9g(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$02by984(rt.stringAsBytes(src), radix); +export function fromStrRadix$1ku3myt(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$1ukmfx2(rt.stringAsBytes(src), radix); } -export function fromStrRadix$1gamglm(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$1wmuzvm(rt.stringAsBytes(src), radix); +export function fromStrRadix$05zvwcf(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0ax4wbr(rt.stringAsBytes(src), radix); } -export function fromStrRadix$0bx9j5d(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$1qf6fna(rt.stringAsBytes(src), radix); +export function fromStrRadix$1gp4jqq(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$02xpj41(rt.stringAsBytes(src), radix); } -export function fromStrRadix$1ys3fwo(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0kv3dtn(rt.stringAsBytes(src), radix); +export function fromStrRadix$0nj08um(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$1n9fygl(rt.stringAsBytes(src), radix); } -export function fromStrRadix$09ykvvv(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$1z1297b(rt.stringAsBytes(src), radix); +export function fromStrRadix$0tjqkb6(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$00hojjd(rt.stringAsBytes(src), radix); } //# sourceMappingURL=num.ts.map diff --git a/ts/fixtures/lang/expected/core/num/nonzero.ts b/ts/fixtures/lang/expected/core/num/nonzero.ts index 613bff492..cf00ca76f 100644 --- a/ts/fixtures/lang/expected/core/num/nonzero.ts +++ b/ts/fixtures/lang/expected/core/num/nonzero.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. import * as rt from "../../rt.ts"; -import { fromAsciiBytesRadixImpl$1fi5krg as num_fromAsciiBytesRadixImpl$1fi5krg, fromAsciiBytesRadixImpl$0vxnyo2 as num_fromAsciiBytesRadixImpl$0vxnyo2, fromAsciiBytesRadixImpl$084mvn4 as num_fromAsciiBytesRadixImpl$084mvn4, fromAsciiBytesRadixImpl$1txa8fg as num_fromAsciiBytesRadixImpl$1txa8fg, fromAsciiBytesRadixImpl$0jjf32b as num_fromAsciiBytesRadixImpl$0jjf32b, fromAsciiBytesRadixImpl$0z6zuq3 as num_fromAsciiBytesRadixImpl$0z6zuq3, fromAsciiBytesRadixImpl$0upyfqu as num_fromAsciiBytesRadixImpl$0upyfqu, fromAsciiBytesRadixImpl$02by984 as num_fromAsciiBytesRadixImpl$02by984, fromAsciiBytesRadixImpl$1wmuzvm as num_fromAsciiBytesRadixImpl$1wmuzvm, fromAsciiBytesRadixImpl$1qf6fna as num_fromAsciiBytesRadixImpl$1qf6fna, fromAsciiBytesRadixImpl$0kv3dtn as num_fromAsciiBytesRadixImpl$0kv3dtn, fromAsciiBytesRadixImpl$1z1297b as num_fromAsciiBytesRadixImpl$1z1297b } from "../../core/num.ts"; +import { fromAsciiBytesRadixImpl$0xhcrxt as num_fromAsciiBytesRadixImpl$0xhcrxt, fromAsciiBytesRadixImpl$0jbbuu8 as num_fromAsciiBytesRadixImpl$0jbbuu8, fromAsciiBytesRadixImpl$0p2idzk as num_fromAsciiBytesRadixImpl$0p2idzk, fromAsciiBytesRadixImpl$01tfvb9 as num_fromAsciiBytesRadixImpl$01tfvb9, fromAsciiBytesRadixImpl$18og5o1 as num_fromAsciiBytesRadixImpl$18og5o1, fromAsciiBytesRadixImpl$05ylgyc as num_fromAsciiBytesRadixImpl$05ylgyc, fromAsciiBytesRadixImpl$0r1q6uy as num_fromAsciiBytesRadixImpl$0r1q6uy, fromAsciiBytesRadixImpl$1ukmfx2 as num_fromAsciiBytesRadixImpl$1ukmfx2, fromAsciiBytesRadixImpl$0ax4wbr as num_fromAsciiBytesRadixImpl$0ax4wbr, fromAsciiBytesRadixImpl$02xpj41 as num_fromAsciiBytesRadixImpl$02xpj41, fromAsciiBytesRadixImpl$1n9fygl as num_fromAsciiBytesRadixImpl$1n9fygl, fromAsciiBytesRadixImpl$00hojjd as num_fromAsciiBytesRadixImpl$00hojjd } from "../../core/num.ts"; -export function fromAsciiBytesRadixImpl$03b2rg6(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$0kv3dtn(src, radix); +export function fromAsciiBytesRadixImpl$1kc6lwg(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$1n9fygl(src, radix); if (_3.ok) { const _7: rt.u8 | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -15,16 +15,16 @@ export function fromAsciiBytesRadixImpl$03b2rg6(src: rt.ByteSlice, radix: rt.u32 return _3; } -export function fromStr$1d7pnbk(src: string): rt.Result { - return fromStrRadix$1ae2pnm(src, 10); +export function fromStr$0evev4b(src: string): rt.Result { + return fromStrRadix$1dc3cul(src, 10); } -export function fromStrRadix$1ae2pnm(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$03b2rg6(rt.stringAsBytes(src), radix); +export function fromStrRadix$1dc3cul(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$1kc6lwg(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$0inazzq(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$02by984(src, radix); +export function fromAsciiBytesRadixImpl$0gd2ptq(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$1ukmfx2(src, radix); if (_3.ok) { const _7: rt.u16 | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -35,16 +35,16 @@ export function fromAsciiBytesRadixImpl$0inazzq(src: rt.ByteSlice, radix: rt.u32 return _3; } -export function fromStr$15isx69(src: string): rt.Result { - return fromStrRadix$1mr00o6(src, 10); +export function fromStr$1lm2uzl(src: string): rt.Result { + return fromStrRadix$1cv6o7i(src, 10); } -export function fromStrRadix$1mr00o6(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0inazzq(rt.stringAsBytes(src), radix); +export function fromStrRadix$1cv6o7i(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0gd2ptq(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$000rpg7(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$1wmuzvm(src, radix); +export function fromAsciiBytesRadixImpl$0v1vsb2(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$0ax4wbr(src, radix); if (_3.ok) { const _7: rt.u32 | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -55,16 +55,16 @@ export function fromAsciiBytesRadixImpl$000rpg7(src: rt.ByteSlice, radix: rt.u32 return _3; } -export function fromStr$04uijf8(src: string): rt.Result { - return fromStrRadix$1wqmb68(src, 10); +export function fromStr$0gvyqp3(src: string): rt.Result { + return fromStrRadix$18imw6k(src, 10); } -export function fromStrRadix$1wqmb68(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$000rpg7(rt.stringAsBytes(src), radix); +export function fromStrRadix$18imw6k(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0v1vsb2(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$11vh5fk(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$1qf6fna(src, radix); +export function fromAsciiBytesRadixImpl$0573ey0(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$02xpj41(src, radix); if (_3.ok) { const _7: rt.u64 | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -75,16 +75,16 @@ export function fromAsciiBytesRadixImpl$11vh5fk(src: rt.ByteSlice, radix: rt.u32 return _3; } -export function fromStr$0l2zu9x(src: string): rt.Result { - return fromStrRadix$0cd0jvv(src, 10); +export function fromStr$19lq810(src: string): rt.Result { + return fromStrRadix$1u3fi38(src, 10); } -export function fromStrRadix$0cd0jvv(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$11vh5fk(rt.stringAsBytes(src), radix); +export function fromStrRadix$1u3fi38(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0573ey0(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$1k1g4xa(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$0upyfqu(src, radix); +export function fromAsciiBytesRadixImpl$09eombh(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$0r1q6uy(src, radix); if (_3.ok) { const _7: rt.u128 | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -95,16 +95,16 @@ export function fromAsciiBytesRadixImpl$1k1g4xa(src: rt.ByteSlice, radix: rt.u32 return _3; } -export function fromStr$0h0ptos(src: string): rt.Result { - return fromStrRadix$10vntu7(src, 10); +export function fromStr$1lyc2jq(src: string): rt.Result { + return fromStrRadix$0yvapq5(src, 10); } -export function fromStrRadix$10vntu7(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$1k1g4xa(rt.stringAsBytes(src), radix); +export function fromStrRadix$0yvapq5(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$09eombh(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$0923w4z(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$1z1297b(src, radix); +export function fromAsciiBytesRadixImpl$0fv7s51(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$00hojjd(src, radix); if (_3.ok) { const _7: rt.usize | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -115,16 +115,16 @@ export function fromAsciiBytesRadixImpl$0923w4z(src: rt.ByteSlice, radix: rt.u32 return _3; } -export function fromStr$10svit2(src: string): rt.Result { - return fromStrRadix$0wc95fw(src, 10); +export function fromStr$06k4xxy(src: string): rt.Result { + return fromStrRadix$0rmwudb(src, 10); } -export function fromStrRadix$0wc95fw(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0923w4z(rt.stringAsBytes(src), radix); +export function fromStrRadix$0rmwudb(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0fv7s51(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$1dareg4(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$0jjf32b(src, radix); +export function fromAsciiBytesRadixImpl$0o9g9le(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$18og5o1(src, radix); if (_3.ok) { const _7: rt.i8 | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -135,16 +135,16 @@ export function fromAsciiBytesRadixImpl$1dareg4(src: rt.ByteSlice, radix: rt.u32 return _3; } -export function fromStr$19kbj04(src: string): rt.Result { - return fromStrRadix$1o9c7gd(src, 10); +export function fromStr$0xht6mx(src: string): rt.Result { + return fromStrRadix$0qjnxek(src, 10); } -export function fromStrRadix$1o9c7gd(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$1dareg4(rt.stringAsBytes(src), radix); +export function fromStrRadix$0qjnxek(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0o9g9le(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$1h6q0v7(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$0vxnyo2(src, radix); +export function fromAsciiBytesRadixImpl$067wd9q(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$0jbbuu8(src, radix); if (_3.ok) { const _7: rt.i16 | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -155,16 +155,16 @@ export function fromAsciiBytesRadixImpl$1h6q0v7(src: rt.ByteSlice, radix: rt.u32 return _3; } -export function fromStr$0br814e(src: string): rt.Result { - return fromStrRadix$188cokx(src, 10); +export function fromStr$021o7ki(src: string): rt.Result { + return fromStrRadix$0dk3w71(src, 10); } -export function fromStrRadix$188cokx(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$1h6q0v7(rt.stringAsBytes(src), radix); +export function fromStrRadix$0dk3w71(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$067wd9q(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$0oayk4p(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$084mvn4(src, radix); +export function fromAsciiBytesRadixImpl$09l5q1f(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$0p2idzk(src, radix); if (_3.ok) { const _7: rt.i32 | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -175,16 +175,16 @@ export function fromAsciiBytesRadixImpl$0oayk4p(src: rt.ByteSlice, radix: rt.u32 return _3; } -export function fromStr$1471qz1(src: string): rt.Result { - return fromStrRadix$0l5ymb0(src, 10); +export function fromStr$1myv2t6(src: string): rt.Result { + return fromStrRadix$0o6ntrm(src, 10); } -export function fromStrRadix$0l5ymb0(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0oayk4p(rt.stringAsBytes(src), radix); +export function fromStrRadix$0o6ntrm(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$09l5q1f(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$1ar5iuu(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$1txa8fg(src, radix); +export function fromAsciiBytesRadixImpl$1tchpbx(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$01tfvb9(src, radix); if (_3.ok) { const _7: rt.i64 | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -195,16 +195,16 @@ export function fromAsciiBytesRadixImpl$1ar5iuu(src: rt.ByteSlice, radix: rt.u32 return _3; } -export function fromStr$0k8sfhf(src: string): rt.Result { - return fromStrRadix$0fpnm5c(src, 10); +export function fromStr$10p52cj(src: string): rt.Result { + return fromStrRadix$0ebk8xe(src, 10); } -export function fromStrRadix$0fpnm5c(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$1ar5iuu(rt.stringAsBytes(src), radix); +export function fromStrRadix$0ebk8xe(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$1tchpbx(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$19vbc7k(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$1fi5krg(src, radix); +export function fromAsciiBytesRadixImpl$0naj586(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$0xhcrxt(src, radix); if (_3.ok) { const _7: rt.i128 | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -215,16 +215,16 @@ export function fromAsciiBytesRadixImpl$19vbc7k(src: rt.ByteSlice, radix: rt.u32 return _3; } -export function fromStr$0b2xa80(src: string): rt.Result { - return fromStrRadix$1095n8m(src, 10); +export function fromStr$081k88g(src: string): rt.Result { + return fromStrRadix$17xzbib(src, 10); } -export function fromStrRadix$1095n8m(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$19vbc7k(rt.stringAsBytes(src), radix); +export function fromStrRadix$17xzbib(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$0naj586(rt.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$18w47d2(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$0z6zuq3(src, radix); +export function fromAsciiBytesRadixImpl$1ylh0b8(src: rt.ByteSlice, radix: rt.u32): rt.Result { + const _3: rt.Result = num_fromAsciiBytesRadixImpl$05ylgyc(src, radix); if (_3.ok) { const _7: rt.isize | undefined = rt.nonZero(_3.value); if (_7 !== undefined) { @@ -235,12 +235,12 @@ export function fromAsciiBytesRadixImpl$18w47d2(src: rt.ByteSlice, radix: rt.u32 return _3; } -export function fromStr$17dd66m(src: string): rt.Result { - return fromStrRadix$1yrk04t(src, 10); +export function fromStr$1gsgexo(src: string): rt.Result { + return fromStrRadix$0k1ynqn(src, 10); } -export function fromStrRadix$1yrk04t(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$18w47d2(rt.stringAsBytes(src), radix); +export function fromStrRadix$0k1ynqn(src: string, radix: rt.u32): rt.Result { + return fromAsciiBytesRadixImpl$1ylh0b8(rt.stringAsBytes(src), radix); } //# sourceMappingURL=nonzero.ts.map diff --git a/ts/fixtures/lang/expected/core/option.ts b/ts/fixtures/lang/expected/core/option.ts index 7390470f2..6cf5dfb77 100644 --- a/ts/fixtures/lang/expected/core/option.ts +++ b/ts/fixtures/lang/expected/core/option.ts @@ -1,6 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rt from "../rt.ts"; +import { opaque as args_opaque, len as args_len } from "../args.ts"; import type * as borrows_Noisy from "../borrows.Noisy.ts"; import type * as bounds_Item from "../bounds.Item.ts"; import * as clones_Logged from "../clones.Logged.ts"; @@ -35,7 +36,8 @@ import type * as locals_Noisy from "../locals.Noisy.ts"; import type * as orders_Item from "../orders.Item.ts"; import type * as Loaded from "../pointers.Loaded.ts"; import type * as pointers_Pair from "../pointers.Pair.ts"; -import { sum, sumWords, sumPairs, sumTexts, sumTwos } from "../separated.ts"; +import type * as returns_Error from "../returns.Error.ts"; +import { sum as separated_sum, sumWords, sumPairs, sumTexts, sumTwos } from "../separated.ts"; import type * as separated_Pair from "../separated.Pair.ts"; import { from$convert_From_shapes_Dir_u8 } from "../shapes.ts"; import type * as shapes_Dir from "../shapes.Dir.ts"; @@ -46,7 +48,6 @@ import { digest as slices_digest, digestWords } from "../slices.ts"; import type * as slices_Item from "../slices.Item.ts"; import * as slices_Noisy from "../slices.Noisy.ts"; import type * as slices_Pair from "../slices.Pair.ts"; -import type * as Short from "../splits.Short.ts"; import type * as Loud from "../zeros.Loud.ts"; import * as zeros_Tagged from "../zeros.Tagged.ts"; @@ -577,11 +578,18 @@ export function map$0qyyft9(self: rt.u16[] | undefined, _: (a0: rt.u16[]) => rt. return digestWords(self); } +export function map$0waqle9(self: rt.ByteSlice | undefined, _: (a0: rt.ByteSlice) => rt.u8): rt.u8 | undefined { + if (self === undefined) { + return undefined; + } + return args_opaque(self); +} + export function map$1uuzv15(self: rt.ByteSlice | undefined, _: (a0: rt.ByteSlice) => rt.u8): rt.u8 | undefined { if (self === undefined) { return undefined; } - return sum(self); + return separated_sum(self); } export function map$1xk4yz1(self: rt.ByteSlice | undefined, _: (a0: rt.ByteSlice) => rt.u8): rt.u8 | undefined { @@ -669,6 +677,13 @@ export function map$0jcaaxx(self: [rt.u8 | undefined, rt.u8] | undefined, f: (a0 return f(self); } +export function map$1yogfym(self: [rt.u8, rt.ByteSlice] | undefined, f: (a0: [rt.u8, rt.ByteSlice]) => rt.ByteSlice): rt.ByteSlice | undefined { + if (self === undefined) { + return undefined; + } + return f(self); +} + export function map$1hdkvwd(self: [rt.u8, rt.u8] | undefined, f: (a0: [rt.u8, rt.u8]) => rt.u8): rt.u8 | undefined { if (self === undefined) { return undefined; @@ -1163,7 +1178,14 @@ export function mapOr$18m1ie6(self: rt.ByteSlice | undefined, default_: rt.u8, _ if (self === undefined) { return default_; } - return sum(self); + return separated_sum(self); +} + +export function mapOr$0dk8jdr(self: rt.ByteSlice | undefined, default_: rt.usize, _: (a0: rt.ByteSlice) => rt.usize): rt.usize { + if (self === undefined) { + return default_; + } + return args_len(self.data, self.start, self.length); } export function mapOr$189goit(self: slices_Noisy.Noisy | undefined, default_: rt.u8, f: (a0: slices_Noisy.Noisy) => rt.u8): rt.u8 { @@ -1467,21 +1489,28 @@ export function okOr$07zal2e(self: rt.u32[] | undefined, err: rt.u8): rt.Result< return rt.Ok(self); } -export function okOr$0jslmu4(self: [rt.ByteSlice, rt.ByteSlice] | undefined, err: rt.u8): rt.Result<[rt.ByteSlice, rt.ByteSlice], rt.u8> { +export function okOr$0gtm15y(self: rt.ByteSlice | undefined, err: rt.u8 | undefined): rt.Result { if (self === undefined) { return rt.Err(err); } return rt.Ok(self); } -export function okOr$0q0ogpn(self: [rt.ByteSlice, rt.ByteSlice] | undefined, err: rt.u8 | undefined): rt.Result<[rt.ByteSlice, rt.ByteSlice], rt.u8 | undefined> { +export function okOr$12p77jh(self: rt.ByteSlice | undefined, err: returns_Error.Error): rt.Result { if (self === undefined) { return rt.Err(err); } return rt.Ok(self); } -export function okOr$1np0z7r(self: [rt.ByteSlice, rt.ByteSlice] | undefined, err: Short.Short): rt.Result<[rt.ByteSlice, rt.ByteSlice], Short.Short> { +export function okOr$0tezn0w(self: rt.ByteSlice | undefined, _: undefined): rt.Result { + if (self === undefined) { + return rt.ERR; + } + return rt.Ok(self); +} + +export function okOr$0q0ogpn(self: [rt.ByteSlice, rt.ByteSlice] | undefined, err: rt.u8 | undefined): rt.Result<[rt.ByteSlice, rt.ByteSlice], rt.u8 | undefined> { if (self === undefined) { return rt.Err(err); } diff --git a/ts/fixtures/lang/expected/core/result.ts b/ts/fixtures/lang/expected/core/result.ts index e3449b6b5..7616af035 100644 --- a/ts/fixtures/lang/expected/core/result.ts +++ b/ts/fixtures/lang/expected/core/result.ts @@ -14,6 +14,7 @@ import { eq$1v93ipo as str_error_eq$1v93ipo, eq$1f3e51k as str_error_eq$1f3e51k import { cmp$175ka5q as poll_cmp$175ka5q } from "../core/task/poll.ts"; import { eq$0dhyfbb as time_eq$0dhyfbb } from "../core/time.ts"; import * as Part from "../orders.Part.ts"; +import type * as returns_Error from "../returns.Error.ts"; export function eq$04qb8k3(self: rt.Result, other: rt.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { @@ -557,6 +558,13 @@ export function map$03hz3l7(self: rt.Result, op: (a0: rt.u8) => un return self as rt.Result; } +export function mapOr$0fbyajt(self: rt.Result, default_: rt.usize, _: (a0: rt.ByteSlice) => rt.usize): rt.usize { + if (self.ok) { + return self.value.length; + } + return default_; +} + export function mapOr$1mu5bvh(self: rt.Result, default_: rt.u8, f: (a0: rt.u8) => rt.u8): rt.u8 { if (self.ok) { return f(self.value); @@ -642,6 +650,13 @@ export function and$0l7ltae(self: rt.Result, res: rt.Result, op: (a0: [rt.ByteSlice, rt.ByteSlice]) => rt.Result): rt.Result { + if (self.ok) { + return op(self.value); + } + return self as rt.Result; +} + export function andThen$0hd6ik8(self: rt.Result, op: (a0: rt.u8) => rt.Result): rt.Result { if (self.ok) { return op(self.value); diff --git a/ts/fixtures/lang/expected/core/str.ts b/ts/fixtures/lang/expected/core/str.ts index e1f78747f..c46867777 100644 --- a/ts/fixtures/lang/expected/core/str.ts +++ b/ts/fixtures/lang/expected/core/str.ts @@ -1,108 +1,108 @@ // Generated by rust2-ts. Do not edit. import * as rt from "../rt.ts"; -import { fromStr$1ej7fl2 as num_fromStr$1ej7fl2, fromStr$076yg1t as num_fromStr$076yg1t, fromStr$1dxzqb4 as num_fromStr$1dxzqb4, fromStr$09oey6q as num_fromStr$09oey6q, fromStr$1m3wp28 as num_fromStr$1m3wp28, fromStr$1gsa29j as num_fromStr$1gsa29j, fromStr$0pnvd2c as num_fromStr$0pnvd2c, fromStr$1bigolo as num_fromStr$1bigolo, fromStr$1uzmhcw as num_fromStr$1uzmhcw, fromStr$05sn9io as num_fromStr$05sn9io, fromStr$0kn8g72 as num_fromStr$0kn8g72, fromStr$0qgw0pl as num_fromStr$0qgw0pl } from "../core/num.ts"; -import { fromStr$1d7pnbk as nonzero_fromStr$1d7pnbk, fromStr$15isx69 as nonzero_fromStr$15isx69, fromStr$04uijf8 as nonzero_fromStr$04uijf8, fromStr$0l2zu9x as nonzero_fromStr$0l2zu9x, fromStr$0h0ptos as nonzero_fromStr$0h0ptos, fromStr$10svit2 as nonzero_fromStr$10svit2, fromStr$19kbj04 as nonzero_fromStr$19kbj04, fromStr$0br814e as nonzero_fromStr$0br814e, fromStr$1471qz1 as nonzero_fromStr$1471qz1, fromStr$0k8sfhf as nonzero_fromStr$0k8sfhf, fromStr$0b2xa80 as nonzero_fromStr$0b2xa80, fromStr$17dd66m as nonzero_fromStr$17dd66m } from "../core/num/nonzero.ts"; +import { fromStr$0zyj6he as num_fromStr$0zyj6he, fromStr$17ewwma as num_fromStr$17ewwma, fromStr$0zhqfgx as num_fromStr$0zhqfgx, fromStr$116mp4t as num_fromStr$116mp4t, fromStr$0ovlgjd as num_fromStr$0ovlgjd, fromStr$1grmucc as num_fromStr$1grmucc, fromStr$0qvzsmz as num_fromStr$0qvzsmz, fromStr$0yqu2i9 as num_fromStr$0yqu2i9, fromStr$08wf09w as num_fromStr$08wf09w, fromStr$1ypcnp8 as num_fromStr$1ypcnp8, fromStr$1hq0zfa as num_fromStr$1hq0zfa, fromStr$10ypyht as num_fromStr$10ypyht } from "../core/num.ts"; +import { fromStr$0evev4b as nonzero_fromStr$0evev4b, fromStr$1lm2uzl as nonzero_fromStr$1lm2uzl, fromStr$0gvyqp3 as nonzero_fromStr$0gvyqp3, fromStr$19lq810 as nonzero_fromStr$19lq810, fromStr$1lyc2jq as nonzero_fromStr$1lyc2jq, fromStr$06k4xxy as nonzero_fromStr$06k4xxy, fromStr$0xht6mx as nonzero_fromStr$0xht6mx, fromStr$021o7ki as nonzero_fromStr$021o7ki, fromStr$1myv2t6 as nonzero_fromStr$1myv2t6, fromStr$10p52cj as nonzero_fromStr$10p52cj, fromStr$081k88g as nonzero_fromStr$081k88g, fromStr$1gsgexo as nonzero_fromStr$1gsgexo } from "../core/num/nonzero.ts"; import { fromStr$05d44vn as traits_fromStr$05d44vn } from "../core/str/traits.ts"; export function parse$0vh4cry(self: string): rt.Result { return traits_fromStr$05d44vn(self); } -export function parse$0zwe7sh(self: string): rt.Result { - return num_fromStr$1ej7fl2(self); +export function parse$082ztwj(self: string): rt.Result { + return num_fromStr$0zyj6he(self); } -export function parse$1rrjn2d(self: string): rt.Result { - return num_fromStr$076yg1t(self); +export function parse$0xnscjy(self: string): rt.Result { + return num_fromStr$17ewwma(self); } -export function parse$12n9p35(self: string): rt.Result { - return num_fromStr$1dxzqb4(self); +export function parse$12szghw(self: string): rt.Result { + return num_fromStr$0zhqfgx(self); } -export function parse$1ilajpu(self: string): rt.Result { - return num_fromStr$09oey6q(self); +export function parse$11m1f1e(self: string): rt.Result { + return num_fromStr$116mp4t(self); } -export function parse$1fq462u(self: string): rt.Result { - return num_fromStr$1m3wp28(self); +export function parse$1ci7nyc(self: string): rt.Result { + return num_fromStr$0ovlgjd(self); } -export function parse$1g5tknx(self: string): rt.Result { - return num_fromStr$1gsa29j(self); +export function parse$07xyv4i(self: string): rt.Result { + return num_fromStr$1grmucc(self); } -export function parse$0ub96so(self: string): rt.Result { - return nonzero_fromStr$0b2xa80(self); +export function parse$1bh1yup(self: string): rt.Result { + return nonzero_fromStr$081k88g(self); } -export function parse$1ogkfqt(self: string): rt.Result { - return nonzero_fromStr$0br814e(self); +export function parse$034rhh2(self: string): rt.Result { + return nonzero_fromStr$021o7ki(self); } -export function parse$1n7pf37(self: string): rt.Result { - return nonzero_fromStr$1471qz1(self); +export function parse$1wp6z3o(self: string): rt.Result { + return nonzero_fromStr$1myv2t6(self); } -export function parse$1xm5283(self: string): rt.Result { - return nonzero_fromStr$0k8sfhf(self); +export function parse$00wf0ig(self: string): rt.Result { + return nonzero_fromStr$10p52cj(self); } -export function parse$0xeilg3(self: string): rt.Result { - return nonzero_fromStr$19kbj04(self); +export function parse$1bfudtm(self: string): rt.Result { + return nonzero_fromStr$0xht6mx(self); } -export function parse$0eefxsx(self: string): rt.Result { - return nonzero_fromStr$17dd66m(self); +export function parse$16jvjal(self: string): rt.Result { + return nonzero_fromStr$1gsgexo(self); } -export function parse$0bwhuel(self: string): rt.Result { - return nonzero_fromStr$0h0ptos(self); +export function parse$0y8gj7z(self: string): rt.Result { + return nonzero_fromStr$1lyc2jq(self); } -export function parse$0zy5dnc(self: string): rt.Result { - return nonzero_fromStr$15isx69(self); +export function parse$0y6waa4(self: string): rt.Result { + return nonzero_fromStr$1lm2uzl(self); } -export function parse$1o8vfr6(self: string): rt.Result { - return nonzero_fromStr$04uijf8(self); +export function parse$1s5pqso(self: string): rt.Result { + return nonzero_fromStr$0gvyqp3(self); } -export function parse$0l0cs1u(self: string): rt.Result { - return nonzero_fromStr$0l2zu9x(self); +export function parse$129b0a7(self: string): rt.Result { + return nonzero_fromStr$19lq810(self); } -export function parse$0zrdgp4(self: string): rt.Result { - return nonzero_fromStr$1d7pnbk(self); +export function parse$150tkxc(self: string): rt.Result { + return nonzero_fromStr$0evev4b(self); } -export function parse$0s8xu45(self: string): rt.Result { - return nonzero_fromStr$10svit2(self); +export function parse$02m155k(self: string): rt.Result { + return nonzero_fromStr$06k4xxy(self); } -export function parse$137ljop(self: string): rt.Result { - return num_fromStr$0pnvd2c(self); +export function parse$069o3rw(self: string): rt.Result { + return num_fromStr$0qvzsmz(self); } -export function parse$0mrlpzv(self: string): rt.Result { - return num_fromStr$1bigolo(self); +export function parse$0fi19ig(self: string): rt.Result { + return num_fromStr$0yqu2i9(self); } -export function parse$1bassid(self: string): rt.Result { - return num_fromStr$1uzmhcw(self); +export function parse$1aq2uo0(self: string): rt.Result { + return num_fromStr$08wf09w(self); } -export function parse$1q1obm6(self: string): rt.Result { - return num_fromStr$05sn9io(self); +export function parse$0o4ono0(self: string): rt.Result { + return num_fromStr$1ypcnp8(self); } -export function parse$0yt2578(self: string): rt.Result { - return num_fromStr$0kn8g72(self); +export function parse$0at0fdl(self: string): rt.Result { + return num_fromStr$1hq0zfa(self); } -export function parse$1m4h82x(self: string): rt.Result { - return num_fromStr$0qgw0pl(self); +export function parse$08wetap(self: string): rt.Result { + return num_fromStr$10ypyht(self); } //# sourceMappingURL=str.ts.map diff --git a/ts/fixtures/lang/expected/dyns.ts b/ts/fixtures/lang/expected/dyns.ts index 9551722b0..8d043d1ba 100644 --- a/ts/fixtures/lang/expected/dyns.ts +++ b/ts/fixtures/lang/expected/dyns.ts @@ -79,11 +79,11 @@ export function make(kind: rt.u8, n: rt.u8): dyns_Named.Named { return new dyns_Named.of$dyns_Tri(_10); } -export function dyns(data: rt.ByteSlice, out: rt.ByteVec): void { +export function dyns(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let tri!: Tri.Tri; let _109!: rt.usize; - if (data.length >= 3) { - const _12: [rt.u8, rt.u8, rt.u8] = [data.data[data.start], data.data[data.start + 1], data.data[data.start + 2]]; + if (dataLen >= 3) { + const _12: [rt.u8, rt.u8, rt.u8] = [dataData[dataStart], dataData[dataStart + 1], dataData[dataStart + 2]]; const a: rt.u8 = _12[0]; const b: rt.u8 = _12[1]; const c: rt.u8 = _12[2]; @@ -108,7 +108,7 @@ export function dyns(data: rt.ByteSlice, out: rt.ByteVec): void { const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(_78, f), (f: rt.Formatter) => rt.u8Display(_82, f)]; fmt_put(out, rt.fmtFormat([args6[0], " ", args6[1], " "])); const shapes: dyns_Named.Named[] = []; - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(data.data, data.start + 3, data.length - 3)))); + const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart + 3, dataLen - 3)))); while (true) { const _94: [rt.usize, rt.u8] | rt.Done = iter.next(); if (_94 === rt.DONE) { @@ -184,9 +184,9 @@ export function counts$dyns_Square(arcs: rt.Arc[]): string { }), undefined, 12, true), ","); } -export function shared(data: rt.ByteSlice, out: rt.ByteVec): void { - if (data.length >= 2) { - const sq: rt.Arc = new rt.Arc({ side: data.data[data.start] as rt.u16 }); +export function shared(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + if (dataLen >= 2) { + const sq: rt.Arc = new rt.Arc({ side: dataData[dataStart] as rt.u16 }); const _13: rt.Arc = rt.arcClone(sq); const named: rt.Arc = new rt.ArcDyn(_13, new dyns_Named.of$dyns_Square(_13.value)); const _16: rt.Arc = rt.arcClone(sq); @@ -241,7 +241,7 @@ export function shared(data: rt.ByteSlice, out: rt.ByteVec): void { const _178: string = rt.fmtFormat([args14[0], " ", args14[1], " "]); rt.drop(_184); fmt_put(out, _178); - const hits: rt.Arc = new rt.Arc({ _0: new rt.Atomic(data.data[data.start + 1] as rt.u32) }); + const hits: rt.Arc = new rt.Arc({ _0: new rt.Atomic(dataData[dataStart + 1] as rt.u32) }); const objects: rt.Arc[] = rt.iterToArray(rt.iterMap(new rt.Range(0, 3), (_2: rt.i32): rt.Arc => { const _34: rt.Arc = rt.arcClone(hits); return new rt.ArcDyn(_34, new dyns_Shape.of$dyns_Hits(_34.value)); @@ -257,15 +257,15 @@ export function shared(data: rt.ByteSlice, out: rt.ByteVec): void { const part3 = counts$dyns_Hits([hits]); const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part3)]; fmt_put(out, rt.fmtFormat([args18[0], " "])); - const _253: rt.Arc = new rt.Arc(data.data[data.start + 1] as rt.u32); + const _253: rt.Arc = new rt.Arc(dataData[dataStart + 1] as rt.u32); const n: rt.Arc = new rt.ArcDyn(_253, new dyns_Shape.of$u32(_253.value)); - const _257: rt.Arc = new rt.Arc(data.data[data.start + 1] as rt.u32); + const _257: rt.Arc = new rt.Arc(dataData[dataStart + 1] as rt.u32); const m: rt.Arc = new rt.ArcDyn(_257, new dyns_Shape.of$u32(_257.value)); const _268: rt.u32 = n.value.area$Shape(); const _272: boolean = rt.arcPtrEq(n, m); const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_268, f), (f: rt.Formatter) => rt.fmtBool(_272, f)]; fmt_put(out, rt.fmtFormat([args20[0], " ", args20[1], " "])); - const tris: rt.Arc[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(data.data, data.start + 2, data.length - 2))), (_23: rt.u8): rt.Arc => { + const tris: rt.Arc[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart + 2, dataLen - 2))), (_23: rt.u8): rt.Arc => { const x: rt.u8 = _23; const _43: rt.u8 = rt.u8Rem(x, 3); if (_43 === 0) { @@ -370,11 +370,11 @@ export function isA$u32(e: dyns_Erased.Erased): boolean { return ((_4 instanceof Any.of$u32 ? _4.v : _4 instanceof Any.ofPlace$u32 ? _4.v.v : undefined)) !== undefined; } -export function anys(data: rt.ByteSlice, out: rt.ByteVec): void { +export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let tri!: Tri.Tri; let _237!: Any.Any; - if (data.length >= 2) { - const _10: [rt.u8, rt.u8] = [data.data[data.start], data.data[data.start + 1]]; + if (dataLen >= 2) { + const _10: [rt.u8, rt.u8] = [dataData[dataStart], dataData[dataStart + 1]]; const a: rt.u8 = _10[0]; const b: rt.u8 = _10[1]; const sq: Square.Square = { side: a as rt.u16 }; @@ -451,7 +451,7 @@ export function anys(data: rt.ByteSlice, out: rt.ByteVec): void { const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(some, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtOption(none, f, rt.u8Debug)]; fmt_put(out, rt.fmtFormat([args16[0], " ", args16[1], " "])); const boxes: Any.Any[] = []; - const iter4: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(data.data, data.start + 2, data.length - 2)))); + const iter4: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart + 2, dataLen - 2)))); while (true) { const _229: [rt.usize, rt.u8] | rt.Done = iter4.next(); if (_229 === rt.DONE) { diff --git a/ts/fixtures/lang/expected/errors.ts b/ts/fixtures/lang/expected/errors.ts index deedeaf61..67b4a0d98 100644 --- a/ts/fixtures/lang/expected/errors.ts +++ b/ts/fixtures/lang/expected/errors.ts @@ -5,7 +5,7 @@ import { then$0afp4no } from "./core/bool.ts"; import { eq$09vw48j as convert_eq$09vw48j } from "./core/char/convert.ts"; import { eq$18sin5z as num_error_eq$18sin5z } from "./core/num/error.ts"; import { eq$04qb8k3 as result_eq$04qb8k3, eq$10fppe8 as result_eq$10fppe8, eq$0ecfqx9 as result_eq$0ecfqx9, eq$0nlhjpf as result_eq$0nlhjpf, eq$04iua4k as result_eq$04iua4k, eq$1dhtbkj as result_eq$1dhtbkj, eq$0pe0qmq as result_eq$0pe0qmq, eq$1mpp8xa as result_eq$1mpp8xa, eq$0grmb7g as result_eq$0grmb7g, eq$19kc15f as result_eq$19kc15f, eq$0rj0czq as result_eq$0rj0czq, eq$1hq3neq as result_eq$1hq3neq, eq$08241oi as result_eq$08241oi, eq$0bl30vt as result_eq$0bl30vt, eq$1fkhuzl as result_eq$1fkhuzl, eq$0p1bb4y as result_eq$0p1bb4y, eq$03gbayb as result_eq$03gbayb, err$1ujom0k, err$02r96h1, err$0jf6smd, map$0fm1w6u as result_map$0fm1w6u, map$0r57egs as result_map$0r57egs, mapErr$0u5yxjj as result_mapErr$0u5yxjj } from "./core/result.ts"; -import { parse$0vh4cry, parse$0zwe7sh, parse$1fq462u, parse$1o8vfr6, parse$1q1obm6, parse$0yt2578 } from "./core/str.ts"; +import { parse$0vh4cry, parse$082ztwj, parse$1ci7nyc, parse$1s5pqso, parse$0o4ono0, parse$0at0fdl } from "./core/str.ts"; import { eq$1f3e51k as str_error_eq$1f3e51k } from "./core/str/error.ts"; /** Each pair's `==` and `!=`, a bit each. */ @@ -396,31 +396,31 @@ export function parsed$f64(all: string[]): rt.Result export function parsed$i128(all: string[]): rt.Result[] { return rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { - return parse$0zwe7sh(s); + return parse$082ztwj(s); }), undefined, 32, true); } export function parsed$i8(all: string[]): rt.Result[] { return rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { - return parse$1fq462u(s); + return parse$1ci7nyc(s); }), undefined, 2, true); } export function parsed$num_NonZero_u32(all: string[]): rt.Result[] { return rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { - return parse$1o8vfr6(s); + return parse$1s5pqso(s); }), undefined, 8, true); } export function parsed$u64(all: string[]): rt.Result[] { return rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { - return parse$1q1obm6(s); + return parse$0o4ono0(s); }), undefined, 16, true); } export function parsed$u8(all: string[]): rt.Result[] { return rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { - return parse$0yt2578(s); + return parse$0at0fdl(s); }), undefined, 2, true); } @@ -485,7 +485,7 @@ export function eqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }), undefined, 16, true), out); } else if (_32 === 12) { pairs$Result_Option_u8_num_ParseIntError(rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s6: string): rt.Result => { - return result_map$0r57egs(parse$0yt2578(s6), (v10: rt.u8): rt.u8 | undefined => { + return result_map$0r57egs(parse$0at0fdl(s6), (v10: rt.u8): rt.u8 | undefined => { return rt.u8CheckedSub(v10, 1); }); }), undefined, 2, true), out); @@ -496,7 +496,7 @@ export function eqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }); }), undefined, 8, true), out); pairs$Result_u8_num_IntErrorKind(rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s8: string): rt.Result => { - return result_mapErr$0u5yxjj(parse$0yt2578(s8), (e: rt.ParseIntError): rt.IntErrorKind => { + return result_mapErr$0u5yxjj(parse$0at0fdl(s8), (e: rt.ParseIntError): rt.IntErrorKind => { return e.kind; }); }), undefined, 2, true), out); @@ -514,7 +514,7 @@ export function eqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { pairs$Option_Result_u8_num_ParseIntError(rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result | undefined => { const _73: string = s; return then$0afp4no(!((s.length === 0)), (): rt.Result => { - return parse$0yt2578(_73); + return parse$0at0fdl(_73); }); }), undefined, 2, true), out); pairs$Vec_Result_bool_str_ParseBoolError(rt.iterToArray(rt.iterMap(rt.sliceChunks(all, 2), parsed$bool), undefined, 12, true), out); @@ -528,7 +528,7 @@ export function eqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return err$1ujom0k(parse$0vh4cry(s4)); }), "next", 0), out); pairs$num_ParseIntError(rt.iterToArray(rt.iterFilterMap(rt.iterSlice(all), (s5: string): rt.ParseIntError | undefined => { - return err$0jf6smd(parse$1fq462u(s5)); + return err$0jf6smd(parse$1ci7nyc(s5)); }), "next", 1), out); } } diff --git a/ts/fixtures/lang/expected/fmt.ts b/ts/fixtures/lang/expected/fmt.ts index 48bad6993..c19f86727 100644 --- a/ts/fixtures/lang/expected/fmt.ts +++ b/ts/fixtures/lang/expected/fmt.ts @@ -340,14 +340,18 @@ export function note(log: rt.ByteVec, v: rt.u8): rt.u8 { } /** Arguments that read `log` before and after one changes it, through a reference. */ -export function logged(log: rt.ByteVec, data: rt.ByteSlice): string { +export function logged(log: rt.ByteVec, dataData: Uint8Array, dataStart: number, dataLen: number): string { const _7: rt.usize = log.length; - rt.idx(data, 0); - const _10: rt.u8 = note(log, data.data[data.start]); - const _16: rt.usize = rt.usizeRem(log.length, data.length); - rt.idx(data, _16); + if (0 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + 0); + } + const _10: rt.u8 = note(log, dataData[dataStart]); + const _16: rt.usize = rt.usizeRem(log.length, dataLen); + if (_16 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _16); + } const _24: rt.usize = log.length; - const part = data.data[data.start + _16]; + const part = dataData[dataStart + _16]; const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_7, f), (f: rt.Formatter) => rt.u8Display(_10, f), (f: rt.Formatter) => rt.u8Display(part, f), (f: rt.Formatter) => rt.usizeDisplay(_24, f)]; return rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3]]); } @@ -406,7 +410,7 @@ export function written(data: rt.ByteSlice, out: rt.ByteVec): void { const args20: rt.Fmt[] = [(f: rt.Formatter) => Noted.fmt$fmt_Display(_218, f), (f: rt.Formatter) => Noted.fmt$fmt_Display(_222, f)]; put(out, rt.fmtFormat([args20[0], "|", rt.fmtSpec({ align: ">", width: 6 }, args20[1])])); if (!((data.length === 0))) { - put(out, logged(log, data)); + put(out, logged(log, data.data, data.start, data.length)); } const _241: rt.u8 = at(13); const part2 = note(log, _241); diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 6c513a9eb..d0cf80185 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -1,6 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; +import { args } from "./args.ts"; import { fromFns, maps, lent as arrays_lent, asSlices, given, flattened as arrays_flattened } from "./arrays.ts"; import { bytes as ascii_bytes, chars as ascii_chars, slices as ascii_slices } from "./ascii.ts"; import { atomics } from "./atomics.ts"; @@ -43,6 +44,7 @@ import { objects } from "./objects.ts"; import { orders, bytes as orders_bytes, tuples as orders_tuples, held as orders_held, btrees } from "./orders.ts"; import { lists as pointers_lists, shared as pointers_shared, places as pointers_places, unchecked, nested as pointers_nested, copies as pointers_copies, sentinels, cells as pointers_cells, rebound as pointers_rebound, lapsed, writers, made as pointers_made, segments, uninitRuns, iteratedRuns, besideWritten, waiters, taken as pointers_taken, bytes as pointers_bytes, loaded, reattached, partWritten } from "./pointers.ts"; import { refs, toRefs } from "./refs.ts"; +import { returns } from "./returns.ts"; import { u8s as saturates_u8s, u16s as saturates_u16s, u32s as saturates_u32s, u64s as saturates_u64s, u128s as saturates_u128s, usizes as saturates_usizes, i8s as saturates_i8s, i16s as saturates_i16s, i32s as saturates_i32s, i64s as saturates_i64s, i128s as saturates_i128s, isizes as saturates_isizes } from "./saturates.ts"; import { separated } from "./separated.ts"; import { copies as shapes_copies, order as shapes_order, discriminants, loops, patterns, uninhabited, closures as shapes_closures, library, flows } from "./shapes.ts"; @@ -109,9 +111,9 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::rounding", (_2122: rt.u8, _3100: rt.ByteSlice, out23: rt.ByteVec): undefined => { rounding(out23); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::skips", skips as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wrappers::wrappers", wrappers as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["edits::edits", edits_edits as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["utf8::decodes", decodes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::floats", floats as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["atomics::atomics", atomics as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::overrides", overrides as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::dyns", (_2123: rt.u8, data23: rt.ByteSlice, out24: rt.ByteVec): undefined => { - dyns(data23, out24); + dyns(data23.data, data23.start, data23.length, out24); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cells::cells", cells_cells as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::shared", (_2124: rt.u8, data24: rt.ByteSlice, out25: rt.ByteVec): undefined => { - dyns_shared(data24, out25); + dyns_shared(data24.data, data24.start, data24.length, out25); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::ranked", iters_ranked as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["captures::captures", captures as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locks::locks", (_2125: rt.u8, data25: rt.ByteSlice, out26: rt.ByteVec): undefined => { locks(data25, out26); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locks::relock", (_2126: rt.u8, data26: rt.ByteSlice, out27: rt.ByteVec): undefined => { @@ -139,13 +141,13 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::unique_rcs", (_2137: rt.u8, data37: rt.ByteSlice, out38: rt.ByteVec): undefined => { uniqueRcs(data37, out38); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::anys", (_2138: rt.u8, data38: rt.ByteSlice, out39: rt.ByteVec): undefined => { - anys(data38, out39); + anys(data38.data, data38.start, data38.length, out39); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::fns", (_2139: rt.u8, data39: rt.ByteSlice, out40: rt.ByteVec): undefined => { fns(data39, out40); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::copies", (_2140: rt.u8, data40: rt.ByteSlice, out41: rt.ByteVec): undefined => { pointers_copies(data40, out41); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::lists", (_2141: rt.u8, data41: rt.ByteSlice, out42: rt.ByteVec): undefined => { - pointers_lists(data41, out42); + pointers_lists(data41.data, data41.start, data41.length, out42); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::nested", (_2142: rt.u8, data42: rt.ByteSlice, out43: rt.ByteVec): undefined => { pointers_nested(data42, out43); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::places", (_2143: rt.u8, data43: rt.ByteSlice, out44: rt.ByteVec): undefined => { @@ -153,7 +155,7 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::sentinels", (_2144: rt.u8, data44: rt.ByteSlice, out45: rt.ByteVec): undefined => { sentinels(data44, out45); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::shared", (_2145: rt.u8, data45: rt.ByteSlice, out46: rt.ByteVec): undefined => { - pointers_shared(data45, out46); + pointers_shared(data45.data, data45.start, data45.length, out46); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::unchecked", (_2146: rt.u8, data46: rt.ByteSlice, out47: rt.ByteVec): undefined => { unchecked(data46, out47); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["edits::bytes", edits_bytes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::from_fns", (_2147: rt.u8, data47: rt.ByteSlice, out48: rt.ByteVec): undefined => { @@ -184,7 +186,11 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) fmt_writes(data59, out60); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["bounds::bounds", bounds_bounds as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::cells", (_2160: rt.u8, data60: rt.ByteSlice, out61: rt.ByteVec): undefined => { pointers_cells(data60, out61); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::parses", ints_parses as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::edits", strs_edits as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::subslices", subslices as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::bytes", (_2161: rt.u8, data61: rt.ByteSlice, out62: rt.ByteVec): undefined => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::parses", (a053: rt.u8, a153: rt.ByteSlice, a253: rt.ByteVec): undefined => { + ints_parses(a053, a153.data, a153.start, a153.length, a253); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::edits", (a054: rt.u8, a154: rt.ByteSlice, a254: rt.ByteVec): undefined => { + strs_edits(a054, a154.data, a154.start, a154.length, a254); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::subslices", subslices as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::bytes", (_2161: rt.u8, data61: rt.ByteSlice, out62: rt.ByteVec): undefined => { hashes_bytes(data61, out62); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::bytes", keys_bytes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::parses", strs_parses as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::rebound", (_2162: rt.u8, data62: rt.ByteSlice, out63: rt.ByteVec): undefined => { pointers_rebound(data62, out63); @@ -192,7 +198,9 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) reducers(data63, out64); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::writers", (_2164: rt.u8, data64: rt.ByteSlice, out65: rt.ByteVec): undefined => { writers(data64, out65); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["errors::eqs", eqs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::edits", slices_edits as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::iters", strs_iters as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::drains", strs_drains as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::hinted", hinted as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::made", (_2165: rt.u8, data65: rt.ByteSlice, out66: rt.ByteVec): undefined => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["errors::eqs", eqs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::edits", slices_edits as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::iters", strs_iters as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::drains", (a062: rt.u8, a162: rt.ByteSlice, a262: rt.ByteVec): undefined => { + strs_drains(a062, a162.data, a162.start, a162.length, a262); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::hinted", hinted as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::made", (_2165: rt.u8, data65: rt.ByteSlice, out66: rt.ByteVec): undefined => { pointers_made(data65, out66); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::as_slices", (_2166: rt.u8, data66: rt.ByteSlice, out67: rt.ByteVec): undefined => { asSlices(data66, out67); @@ -222,7 +230,9 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) orders_held(data78, out79); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["joins::joins", joins as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::iterated_runs", (_2179: rt.u8, data79: rt.ByteSlice, out80: rt.ByteVec): undefined => { iteratedRuns(data79, out80); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::writes", zeros_writes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::tuples", (_2180: rt.u8, data80: rt.ByteSlice, out81: rt.ByteVec): undefined => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::writes", (a0109: rt.u8, a1109: rt.ByteSlice, a2109: rt.ByteVec): undefined => { + zeros_writes(a0109, a1109.data, a1109.start, a1109.length, a2109); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::tuples", (_2180: rt.u8, data80: rt.ByteSlice, out81: rt.ByteVec): undefined => { orders_tuples(data80, out81); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["tuples::tuples", tuples_tuples as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u8s", saturates_u8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u16s", saturates_u16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u32s", saturates_u32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u64s", saturates_u64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u128s", saturates_u128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::usizes", saturates_usizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i8s", saturates_i8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i16s", saturates_i16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i32s", saturates_i32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i64s", saturates_i64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i128s", saturates_i128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::isizes", saturates_isizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u8s", methods_u8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u16s", methods_u16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u32s", methods_u32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u64s", methods_u64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u128s", methods_u128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::usizes", methods_usizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i8s", methods_i8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i16s", methods_i16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i32s", methods_i32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i64s", methods_i64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i128s", methods_i128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::isizes", methods_isizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["separated::separated", separated as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::waiters", (_2181: rt.u8, data81: rt.ByteSlice, out82: rt.ByteVec): undefined => { waiters(data81, out82); @@ -238,7 +248,7 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) reattached(data86, out87); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::part_written", (_2187: rt.u8, data87: rt.ByteSlice, out88: rt.ByteVec): undefined => { partWritten(data87, out88); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::flattened", arrays_flattened as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::flattened", arrays_flattened as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["args::args", args as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["returns::returns", returns as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; } /** Run one case. */ diff --git a/ts/fixtures/lang/expected/holds.ts b/ts/fixtures/lang/expected/holds.ts index 1d231e71e..234798d63 100644 --- a/ts/fixtures/lang/expected/holds.ts +++ b/ts/fixtures/lang/expected/holds.ts @@ -30,7 +30,7 @@ export function holds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_10 === 5) { parts(a, b, data, out); } else { - ranges(data, out); + ranges(data.data, data.start, data.length, out); } } @@ -298,16 +298,16 @@ export function parts(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): } /** A range's start read, then the range stepped, once and in a loop. */ -export function ranges(data: rt.ByteSlice, out: rt.ByteVec): void { +export function ranges(_dataData: Uint8Array, _dataStart: number, dataLen: number, out: rt.ByteVec): void { let _16!: rt.usize; - const range: rt.Range = new rt.Range(0, data.length); + const range: rt.Range = new rt.Range(0, dataLen); const before: rt.usize = range.start; const first: rt.usize | undefined = range.start < range.end ? range.start++ : undefined; rt.byteVecPush(out, before & 0xff); rt.byteVecPush(out, option_mapOr$02k4ito(first, 255, (f: rt.usize): rt.u8 => { return f & 0xff; })); - const range2: rt.Range = new rt.Range(0, data.length); + const range2: rt.Range = new rt.Range(0, dataLen); while (true) { const before2: rt.usize = range2.start; const _16Some: boolean = range2.start < range2.end; diff --git a/ts/fixtures/lang/expected/ints.ts b/ts/fixtures/lang/expected/ints.ts index ee151318e..49b37a30a 100644 --- a/ts/fixtures/lang/expected/ints.ts +++ b/ts/fixtures/lang/expected/ints.ts @@ -2,10 +2,10 @@ import * as rt from "./rt.ts"; import { toDigit$01k9ewn } from "./core/char/methods.ts"; -import { fromStr$1ej7fl2 as num_fromStr$1ej7fl2, fromStr$076yg1t as num_fromStr$076yg1t, fromStr$1dxzqb4 as num_fromStr$1dxzqb4, fromStr$09oey6q as num_fromStr$09oey6q, fromStr$1m3wp28 as num_fromStr$1m3wp28, fromStr$1gsa29j as num_fromStr$1gsa29j, fromStrRadix$1cxc8v7 as num_fromStrRadix$1cxc8v7, fromStrRadix$0w5k2s7 as num_fromStrRadix$0w5k2s7, fromStrRadix$1a42la1 as num_fromStrRadix$1a42la1, fromStrRadix$0olne29 as num_fromStrRadix$0olne29, fromStrRadix$0snhnv5 as num_fromStrRadix$0snhnv5, fromStrRadix$1mq18rn as num_fromStrRadix$1mq18rn, fromStr$0pnvd2c as num_fromStr$0pnvd2c, fromStr$1bigolo as num_fromStr$1bigolo, fromStr$1uzmhcw as num_fromStr$1uzmhcw, fromStr$05sn9io as num_fromStr$05sn9io, fromStr$0kn8g72 as num_fromStr$0kn8g72, fromStr$0qgw0pl as num_fromStr$0qgw0pl, fromStrRadix$1549erz as num_fromStrRadix$1549erz, fromStrRadix$1x7yq9g as num_fromStrRadix$1x7yq9g, fromStrRadix$1gamglm as num_fromStrRadix$1gamglm, fromStrRadix$0bx9j5d as num_fromStrRadix$0bx9j5d, fromStrRadix$1ys3fwo as num_fromStrRadix$1ys3fwo, fromStrRadix$09ykvvv as num_fromStrRadix$09ykvvv } from "./core/num.ts"; +import { fromStr$0zyj6he as num_fromStr$0zyj6he, fromStr$17ewwma as num_fromStr$17ewwma, fromStr$0zhqfgx as num_fromStr$0zhqfgx, fromStr$116mp4t as num_fromStr$116mp4t, fromStr$0ovlgjd as num_fromStr$0ovlgjd, fromStr$1grmucc as num_fromStr$1grmucc, fromStrRadix$0366bau as num_fromStrRadix$0366bau, fromStrRadix$02mhuxs as num_fromStrRadix$02mhuxs, fromStrRadix$1bgm1z0 as num_fromStrRadix$1bgm1z0, fromStrRadix$11y6fsf as num_fromStrRadix$11y6fsf, fromStrRadix$0s9rspw as num_fromStrRadix$0s9rspw, fromStrRadix$1473bi0 as num_fromStrRadix$1473bi0, fromStr$0qvzsmz as num_fromStr$0qvzsmz, fromStr$0yqu2i9 as num_fromStr$0yqu2i9, fromStr$08wf09w as num_fromStr$08wf09w, fromStr$1ypcnp8 as num_fromStr$1ypcnp8, fromStr$1hq0zfa as num_fromStr$1hq0zfa, fromStr$10ypyht as num_fromStr$10ypyht, fromStrRadix$0g0g31i as num_fromStrRadix$0g0g31i, fromStrRadix$1ku3myt as num_fromStrRadix$1ku3myt, fromStrRadix$05zvwcf as num_fromStrRadix$05zvwcf, fromStrRadix$1gp4jqq as num_fromStrRadix$1gp4jqq, fromStrRadix$0nj08um as num_fromStrRadix$0nj08um, fromStrRadix$0tjqkb6 as num_fromStrRadix$0tjqkb6 } from "./core/num.ts"; import { isSomeAnd$09tpccf, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, unwrapOr$11c0we2 as option_unwrapOr$11c0we2 } from "./core/option.ts"; import { eq$0pee78b as result_eq$0pee78b, eq$1mi4cle as result_eq$1mi4cle, eq$1ukayff as result_eq$1ukayff, eq$1hy1is1 as result_eq$1hy1is1, eq$1hd8lo9 as result_eq$1hd8lo9, eq$0w2dfat as result_eq$0w2dfat, eq$06vyx9e as result_eq$06vyx9e, eq$08241oi as result_eq$08241oi, eq$0nbftnc as result_eq$0nbftnc, eq$1gq81ib as result_eq$1gq81ib, eq$12e5exx as result_eq$12e5exx, eq$1xhgva4 as result_eq$1xhgva4, unwrapOr$01jdcm7 as result_unwrapOr$01jdcm7, unwrapOr$0nhd29g as result_unwrapOr$0nhd29g, unwrapOr$09i71ei as result_unwrapOr$09i71ei } from "./core/result.ts"; -import { parse$0zwe7sh, parse$1rrjn2d, parse$12n9p35, parse$1ilajpu, parse$1fq462u, parse$1g5tknx, parse$137ljop, parse$0mrlpzv, parse$1bassid, parse$1q1obm6, parse$0yt2578, parse$1m4h82x } from "./core/str.ts"; +import { parse$082ztwj, parse$0xnscjy, parse$12szghw, parse$11m1f1e, parse$1ci7nyc, parse$07xyv4i, parse$069o3rw, parse$0fi19ig, parse$1aq2uo0, parse$0o4ono0, parse$0at0fdl, parse$08wetap } from "./core/str.ts"; import { put as fmt_put } from "./fmt.ts"; import * as Scaled from "./ints.Scaled.ts"; @@ -2884,7 +2884,7 @@ export function edges(max: rt.u128, min: rt.u128, bits: rt.usize, radix: rt.u32) * into the alphabet of signs and digits, every edge of every radix, or a radix of any * value, which panics outside 2 to 36 as `from_str_radix` or `char::to_digit` does. */ -export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let kind2!: rt.i32; let over!: boolean; let max!: rt.u8; @@ -3044,9 +3044,9 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { b0: { const _4: rt.u8 = rt.u8Rem(kind, 12); if (_4 === 0) { - if (data.length !== 0) { - const first: rt.u8 = data.data[data.start]; - const rest: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + 1, data.length - 1); + if (dataLen !== 0) { + const first: rt.u8 = dataData[dataStart]; + const rest: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); const radix: rt.u32 = rt.u32Add(2, rt.u32Rem(first as rt.u32, 35)); const _15: rt.u8 = rt.u8Rem(rt.u8Div(kind, 12), 4); if (_15 === 0) { @@ -3061,7 +3061,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_25, radix), 99)))); } const radix2: rt.u32 = radix; - const _40: rt.Result = num_fromStrRadix$1ys3fwo(_19.value, radix2); + const _40: rt.Result = num_fromStrRadix$0nj08um(_19.value, radix2); if (_40.ok) { const arg48 = _40.value; const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg48, f)]; @@ -3090,8 +3090,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args4[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args4[0]), "|", args4[3], "|", args4[4]])); } if (radix2 === 10) { - const parsed: rt.Result = parse$0yt2578(_19.value); - const from: rt.Result = num_fromStr$0kn8g72(_19.value); + const parsed: rt.Result = parse$0at0fdl(_19.value); + const from: rt.Result = num_fromStr$1hq0zfa(_19.value); if (from.ok) { max = rt.u8Mul(from.value === 255 ? 1 : 0, 4); } else { @@ -3110,7 +3110,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const _128: string = s; const radix3: rt.u32 = radix; - const _131: rt.Result = num_fromStrRadix$1ys3fwo(_128, radix3); + const _131: rt.Result = num_fromStrRadix$0nj08um(_128, radix3); if (_131.ok) { const arg47 = _131.value; const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg47, f)]; @@ -3139,8 +3139,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args8[0], "|", args8[1], "|", args8[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args8[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args8[0]), "|", args8[3], "|", args8[4]])); } if (radix3 === 10) { - const parsed2: rt.Result = parse$0yt2578(_128); - const from2: rt.Result = num_fromStr$0kn8g72(_128); + const parsed2: rt.Result = parse$0at0fdl(_128); + const from2: rt.Result = num_fromStr$1hq0zfa(_128); if (from2.ok) { max2 = rt.u8Mul(from2.value === 255 ? 1 : 0, 4); } else { @@ -3159,7 +3159,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const radix4: rt.u32 = _199; for (const _207 of edges(255, 0, 8, radix4)) { const radix5: rt.u32 = radix4; - const _218: rt.Result = num_fromStrRadix$1ys3fwo(_207, radix5); + const _218: rt.Result = num_fromStrRadix$0nj08um(_207, radix5); if (_218.ok) { const arg46 = _218.value; const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg46, f)]; @@ -3188,8 +3188,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args12[0], "|", args12[1], "|", args12[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args12[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args12[0]), "|", args12[3], "|", args12[4]])); } if (radix5 === 10) { - const parsed3: rt.Result = parse$0yt2578(_207); - const from3: rt.Result = num_fromStr$0kn8g72(_207); + const parsed3: rt.Result = parse$0at0fdl(_207); + const from3: rt.Result = num_fromStr$1hq0zfa(_207); if (from3.ok) { max3 = rt.u8Mul(from3.value === 255 ? 1 : 0, 4); } else { @@ -3213,7 +3213,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const _310: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text), "1"); const radix7: rt.u32 = radix6; - const _315: rt.Result = num_fromStrRadix$1ys3fwo(_310, radix7); + const _315: rt.Result = num_fromStrRadix$0nj08um(_310, radix7); if (_315.ok) { const arg45 = _315.value; const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg45, f)]; @@ -3242,8 +3242,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args16[0], "|", args16[1], "|", args16[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args16[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args16[0]), "|", args16[3], "|", args16[4]])); } if (radix7 === 10) { - const parsed4: rt.Result = parse$0yt2578(_310); - const from4: rt.Result = num_fromStr$0kn8g72(_310); + const parsed4: rt.Result = parse$0at0fdl(_310); + const from4: rt.Result = num_fromStr$1hq0zfa(_310); if (from4.ok) { max4 = rt.u8Mul(from4.value === 255 ? 1 : 0, 4); } else { @@ -3254,9 +3254,9 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } } else if (_4 === 1) { - if (data.length !== 0) { - const first2: rt.u8 = data.data[data.start]; - const rest2: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + 1, data.length - 1); + if (dataLen !== 0) { + const first2: rt.u8 = dataData[dataStart]; + const rest2: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); const radix8: rt.u32 = rt.u32Add(2, rt.u32Rem(first2 as rt.u32, 35)); const _389: rt.u8 = rt.u8Rem(rt.u8Div(kind, 12), 4); if (_389 === 0) { @@ -3271,7 +3271,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_399, radix8), 99)))); } const radix9: rt.u32 = radix8; - const _414: rt.Result = num_fromStrRadix$1x7yq9g(_393.value, radix9); + const _414: rt.Result = num_fromStrRadix$1ku3myt(_393.value, radix9); if (_414.ok) { const arg44 = _414.value; const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(arg44, f)]; @@ -3300,8 +3300,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args20[0], "|", args20[1], "|", args20[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args20[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args20[0]), "|", args20[3], "|", args20[4]])); } if (radix9 === 10) { - const parsed5: rt.Result = parse$0mrlpzv(_393.value); - const from5: rt.Result = num_fromStr$1bigolo(_393.value); + const parsed5: rt.Result = parse$0fi19ig(_393.value); + const from5: rt.Result = num_fromStr$0yqu2i9(_393.value); if (from5.ok) { max5 = rt.u8Mul(from5.value === 65535 ? 1 : 0, 4); } else { @@ -3320,7 +3320,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const _502: string = s3; const radix10: rt.u32 = radix8; - const _505: rt.Result = num_fromStrRadix$1x7yq9g(_502, radix10); + const _505: rt.Result = num_fromStrRadix$1ku3myt(_502, radix10); if (_505.ok) { const arg43 = _505.value; const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(arg43, f)]; @@ -3349,8 +3349,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args24[0], "|", args24[1], "|", args24[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args24[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args24[0]), "|", args24[3], "|", args24[4]])); } if (radix10 === 10) { - const parsed6: rt.Result = parse$0mrlpzv(_502); - const from6: rt.Result = num_fromStr$1bigolo(_502); + const parsed6: rt.Result = parse$0fi19ig(_502); + const from6: rt.Result = num_fromStr$0yqu2i9(_502); if (from6.ok) { max6 = rt.u8Mul(from6.value === 65535 ? 1 : 0, 4); } else { @@ -3369,7 +3369,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const radix11: rt.u32 = _573; for (const _581 of edges(65535, 0, 16, radix11)) { const radix12: rt.u32 = radix11; - const _592: rt.Result = num_fromStrRadix$1x7yq9g(_581, radix12); + const _592: rt.Result = num_fromStrRadix$1ku3myt(_581, radix12); if (_592.ok) { const arg42 = _592.value; const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(arg42, f)]; @@ -3398,8 +3398,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args28[0], "|", args28[1], "|", args28[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args28[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args28[0]), "|", args28[3], "|", args28[4]])); } if (radix12 === 10) { - const parsed7: rt.Result = parse$0mrlpzv(_581); - const from7: rt.Result = num_fromStr$1bigolo(_581); + const parsed7: rt.Result = parse$0fi19ig(_581); + const from7: rt.Result = num_fromStr$0yqu2i9(_581); if (from7.ok) { max7 = rt.u8Mul(from7.value === 65535 ? 1 : 0, 4); } else { @@ -3423,7 +3423,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const _684: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text2), "1"); const radix14: rt.u32 = radix13; - const _689: rt.Result = num_fromStrRadix$1x7yq9g(_684, radix14); + const _689: rt.Result = num_fromStrRadix$1ku3myt(_684, radix14); if (_689.ok) { const arg41 = _689.value; const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(arg41, f)]; @@ -3452,8 +3452,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args32[0], "|", args32[1], "|", args32[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args32[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args32[0]), "|", args32[3], "|", args32[4]])); } if (radix14 === 10) { - const parsed8: rt.Result = parse$0mrlpzv(_684); - const from8: rt.Result = num_fromStr$1bigolo(_684); + const parsed8: rt.Result = parse$0fi19ig(_684); + const from8: rt.Result = num_fromStr$0yqu2i9(_684); if (from8.ok) { max8 = rt.u8Mul(from8.value === 65535 ? 1 : 0, 4); } else { @@ -3464,9 +3464,9 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } } else if (_4 === 2) { - if (data.length !== 0) { - const first3: rt.u8 = data.data[data.start]; - const rest3: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + 1, data.length - 1); + if (dataLen !== 0) { + const first3: rt.u8 = dataData[dataStart]; + const rest3: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); const radix15: rt.u32 = rt.u32Add(2, rt.u32Rem(first3 as rt.u32, 35)); const _763: rt.u8 = rt.u8Rem(rt.u8Div(kind, 12), 4); if (_763 === 0) { @@ -3481,7 +3481,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_773, radix15), 99)))); } const radix16: rt.u32 = radix15; - const _788: rt.Result = num_fromStrRadix$1gamglm(_767.value, radix16); + const _788: rt.Result = num_fromStrRadix$05zvwcf(_767.value, radix16); if (_788.ok) { const arg40 = _788.value; const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg40, f)]; @@ -3510,8 +3510,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args36[0], "|", args36[1], "|", args36[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args36[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args36[0]), "|", args36[3], "|", args36[4]])); } if (radix16 === 10) { - const parsed9: rt.Result = parse$1bassid(_767.value); - const from9: rt.Result = num_fromStr$1uzmhcw(_767.value); + const parsed9: rt.Result = parse$1aq2uo0(_767.value); + const from9: rt.Result = num_fromStr$08wf09w(_767.value); if (from9.ok) { max9 = rt.u8Mul(from9.value === 4294967295 ? 1 : 0, 4); } else { @@ -3530,7 +3530,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const _876: string = s5; const radix17: rt.u32 = radix15; - const _879: rt.Result = num_fromStrRadix$1gamglm(_876, radix17); + const _879: rt.Result = num_fromStrRadix$05zvwcf(_876, radix17); if (_879.ok) { const arg39 = _879.value; const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg39, f)]; @@ -3559,8 +3559,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args40[0], "|", args40[1], "|", args40[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args40[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args40[0]), "|", args40[3], "|", args40[4]])); } if (radix17 === 10) { - const parsed10: rt.Result = parse$1bassid(_876); - const from10: rt.Result = num_fromStr$1uzmhcw(_876); + const parsed10: rt.Result = parse$1aq2uo0(_876); + const from10: rt.Result = num_fromStr$08wf09w(_876); if (from10.ok) { max10 = rt.u8Mul(from10.value === 4294967295 ? 1 : 0, 4); } else { @@ -3579,7 +3579,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const radix18: rt.u32 = _947; for (const _955 of edges(4294967295, 0, 32, radix18)) { const radix19: rt.u32 = radix18; - const _966: rt.Result = num_fromStrRadix$1gamglm(_955, radix19); + const _966: rt.Result = num_fromStrRadix$05zvwcf(_955, radix19); if (_966.ok) { const arg38 = _966.value; const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg38, f)]; @@ -3608,8 +3608,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args44[0], "|", args44[1], "|", args44[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args44[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args44[0]), "|", args44[3], "|", args44[4]])); } if (radix19 === 10) { - const parsed11: rt.Result = parse$1bassid(_955); - const from11: rt.Result = num_fromStr$1uzmhcw(_955); + const parsed11: rt.Result = parse$1aq2uo0(_955); + const from11: rt.Result = num_fromStr$08wf09w(_955); if (from11.ok) { max11 = rt.u8Mul(from11.value === 4294967295 ? 1 : 0, 4); } else { @@ -3633,7 +3633,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const _1058: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text3), "1"); const radix21: rt.u32 = radix20; - const _1063: rt.Result = num_fromStrRadix$1gamglm(_1058, radix21); + const _1063: rt.Result = num_fromStrRadix$05zvwcf(_1058, radix21); if (_1063.ok) { const arg37 = _1063.value; const args46: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg37, f)]; @@ -3662,8 +3662,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args48[0], "|", args48[1], "|", args48[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args48[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args48[0]), "|", args48[3], "|", args48[4]])); } if (radix21 === 10) { - const parsed12: rt.Result = parse$1bassid(_1058); - const from12: rt.Result = num_fromStr$1uzmhcw(_1058); + const parsed12: rt.Result = parse$1aq2uo0(_1058); + const from12: rt.Result = num_fromStr$08wf09w(_1058); if (from12.ok) { max12 = rt.u8Mul(from12.value === 4294967295 ? 1 : 0, 4); } else { @@ -3674,9 +3674,9 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } } else if (_4 === 3) { - if (data.length !== 0) { - const first4: rt.u8 = data.data[data.start]; - const rest4: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + 1, data.length - 1); + if (dataLen !== 0) { + const first4: rt.u8 = dataData[dataStart]; + const rest4: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); const radix22: rt.u32 = rt.u32Add(2, rt.u32Rem(first4 as rt.u32, 35)); const _1137: rt.u8 = rt.u8Rem(rt.u8Div(kind, 12), 4); if (_1137 === 0) { @@ -3691,7 +3691,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_1147, radix22), 99)))); } const radix23: rt.u32 = radix22; - const _1162: rt.Result = num_fromStrRadix$0bx9j5d(_1141.value, radix23); + const _1162: rt.Result = num_fromStrRadix$1gp4jqq(_1141.value, radix23); if (_1162.ok) { const arg36 = _1162.value; const args50: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(arg36, f)]; @@ -3720,8 +3720,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args52[0], "|", args52[1], "|", args52[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args52[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args52[0]), "|", args52[3], "|", args52[4]])); } if (radix23 === 10) { - const parsed13: rt.Result = parse$1q1obm6(_1141.value); - const from13: rt.Result = num_fromStr$05sn9io(_1141.value); + const parsed13: rt.Result = parse$0o4ono0(_1141.value); + const from13: rt.Result = num_fromStr$1ypcnp8(_1141.value); if (from13.ok) { max13 = rt.u8Mul(rt.u64Eq(from13.value, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64) ? 1 : 0, 4); } else { @@ -3740,7 +3740,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const _1250: string = s7; const radix24: rt.u32 = radix22; - const _1253: rt.Result = num_fromStrRadix$0bx9j5d(_1250, radix24); + const _1253: rt.Result = num_fromStrRadix$1gp4jqq(_1250, radix24); if (_1253.ok) { const arg35 = _1253.value; const args54: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(arg35, f)]; @@ -3769,8 +3769,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args56[0], "|", args56[1], "|", args56[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args56[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args56[0]), "|", args56[3], "|", args56[4]])); } if (radix24 === 10) { - const parsed14: rt.Result = parse$1q1obm6(_1250); - const from14: rt.Result = num_fromStr$05sn9io(_1250); + const parsed14: rt.Result = parse$0o4ono0(_1250); + const from14: rt.Result = num_fromStr$1ypcnp8(_1250); if (from14.ok) { max14 = rt.u8Mul(rt.u64Eq(from14.value, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64) ? 1 : 0, 4); } else { @@ -3789,7 +3789,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const radix25: rt.u32 = _1321; for (const _1329 of edges({ hi: 0, w2: 0, w1: 0xffffffff, lo: 0xffffffff } as rt.u128, 0, 64, radix25)) { const radix26: rt.u32 = radix25; - const _1340: rt.Result = num_fromStrRadix$0bx9j5d(_1329, radix26); + const _1340: rt.Result = num_fromStrRadix$1gp4jqq(_1329, radix26); if (_1340.ok) { const arg34 = _1340.value; const args58: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(arg34, f)]; @@ -3818,8 +3818,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args60[0], "|", args60[1], "|", args60[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args60[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args60[0]), "|", args60[3], "|", args60[4]])); } if (radix26 === 10) { - const parsed15: rt.Result = parse$1q1obm6(_1329); - const from15: rt.Result = num_fromStr$05sn9io(_1329); + const parsed15: rt.Result = parse$0o4ono0(_1329); + const from15: rt.Result = num_fromStr$1ypcnp8(_1329); if (from15.ok) { max15 = rt.u8Mul(rt.u64Eq(from15.value, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64) ? 1 : 0, 4); } else { @@ -3843,7 +3843,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const _1432: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text4), "1"); const radix28: rt.u32 = radix27; - const _1437: rt.Result = num_fromStrRadix$0bx9j5d(_1432, radix28); + const _1437: rt.Result = num_fromStrRadix$1gp4jqq(_1432, radix28); if (_1437.ok) { const arg33 = _1437.value; const args62: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(arg33, f)]; @@ -3872,8 +3872,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args64[0], "|", args64[1], "|", args64[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args64[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args64[0]), "|", args64[3], "|", args64[4]])); } if (radix28 === 10) { - const parsed16: rt.Result = parse$1q1obm6(_1432); - const from16: rt.Result = num_fromStr$05sn9io(_1432); + const parsed16: rt.Result = parse$0o4ono0(_1432); + const from16: rt.Result = num_fromStr$1ypcnp8(_1432); if (from16.ok) { max16 = rt.u8Mul(rt.u64Eq(from16.value, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64) ? 1 : 0, 4); } else { @@ -3884,9 +3884,9 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } } else if (_4 === 4) { - if (data.length !== 0) { - const first5: rt.u8 = data.data[data.start]; - const rest5: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + 1, data.length - 1); + if (dataLen !== 0) { + const first5: rt.u8 = dataData[dataStart]; + const rest5: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); const radix29: rt.u32 = rt.u32Add(2, rt.u32Rem(first5 as rt.u32, 35)); const _1511: rt.u8 = rt.u8Rem(rt.u8Div(kind, 12), 4); if (_1511 === 0) { @@ -3901,7 +3901,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_1521, radix29), 99)))); } const radix30: rt.u32 = radix29; - const _1536: rt.Result = num_fromStrRadix$1549erz(_1515.value, radix30); + const _1536: rt.Result = num_fromStrRadix$0g0g31i(_1515.value, radix30); if (_1536.ok) { const arg32 = _1536.value; const args66: rt.Fmt[] = [(f: rt.Formatter) => rt.u128Display(arg32, f)]; @@ -3930,8 +3930,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args68[0], "|", args68[1], "|", args68[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args68[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args68[0]), "|", args68[3], "|", args68[4]])); } if (radix30 === 10) { - const parsed17: rt.Result = parse$137ljop(_1515.value); - const from17: rt.Result = num_fromStr$0pnvd2c(_1515.value); + const parsed17: rt.Result = parse$069o3rw(_1515.value); + const from17: rt.Result = num_fromStr$0qvzsmz(_1515.value); if (from17.ok) { max17 = rt.u8Mul(rt.u128Eq(from17.value, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128) ? 1 : 0, 4); } else { @@ -3950,7 +3950,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const _1624: string = s9; const radix31: rt.u32 = radix29; - const _1627: rt.Result = num_fromStrRadix$1549erz(_1624, radix31); + const _1627: rt.Result = num_fromStrRadix$0g0g31i(_1624, radix31); if (_1627.ok) { const arg31 = _1627.value; const args70: rt.Fmt[] = [(f: rt.Formatter) => rt.u128Display(arg31, f)]; @@ -3979,8 +3979,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args72[0], "|", args72[1], "|", args72[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args72[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args72[0]), "|", args72[3], "|", args72[4]])); } if (radix31 === 10) { - const parsed18: rt.Result = parse$137ljop(_1624); - const from18: rt.Result = num_fromStr$0pnvd2c(_1624); + const parsed18: rt.Result = parse$069o3rw(_1624); + const from18: rt.Result = num_fromStr$0qvzsmz(_1624); if (from18.ok) { max18 = rt.u8Mul(rt.u128Eq(from18.value, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128) ? 1 : 0, 4); } else { @@ -3999,7 +3999,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const radix32: rt.u32 = _1695; for (const _1702 of edges({ hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128, 0, 128, radix32)) { const radix33: rt.u32 = radix32; - const _1713: rt.Result = num_fromStrRadix$1549erz(_1702, radix33); + const _1713: rt.Result = num_fromStrRadix$0g0g31i(_1702, radix33); if (_1713.ok) { const arg30 = _1713.value; const args74: rt.Fmt[] = [(f: rt.Formatter) => rt.u128Display(arg30, f)]; @@ -4028,8 +4028,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args76[0], "|", args76[1], "|", args76[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args76[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args76[0]), "|", args76[3], "|", args76[4]])); } if (radix33 === 10) { - const parsed19: rt.Result = parse$137ljop(_1702); - const from19: rt.Result = num_fromStr$0pnvd2c(_1702); + const parsed19: rt.Result = parse$069o3rw(_1702); + const from19: rt.Result = num_fromStr$0qvzsmz(_1702); if (from19.ok) { max19 = rt.u8Mul(rt.u128Eq(from19.value, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128) ? 1 : 0, 4); } else { @@ -4053,7 +4053,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const _1805: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text5), "1"); const radix35: rt.u32 = radix34; - const _1810: rt.Result = num_fromStrRadix$1549erz(_1805, radix35); + const _1810: rt.Result = num_fromStrRadix$0g0g31i(_1805, radix35); if (_1810.ok) { const arg29 = _1810.value; const args78: rt.Fmt[] = [(f: rt.Formatter) => rt.u128Display(arg29, f)]; @@ -4082,8 +4082,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args80[0], "|", args80[1], "|", args80[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args80[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args80[0]), "|", args80[3], "|", args80[4]])); } if (radix35 === 10) { - const parsed20: rt.Result = parse$137ljop(_1805); - const from20: rt.Result = num_fromStr$0pnvd2c(_1805); + const parsed20: rt.Result = parse$069o3rw(_1805); + const from20: rt.Result = num_fromStr$0qvzsmz(_1805); if (from20.ok) { max20 = rt.u8Mul(rt.u128Eq(from20.value, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128) ? 1 : 0, 4); } else { @@ -4094,9 +4094,9 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } } else if (_4 === 5) { - if (data.length !== 0) { - const first6: rt.u8 = data.data[data.start]; - const rest6: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + 1, data.length - 1); + if (dataLen !== 0) { + const first6: rt.u8 = dataData[dataStart]; + const rest6: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); const radix36: rt.u32 = rt.u32Add(2, rt.u32Rem(first6 as rt.u32, 35)); const _1884: rt.u8 = rt.u8Rem(rt.u8Div(kind, 12), 4); if (_1884 === 0) { @@ -4111,7 +4111,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_1894, radix36), 99)))); } const radix37: rt.u32 = radix36; - const _1909: rt.Result = num_fromStrRadix$09ykvvv(_1888.value, radix37); + const _1909: rt.Result = num_fromStrRadix$0tjqkb6(_1888.value, radix37); if (_1909.ok) { const arg28 = _1909.value; const args82: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg28, f)]; @@ -4140,8 +4140,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args84[0], "|", args84[1], "|", args84[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args84[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args84[0]), "|", args84[3], "|", args84[4]])); } if (radix37 === 10) { - const parsed21: rt.Result = parse$1m4h82x(_1888.value); - const from21: rt.Result = num_fromStr$0qgw0pl(_1888.value); + const parsed21: rt.Result = parse$08wetap(_1888.value); + const from21: rt.Result = num_fromStr$10ypyht(_1888.value); if (from21.ok) { max21 = rt.u8Mul(from21.value === 4294967295 ? 1 : 0, 4); } else { @@ -4160,7 +4160,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const _1997: string = s11; const radix38: rt.u32 = radix36; - const _2000: rt.Result = num_fromStrRadix$09ykvvv(_1997, radix38); + const _2000: rt.Result = num_fromStrRadix$0tjqkb6(_1997, radix38); if (_2000.ok) { const arg27 = _2000.value; const args86: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg27, f)]; @@ -4189,8 +4189,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args88[0], "|", args88[1], "|", args88[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args88[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args88[0]), "|", args88[3], "|", args88[4]])); } if (radix38 === 10) { - const parsed22: rt.Result = parse$1m4h82x(_1997); - const from22: rt.Result = num_fromStr$0qgw0pl(_1997); + const parsed22: rt.Result = parse$08wetap(_1997); + const from22: rt.Result = num_fromStr$10ypyht(_1997); if (from22.ok) { max22 = rt.u8Mul(from22.value === 4294967295 ? 1 : 0, 4); } else { @@ -4209,7 +4209,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const radix39: rt.u32 = _2068; for (const _2076 of edges(4294967295, 0, 32, radix39)) { const radix40: rt.u32 = radix39; - const _2087: rt.Result = num_fromStrRadix$09ykvvv(_2076, radix40); + const _2087: rt.Result = num_fromStrRadix$0tjqkb6(_2076, radix40); if (_2087.ok) { const arg26 = _2087.value; const args90: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg26, f)]; @@ -4238,8 +4238,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args92[0], "|", args92[1], "|", args92[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args92[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args92[0]), "|", args92[3], "|", args92[4]])); } if (radix40 === 10) { - const parsed23: rt.Result = parse$1m4h82x(_2076); - const from23: rt.Result = num_fromStr$0qgw0pl(_2076); + const parsed23: rt.Result = parse$08wetap(_2076); + const from23: rt.Result = num_fromStr$10ypyht(_2076); if (from23.ok) { max23 = rt.u8Mul(from23.value === 4294967295 ? 1 : 0, 4); } else { @@ -4263,7 +4263,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const _2179: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text6), "1"); const radix42: rt.u32 = radix41; - const _2184: rt.Result = num_fromStrRadix$09ykvvv(_2179, radix42); + const _2184: rt.Result = num_fromStrRadix$0tjqkb6(_2179, radix42); if (_2184.ok) { const arg25 = _2184.value; const args94: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg25, f)]; @@ -4292,8 +4292,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args96[0], "|", args96[1], "|", args96[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args96[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args96[0]), "|", args96[3], "|", args96[4]])); } if (radix42 === 10) { - const parsed24: rt.Result = parse$1m4h82x(_2179); - const from24: rt.Result = num_fromStr$0qgw0pl(_2179); + const parsed24: rt.Result = parse$08wetap(_2179); + const from24: rt.Result = num_fromStr$10ypyht(_2179); if (from24.ok) { max24 = rt.u8Mul(from24.value === 4294967295 ? 1 : 0, 4); } else { @@ -4304,9 +4304,9 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } } else if (_4 === 6) { - if (data.length !== 0) { - const first7: rt.u8 = data.data[data.start]; - const rest7: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + 1, data.length - 1); + if (dataLen !== 0) { + const first7: rt.u8 = dataData[dataStart]; + const rest7: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); const radix43: rt.u32 = rt.u32Add(2, rt.u32Rem(first7 as rt.u32, 35)); const _2258: rt.u8 = rt.u8Rem(rt.u8Div(kind, 12), 4); if (_2258 === 0) { @@ -4321,7 +4321,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_2268, radix43), 99)))); } const radix44: rt.u32 = radix43; - const _2283: rt.Result = num_fromStrRadix$0snhnv5(_2262.value, radix44); + const _2283: rt.Result = num_fromStrRadix$0s9rspw(_2262.value, radix44); if (_2283.ok) { const arg24 = _2283.value; const args98: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(arg24, f)]; @@ -4350,8 +4350,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args100[0], "|", args100[1], "|", args100[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args100[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args100[0]), "|", args100[3], "|", args100[4]])); } if (radix44 === 10) { - const parsed25: rt.Result = parse$1fq462u(_2262.value); - const from25: rt.Result = num_fromStr$1m3wp28(_2262.value); + const parsed25: rt.Result = parse$1ci7nyc(_2262.value); + const from25: rt.Result = num_fromStr$0ovlgjd(_2262.value); if (from25.ok) { max25 = rt.u8Mul(from25.value === 127 ? 1 : 0, 4); } else { @@ -4370,7 +4370,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const _2371: string = s13; const radix45: rt.u32 = radix43; - const _2374: rt.Result = num_fromStrRadix$0snhnv5(_2371, radix45); + const _2374: rt.Result = num_fromStrRadix$0s9rspw(_2371, radix45); if (_2374.ok) { const arg23 = _2374.value; const args102: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(arg23, f)]; @@ -4399,8 +4399,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args104[0], "|", args104[1], "|", args104[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args104[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args104[0]), "|", args104[3], "|", args104[4]])); } if (radix45 === 10) { - const parsed26: rt.Result = parse$1fq462u(_2371); - const from26: rt.Result = num_fromStr$1m3wp28(_2371); + const parsed26: rt.Result = parse$1ci7nyc(_2371); + const from26: rt.Result = num_fromStr$0ovlgjd(_2371); if (from26.ok) { max26 = rt.u8Mul(from26.value === 127 ? 1 : 0, 4); } else { @@ -4419,7 +4419,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const radix46: rt.u32 = _2442; for (const _2453 of edges(127, rt.u128Add(127, 1), 8, radix46)) { const radix47: rt.u32 = radix46; - const _2464: rt.Result = num_fromStrRadix$0snhnv5(_2453, radix47); + const _2464: rt.Result = num_fromStrRadix$0s9rspw(_2453, radix47); if (_2464.ok) { const arg22 = _2464.value; const args106: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(arg22, f)]; @@ -4448,8 +4448,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args108[0], "|", args108[1], "|", args108[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args108[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args108[0]), "|", args108[3], "|", args108[4]])); } if (radix47 === 10) { - const parsed27: rt.Result = parse$1fq462u(_2453); - const from27: rt.Result = num_fromStr$1m3wp28(_2453); + const parsed27: rt.Result = parse$1ci7nyc(_2453); + const from27: rt.Result = num_fromStr$0ovlgjd(_2453); if (from27.ok) { max27 = rt.u8Mul(from27.value === 127 ? 1 : 0, 4); } else { @@ -4473,7 +4473,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const _2556: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text7), "1"); const radix49: rt.u32 = radix48; - const _2561: rt.Result = num_fromStrRadix$0snhnv5(_2556, radix49); + const _2561: rt.Result = num_fromStrRadix$0s9rspw(_2556, radix49); if (_2561.ok) { const arg21 = _2561.value; const args110: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(arg21, f)]; @@ -4502,8 +4502,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args112[0], "|", args112[1], "|", args112[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args112[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args112[0]), "|", args112[3], "|", args112[4]])); } if (radix49 === 10) { - const parsed28: rt.Result = parse$1fq462u(_2556); - const from28: rt.Result = num_fromStr$1m3wp28(_2556); + const parsed28: rt.Result = parse$1ci7nyc(_2556); + const from28: rt.Result = num_fromStr$0ovlgjd(_2556); if (from28.ok) { max28 = rt.u8Mul(from28.value === 127 ? 1 : 0, 4); } else { @@ -4514,9 +4514,9 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } } else if (_4 === 7) { - if (data.length !== 0) { - const first8: rt.u8 = data.data[data.start]; - const rest8: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + 1, data.length - 1); + if (dataLen !== 0) { + const first8: rt.u8 = dataData[dataStart]; + const rest8: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); const radix50: rt.u32 = rt.u32Add(2, rt.u32Rem(first8 as rt.u32, 35)); const _2635: rt.u8 = rt.u8Rem(rt.u8Div(kind, 12), 4); if (_2635 === 0) { @@ -4531,7 +4531,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_2645, radix50), 99)))); } const radix51: rt.u32 = radix50; - const _2660: rt.Result = num_fromStrRadix$0w5k2s7(_2639.value, radix51); + const _2660: rt.Result = num_fromStrRadix$02mhuxs(_2639.value, radix51); if (_2660.ok) { const arg20 = _2660.value; const args114: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Display(arg20, f)]; @@ -4560,8 +4560,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args116[0], "|", args116[1], "|", args116[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args116[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args116[0]), "|", args116[3], "|", args116[4]])); } if (radix51 === 10) { - const parsed29: rt.Result = parse$1rrjn2d(_2639.value); - const from29: rt.Result = num_fromStr$076yg1t(_2639.value); + const parsed29: rt.Result = parse$0xnscjy(_2639.value); + const from29: rt.Result = num_fromStr$17ewwma(_2639.value); if (from29.ok) { max29 = rt.u8Mul(from29.value === 32767 ? 1 : 0, 4); } else { @@ -4580,7 +4580,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const _2748: string = s15; const radix52: rt.u32 = radix50; - const _2751: rt.Result = num_fromStrRadix$0w5k2s7(_2748, radix52); + const _2751: rt.Result = num_fromStrRadix$02mhuxs(_2748, radix52); if (_2751.ok) { const arg19 = _2751.value; const args118: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Display(arg19, f)]; @@ -4609,8 +4609,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args120[0], "|", args120[1], "|", args120[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args120[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args120[0]), "|", args120[3], "|", args120[4]])); } if (radix52 === 10) { - const parsed30: rt.Result = parse$1rrjn2d(_2748); - const from30: rt.Result = num_fromStr$076yg1t(_2748); + const parsed30: rt.Result = parse$0xnscjy(_2748); + const from30: rt.Result = num_fromStr$17ewwma(_2748); if (from30.ok) { max30 = rt.u8Mul(from30.value === 32767 ? 1 : 0, 4); } else { @@ -4629,7 +4629,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const radix53: rt.u32 = _2819; for (const _2830 of edges(32767, rt.u128Add(32767, 1), 16, radix53)) { const radix54: rt.u32 = radix53; - const _2841: rt.Result = num_fromStrRadix$0w5k2s7(_2830, radix54); + const _2841: rt.Result = num_fromStrRadix$02mhuxs(_2830, radix54); if (_2841.ok) { const arg18 = _2841.value; const args122: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Display(arg18, f)]; @@ -4658,8 +4658,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args124[0], "|", args124[1], "|", args124[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args124[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args124[0]), "|", args124[3], "|", args124[4]])); } if (radix54 === 10) { - const parsed31: rt.Result = parse$1rrjn2d(_2830); - const from31: rt.Result = num_fromStr$076yg1t(_2830); + const parsed31: rt.Result = parse$0xnscjy(_2830); + const from31: rt.Result = num_fromStr$17ewwma(_2830); if (from31.ok) { max31 = rt.u8Mul(from31.value === 32767 ? 1 : 0, 4); } else { @@ -4683,7 +4683,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const _2933: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text8), "1"); const radix56: rt.u32 = radix55; - const _2938: rt.Result = num_fromStrRadix$0w5k2s7(_2933, radix56); + const _2938: rt.Result = num_fromStrRadix$02mhuxs(_2933, radix56); if (_2938.ok) { const arg17 = _2938.value; const args126: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Display(arg17, f)]; @@ -4712,8 +4712,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args128[0], "|", args128[1], "|", args128[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args128[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args128[0]), "|", args128[3], "|", args128[4]])); } if (radix56 === 10) { - const parsed32: rt.Result = parse$1rrjn2d(_2933); - const from32: rt.Result = num_fromStr$076yg1t(_2933); + const parsed32: rt.Result = parse$0xnscjy(_2933); + const from32: rt.Result = num_fromStr$17ewwma(_2933); if (from32.ok) { max32 = rt.u8Mul(from32.value === 32767 ? 1 : 0, 4); } else { @@ -4724,9 +4724,9 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } } else if (_4 === 8) { - if (data.length !== 0) { - const first9: rt.u8 = data.data[data.start]; - const rest9: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + 1, data.length - 1); + if (dataLen !== 0) { + const first9: rt.u8 = dataData[dataStart]; + const rest9: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); const radix57: rt.u32 = rt.u32Add(2, rt.u32Rem(first9 as rt.u32, 35)); const _3012: rt.u8 = rt.u8Rem(rt.u8Div(kind, 12), 4); if (_3012 === 0) { @@ -4741,7 +4741,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_3022, radix57), 99)))); } const radix58: rt.u32 = radix57; - const _3037: rt.Result = num_fromStrRadix$1a42la1(_3016.value, radix58); + const _3037: rt.Result = num_fromStrRadix$1bgm1z0(_3016.value, radix58); if (_3037.ok) { const arg16 = _3037.value; const args130: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(arg16, f)]; @@ -4770,8 +4770,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args132[0], "|", args132[1], "|", args132[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args132[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args132[0]), "|", args132[3], "|", args132[4]])); } if (radix58 === 10) { - const parsed33: rt.Result = parse$12n9p35(_3016.value); - const from33: rt.Result = num_fromStr$1dxzqb4(_3016.value); + const parsed33: rt.Result = parse$12szghw(_3016.value); + const from33: rt.Result = num_fromStr$0zhqfgx(_3016.value); if (from33.ok) { max33 = rt.u8Mul(from33.value === 2147483647 ? 1 : 0, 4); } else { @@ -4790,7 +4790,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const _3125: string = s17; const radix59: rt.u32 = radix57; - const _3128: rt.Result = num_fromStrRadix$1a42la1(_3125, radix59); + const _3128: rt.Result = num_fromStrRadix$1bgm1z0(_3125, radix59); if (_3128.ok) { const arg15 = _3128.value; const args134: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(arg15, f)]; @@ -4819,8 +4819,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args136[0], "|", args136[1], "|", args136[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args136[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args136[0]), "|", args136[3], "|", args136[4]])); } if (radix59 === 10) { - const parsed34: rt.Result = parse$12n9p35(_3125); - const from34: rt.Result = num_fromStr$1dxzqb4(_3125); + const parsed34: rt.Result = parse$12szghw(_3125); + const from34: rt.Result = num_fromStr$0zhqfgx(_3125); if (from34.ok) { max34 = rt.u8Mul(from34.value === 2147483647 ? 1 : 0, 4); } else { @@ -4839,7 +4839,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const radix60: rt.u32 = _3196; for (const _3207 of edges(2147483647, rt.u128Add(2147483647, 1), 32, radix60)) { const radix61: rt.u32 = radix60; - const _3218: rt.Result = num_fromStrRadix$1a42la1(_3207, radix61); + const _3218: rt.Result = num_fromStrRadix$1bgm1z0(_3207, radix61); if (_3218.ok) { const arg14 = _3218.value; const args138: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(arg14, f)]; @@ -4868,8 +4868,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args140[0], "|", args140[1], "|", args140[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args140[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args140[0]), "|", args140[3], "|", args140[4]])); } if (radix61 === 10) { - const parsed35: rt.Result = parse$12n9p35(_3207); - const from35: rt.Result = num_fromStr$1dxzqb4(_3207); + const parsed35: rt.Result = parse$12szghw(_3207); + const from35: rt.Result = num_fromStr$0zhqfgx(_3207); if (from35.ok) { max35 = rt.u8Mul(from35.value === 2147483647 ? 1 : 0, 4); } else { @@ -4893,7 +4893,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const _3310: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text9), "1"); const radix63: rt.u32 = radix62; - const _3315: rt.Result = num_fromStrRadix$1a42la1(_3310, radix63); + const _3315: rt.Result = num_fromStrRadix$1bgm1z0(_3310, radix63); if (_3315.ok) { const arg13 = _3315.value; const args142: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(arg13, f)]; @@ -4922,8 +4922,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args144[0], "|", args144[1], "|", args144[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args144[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args144[0]), "|", args144[3], "|", args144[4]])); } if (radix63 === 10) { - const parsed36: rt.Result = parse$12n9p35(_3310); - const from36: rt.Result = num_fromStr$1dxzqb4(_3310); + const parsed36: rt.Result = parse$12szghw(_3310); + const from36: rt.Result = num_fromStr$0zhqfgx(_3310); if (from36.ok) { max36 = rt.u8Mul(from36.value === 2147483647 ? 1 : 0, 4); } else { @@ -4934,9 +4934,9 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } } else if (_4 === 9) { - if (data.length !== 0) { - const first10: rt.u8 = data.data[data.start]; - const rest10: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + 1, data.length - 1); + if (dataLen !== 0) { + const first10: rt.u8 = dataData[dataStart]; + const rest10: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); const radix64: rt.u32 = rt.u32Add(2, rt.u32Rem(first10 as rt.u32, 35)); const _3389: rt.u8 = rt.u8Rem(rt.u8Div(kind, 12), 4); if (_3389 === 0) { @@ -4951,7 +4951,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_3399, radix64), 99)))); } const radix65: rt.u32 = radix64; - const _3414: rt.Result = num_fromStrRadix$0olne29(_3393.value, radix65); + const _3414: rt.Result = num_fromStrRadix$11y6fsf(_3393.value, radix65); if (_3414.ok) { const arg12 = _3414.value; const args146: rt.Fmt[] = [(f: rt.Formatter) => rt.i64Display(arg12, f)]; @@ -4980,8 +4980,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args148[0], "|", args148[1], "|", args148[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args148[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args148[0]), "|", args148[3], "|", args148[4]])); } if (radix65 === 10) { - const parsed37: rt.Result = parse$1ilajpu(_3393.value); - const from37: rt.Result = num_fromStr$09oey6q(_3393.value); + const parsed37: rt.Result = parse$11m1f1e(_3393.value); + const from37: rt.Result = num_fromStr$116mp4t(_3393.value); if (from37.ok) { max37 = rt.u8Mul(rt.i64Eq(from37.value, { hi: 0x7fffffff, lo: 0xffffffff } as rt.i64) ? 1 : 0, 4); } else { @@ -5000,7 +5000,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const _3502: string = s19; const radix66: rt.u32 = radix64; - const _3505: rt.Result = num_fromStrRadix$0olne29(_3502, radix66); + const _3505: rt.Result = num_fromStrRadix$11y6fsf(_3502, radix66); if (_3505.ok) { const arg11 = _3505.value; const args150: rt.Fmt[] = [(f: rt.Formatter) => rt.i64Display(arg11, f)]; @@ -5029,8 +5029,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args152[0], "|", args152[1], "|", args152[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args152[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args152[0]), "|", args152[3], "|", args152[4]])); } if (radix66 === 10) { - const parsed38: rt.Result = parse$1ilajpu(_3502); - const from38: rt.Result = num_fromStr$09oey6q(_3502); + const parsed38: rt.Result = parse$11m1f1e(_3502); + const from38: rt.Result = num_fromStr$116mp4t(_3502); if (from38.ok) { max38 = rt.u8Mul(rt.i64Eq(from38.value, { hi: 0x7fffffff, lo: 0xffffffff } as rt.i64) ? 1 : 0, 4); } else { @@ -5049,7 +5049,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const radix67: rt.u32 = _3573; for (const _3584 of edges({ hi: 0, w2: 0, w1: 0x7fffffff, lo: 0xffffffff } as rt.u128, rt.u128Add({ hi: 0, w2: 0, w1: 0x7fffffff, lo: 0xffffffff } as rt.u128, 1), 64, radix67)) { const radix68: rt.u32 = radix67; - const _3595: rt.Result = num_fromStrRadix$0olne29(_3584, radix68); + const _3595: rt.Result = num_fromStrRadix$11y6fsf(_3584, radix68); if (_3595.ok) { const arg10 = _3595.value; const args154: rt.Fmt[] = [(f: rt.Formatter) => rt.i64Display(arg10, f)]; @@ -5078,8 +5078,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args156[0], "|", args156[1], "|", args156[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args156[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args156[0]), "|", args156[3], "|", args156[4]])); } if (radix68 === 10) { - const parsed39: rt.Result = parse$1ilajpu(_3584); - const from39: rt.Result = num_fromStr$09oey6q(_3584); + const parsed39: rt.Result = parse$11m1f1e(_3584); + const from39: rt.Result = num_fromStr$116mp4t(_3584); if (from39.ok) { max39 = rt.u8Mul(rt.i64Eq(from39.value, { hi: 0x7fffffff, lo: 0xffffffff } as rt.i64) ? 1 : 0, 4); } else { @@ -5103,7 +5103,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const _3687: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text10), "1"); const radix70: rt.u32 = radix69; - const _3692: rt.Result = num_fromStrRadix$0olne29(_3687, radix70); + const _3692: rt.Result = num_fromStrRadix$11y6fsf(_3687, radix70); if (_3692.ok) { const arg9 = _3692.value; const args158: rt.Fmt[] = [(f: rt.Formatter) => rt.i64Display(arg9, f)]; @@ -5132,8 +5132,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args160[0], "|", args160[1], "|", args160[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args160[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args160[0]), "|", args160[3], "|", args160[4]])); } if (radix70 === 10) { - const parsed40: rt.Result = parse$1ilajpu(_3687); - const from40: rt.Result = num_fromStr$09oey6q(_3687); + const parsed40: rt.Result = parse$11m1f1e(_3687); + const from40: rt.Result = num_fromStr$116mp4t(_3687); if (from40.ok) { max40 = rt.u8Mul(rt.i64Eq(from40.value, { hi: 0x7fffffff, lo: 0xffffffff } as rt.i64) ? 1 : 0, 4); } else { @@ -5144,9 +5144,9 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } } else if (_4 === 10) { - if (data.length !== 0) { - const first11: rt.u8 = data.data[data.start]; - const rest11: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + 1, data.length - 1); + if (dataLen !== 0) { + const first11: rt.u8 = dataData[dataStart]; + const rest11: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); const radix71: rt.u32 = rt.u32Add(2, rt.u32Rem(first11 as rt.u32, 35)); const _3766: rt.u8 = rt.u8Rem(rt.u8Div(kind, 12), 4); if (_3766 === 0) { @@ -5161,7 +5161,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_3776, radix71), 99)))); } const radix72: rt.u32 = radix71; - const _3791: rt.Result = num_fromStrRadix$1cxc8v7(_3770.value, radix72); + const _3791: rt.Result = num_fromStrRadix$0366bau(_3770.value, radix72); if (_3791.ok) { const arg8 = _3791.value; const args162: rt.Fmt[] = [(f: rt.Formatter) => rt.i128Display(arg8, f)]; @@ -5190,8 +5190,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args164[0], "|", args164[1], "|", args164[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args164[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args164[0]), "|", args164[3], "|", args164[4]])); } if (radix72 === 10) { - const parsed41: rt.Result = parse$0zwe7sh(_3770.value); - const from41: rt.Result = num_fromStr$1ej7fl2(_3770.value); + const parsed41: rt.Result = parse$082ztwj(_3770.value); + const from41: rt.Result = num_fromStr$0zyj6he(_3770.value); if (from41.ok) { max41 = rt.u8Mul(rt.i128Eq(from41.value, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128) ? 1 : 0, 4); } else { @@ -5210,7 +5210,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const _3879: string = s21; const radix73: rt.u32 = radix71; - const _3882: rt.Result = num_fromStrRadix$1cxc8v7(_3879, radix73); + const _3882: rt.Result = num_fromStrRadix$0366bau(_3879, radix73); if (_3882.ok) { const arg7 = _3882.value; const args166: rt.Fmt[] = [(f: rt.Formatter) => rt.i128Display(arg7, f)]; @@ -5239,8 +5239,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args168[0], "|", args168[1], "|", args168[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args168[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args168[0]), "|", args168[3], "|", args168[4]])); } if (radix73 === 10) { - const parsed42: rt.Result = parse$0zwe7sh(_3879); - const from42: rt.Result = num_fromStr$1ej7fl2(_3879); + const parsed42: rt.Result = parse$082ztwj(_3879); + const from42: rt.Result = num_fromStr$0zyj6he(_3879); if (from42.ok) { max42 = rt.u8Mul(rt.i128Eq(from42.value, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128) ? 1 : 0, 4); } else { @@ -5259,7 +5259,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const radix74: rt.u32 = _3950; for (const _3961 of edges({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128, rt.u128Add({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128, 1), 128, radix74)) { const radix75: rt.u32 = radix74; - const _3972: rt.Result = num_fromStrRadix$1cxc8v7(_3961, radix75); + const _3972: rt.Result = num_fromStrRadix$0366bau(_3961, radix75); if (_3972.ok) { const arg6 = _3972.value; const args170: rt.Fmt[] = [(f: rt.Formatter) => rt.i128Display(arg6, f)]; @@ -5288,8 +5288,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args172[0], "|", args172[1], "|", args172[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args172[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args172[0]), "|", args172[3], "|", args172[4]])); } if (radix75 === 10) { - const parsed43: rt.Result = parse$0zwe7sh(_3961); - const from43: rt.Result = num_fromStr$1ej7fl2(_3961); + const parsed43: rt.Result = parse$082ztwj(_3961); + const from43: rt.Result = num_fromStr$0zyj6he(_3961); if (from43.ok) { max43 = rt.u8Mul(rt.i128Eq(from43.value, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128) ? 1 : 0, 4); } else { @@ -5313,7 +5313,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const _4064: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text11), "1"); const radix77: rt.u32 = radix76; - const _4069: rt.Result = num_fromStrRadix$1cxc8v7(_4064, radix77); + const _4069: rt.Result = num_fromStrRadix$0366bau(_4064, radix77); if (_4069.ok) { const arg5 = _4069.value; const args174: rt.Fmt[] = [(f: rt.Formatter) => rt.i128Display(arg5, f)]; @@ -5342,8 +5342,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args176[0], "|", args176[1], "|", args176[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args176[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args176[0]), "|", args176[3], "|", args176[4]])); } if (radix77 === 10) { - const parsed44: rt.Result = parse$0zwe7sh(_4064); - const from44: rt.Result = num_fromStr$1ej7fl2(_4064); + const parsed44: rt.Result = parse$082ztwj(_4064); + const from44: rt.Result = num_fromStr$0zyj6he(_4064); if (from44.ok) { max44 = rt.u8Mul(rt.i128Eq(from44.value, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128) ? 1 : 0, 4); } else { @@ -5354,9 +5354,9 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } } else if (_4 === 11) { - if (data.length !== 0) { - const first12: rt.u8 = data.data[data.start]; - const rest12: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + 1, data.length - 1); + if (dataLen !== 0) { + const first12: rt.u8 = dataData[dataStart]; + const rest12: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); const radix78: rt.u32 = rt.u32Add(2, rt.u32Rem(first12 as rt.u32, 35)); const _4143: rt.u8 = rt.u8Rem(rt.u8Div(kind, 12), 4); if (_4143 === 0) { @@ -5371,7 +5371,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_4153, radix78), 99)))); } const radix79: rt.u32 = radix78; - const _4168: rt.Result = num_fromStrRadix$1mq18rn(_4147.value, radix79); + const _4168: rt.Result = num_fromStrRadix$1473bi0(_4147.value, radix79); if (_4168.ok) { const arg4 = _4168.value; const args178: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDisplay(arg4, f)]; @@ -5400,8 +5400,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args180[0], "|", args180[1], "|", args180[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args180[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args180[0]), "|", args180[3], "|", args180[4]])); } if (radix79 === 10) { - const parsed45: rt.Result = parse$1g5tknx(_4147.value); - const from45: rt.Result = num_fromStr$1gsa29j(_4147.value); + const parsed45: rt.Result = parse$07xyv4i(_4147.value); + const from45: rt.Result = num_fromStr$1grmucc(_4147.value); if (from45.ok) { max45 = rt.u8Mul(from45.value === 2147483647 ? 1 : 0, 4); } else { @@ -5420,7 +5420,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const _4256: string = s23; const radix80: rt.u32 = radix78; - const _4259: rt.Result = num_fromStrRadix$1mq18rn(_4256, radix80); + const _4259: rt.Result = num_fromStrRadix$1473bi0(_4256, radix80); if (_4259.ok) { const arg3 = _4259.value; const args182: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDisplay(arg3, f)]; @@ -5449,8 +5449,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args184[0], "|", args184[1], "|", args184[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args184[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args184[0]), "|", args184[3], "|", args184[4]])); } if (radix80 === 10) { - const parsed46: rt.Result = parse$1g5tknx(_4256); - const from46: rt.Result = num_fromStr$1gsa29j(_4256); + const parsed46: rt.Result = parse$07xyv4i(_4256); + const from46: rt.Result = num_fromStr$1grmucc(_4256); if (from46.ok) { max46 = rt.u8Mul(from46.value === 2147483647 ? 1 : 0, 4); } else { @@ -5469,7 +5469,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const radix81: rt.u32 = _4327; for (const _4338 of edges(2147483647, rt.u128Add(2147483647, 1), 32, radix81)) { const radix82: rt.u32 = radix81; - const _4349: rt.Result = num_fromStrRadix$1mq18rn(_4338, radix82); + const _4349: rt.Result = num_fromStrRadix$1473bi0(_4338, radix82); if (_4349.ok) { const arg2 = _4349.value; const args186: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDisplay(arg2, f)]; @@ -5498,8 +5498,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args188[0], "|", args188[1], "|", args188[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args188[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args188[0]), "|", args188[3], "|", args188[4]])); } if (radix82 === 10) { - const parsed47: rt.Result = parse$1g5tknx(_4338); - const from47: rt.Result = num_fromStr$1gsa29j(_4338); + const parsed47: rt.Result = parse$07xyv4i(_4338); + const from47: rt.Result = num_fromStr$1grmucc(_4338); if (from47.ok) { max47 = rt.u8Mul(from47.value === 2147483647 ? 1 : 0, 4); } else { @@ -5523,7 +5523,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const _4441: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text12), "1"); const radix84: rt.u32 = radix83; - const _4446: rt.Result = num_fromStrRadix$1mq18rn(_4441, radix84); + const _4446: rt.Result = num_fromStrRadix$1473bi0(_4441, radix84); if (_4446.ok) { const arg = _4446.value; const args190: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDisplay(arg, f)]; @@ -5552,8 +5552,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args192[0], "|", args192[1], "|", args192[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args192[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args192[0]), "|", args192[3], "|", args192[4]])); } if (radix84 === 10) { - const parsed48: rt.Result = parse$1g5tknx(_4441); - const from48: rt.Result = num_fromStr$1gsa29j(_4441); + const parsed48: rt.Result = parse$07xyv4i(_4441); + const from48: rt.Result = num_fromStr$1grmucc(_4441); if (from48.ok) { max48 = rt.u8Mul(from48.value === 2147483647 ? 1 : 0, 4); } else { diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index 31b176778..8aafa5244 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -1683,7 +1683,7 @@ export function own(data: rt.ByteSlice, out: rt.ByteVec): void { * The last two bytes of `data`, as a `slice::Iter` made from the second argument: a * `for` must iterate it, not the first. */ -export function tail(_head: rt.ByteSlice, data: rt.ByteSlice): rt.Iter { +export function tail(_headData: Uint8Array, _headStart: number, _headLen: number, data: rt.ByteSlice): rt.Iter { return rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, rt.usizeSaturatingSub(data.length, 2)))); } @@ -1696,7 +1696,8 @@ export function odds(data: rt.ByteSlice): rt.Iter { /** Iterators as values: returned, stored, and printed. */ export function values(data: rt.ByteSlice, out: rt.ByteVec): void { - const iter: rt.Iter = tail(rt.byteSliceFrom(Uint8Array.of(1, 2, 3)), data); + const _5: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(1, 2, 3)); + const iter: rt.Iter = tail(_5.data, _5.start, _5.length, data); while (true) { const _8: rt.u8 | rt.Done = iter.next(); if (_8 === rt.DONE) { @@ -3741,7 +3742,7 @@ export function rangeFroms(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo } else if (_12 === 14) { adapted(a, data, out); } else { - overflowed(a, data, out); + overflowed(a, data.data, data.start, data.length, out); } } @@ -4669,9 +4670,9 @@ export function adapted(a: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Consumers that step `start..` past its type's last value, which panics in std's * debug build, as the fixture is built. */ -export function overflowed(a: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function overflowed(a: rt.u8, _dataData: Uint8Array, _dataStart: number, dataLen: number, out: rt.ByteVec): void { const top: rt.u8 = rt.max(a, 250); - const _5: rt.usize = rt.usizeRem(data.length, 8); + const _5: rt.usize = rt.usizeRem(dataLen, 8); if (_5 === 0) { rt.iterExtendBytes(out, new rt.RangeFrom(top, rt.u8Step), undefined, true); } else if (_5 === 1) { diff --git a/ts/fixtures/lang/expected/keys.ts b/ts/fixtures/lang/expected/keys.ts index 7905703ec..39b2e0b44 100644 --- a/ts/fixtures/lang/expected/keys.ts +++ b/ts/fixtures/lang/expected/keys.ts @@ -180,11 +180,11 @@ export function find$u8_u8(keys: rt.ByteSlice, q: rt.u8): rt.u8 { export function keys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _4: rt.u8 = rt.u8Rem(kind, 5); if (_4 === 0) { - options(data, out); + options(data.data, data.start, data.length, out); } else if (_4 === 1) { arcs(data, out); } else if (_4 === 2) { - borrows(data, out); + borrows(data.data, data.start, data.length, out); } else if (_4 === 3) { defaults(data, out); } else { @@ -488,17 +488,21 @@ export function seen(k: rt.u8, hop: Hop.Hop | undefined, horizon: Horizon.Horizo * Borrows compared, ordered, and hashed as what they point at, through one reference * or two, shared or mutable. */ -export function borrows(data: rt.ByteSlice, out: rt.ByteVec): void { +export function borrows(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let _7!: rt.usize; let iterStart: rt.usize = 1; - const iterEnd: rt.usize = data.length; + const iterEnd: rt.usize = dataLen; while ((_7 = iterStart++) < iterEnd) { const i: rt.usize = _7; const _15: rt.usize = rt.usizeSub(i, 1); - rt.idx(data, _15); - const _14: rt.u8 = data.data[data.start + _15]; - rt.idx(data, i); - const _13: [rt.u8, rt.u8] = [_14, data.data[data.start + i]]; + if (_15 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _15); + } + const _14: rt.u8 = dataData[dataStart + _15]; + if (i >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + i); + } + const _13: [rt.u8, rt.u8] = [_14, dataData[dataStart + i]]; const c: rt.u8 = _14; const d: rt.u8 = _13[1]; const _24: [Hop.Hop | undefined, Hop.Hop | undefined] = [hop(c), hop(d)]; @@ -530,7 +534,7 @@ export function borrows(data: rt.ByteSlice, out: rt.ByteVec): void { } /** `Option`s compared, ordered, and hashed, alone and in keys. */ -export function options(data: rt.ByteSlice, out: rt.ByteVec): void { +export function options(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let _12!: rt.usize; const _313: (a0: rt.u8) => Way.Way | undefined | rt.None = (b2: rt.u8): Way.Way | undefined | rt.None => { return then$18np55d(rt.u8Rem(b2, 5) !== 0, (): Way.Way | undefined => { @@ -543,14 +547,18 @@ export function options(data: rt.ByteSlice, out: rt.ByteVec): void { const bare: rt.HashMap = rt.hashNew(rt.hashing(rt.hashOption(Way.hash$Hash_hash_DefaultHasher as (a0: Way.Way, a1: rt.Hasher) => undefined), rt.eqOption(Way.eq$cmp_PartialEq), true)) as rt.HashMap; const deep: rt.HashSet = rt.hashNew(rt.hashing(rt.hashOption(rt.hashOption(Way.hash$Hash_hash_DefaultHasher as (a0: Way.Way, a1: rt.Hasher) => undefined), rt.None), rt.eqOption(rt.eqOption(Way.eq$cmp_PartialEq), rt.None), true)) as rt.HashSet; let iterStart: rt.usize = 1; - const iterEnd: rt.usize = data.length; + const iterEnd: rt.usize = dataLen; while ((_12 = iterStart++) < iterEnd) { const i: rt.usize = _12; const _20: rt.usize = rt.usizeSub(i, 1); - rt.idx(data, _20); - const _19: rt.u8 = data.data[data.start + _20]; - rt.idx(data, i); - const _18: [rt.u8, rt.u8] = [_19, data.data[data.start + i]]; + if (_20 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _20); + } + const _19: rt.u8 = dataData[dataStart + _20]; + if (i >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + i); + } + const _18: [rt.u8, rt.u8] = [_19, dataData[dataStart + i]]; const c: rt.u8 = _19; const d: rt.u8 = _18[1]; const _29: [Hop.Hop | undefined, Hop.Hop | undefined] = [hop(c), hop(d)]; diff --git a/ts/fixtures/lang/expected/nested.ts b/ts/fixtures/lang/expected/nested.ts index c9527de6c..d0dbb0d74 100644 --- a/ts/fixtures/lang/expected/nested.ts +++ b/ts/fixtures/lang/expected/nested.ts @@ -18,7 +18,7 @@ export function nested(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (_4 === 0) { made(data, out); } else if (_4 === 1) { - keys(data, out); + keys(data.data, data.start, data.length, out); } else if (_4 === 2) { iters(data, out); } else if (_4 === 3) { @@ -147,32 +147,42 @@ export function order(o: rt.Ordering): rt.u8 { * Compared, ordered, and hashed: `None` orders before `Some(None)`, which orders before * each `Some(Some(_))`. */ -export function keys(data: rt.ByteSlice, out: rt.ByteVec): void { +export function keys(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let _9!: rt.usize; const hashed: rt.HashMap<[rt.u8, rt.u8 | undefined | rt.None], rt.u8> = rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hashOption(rt.hashOption(rt.hash8), rt.None)]), rt.eqTuple([rt.same, rt.same]))) as rt.HashMap<[rt.u8, rt.u8 | undefined | rt.None], rt.u8>; const sorted: rt.BTreeMap<[rt.u8 | undefined | rt.None, rt.u8], rt.u8> = rt.btreeNew(rt.cmpTuple<[rt.u8 | undefined | rt.None, rt.u8], rt.Ordering>([rt.cmpOption(rt.cmpOption(rt.cmp), rt.None), rt.cmp])) as rt.BTreeMap<[rt.u8 | undefined | rt.None, rt.u8], rt.u8>; let iterStart: rt.usize = 1; - const iterEnd: rt.usize = data.length; + const iterEnd: rt.usize = dataLen; while ((_9 = iterStart++) < iterEnd) { const i: rt.usize = _9; const _18: rt.usize = rt.usizeSub(i, 1); - rt.idx(data, _18); - const _16: rt.u8 | undefined | rt.None = pick(data.data[data.start + _18]); - rt.idx(data, i); - const _15: [rt.u8 | undefined | rt.None, rt.u8 | undefined | rt.None] = [_16, pick(data.data[data.start + i])]; + if (_18 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _18); + } + const _16: rt.u8 | undefined | rt.None = pick(dataData[dataStart + _18]); + if (i >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + i); + } + const _15: [rt.u8 | undefined | rt.None, rt.u8 | undefined | rt.None] = [_16, pick(dataData[dataStart + i])]; const a: rt.u8 | undefined | rt.None = _16; const b: rt.u8 | undefined | rt.None = _15[1]; rt.byteVecPush(out, (a === b ? 1 : 0) | (((a !== b ? 1 : 0) << 1) & 0xff) | (((rt.cmpOption(rt.cmpOption(rt.cmp), rt.None)(a, b) === -1 ? 1 : 0) << 2) & 0xff) | ((order(rt.cmpOption(rt.cmpOption(rt.cmp), rt.None)(a, b)) << 3) & 0xff)); rt.byteVecPush(out, (rt.ordMax(a, b, rt.cmpLt(rt.cmpOption(rt.cmpOption(rt.cmp), rt.None))) === b ? 1 : 0) | (((rt.u64Eq(hashOf$Option_Option_u8(a), hashOf$Option_Option_u8(b)) ? 1 : 0) << 1) & 0xff)); - rt.idx(data, i); - const _75: [rt.u8, rt.u8 | undefined | rt.None] = [rt.u8Rem(data.data[data.start + i], 2), a]; + if (i >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + i); + } + const _75: [rt.u8, rt.u8 | undefined | rt.None] = [rt.u8Rem(dataData[dataStart + i], 2), a]; rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(hashed, _75, i & 0xff), 204)); - rt.idx(data, i); - const _86: [rt.u8 | undefined | rt.None, rt.u8] = [a, rt.u8Rem(data.data[data.start + i], 2)]; + if (i >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + i); + } + const _86: [rt.u8 | undefined | rt.None, rt.u8] = [a, rt.u8Rem(dataData[dataStart + i], 2)]; rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeInsert(sorted, _86, i & 0xff), 204)); const _101: rt.usize = rt.usizeSub(i, 1); - rt.idx(data, _101); - const _98: [rt.u8, rt.u8 | undefined | rt.None] = [rt.u8Rem(data.data[data.start + _101], 2), b]; + if (_101 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _101); + } + const _98: [rt.u8, rt.u8 | undefined | rt.None] = [rt.u8Rem(dataData[dataStart + _101], 2), b]; rt.byteVecPush(out, rt.hashContains(hashed, _98) ? 1 : 0); } const iter2: rt.Iter<[[rt.u8 | undefined | rt.None, rt.u8], rt.u8]> = rt.btreeIter(sorted); diff --git a/ts/fixtures/lang/expected/orders.ts b/ts/fixtures/lang/expected/orders.ts index b6b7e3245..c9074b7fe 100644 --- a/ts/fixtures/lang/expected/orders.ts +++ b/ts/fixtures/lang/expected/orders.ts @@ -41,7 +41,7 @@ export function item(tag: rt.usize, key: rt.u8): orders_Item.Item { export function orders(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _5: rt.u8 = rt.u8Rem(kind, 4); if (_5 === 0) { - cmps(data, out); + cmps(data.data, data.start, data.length, out); } else if (_5 === 1) { sorted(data, out); } else if (_5 === 2) { @@ -56,17 +56,21 @@ export function orders(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * `cmp::max` and `min` and their forms of each byte and the next, as integers, strings, * and items, which the one not returned drops, and of references to items. */ -export function cmps(data: rt.ByteSlice, out: rt.ByteVec): void { +export function cmps(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let _7!: rt.usize; let iterStart: rt.usize = 1; - const iterEnd: rt.usize = data.length; + const iterEnd: rt.usize = dataLen; while ((_7 = iterStart++) < iterEnd) { const i: rt.usize = _7; const _15: rt.usize = rt.usizeSub(i, 1); - rt.idx(data, _15); - const _14: rt.u8 = data.data[data.start + _15]; - rt.idx(data, i); - const _13: [rt.u8, rt.u8] = [_14, data.data[data.start + i]]; + if (_15 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _15); + } + const _14: rt.u8 = dataData[dataStart + _15]; + if (i >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + i); + } + const _13: [rt.u8, rt.u8] = [_14, dataData[dataStart + i]]; const a: rt.u8 = _14; const b: rt.u8 = _13[1]; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(max$0g5g0ks(a, b), min$1mtc1eg(a, b), max$0i3ups8((a << 24) >> 24, (b << 24) >> 24) & 0xff)), undefined, true); @@ -733,23 +737,23 @@ export function order(o: rt.Ordering | undefined): rt.u8 { * A deque of `f` of each byte and its index: straight, or with its first half pushed to the * front in reverse, so it wraps around its buffer. */ -export function deque$orders_Part_orders_held_closure3(s: rt.ByteSlice, wraps: boolean, f: (a0: rt.usize, a1: rt.u8) => Part.Part): rt.VecDeque { +export function deque$orders_Part_orders_held_closure3(sData: Uint8Array, sStart: number, sLen: number, wraps: boolean, f: (a0: rt.usize, a1: rt.u8) => Part.Part): rt.VecDeque { let at!: rt.usize; if (!wraps) { at = 0; } else { - at = rt.usizeDiv(s.length, 2); + at = rt.usizeDiv(sLen, 2); } const mid: number = at; - if (mid > s.length) { + if (mid > sLen) { rt.panic("mid > len"); } const _17: rt.usize = at; - const _12: rt.Iter = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(s.data, s.start + mid, s.length - mid)))), (_2: [rt.usize, rt.u8]): Part.Part => { + const _12: rt.Iter = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rt.usize, rt.u8]): Part.Part => { return f(rt.usizeAdd(_2[0], _17), _2[1]); }); const d: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _12, undefined, 2, true); - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(s.data, s.start, mid))))); + const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart, mid))))); while (true) { const _23: [rt.usize, rt.u8] | rt.Done = iter.next(); if (_23 === rt.DONE) { @@ -764,23 +768,23 @@ export function deque$orders_Part_orders_held_closure3(s: rt.ByteSlice, wraps: b * A deque of `f` of each byte and its index: straight, or with its first half pushed to the * front in reverse, so it wraps around its buffer. */ -export function deque$orders_Part_orders_part(s: rt.ByteSlice, wraps: boolean, _: (a0: rt.usize, a1: rt.u8) => Part.Part): rt.VecDeque { +export function deque$orders_Part_orders_part(sData: Uint8Array, sStart: number, sLen: number, wraps: boolean, _: (a0: rt.usize, a1: rt.u8) => Part.Part): rt.VecDeque { let at!: rt.usize; if (!wraps) { at = 0; } else { - at = rt.usizeDiv(s.length, 2); + at = rt.usizeDiv(sLen, 2); } const mid: number = at; - if (mid > s.length) { + if (mid > sLen) { rt.panic("mid > len"); } const _17: rt.usize = at; - const _12: rt.Iter = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(s.data, s.start + mid, s.length - mid)))), (_2: [rt.usize, rt.u8]): Part.Part => { + const _12: rt.Iter = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rt.usize, rt.u8]): Part.Part => { return part(rt.usizeAdd(_2[0], _17), _2[1]); }); const d: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _12, undefined, 2, true); - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(s.data, s.start, mid))))); + const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart, mid))))); while (true) { const _23: [rt.usize, rt.u8] | rt.Done = iter.next(); if (_23 === rt.DONE) { @@ -795,23 +799,23 @@ export function deque$orders_Part_orders_part(s: rt.ByteSlice, wraps: boolean, _ * A deque of `f` of each byte and its index: straight, or with its first half pushed to the * front in reverse, so it wraps around its buffer. */ -export function deque$u8_orders_held_closure11(s: rt.ByteSlice, wraps: boolean, f: (a0: rt.usize, a1: rt.u8) => rt.u8): rt.VecDeque { +export function deque$u8_orders_held_closure11(sData: Uint8Array, sStart: number, sLen: number, wraps: boolean, f: (a0: rt.usize, a1: rt.u8) => rt.u8): rt.VecDeque { let at!: rt.usize; if (!wraps) { at = 0; } else { - at = rt.usizeDiv(s.length, 2); + at = rt.usizeDiv(sLen, 2); } const mid: number = at; - if (mid > s.length) { + if (mid > sLen) { rt.panic("mid > len"); } const _17: rt.usize = at; - const _12: rt.Iter = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(s.data, s.start + mid, s.length - mid)))), (_2: [rt.usize, rt.u8]): rt.u8 => { + const _12: rt.Iter = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rt.usize, rt.u8]): rt.u8 => { return f(rt.usizeAdd(_2[0], _17), _2[1]); }); const d: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _12, undefined, 1, true); - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(s.data, s.start, mid))))); + const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart, mid))))); while (true) { const _23: [rt.usize, rt.u8] | rt.Done = iter.next(); if (_23 === rt.DONE) { @@ -826,23 +830,23 @@ export function deque$u8_orders_held_closure11(s: rt.ByteSlice, wraps: boolean, * A deque of `f` of each byte and its index: straight, or with its first half pushed to the * front in reverse, so it wraps around its buffer. */ -export function deque$u8_orders_held_closure8(s: rt.ByteSlice, wraps: boolean, f: (a0: rt.usize, a1: rt.u8) => rt.u8): rt.VecDeque { +export function deque$u8_orders_held_closure8(sData: Uint8Array, sStart: number, sLen: number, wraps: boolean, f: (a0: rt.usize, a1: rt.u8) => rt.u8): rt.VecDeque { let at!: rt.usize; if (!wraps) { at = 0; } else { - at = rt.usizeDiv(s.length, 2); + at = rt.usizeDiv(sLen, 2); } const mid: number = at; - if (mid > s.length) { + if (mid > sLen) { rt.panic("mid > len"); } const _17: rt.usize = at; - const _12: rt.Iter = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(s.data, s.start + mid, s.length - mid)))), (_2: [rt.usize, rt.u8]): rt.u8 => { + const _12: rt.Iter = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rt.usize, rt.u8]): rt.u8 => { return f(rt.usizeAdd(_2[0], _17), _2[1]); }); const d: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _12, undefined, 1, true); - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(s.data, s.start, mid))))); + const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart, mid))))); while (true) { const _23: [rt.usize, rt.u8] | rt.Done = iter.next(); if (_23 === rt.DONE) { @@ -990,9 +994,11 @@ export function held(data: rt.ByteSlice, out: rt.ByteVec): void { if (_232 === rt.DONE) { continue l3; } + const _240: rt.ByteSlice = rt.byteSliceRange(data, 0, i2); const j: rt.usize = _232; - const _239: rt.VecDeque = deque$orders_Part_orders_part(rt.byteSliceRange(data, 0, i2), false, part); - const _238: [rt.VecDeque, rt.VecDeque] = [_239, deque$orders_Part_orders_held_closure3(rt.byteSliceRange(data, j, cut), true, (i6: rt.usize, b5: rt.u8): Part.Part => { + const _239: rt.VecDeque = deque$orders_Part_orders_part(_240.data, _240.start, _240.length, false, part); + const _243: rt.ByteSlice = rt.byteSliceRange(data, j, cut); + const _238: [rt.VecDeque, rt.VecDeque] = [_239, deque$orders_Part_orders_held_closure3(_243.data, _243.start, _243.length, true, (i6: rt.usize, b5: rt.u8): Part.Part => { return part(rt.usizeAdd(i6, 50), b5); })]; const d: rt.VecDeque = _239; @@ -1059,7 +1065,7 @@ export function held(data: rt.ByteSlice, out: rt.ByteVec): void { break; } const i4: rt.usize = _366[0]; - const d2: rt.VecDeque = deque$u8_orders_held_closure8(_366[1], rt.usizeRem(i4, 2) === 1, (_211: rt.usize, b7: rt.u8): rt.u8 => { + const d2: rt.VecDeque = deque$u8_orders_held_closure8(_366[1].data, _366[1].start, _366[1].length, rt.usizeRem(i4, 2) === 1, (_211: rt.usize, b7: rt.u8): rt.u8 => { return rt.u8Rem(b7, 4); }); rt.idx(_366[1], 0); @@ -1076,7 +1082,8 @@ export function held(data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterMap(rt.btreeValues(deques), (_213: rt.usize): rt.u8 => { return _213 & 0xff; }), undefined, true); - const _409: rt.Result, rt.Poll> = rt.Ok(deque$u8_orders_held_closure11(rt.byteSliceRange(data, 0, rt.min(data.length, 3)), true, (_216: rt.usize, b8: rt.u8): rt.u8 => { + const _400: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(data.length, 3)); + const _409: rt.Result, rt.Poll> = rt.Ok(deque$u8_orders_held_closure11(_400.data, _400.start, _400.length, true, (_216: rt.usize, b8: rt.u8): rt.u8 => { return rt.u8Rem(b8, 4); })); rt.byteVecPush(out, rt.btreeContains(deques, _409) ? 1 : 0); diff --git a/ts/fixtures/lang/expected/pointers.ts b/ts/fixtures/lang/expected/pointers.ts index e22c82f65..23c5636bc 100644 --- a/ts/fixtures/lang/expected/pointers.ts +++ b/ts/fixtures/lang/expected/pointers.ts @@ -33,7 +33,7 @@ import type * as Viewed from "./pointers.Viewed.ts"; import type * as Waiter from "./pointers.Waiter.ts"; import * as Waiters from "./pointers.Waiters.ts"; import type * as pointers_Window from "./pointers.Window.ts"; -import * as Wrapped from "./pointers.Wrapped.ts"; +import * as pointers_Wrapped from "./pointers.Wrapped.ts"; import type * as Written from "./pointers.Written.ts"; /** Put `node` in the list just before `at`. */ @@ -70,20 +70,20 @@ export function detach$sync_Arc_u8(node: pointers_Node.Node>): voi * Steps on a list of the operation and key each pair of bytes picks, putting what each * finds and then the list in order. */ -export function lists(data: rt.ByteSlice, out: rt.ByteVec): void { +export function lists(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { const list: List.List = List.new$String(); - let dataData: Uint8Array = data.data; - let dataStart: number = data.start; - let dataLen: number = data.length; - while (dataLen >= 2) { - const op: rt.u8 = dataData[dataStart]; - const key: rt.u8 = dataData[dataStart + 1]; - const restData: Uint8Array = dataData; - const restStart: number = dataStart + 2; - const restLen: number = dataLen - 2; - dataData = restData; - dataStart = restStart; - dataLen = restLen; + let dataData2: Uint8Array = dataData; + let dataStart2: number = dataStart; + let dataLen2: number = dataLen; + while (dataLen2 >= 2) { + const op: rt.u8 = dataData2[dataStart2]; + const key: rt.u8 = dataData2[dataStart2 + 1]; + const restData: Uint8Array = dataData2; + const restStart: number = dataStart2 + 2; + const restLen: number = dataLen2 - 2; + dataData2 = restData; + dataStart2 = restStart; + dataLen2 = restLen; const _13: [rt.u8, rt.u8] = [op, rt.u8Rem(key, 8)]; const op2: rt.u8 = op; const key2: rt.u8 = _13[1]; @@ -124,21 +124,21 @@ export function lists(data: rt.ByteSlice, out: rt.ByteVec): void { * Steps on a list of shared counts, putting how many hold the one each push clones * while the list lives, and after it drops. */ -export function shared(data: rt.ByteSlice, out: rt.ByteVec): void { +export function shared(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { const held: rt.Arc = new rt.Arc(0); const list: List.List> = List.new$sync_Arc_u8(); - let dataData: Uint8Array = data.data; - let dataStart: number = data.start; - let dataLen: number = data.length; - while (dataLen >= 2) { - const op: rt.u8 = dataData[dataStart]; - const key: rt.u8 = dataData[dataStart + 1]; - const restData: Uint8Array = dataData; - const restStart: number = dataStart + 2; - const restLen: number = dataLen - 2; - dataData = restData; - dataStart = restStart; - dataLen = restLen; + let dataData2: Uint8Array = dataData; + let dataStart2: number = dataStart; + let dataLen2: number = dataLen; + while (dataLen2 >= 2) { + const op: rt.u8 = dataData2[dataStart2]; + const key: rt.u8 = dataData2[dataStart2 + 1]; + const restData: Uint8Array = dataData2; + const restStart: number = dataStart2 + 2; + const restLen: number = dataLen2 - 2; + dataData2 = restData; + dataStart2 = restStart; + dataLen2 = restLen; const _13: [rt.u8, rt.u8] = [op, rt.u8Rem(key, 4)]; const op2: rt.u8 = op; const key2: rt.u8 = _13[1]; @@ -388,7 +388,7 @@ export function cells(data: rt.ByteSlice, out: rt.ByteVec): void { let num: rt.Cell = new rt.Cell(4294967295 - 1); const pair: rt.Cell = new rt.Cell({ _0: 0, _1: 255 }); let text: rt.Cell = new rt.Cell(""); - const held: Wrapped.Wrapped = Wrapped.new$pointers_Held(new pointers_Held.Held(0, rt.arcClone(count))); + const held: pointers_Wrapped.Wrapped = pointers_Wrapped.new$pointers_Held(new pointers_Held.Held(0, rt.arcClone(count))); for (const op of rt.byteSliceView(data)) { const n: rt.u8 = rt.u8Div(op, 8); const _23: rt.u8 = rt.u8Rem(op, 8); @@ -423,7 +423,7 @@ export function cells(data: rt.ByteSlice, out: rt.ByteVec): void { const fresh: pointers_Held.Held = new pointers_Held.Held(n, _99); if (rt.u8Rem(n, 2) === 0) { const captured2 = fresh; - Wrapped.withMut$pointers_Held_unit_pointers_cells_closure0(held, rt.closure((p6: pointers_Held.Held): undefined => { + pointers_Wrapped.withMut$pointers_Held_unit_pointers_cells_closure0(held, rt.closure((p6: pointers_Held.Held): undefined => { const _311: pointers_Held.Held = captured2; p6[Symbol.dispose](); rt.ptrWrite(p6, _311); @@ -432,22 +432,22 @@ export function cells(data: rt.ByteSlice, out: rt.ByteVec): void { })); } else { const captured = fresh; - Wrapped.withMut$pointers_Held_unit_pointers_cells_closure1(held, rt.closure((p5: pointers_Held.Held): undefined => { + pointers_Wrapped.withMut$pointers_Held_unit_pointers_cells_closure1(held, rt.closure((p5: pointers_Held.Held): undefined => { rt.ptrWrite(p5, captured); }, (): void => { captured[Symbol.dispose](); })); } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(Wrapped.with$pointers_Held_u8_pointers_cells_closure2(held, (p7: pointers_Held.Held): rt.u8 => { + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(pointers_Wrapped.with$pointers_Held_u8_pointers_cells_closure2(held, (p7: pointers_Held.Held): rt.u8 => { return p7.n; }), count.strong & 0xff)), undefined, true); } else if (_23 === 5) { - Wrapped.withMut$pointers_Held_unit_pointers_cells_closure3(held, (p3: pointers_Held.Held): undefined => { + pointers_Wrapped.withMut$pointers_Held_unit_pointers_cells_closure3(held, (p3: pointers_Held.Held): undefined => { p3.n = rt.u8WrappingAdd(p3.n, n); }); const _119: pointers_Held.Held = held._0.v; _119.n = _119.n ^ 1; - rt.byteVecPush(out, Wrapped.with$pointers_Held_u8_pointers_cells_closure4(held, (p4: pointers_Held.Held): rt.u8 => { + rt.byteVecPush(out, pointers_Wrapped.with$pointers_Held_u8_pointers_cells_closure4(held, (p4: pointers_Held.Held): rt.u8 => { return p4.n; })); } else if (_23 === 6) { @@ -463,8 +463,8 @@ export function cells(data: rt.ByteSlice, out: rt.ByteVec): void { Object.assign(pair.v, _140); } else { const _146: rt.Arc = rt.arcClone(count); - const made: Wrapped.Wrapped = Wrapped.new$pointers_Held(new pointers_Held.Held(n, _146)); - Wrapped.withMut$pointers_Held_unit_pointers_cells_closure5(made, (p2: pointers_Held.Held): undefined => { + const made: pointers_Wrapped.Wrapped = pointers_Wrapped.new$pointers_Held(new pointers_Held.Held(n, _146)); + pointers_Wrapped.withMut$pointers_Held_unit_pointers_cells_closure5(made, (p2: pointers_Held.Held): undefined => { p2.n = p2.n ^ 85; }); rt.byteVecPush(out, count.strong & 0xff); diff --git a/ts/fixtures/lang/expected/returns.At.ts b/ts/fixtures/lang/expected/returns.At.ts new file mode 100644 index 000000000..d58cc8d8e --- /dev/null +++ b/ts/fixtures/lang/expected/returns.At.ts @@ -0,0 +1,27 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import type * as returns_Error from "./returns.Error.ts"; + +export interface At { + _0: rt.usize; +} + +export function split$returns_Split(self: At, dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { + const mid: number = self._0; + const _5 = { tag: "Short", _0: self._0 } as returns_Error.Error; + if (!(mid <= dataLen)) { + return _5; + } + splitOut$returns_Split.p_0Data = dataData; + splitOut$returns_Split.p_0Start = dataStart; + splitOut$returns_Split.p_0Len = mid; + splitOut$returns_Split.p_1Data = dataData; + splitOut$returns_Split.p_1Start = dataStart + mid; + splitOut$returns_Split.p_1Len = dataLen - mid; + return undefined; +} + +export const splitOut$returns_Split: { p_0Data: Uint8Array; p_0Start: number; p_0Len: number; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { p_0Data: undefined as never, p_0Start: undefined as never, p_0Len: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; + +//# sourceMappingURL=returns.At.ts.map diff --git a/ts/fixtures/lang/expected/returns.Error.ts b/ts/fixtures/lang/expected/returns.Error.ts new file mode 100644 index 000000000..68fd7edad --- /dev/null +++ b/ts/fixtures/lang/expected/returns.Error.ts @@ -0,0 +1,14 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; + +export type Error = { tag: "Short"; _0: rt.usize } | { tag: "Bad" }; + +export function code(self: Error): rt.u8 { + if (self.tag === "Short") { + return self._0 & 0xff; + } + return 255; +} + +//# sourceMappingURL=returns.Error.ts.map diff --git a/ts/fixtures/lang/expected/returns.Guard.ts b/ts/fixtures/lang/expected/returns.Guard.ts new file mode 100644 index 000000000..a9303ba4a --- /dev/null +++ b/ts/fixtures/lang/expected/returns.Guard.ts @@ -0,0 +1,27 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import { wideOut, narrow } from "./returns.ts"; +import type * as returns_Error from "./returns.Error.ts"; + +/** A guard whose drop writes the slot after its function's call did. */ +export class Guard { + _0: rt.ByteSlice; + _1: rt.u8; + + constructor(_0: rt.ByteSlice, _1: rt.u8) { + this._0 = _0; + this._1 = _1; + } + + [Symbol.dispose](): void { + drop$ops_Drop(this); + } +} + +export function drop$ops_Drop(self: Guard): void { + const _3: rt.ByteSlice = rt.byteSliceRange(self._0, rt.usizeRem(self._1 as rt.usize, 2)); + narrow(_3.data, _3.start, _3.length) === undefined ? wideOut.err as returns_Error.Error : undefined; +} + +//# sourceMappingURL=returns.Guard.ts.map diff --git a/ts/fixtures/lang/expected/returns.Split.ts b/ts/fixtures/lang/expected/returns.Split.ts new file mode 100644 index 000000000..cb32fc30e --- /dev/null +++ b/ts/fixtures/lang/expected/returns.Split.ts @@ -0,0 +1,24 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import * as At from "./returns.At.ts"; +import type * as returns_Error from "./returns.Error.ts"; + +export type Split = + | { split$Split: (a0: rt.ByteSlice) => rt.Result<[rt.ByteSlice, rt.ByteSlice], returns_Error.Error> }; + +export class of$returns_At { + v: At.At; + + constructor(v: At.At) { + this.v = v; + } + + split$Split(a: rt.ByteSlice): rt.Result<[rt.ByteSlice, rt.ByteSlice], returns_Error.Error> { + const err = At.split$returns_Split(this.v, a.data, a.start, a.length); + const result: rt.Result<[rt.ByteSlice, rt.ByteSlice], returns_Error.Error> = err !== undefined ? rt.Err(err as returns_Error.Error) : rt.Ok([new rt.ByteSlice(At.splitOut$returns_Split.p_0Data, At.splitOut$returns_Split.p_0Start, At.splitOut$returns_Split.p_0Len), new rt.ByteSlice(At.splitOut$returns_Split.p_1Data, At.splitOut$returns_Split.p_1Start, At.splitOut$returns_Split.p_1Len)] as [rt.ByteSlice, rt.ByteSlice]); + return result; + } +} + +//# sourceMappingURL=returns.Split.ts.map diff --git a/ts/fixtures/lang/expected/returns.Wrapped.ts b/ts/fixtures/lang/expected/returns.Wrapped.ts new file mode 100644 index 000000000..44694a899 --- /dev/null +++ b/ts/fixtures/lang/expected/returns.Wrapped.ts @@ -0,0 +1,17 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr } from "./core/option.ts"; + +/** An error converted from a residual of a slice and a byte. */ +export interface Wrapped { + _0: rt.u8; + _1: rt.u8; +} + +export function from$convert_From_tuple2_ref_slice_u8_u8(_1: [rt.ByteSlice, rt.u8]): Wrapped { + const n: rt.u8 = _1[1]; + return { _0: (_1[0].length & 0xff) ^ option_unwrapOr$0r2bmpr(rt.byteSliceFirst(_1[0]), 90), _1: n }; +} + +//# sourceMappingURL=returns.Wrapped.ts.map diff --git a/ts/fixtures/lang/expected/returns.ts b/ts/fixtures/lang/expected/returns.ts new file mode 100644 index 000000000..27cb7b559 --- /dev/null +++ b/ts/fixtures/lang/expected/returns.ts @@ -0,0 +1,569 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import { then$0w2ymju } from "./core/bool.ts"; +import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$0c2keyb as option_map$0c2keyb, map$1yogfym as option_map$1yogfym, okOr$0gtm15y as option_okOr$0gtm15y, okOr$12p77jh as option_okOr$12p77jh, okOr$0tezn0w as option_okOr$0tezn0w } from "./core/option.ts"; +import { mapOr$0fbyajt as result_mapOr$0fbyajt, andThen$1yropo4 as result_andThen$1yropo4 } from "./core/result.ts"; +import * as At from "./returns.At.ts"; +import * as returns_Error from "./returns.Error.ts"; +import * as Guard from "./returns.Guard.ts"; +import * as Split from "./returns.Split.ts"; +import * as returns_Wrapped from "./returns.Wrapped.ts"; + +/** A slice alone, with returns from several places. */ +export function take(dataData: Uint8Array, dataStart: number, dataLen: number, n: rt.usize): returns_Error.Error | undefined { + if (!(n > 200)) { + if (!(n <= dataLen)) { + return { tag: "Short", _0: rt.usizeSub(n, dataLen) } as returns_Error.Error; + } + takeOut.pData = dataData; + takeOut.pStart = dataStart; + takeOut.pLen = n; + return undefined; + } + return { tag: "Bad" } as returns_Error.Error; +} + +export const takeOut: { pData: Uint8Array; pStart: number; pLen: number } = { pData: undefined as never, pStart: undefined as never, pLen: undefined as never }; + +/** The same slice type through another function, which shares its slot. */ +export function tail(data: rt.ByteSlice, n: rt.usize): returns_Error.Error | undefined { + const _0: rt.Result = option_okOr$12p77jh(then$0w2ymju(n <= data.length, (): rt.ByteSlice => { + return rt.byteSliceRange(data, n); + }), { tag: "Short", _0: n } as returns_Error.Error); + if (!_0.ok) { + return _0.error; + } + const slice: rt.ByteSlice = _0.value; + takeOut.pData = slice.data; + takeOut.pStart = slice.start; + takeOut.pLen = slice.length; + return undefined; +} + +/** A number past 2^31 and the rest. */ +export function wide(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u64 | undefined { + if (dataLen >= 8) { + const _11_0: rt.u64 = rt.u64FromBeBytes(rt.byteSliceToArray(new rt.ByteSlice(dataData, dataStart, 8))); + wideOut.p_1Data = dataData; + wideOut.p_1Start = dataStart + 8; + wideOut.p_1Len = dataLen - 8; + return _11_0; + } + wideOut.err = { tag: "Short", _0: 8 } as returns_Error.Error; + return undefined; +} + +export const wideOut: { err: unknown; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { err: undefined, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; + +export function narrow(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u64 | undefined { + if (dataLen !== 0) { + const b: rt.u8 = dataData[dataStart]; + if (b === 255) { + wideOut.err = { tag: "Bad" } as returns_Error.Error; + return undefined; + } + wideOut.p_1Data = dataData; + wideOut.p_1Start = dataStart + 1; + wideOut.p_1Len = dataLen - 1; + return b as rt.u64; + } + wideOut.err = { tag: "Short", _0: 1 } as returns_Error.Error; + return undefined; +} + +/** What either returns, returned as is. */ +export function number(dataData: Uint8Array, dataStart: number, dataLen: number, wide_: boolean): rt.u64 | undefined { + if (!wide_) { + return narrow(dataData, dataStart, dataLen); + } + return wide(dataData, dataStart, dataLen); +} + +/** Each byte before a zero counted, recursively. */ +export function count(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u64 | undefined { + if (dataLen === 0) { + wideOut.err = { tag: "Short", _0: 1 } as returns_Error.Error; + return undefined; + } + if (dataData[dataStart] === 0) { + wideOut.p_1Data = dataData; + wideOut.p_1Start = dataStart + 1; + wideOut.p_1Len = dataLen - 1; + return 0; + } + const part: rt.u64 | undefined = count(dataData, dataStart + 1, dataLen - 1); + const err: returns_Error.Error | undefined = part === undefined ? wideOut.err as returns_Error.Error : undefined; + const part2: Uint8Array = wideOut.p_1Data; + const part3: number = wideOut.p_1Start; + const part4: number = wideOut.p_1Len; + if (err === undefined) { + const _14_0: rt.u64 = rt.u64Add(part as rt.u64, 1); + wideOut.p_1Data = part2; + wideOut.p_1Start = part3; + wideOut.p_1Len = part4; + return _14_0; + } + wideOut.err = err as returns_Error.Error; + return undefined; +} + +/** Two slices, and a reference to an array. */ +export function halves(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 | undefined { + if (dataLen >= 2) { + const mid: number = rt.usizeDiv(dataLen - 2, 2); + if (mid > dataLen - 2) { + rt.panic("mid > len"); + } + halvesOut.p_0Data = dataData; + halvesOut.p_0Start = dataStart + 2; + halvesOut.p_0Len = mid; + halvesOut.p_1Data = dataData; + halvesOut.p_1Start = dataStart; + halvesOut.p_1Len = 2; + halvesOut.p_2Data = dataData; + halvesOut.p_2Start = dataStart + 2 + mid; + halvesOut.p_2Len = dataLen - 2 - mid; + return undefined; + } + return dataLen & 0xff; +} + +export const halvesOut: { p_0Data: Uint8Array; p_0Start: number; p_0Len: number; p_1Data: Uint8Array; p_1Start: number; p_1Len: number; p_2Data: Uint8Array; p_2Start: number; p_2Len: number } = { p_0Data: undefined as never, p_0Start: undefined as never, p_0Len: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never, p_2Data: undefined as never, p_2Start: undefined as never, p_2Len: undefined as never }; + +/** Calls whose results are both held while the slot is written again between them. */ +export function both(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u64 | undefined { + const part: rt.u64 | undefined = narrow(dataData, dataStart, dataLen); + const err: returns_Error.Error | undefined = part === undefined ? wideOut.err as returns_Error.Error : undefined; + const part2: Uint8Array = wideOut.p_1Data; + const part3: number = wideOut.p_1Start; + const part4: number = wideOut.p_1Len; + if (err === undefined) { + const a: rt.u64 = part as rt.u64; + const part5: rt.u64 | undefined = number(part2, part3, part4, rt.u64Rem(a, 2) === 1); + const err2: returns_Error.Error | undefined = part5 === undefined ? wideOut.err as returns_Error.Error : undefined; + const part6: Uint8Array = wideOut.p_1Data; + const part7: number = wideOut.p_1Start; + const part8: number = wideOut.p_1Len; + if (err2 === undefined) { + const b: rt.u64 = part5 as rt.u64; + const err3: returns_Error.Error | undefined = tail(new rt.ByteSlice(part6, part7, part8), rt.u64Low(rt.u64Rem(a, 3))); + const part9: Uint8Array = takeOut.pData; + const part10: number = takeOut.pStart; + const part11: number = takeOut.pLen; + if (err3 === undefined) { + const err4: returns_Error.Error | undefined = take(part9, part10, part11, rt.u64Low(rt.u64Rem(b, 4))); + const part14: number = takeOut.pLen; + if (err4 === undefined) { + bothOut.p_1 = rt.u64Xor(b, part14 as rt.u64); + bothOut.p_2Data = part9; + bothOut.p_2Start = part10; + bothOut.p_2Len = part11; + return a; + } + bothOut.err = err4 as returns_Error.Error; + return undefined; + } + bothOut.err = err3 as returns_Error.Error; + return undefined; + } + bothOut.err = err2 as returns_Error.Error; + return undefined; + } + bothOut.err = err as returns_Error.Error; + return undefined; +} + +export const bothOut: { err: unknown; p_1: rt.u64; p_2Data: Uint8Array; p_2Start: number; p_2Len: number } = { err: undefined, p_1: undefined as never, p_2Data: undefined as never, p_2Start: undefined as never, p_2Len: undefined as never }; + +export function guarded(dataData: Uint8Array, dataStart: number, dataLen: number, other: rt.ByteSlice): rt.u64 | undefined { + const part: rt.u64 | undefined = narrow(dataData, dataStart, dataLen); + const err: returns_Error.Error | undefined = part === undefined ? wideOut.err as returns_Error.Error : undefined; + const part2: Uint8Array = wideOut.p_1Data; + const part3: number = wideOut.p_1Start; + const part4: number = wideOut.p_1Len; + new Guard.Guard(other, dataLen & 0xff)[Symbol.dispose](); + if (err !== undefined) { + wideOut.err = err as returns_Error.Error; + return undefined; + } + wideOut.p_1Data = part2; + wideOut.p_1Start = part3; + wideOut.p_1Len = part4; + return part as rt.u64; +} + +/** Errors that are no single value: `()`, and an `Option`. */ +export function unitErr(dataData: Uint8Array, dataStart: number, dataLen: number): rt.Result { + return option_okOr$0tezn0w(option_map$1yogfym((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, (_22: [rt.u8, rt.ByteSlice]): rt.ByteSlice => { + return _22[1]; + }), undefined); +} + +export function noneErr(data: rt.ByteSlice): rt.Result { + const _2: rt.u8 | undefined = rt.byteSliceFirst(data); + if (_2 !== undefined) { + if (_2 === 0) { + return rt.ERR; + } + if (_2 > 240) { + return rt.Err(_2); + } + } + return option_okOr$0gtm15y(option_map$1yogfym((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, (_22: [rt.u8, rt.ByteSlice]): rt.ByteSlice => { + return _22[1]; + }), undefined as rt.u8 | undefined); +} + +export function lead$u16(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u16 | undefined { + if (dataLen !== 0) { + const _11_0: rt.u16 = dataData[dataStart] as rt.u16; + leadOut$u16.p_1Data = dataData; + leadOut$u16.p_1Start = dataStart + 1; + leadOut$u16.p_1Len = dataLen - 1; + return _11_0; + } + leadOut$u16.err = { tag: "Short", _0: 1 } as returns_Error.Error; + return undefined; +} + +export function lead$u32(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u32 | undefined { + if (dataLen !== 0) { + const _11_0: rt.u32 = dataData[dataStart] as rt.u32; + leadOut$u32.p_1Data = dataData; + leadOut$u32.p_1Start = dataStart + 1; + leadOut$u32.p_1Len = dataLen - 1; + return _11_0; + } + leadOut$u32.err = { tag: "Short", _0: 1 } as returns_Error.Error; + return undefined; +} + +export const leadOut$u16: { err: unknown; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { err: undefined, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; + +export const leadOut$u32: { err: unknown; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { err: undefined, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; + +export function splitWith$returns_At(s: At.At, dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { + return At.split$returns_Split(s, dataData, dataStart, dataLen); +} + +export function push(out: rt.ByteVec, r: rt.Result): void { + if (r.ok) { + rt.byteVecPush(out, r.value.length & 0xff); + rt.byteVecExtendFromSlice(out, rt.byteSliceRange(r.value, 0, rt.min(r.value.length, 4))); + } else { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, returns_Error.code(r.error)))); + } +} + +export function pushNumber(out: rt.ByteVec, r: rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>): void { + if (r.ok) { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(r.value[0]))); + rt.byteVecPush(out, r.value[1].length & 0xff); + } else { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, returns_Error.code(r.error)))); + } +} + +/** A slice that takes no argument. */ +export function fixed(): returns_Error.Error | undefined { + const slice: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(97, 98, 99)); + takeOut.pData = slice.data; + takeOut.pStart = slice.start; + takeOut.pLen = slice.length; + return undefined; +} + +/** Takes `fixed`'s result apart, so it is held as parts. */ +export function afterFixed(_dataData: Uint8Array, _dataStart: number, dataLen: number): returns_Error.Error | undefined { + const err: returns_Error.Error | undefined = fixed(); + const part: Uint8Array = takeOut.pData; + const part2: number = takeOut.pStart; + const part3: number = takeOut.pLen; + if (err === undefined) { + const slice2: rt.ByteSlice = rt.byteSliceRange(new rt.ByteSlice(part, part2, part3), 0, rt.min(dataLen, part3)); + takeOut.pData = slice2.data; + takeOut.pStart = slice2.start; + takeOut.pLen = slice2.length; + return undefined; + } + return err as returns_Error.Error; +} + +/** `?` on a residual whose error is a slice and a byte, converted. */ +export function wrapped(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 | undefined { + let rErr!: boolean; + let r2!: rt.u8; + let r_0Data!: Uint8Array; + let r_0Start!: number; + let r_0Len!: number; + let r_1!: rt.u8; + if (dataLen === 0) { + rErr = true; + r_0Data = dataData; + r_0Start = dataStart; + r_0Len = dataLen; + r_1 = 0; + } else if (!(rt.u8Rem(dataData[dataStart], 2) === 0)) { + const _12_1: rt.u8 = dataData[dataStart]; + rErr = true; + r_0Data = dataData; + r_0Start = dataStart + 1; + r_0Len = dataLen - 1; + r_1 = _12_1; + } else { + const b: rt.u8 = dataData[dataStart]; + rErr = false; + r2 = b; + } + const _15Err: boolean = rErr; + const _152: rt.u8 = r2; + const _15_0Data: Uint8Array = r_0Data; + const _15_0Start: number = r_0Start; + const _15_0Len: number = r_0Len; + const _15_1: rt.u8 = r_1; + if (!_15Err) { + const _19_0: rt.u8 = _152; + wrappedOut.p_1Data = dataData; + wrappedOut.p_1Start = dataStart; + wrappedOut.p_1Len = dataLen; + return _19_0; + } + wrappedOut.err = returns_Wrapped.from$convert_From_tuple2_ref_slice_u8_u8([new rt.ByteSlice(_15_0Data, _15_0Start, _15_0Len), _15_1]); + return undefined; +} + +export const wrappedOut: { err: unknown; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { err: undefined, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; + +export function returns(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + let f!: (a0: rt.ByteSlice) => rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>; + b0: { + const _4: rt.u8 = rt.u8Rem(kind, 7); + if (_4 === 0) { + const err16: returns_Error.Error | undefined = take(data.data, data.start, data.length, rt.usizeRem(kind as rt.usize, 7)); + const part65: Uint8Array = takeOut.pData; + const part66: number = takeOut.pStart; + const part67: number = takeOut.pLen; + push(out, (err16 !== undefined ? rt.Err(err16 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part65, part66, part67))) as rt.Result); + const err17: returns_Error.Error | undefined = take(data.data, data.start, data.length, 201); + const part68: Uint8Array = takeOut.pData; + const part69: number = takeOut.pStart; + const part70: number = takeOut.pLen; + push(out, (err17 !== undefined ? rt.Err(err17 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part68, part69, part70))) as rt.Result); + const err18: returns_Error.Error | undefined = tail(data, 3); + const part71: Uint8Array = takeOut.pData; + const part72: number = takeOut.pStart; + const part73: number = takeOut.pLen; + push(out, (err18 !== undefined ? rt.Err(err18 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part71, part72, part73))) as rt.Result); + const part74: rt.u64 | undefined = number(data.data, data.start, data.length, rt.u8Rem(kind, 2) === 0); + const err19: returns_Error.Error | undefined = part74 === undefined ? wideOut.err as returns_Error.Error : undefined; + const part75: Uint8Array = wideOut.p_1Data; + const part76: number = wideOut.p_1Start; + const part77: number = wideOut.p_1Len; + pushNumber(out, (err19 !== undefined ? rt.Err(err19 as returns_Error.Error) : rt.Ok([part74 as rt.u64, new rt.ByteSlice(part75, part76, part77)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); + const part78: rt.u64 | undefined = count(data.data, data.start, data.length); + const err20: returns_Error.Error | undefined = part78 === undefined ? wideOut.err as returns_Error.Error : undefined; + const part79: Uint8Array = wideOut.p_1Data; + const part80: number = wideOut.p_1Start; + const part81: number = wideOut.p_1Len; + pushNumber(out, (err20 !== undefined ? rt.Err(err20 as returns_Error.Error) : rt.Ok([part78 as rt.u64, new rt.ByteSlice(part79, part80, part81)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); + } else if (_4 === 1) { + const kept: rt.Result[] = rt.iterToArray(rt.iterMap(new rt.Range(0, 4), (n3: rt.usize): rt.Result => { + const err13 = take(data.data, data.start, data.length, rt.usizeMul(n3, 3)); + return err13 !== undefined ? rt.Err(err13 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(takeOut.pData, takeOut.pStart, takeOut.pLen)); + }), undefined, 12, true); + const err14: returns_Error.Error | undefined = tail(data, 1); + const part57: Uint8Array = takeOut.pData; + const part58: number = takeOut.pStart; + const part59: number = takeOut.pLen; + for (const _29 of kept) { + push(out, _29); + } + push(out, (err14 !== undefined ? rt.Err(err14 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part57, part58, part59))) as rt.Result); + const part60: rt.u64 | undefined = both(data.data, data.start, data.length); + const err15: returns_Error.Error | undefined = part60 === undefined ? bothOut.err as returns_Error.Error : undefined; + const part61: rt.u64 = bothOut.p_1; + const part64: number = bothOut.p_2Len; + if (err15 === undefined) { + const a: rt.u64 = part60 as rt.u64; + const b: rt.u64 = part61; + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(a))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(b))); + rt.byteVecPush(out, part64 & 0xff); + } else { + rt.byteVecPush(out, returns_Error.code(err15 as returns_Error.Error)); + } + } else if (_4 === 2) { + if (!(rt.usizeRem(data.length, 2) === 0)) { + f = (a02: rt.ByteSlice): rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> => { + const part51 = narrow(a02.data, a02.start, a02.length); + const result3: rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> = part51 === undefined ? rt.Err(wideOut.err as returns_Error.Error) : rt.Ok([part51, new rt.ByteSlice(wideOut.p_1Data, wideOut.p_1Start, wideOut.p_1Len)] as [rt.u64, rt.ByteSlice]); + return result3; + }; + } else { + f = (a0: rt.ByteSlice): rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> => { + const part50 = wide(a0.data, a0.start, a0.length); + const result2: rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> = part50 === undefined ? rt.Err(wideOut.err as returns_Error.Error) : rt.Ok([part50, new rt.ByteSlice(wideOut.p_1Data, wideOut.p_1Start, wideOut.p_1Len)] as [rt.u64, rt.ByteSlice]); + return result2; + }; + } + pushNumber(out, f(data)); + for (const _71 of rt.iterToArray(rt.iterMap(rt.iterSlice([data, rt.byteSliceRange(data, rt.min(data.length, 3))]), (a03: rt.ByteSlice): rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> => { + const part53 = count(a03.data, a03.start, a03.length); + const result4: rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> = part53 === undefined ? rt.Err(wideOut.err as returns_Error.Error) : rt.Ok([part53, new rt.ByteSlice(wideOut.p_1Data, wideOut.p_1Start, wideOut.p_1Len)] as [rt.u64, rt.ByteSlice]); + return result4; + }), undefined, 16, true)) { + pushNumber(out, _71); + } + rt.iterExtendBytes(out, rt.iterOption(option_map$0c2keyb(option_map$1yogfym((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, (_22: [rt.u8, rt.ByteSlice]): rt.ByteSlice => { + return _22[1]; + }), (s2: rt.ByteSlice): rt.u8 => { + const err12: returns_Error.Error | undefined = tail(s2, 2); + const part54: Uint8Array = takeOut.pData; + const part55: number = takeOut.pStart; + const part56: number = takeOut.pLen; + return result_mapOr$0fbyajt((err12 !== undefined ? rt.Err(err12 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part54, part55, part56))) as rt.Result, 0, (a04: rt.ByteSlice): rt.usize => { + return a04.length; + }) & 0xff; + })), undefined, true); + } else if (_4 === 3) { + const err9: rt.u8 | undefined = halves(data.data, data.start, data.length); + const part35: number = halvesOut.p_0Len; + const part36: Uint8Array = halvesOut.p_1Data; + const part37: number = halvesOut.p_1Start; + const part38: number = halvesOut.p_1Len; + const part39: Uint8Array = halvesOut.p_2Data; + const part40: number = halvesOut.p_2Start; + const part41: number = halvesOut.p_2Len; + if (err9 === undefined) { + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part36, part37, part38)); + rt.byteVecPush(out, part35 & 0xff); + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part39, part40, part41)); + } else { + rt.byteVecPush(out, err9 as rt.u8); + } + const other: Uint8Array = Uint8Array.of(255, 1, 2); + const _96: rt.ByteSlice = rt.byteSliceFrom(other); + const part42: rt.u64 | undefined = guarded(data.data, data.start, data.length, _96); + const err10: returns_Error.Error | undefined = part42 === undefined ? wideOut.err as returns_Error.Error : undefined; + const part43: Uint8Array = wideOut.p_1Data; + const part44: number = wideOut.p_1Start; + const part45: number = wideOut.p_1Len; + pushNumber(out, (err10 !== undefined ? rt.Err(err10 as returns_Error.Error) : rt.Ok([part42 as rt.u64, new rt.ByteSlice(part43, part44, part45)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); + const _100: rt.ByteSlice = rt.byteSliceRange(rt.byteSliceFrom(other), 1); + const part46: rt.u64 | undefined = guarded(data.data, data.start, data.length, _100); + const err11: returns_Error.Error | undefined = part46 === undefined ? wideOut.err as returns_Error.Error : undefined; + const part47: Uint8Array = wideOut.p_1Data; + const part48: number = wideOut.p_1Start; + const part49: number = wideOut.p_1Len; + pushNumber(out, (err11 !== undefined ? rt.Err(err11 as returns_Error.Error) : rt.Ok([part46 as rt.u64, new rt.ByteSlice(part47, part48, part49)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); + } else if (_4 === 4) { + const _104: rt.Result = unitErr(data.data, data.start, data.length); + if (_104.ok) { + rt.byteVecPush(out, _104.value.length & 0xff); + } else { + rt.byteVecPush(out, 238); + } + const _110: rt.Result = noneErr(data); + if (_110.ok) { + rt.byteVecPush(out, _110.value.length & 0xff); + } else { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, option_unwrapOr$0r2bmpr(_110.error, 0)))); + } + const part24: rt.u16 | undefined = lead$u16(data.data, data.start, data.length); + const err7: returns_Error.Error | undefined = part24 === undefined ? leadOut$u16.err as returns_Error.Error : undefined; + const part25: Uint8Array = leadOut$u16.p_1Data; + const part26: number = leadOut$u16.p_1Start; + const part27: number = leadOut$u16.p_1Len; + const _123: rt.ByteSlice = rt.byteSliceRange(data, rt.min(data.length, 1)); + const part29: rt.u32 | undefined = lead$u32(_123.data, _123.start, _123.length); + const err8: returns_Error.Error | undefined = part29 === undefined ? leadOut$u32.err as returns_Error.Error : undefined; + const part30: Uint8Array = leadOut$u32.p_1Data; + const part31: number = leadOut$u32.p_1Start; + const part32: number = leadOut$u32.p_1Len; + if (err7 === undefined) { + if (err8 === undefined) { + const a3: rt.u16 = part24 as rt.u16; + const b3: rt.u32 = part29 as rt.u32; + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(a3))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(b3))); + rt.byteVecPush(out, part32 & 0xff); + break b0; + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(((err7 !== undefined ? rt.Err(err7 as returns_Error.Error) : rt.Ok([part24 as rt.u16, new rt.ByteSlice(part25, part26, part27)] as [rt.u16, rt.ByteSlice])) as rt.Result<[rt.u16, rt.ByteSlice], returns_Error.Error>).ok ? 1 : 0, ((err8 !== undefined ? rt.Err(err8 as returns_Error.Error) : rt.Ok([part29 as rt.u32, new rt.ByteSlice(part30, part31, part32)] as [rt.u32, rt.ByteSlice])) as rt.Result<[rt.u32, rt.ByteSlice], returns_Error.Error>).ok ? 1 : 0))); + } else if (_4 === 5) { + const err5: returns_Error.Error | undefined = afterFixed(data.data, data.start, data.length); + const part17: Uint8Array = takeOut.pData; + const part18: number = takeOut.pStart; + const part19: number = takeOut.pLen; + if (err5 === undefined) { + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part17, part18, part19)); + } else { + rt.byteVecPush(out, returns_Error.code(err5 as returns_Error.Error)); + } + const part20: rt.u8 | undefined = wrapped(data.data, data.start, data.length); + const err6: returns_Wrapped.Wrapped | undefined = part20 === undefined ? wrappedOut.err as returns_Wrapped.Wrapped : undefined; + const part23: number = wrappedOut.p_1Len; + if (err6 === undefined) { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(part20 as rt.u8, part23 & 0xff))); + } else { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, (err6 as returns_Wrapped.Wrapped)._0, (err6 as returns_Wrapped.Wrapped)._1))); + } + } else { + const at: At.At = { _0: rt.usizeRem(kind as rt.usize, 5) }; + const err: returns_Error.Error | undefined = splitWith$returns_At(at, data.data, data.start, data.length); + const part3: number = At.splitOut$returns_Split.p_0Len; + const part6: number = At.splitOut$returns_Split.p_1Len; + if (err === undefined) { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(part3 & 0xff, part6 & 0xff))); + } else { + rt.byteVecPush(out, returns_Error.code(err as returns_Error.Error)); + } + const _196: rt.Result<[rt.ByteSlice, rt.ByteSlice], returns_Error.Error> = new Split.of$returns_At(at).split$Split(data); + if (_196.ok) { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_196.value[1].length & 0xff, _196.value[0].length & 0xff))); + } else { + rt.byteVecPush(out, returns_Error.code(_196.error)); + } + const err2: returns_Error.Error | undefined = At.split$returns_Split(at, data.data, data.start, data.length); + const part7: Uint8Array = At.splitOut$returns_Split.p_0Data; + const part8: number = At.splitOut$returns_Split.p_0Start; + const part9: number = At.splitOut$returns_Split.p_0Len; + const part10: Uint8Array = At.splitOut$returns_Split.p_1Data; + const part11: number = At.splitOut$returns_Split.p_1Start; + const part12: number = At.splitOut$returns_Split.p_1Len; + const _210: rt.Result = result_andThen$1yropo4((err2 !== undefined ? rt.Err(err2 as returns_Error.Error) : rt.Ok([new rt.ByteSlice(part7, part8, part9), new rt.ByteSlice(part10, part11, part12)] as [rt.ByteSlice, rt.ByteSlice])) as rt.Result<[rt.ByteSlice, rt.ByteSlice], returns_Error.Error>, (_2: [rt.ByteSlice, rt.ByteSlice]): rt.Result => { + const err3 = take(_2[1].data, _2[1].start, _2[1].length, _2[0].length); + return err3 !== undefined ? rt.Err(err3 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(takeOut.pData, takeOut.pStart, takeOut.pLen)); + }); + if (_210.ok) { + rt.byteVecPush(out, _210.value.length & 0xff); + } else { + rt.byteVecPush(out, returns_Error.code(_210.error)); + } + let restData4: Uint8Array = data.data; + let restStart4: number = data.start; + let restLen4: number = data.length; + let sum: rt.u64 = 0; + while (true) { + const part13: rt.u64 | undefined = narrow(restData4, restStart4, restLen4); + const err4: returns_Error.Error | undefined = part13 === undefined ? wideOut.err as returns_Error.Error : undefined; + const part14: Uint8Array = wideOut.p_1Data; + const part15: number = wideOut.p_1Start; + const part16: number = wideOut.p_1Len; + if (err4 === undefined) { + sum = rt.u64WrappingAdd(rt.u64WrappingMul(sum, 31), part13 as rt.u64); + restData4 = part14; + restStart4 = part15; + restLen4 = part16; + } else { + break; + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(sum))); + } + } +} + +//# sourceMappingURL=returns.ts.map diff --git a/ts/fixtures/lang/expected/shapes.ts b/ts/fixtures/lang/expected/shapes.ts index 9916540d2..25348fb65 100644 --- a/ts/fixtures/lang/expected/shapes.ts +++ b/ts/fixtures/lang/expected/shapes.ts @@ -77,10 +77,10 @@ export function dir(byte: rt.u8): shapes_Dir.Dir | undefined { return undefined; } -export function shape(data: rt.ByteSlice): shapes_Shape.Shape { - if (data.length !== 0) { - const kind: rt.u8 = data.data[data.start]; - const rest: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + 1, data.length - 1); +export function shape(dataData: Uint8Array, dataStart: number, dataLen: number): shapes_Shape.Shape { + if (dataLen !== 0) { + const kind: rt.u8 = dataData[dataStart]; + const rest: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); const at: (a0: rt.usize) => rt.i32 = (i: rt.usize): rt.i32 => { return rt.i32Sub(option_unwrapOr$0r2bmpr(rt.byteSliceGet(rest, i), 0) as rt.i32, 128); }; @@ -203,7 +203,7 @@ export function copies(data: rt.ByteSlice, out: rt.ByteVec): void { const err: Point.Point = copy$shapes_Point(rt.resultUnwrapErr(fail, rt.u8Debug)); err.y = 3; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(first.x & 0xff, rt.resultUnwrap(res, rt.u8Debug).x & 0xff, err.y & 0xff, rt.resultUnwrapErr(fail, rt.u8Debug).y & 0xff))); - const shape_: shapes_Shape.Shape = copy$shapes_Shape(shape(data)); + const shape_: shapes_Shape.Shape = copy$shapes_Shape(shape(data.data, data.start, data.length)); const before: shapes_Shape.Shape = copy$shapes_Shape(shape_); if (shape_.tag !== "Dot") { if (shape_.tag === "Line") { @@ -258,15 +258,15 @@ export function copies(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, _300); } shares(data, out); - unwritten(data, out); + unwritten(data.data, data.start, data.length, out); } /** * `Copy` aggregates written into only in another module, behind a type parameter, or * through a box. Each copy keeps its value. */ -export function unwritten(data: rt.ByteSlice, out: rt.ByteVec): void { - const n: rt.u8 = data.length & 0xff; +export function unwritten(_dataData: Uint8Array, _dataStart: number, dataLen: number, out: rt.ByteVec): void { + const n: rt.u8 = dataLen & 0xff; const track: Track.Track = { mark: { at: n } }; const seen: Mark.Mark = Track.mark(track); advance(track); @@ -858,12 +858,12 @@ export function loops(data: rt.ByteSlice, out: rt.ByteVec): void { while ((_136 = iterStart4++) < iterEnd4) { rt.byteVecPush(out, _136 & 0xff); } - rt.byteVecPush(out, firstRepeat(data)); + rt.byteVecPush(out, firstRepeat(data.data, data.start, data.length)); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(tailBreak(data)))); rt.byteVecPush(out, armLoop(data)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(position$u8(data, 0) as rt.u32))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(position$u8(data.data, data.start, data.length, 0) as rt.u32))); rt.byteVecPush(out, _158(rt.u8Mul(data.length & 0xff, 7))); - drain(data, out); + drain(data.data, data.start, data.length, out); rt.byteVecPush(out, returnedLoop(data)); branchLoops(data, out); diverging(data, out); @@ -884,10 +884,10 @@ export function diverging(data: rt.ByteSlice, out: rt.ByteVec): void { const head: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(data.length, 2)); const b: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(head), 0); rt.byteVecPush(out, returnedNever(b, data.length)); - rt.byteVecPush(out, brokenNever(head)); + rt.byteVecPush(out, brokenNever(head.data, head.start, head.length)); rt.byteVecPush(out, _15(b)); - rt.byteVecPush(out, guardedReturn(head)); - rt.byteVecPush(out, boundNever(head, out)); + rt.byteVecPush(out, guardedReturn(head.data, head.start, head.length)); + rt.byteVecPush(out, boundNever(head.data, head.start, head.length, out)); rt.byteVecPush(out, closureNever(b)); genericNever(b, data.length); } @@ -993,17 +993,17 @@ export function returnedNever(b: rt.u8, len: rt.usize): rt.u8 { } /** A `return` of a `match` that guards, whose arms fall through to the next. */ -export function guardedReturn(data: rt.ByteSlice): rt.u8 { - if (!((data.length === 0))) { - if (data.length === 2) { - const a: rt.u8 = data.data[data.start]; - const b: rt.u8 = data.data[data.start + 1]; +export function guardedReturn(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { + if (!((dataLen === 0))) { + if (dataLen === 2) { + const a: rt.u8 = dataData[dataStart]; + const b: rt.u8 = dataData[dataStart + 1]; if (a > b) { return rt.u8Sub(a, b); } } - if (data.length >= 1) { - if (data.data[data.start] > 128) { + if (dataLen >= 1) { + if (dataData[dataStart] > 128) { return 1; } } @@ -1013,19 +1013,23 @@ export function guardedReturn(data: rt.ByteSlice): rt.u8 { } /** A loop ending the function, left by `break` with values that never exist. */ -export function brokenNever(data: rt.ByteSlice): rt.u8 { +export function brokenNever(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { let i: rt.usize = 0; - while (!(i >= data.length)) { + while (!(i >= dataLen)) { const _6: rt.usize = i; - rt.idx(data, _6); - const value = data.data[data.start + _6]; + if (_6 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _6); + } + const value = dataData[dataStart + _6]; if (value === 251) { const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(i, f)]; rt.panicFmt(["broken at ", args2[0]]); } else if (value === 252) { const _19: rt.usize = i; - rt.idx(data, _19); - bail(data.data[data.start + _19]); + if (_19 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _19); + } + bail(dataData[dataStart + _19]); } else { if (value === 0) { return i & 0xff; @@ -1040,19 +1044,23 @@ export function brokenNever(data: rt.ByteSlice): 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: rt.ByteSlice, _out: rt.ByteVec): rt.u8 { +export function boundNever(dataData: Uint8Array, dataStart: number, dataLen: number, _out: rt.ByteVec): rt.u8 { let i: rt.usize = 0; - while (!(i >= data.length)) { + while (!(i >= dataLen)) { const _8: rt.usize = i; - rt.idx(data, _8); - const value = data.data[data.start + _8]; + if (_8 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _8); + } + const value = dataData[dataStart + _8]; if (value === 239) { const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(i, f)]; rt.panicFmt(["bound at ", args2[0]]); } else if (value === 240) { const _22: rt.usize = i; - rt.idx(data, _22); - bail(data.data[data.start + _22]); + if (_22 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _22); + } + bail(dataData[dataStart + _22]); } else { if (value === 0) { return i & 0xff; @@ -1060,10 +1068,12 @@ export function boundNever(data: rt.ByteSlice, _out: rt.ByteVec): rt.u8 { if (value === 128) { while (true) { i = rt.usizeAdd(i, 1); - if (!(i >= data.length)) { + if (!(i >= dataLen)) { const _32: rt.usize = i; - rt.idx(data, _32); - if (data.data[data.start + _32] < 128) { + if (_32 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _32); + } + if (dataData[dataStart + _32] < 128) { break; } } else { @@ -1139,25 +1149,33 @@ export function returnedLoop(data: rt.ByteSlice): rt.u8 { } /** A loop that ends the function, left only by `return` from nested scopes. */ -export function firstRepeat(data: rt.ByteSlice): rt.u8 { +export function firstRepeat(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { let i: rt.usize = 0; - l2: while (!(i >= data.length)) { + l2: while (!(i >= dataLen)) { let j: rt.usize = rt.usizeAdd(i, 1); - while (j < data.length) { + while (j < dataLen) { const _14: rt.usize = j; - rt.idx(data, _14); - if (!(data.data[data.start + _14] === 0)) { + if (_14 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _14); + } + if (!(dataData[dataStart + _14] === 0)) { const _21: rt.usize = i; - rt.idx(data, _21); - const _20: rt.u8 = data.data[data.start + _21]; + if (_21 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _21); + } + const _20: rt.u8 = dataData[dataStart + _21]; const _25: rt.usize = j; - rt.idx(data, _25); - if (!(_20 === data.data[data.start + _25])) { + if (_25 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _25); + } + if (!(_20 === dataData[dataStart + _25])) { j = rt.usizeAdd(j, 1); } else { const _29: rt.usize = j; - rt.idx(data, _29); - return data.data[data.start + _29] ^ (i & 0xff); + if (_29 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _29); + } + return dataData[dataStart + _29] ^ (i & 0xff); } } else { i = rt.usizeAdd(j, 1); @@ -1242,13 +1260,15 @@ export function armLoop(data: rt.ByteSlice): rt.u8 { } /** A generic function ending in a loop. */ -export function position$u8(items: rt.ByteSlice, want: rt.u8): rt.usize { +export function position$u8(itemsData: Uint8Array, itemsStart: number, itemsLen: number, want: rt.u8): rt.usize { let i: rt.usize = 0; while (true) { - if (!(i === items.length)) { + if (!(i === itemsLen)) { const _9: rt.usize = i; - rt.idx(items, _9); - if (!((items.data[items.start + _9] === want))) { + if (_9 >= itemsLen) { + rt.panic("index out of bounds: the len is " + itemsLen + " but the index is " + _9); + } + if (!((itemsData[itemsStart + _9] === want))) { i = rt.usizeAdd(i, 1); } else { return i; @@ -1260,12 +1280,14 @@ export function position$u8(items: rt.ByteSlice, want: rt.u8): rt.usize { } /** A unit function ending in a loop. */ -export function drain(data: rt.ByteSlice, out: rt.ByteVec): void { +export function drain(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let i: rt.usize = 0; - while (!(i >= data.length)) { + while (!(i >= dataLen)) { const _10: rt.usize = i; - rt.idx(data, _10); - rt.byteVecPush(out, data.data[data.start + _10] ^ 90); + if (_10 >= dataLen) { + rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _10); + } + rt.byteVecPush(out, dataData[dataStart + _10] ^ 90); i = rt.usizeAdd(i, 2); } } @@ -1336,7 +1358,7 @@ export function patterns(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecPush(out, 238); } - const shape_: shapes_Shape.Shape = shape(data); + const shape_: shapes_Shape.Shape = shape(data.data, data.start, data.length); b8: { if (shape_.tag !== "Dot") { if (shape_.tag === "Line") { @@ -1379,8 +1401,8 @@ export function patterns(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(a2, (parsed as { ok: true; value: rt.u8 }).value, (parsed as { ok: true; value: rt.u8 }).value, early(a2)))); const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(parsed, f, rt.u8Debug, (value: Void.Void, f: rt.Formatter) => Void.fmt$fmt_Debug(value, f))]; rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); - payloads(data, out); - known(data, out); + payloads(data.data, data.start, data.length, out); + known(data.data, data.start, data.length, out); rematched(data, out); } @@ -1396,7 +1418,7 @@ export function parity(n: rt.u8): rt.Result { * Payloads changed through a borrow, which changes the enum holding them where it is * and none of its copies. */ -export function payloads(data: rt.ByteSlice, out: rt.ByteVec): void { +export function payloads(_dataData: Uint8Array, _dataStart: number, dataLen: number, out: rt.ByteVec): void { let _86!: rt.u8; let _104!: rt.u8; let _109!: rt.u8; @@ -1404,7 +1426,7 @@ export function payloads(data: rt.ByteSlice, out: rt.ByteVec): void { let _133!: rt.u8; let _143!: rt.u8; let _149!: rt.u8; - const n: rt.u8 = data.length & 0xff; + const n: rt.u8 = dataLen & 0xff; let res: rt.Result = parity(n); const before: rt.Result = res; if (!res.ok) { @@ -1528,7 +1550,7 @@ export function payloads(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Enums matched where the variant they were made with is in sight. */ -export function known(data: rt.ByteSlice, out: rt.ByteVec): void { +export function known(_dataData: Uint8Array, _dataStart: number, dataLen: number, out: rt.ByteVec): void { let _15!: rt.u8; let _18!: rt.u8; let _21!: rt.u8; @@ -1538,7 +1560,7 @@ export function known(data: rt.ByteSlice, out: rt.ByteVec): void { let _45!: rt.u8; let _52!: rt.u8; let _56!: rt.u8; - const n: rt.u8 = data.length & 0xff; + const n: rt.u8 = dataLen & 0xff; const ready = n as rt.Poll; const idle = rt.Pending as rt.Poll; const none = undefined as Point.Point | undefined; @@ -1647,7 +1669,7 @@ export function rematched(data: rt.ByteSlice, out: rt.ByteVec): void { let lift!: rt.u8; let _206!: rt.u8; let _226!: rt.u8; - const s: shapes_Shape.Shape = shape(data); + const s: shapes_Shape.Shape = shape(data.data, data.start, data.length); if (s.tag === "Dot") { _5 = 2; } else if (s.tag === "Line") { @@ -1735,7 +1757,8 @@ export function rematched(data: rt.ByteSlice, out: rt.ByteVec): void { } let m: shapes_Shape.Shape = s; if (m.tag === "Dot") { - m = shape(rt.byteSliceRange(data, rt.min(data.length, 1))); + const _110: rt.ByteSlice = rt.byteSliceRange(data, rt.min(data.length, 1)); + m = shape(_110.data, _110.start, _110.length); if (m.tag === "Line") { _107 = 18; } else { @@ -1792,9 +1815,10 @@ export function rematched(data: rt.ByteSlice, out: rt.ByteVec): void { while (iterStart3++ < iterEnd3) { rt.byteVecPush(out, Filled.run(filled)); } - let original: shapes_Shape.Shape = shape(data); + let original: shapes_Shape.Shape = shape(data.data, data.start, data.length); if (original.tag === "Dot") { - original = shape(rt.byteSliceFrom(Uint8Array.of(1))); + const _183: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(1)); + original = shape(_183.data, _183.start, _183.length); rt.byteVecPush(out, 24); if (original.tag === "Line") { _189 = 25; @@ -1842,7 +1866,8 @@ export function rematched(data: rt.ByteSlice, out: rt.ByteVec): void { break b31; } if (w.tag === "Dot") { - w = shape(rt.byteSliceFrom(Uint8Array.of(1))); + const _229: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(1)); + w = shape(_229.data, _229.start, _229.length); _226 = 56; } else if (w.tag === "Line") { _226 = 57; @@ -1854,7 +1879,7 @@ export function rematched(data: rt.ByteSlice, out: rt.ByteVec): void { } } } - reseated(data, out); + reseated(data.data, data.start, data.length, out); decidedByBool(data, out); } @@ -1876,7 +1901,7 @@ export function decidedByBool(data: rt.ByteSlice, out: rt.ByteVec): void { let _105!: rt.u8; let _111!: rt.u8; let _113!: boolean; - const s: shapes_Shape.Shape = shape(data); + const s: shapes_Shape.Shape = shape(data.data, data.start, data.length); if (s.tag === "Dot") { _4 = true; } else { @@ -1941,7 +1966,8 @@ export function decidedByBool(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecPush(out, _61); } - const t: shapes_Shape.Shape = shape(rt.byteSliceRange(data, rt.min(data.length, 1))); + const _64: rt.ByteSlice = rt.byteSliceRange(data, rt.min(data.length, 1)); + const t: shapes_Shape.Shape = shape(_64.data, _64.start, _64.length); if (t.tag === "Rect") { if (shapes_Shape.eq$cmp_PartialEq(s, t)) { rt.byteVecPush(out, (((s as shapes_Shape.Shape) as { tag: "Rect"; corner: Point.Point; width: rt.u16; height: rt.u16 }).width & 0xff) ^ 75); @@ -2015,7 +2041,8 @@ export function decidedByBool(data: rt.ByteSlice, out: rt.ByteVec): void { _113 = false; } wasDot = _113; - cur = shape(rt.byteSliceFrom(Uint8Array.of(i, i))); + const _116: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(i, i)); + cur = shape(_116.data, _116.start, _116.length); } } @@ -2023,13 +2050,14 @@ export function decidedByBool(data: rt.ByteSlice, out: rt.ByteVec): void { * A reference pointed elsewhere without an assignment to it: through a `&mut` to it, * a reborrow of that, a closure, and a call. */ -export function reseated(data: rt.ByteSlice, out: rt.ByteVec): void { +export function reseated(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let _12!: rt.u8; let _19!: rt.u8; let _26!: rt.u8; let _37!: rt.u8; let _51!: rt.u8; - const _5: [shapes_Shape.Shape, shapes_Shape.Shape] = [shape(data), shape(rt.byteSliceFrom(Uint8Array.of(1)))]; + const _8: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(1)); + const _5: [shapes_Shape.Shape, shapes_Shape.Shape] = [shape(dataData, dataStart, dataLen), shape(_8.data, _8.start, _8.length)]; const a: shapes_Shape.Shape = _5[0]; const b: shapes_Shape.Shape = _5[1]; let r: shapes_Shape.Shape = a; diff --git a/ts/fixtures/lang/expected/splits.ts b/ts/fixtures/lang/expected/splits.ts index b15191c96..271f3df78 100644 --- a/ts/fixtures/lang/expected/splits.ts +++ b/ts/fixtures/lang/expected/splits.ts @@ -1,27 +1,36 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$11e0ggl as option_mapOr$11e0ggl, okOr$0q0ogpn as option_okOr$0q0ogpn, okOr$1np0z7r as option_okOr$1np0z7r } from "./core/option.ts"; +import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$11e0ggl as option_mapOr$11e0ggl, okOr$0q0ogpn as option_okOr$0q0ogpn } from "./core/option.ts"; +import * as At from "./returns.At.ts"; import type * as Short from "./splits.Short.ts"; /** The first byte, then a big-endian `u16`, by `?` on `ok_or`. */ -export function header(data: rt.ByteSlice): rt.Result<[rt.u8, rt.u16, rt.ByteSlice], Short.Short> { - if (data.length !== 0) { - const a: rt.u8 = data.data[data.start]; - if (data.length - 1 >= 2) { - return rt.Ok([a, (data.data[data.start + 1] << 8) | data.data[data.start + 2], new rt.ByteSlice(data.data, data.start + 3, data.length - 3)] as [rt.u8, rt.u16, rt.ByteSlice]); +export function header(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 | undefined { + if (dataLen !== 0) { + const a: rt.u8 = dataData[dataStart]; + if (dataLen - 1 >= 2) { + headerOut.p_1 = (dataData[dataStart + 1] << 8) | dataData[dataStart + 2]; + headerOut.p_2Data = dataData; + headerOut.p_2Start = dataStart + 3; + headerOut.p_2Len = dataLen - 3; + return a; } - return rt.Err({ tag: "Need", _0: 2 } as Short.Short); + headerOut.err = { tag: "Need", _0: 2 } as Short.Short; + return undefined; } - return rt.Err({ tag: "Empty" } as Short.Short); + headerOut.err = { tag: "Empty" } as Short.Short; + return undefined; } +export const headerOut: { err: unknown; p_1: rt.u16; p_2Data: Uint8Array; p_2Start: number; p_2Len: number } = { err: undefined, p_1: undefined as never, p_2Data: undefined as never, p_2Start: undefined as never, p_2Len: undefined as never }; + /** Two bytes, by `?` on an `Option`. */ -export function two(data: rt.ByteSlice): [rt.u8, rt.u8, rt.ByteSlice] | undefined { - if (data.length !== 0) { - const a: rt.u8 = data.data[data.start]; - if (data.length - 1 !== 0) { - return [a, data.data[data.start + 1], new rt.ByteSlice(data.data, data.start + 2, data.length - 2)] as [rt.u8, rt.u8, rt.ByteSlice]; +export function two(dataData: Uint8Array, dataStart: number, dataLen: number): [rt.u8, rt.u8, rt.ByteSlice] | undefined { + if (dataLen !== 0) { + const a: rt.u8 = dataData[dataStart]; + if (dataLen - 1 !== 0) { + return [a, dataData[dataStart + 1], new rt.ByteSlice(dataData, dataStart + 2, dataLen - 2)] as [rt.u8, rt.u8, rt.ByteSlice]; } return undefined; } @@ -29,13 +38,22 @@ export function two(data: rt.ByteSlice): [rt.u8, rt.u8, rt.ByteSlice] | undefine } /** `n` bytes, or how many it needed. */ -export function take(data: rt.ByteSlice, n: rt.usize): rt.Result<[rt.ByteSlice, rt.ByteSlice], Short.Short> { - return option_okOr$1np0z7r((n <= data.length ? [new rt.ByteSlice(data.data, data.start, n), new rt.ByteSlice(data.data, data.start + n, data.length - n)] as [rt.ByteSlice, rt.ByteSlice] : undefined) as [rt.ByteSlice, rt.ByteSlice] | undefined, { tag: "Need", _0: n } as Short.Short); +export function take(dataData: Uint8Array, dataStart: number, dataLen: number, n: rt.usize): Short.Short | undefined { + if (!(n <= dataLen)) { + return { tag: "Need", _0: n } as Short.Short; + } + At.splitOut$returns_Split.p_0Data = dataData; + At.splitOut$returns_Split.p_0Start = dataStart; + At.splitOut$returns_Split.p_0Len = n; + At.splitOut$returns_Split.p_1Data = dataData; + At.splitOut$returns_Split.p_1Start = dataStart + n; + At.splitOut$returns_Split.p_1Len = dataLen - n; + return undefined; } /** The byte after the first, or an error that is itself an enum, held whole. */ -export function second(data: rt.ByteSlice, e: rt.u8 | undefined): rt.Result { - const _4: rt.Result<[rt.ByteSlice, rt.ByteSlice], rt.u8 | undefined> = option_okOr$0q0ogpn((1 <= data.length ? [new rt.ByteSlice(data.data, data.start, 1), new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.ByteSlice, rt.ByteSlice] : undefined) as [rt.ByteSlice, rt.ByteSlice] | undefined, e); +export function second(dataData: Uint8Array, dataStart: number, dataLen: number, e: rt.u8 | undefined): rt.Result { + const _4: rt.Result<[rt.ByteSlice, rt.ByteSlice], rt.u8 | undefined> = option_okOr$0q0ogpn((1 <= dataLen ? [new rt.ByteSlice(dataData, dataStart, 1), new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.ByteSlice, rt.ByteSlice] : undefined) as [rt.ByteSlice, rt.ByteSlice] | undefined, e); if (_4.ok) { return rt.Ok(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(_4.value[1]), 0)); } @@ -92,17 +110,22 @@ export function splits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, mid4 & 0xff); rt.byteVecExtendFromSlice(out, new rt.ByteSlice(data.data, data.start + mid4, data.length - mid4)); } else if (_4 === 2) { - const _33: rt.Result<[rt.u8, rt.u16, rt.ByteSlice], Short.Short> = header(data); - if (_33.ok) { - const a2: rt.u8 = _33.value[0]; - const b3: rt.u16 = _33.value[1]; + const part7: rt.u8 | undefined = header(data.data, data.start, data.length); + const err3: Short.Short | undefined = part7 === undefined ? headerOut.err as Short.Short : undefined; + const part8: rt.u16 = headerOut.p_1; + const part9: Uint8Array = headerOut.p_2Data; + const part10: number = headerOut.p_2Start; + const part11: number = headerOut.p_2Len; + if (err3 === undefined) { + const a2: rt.u8 = part7 as rt.u8; + const b3: rt.u16 = part8; rt.byteVecPush(out, a2); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(b3))); - rt.byteVecPush(out, opaque(_33.value[2])); - } else if (_33.error.tag === "Empty") { + rt.byteVecPush(out, opaque(new rt.ByteSlice(part9, part10, part11))); + } else if ((err3 as Short.Short).tag === "Empty") { rt.byteVecPush(out, 240); } else { - rt.byteVecPush(out, 241 ^ (_33.error._0 & 0xff)); + rt.byteVecPush(out, 241 ^ (((err3 as Short.Short) as { tag: "Need"; _0: rt.usize })._0 & 0xff)); } } else if (_4 === 3) { const mid3: number = rt.usizeDiv(data.length, 2); @@ -172,17 +195,18 @@ export function splits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, a3.length & 0xff); rt.byteVecPush(out, opaque(b4)); } else if (_4 === 5) { - let rest2: rt.ByteSlice = data; + let rest3: rt.ByteSlice = data; while (true) { - const _124: [rt.u8, rt.u8, rt.ByteSlice] | undefined = two(rest2); + const _125: rt.ByteSlice = rest3; + const _124: [rt.u8, rt.u8, rt.ByteSlice] | undefined = two(_125.data, _125.start, _125.length); if (_124 !== undefined) { rt.byteVecPush(out, _124[0] ^ _124[1]); - rest2 = _124[2]; + rest3 = _124[2]; } else { break; } } - rt.byteVecPush(out, rest2.length & 0xff); + rt.byteVecPush(out, rest3.length & 0xff); } else if (_4 === 6) { const split: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.byteSliceSplitAtChecked(data, 4); b5: { @@ -198,12 +222,16 @@ export function splits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return _2[0].data[_2[0].start + 3] ^ (_2[1].length & 0xff); })); } - const _159: rt.Result<[rt.ByteSlice, rt.ByteSlice], Short.Short> = take(data, 3); - if (_159.ok) { - rt.byteVecPush(out, opaque(_159.value[0])); - rt.byteVecPush(out, _159.value[1].length & 0xff); + const err2: Short.Short | undefined = take(data.data, data.start, data.length, 3); + const part: Uint8Array = At.splitOut$returns_Split.p_0Data; + const part2: number = At.splitOut$returns_Split.p_0Start; + const part3: number = At.splitOut$returns_Split.p_0Len; + const part6: number = At.splitOut$returns_Split.p_1Len; + if (err2 === undefined) { + rt.byteVecPush(out, opaque(new rt.ByteSlice(part, part2, part3))); + rt.byteVecPush(out, part6 & 0xff); } else { - const e: Short.Short = _159.error; + const e: Short.Short = err2 as Short.Short; if (e.tag === "Empty") { _169 = 0; } else { @@ -232,7 +260,7 @@ export function splits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else { rt.byteVecPush(out, 225 ^ (_1902._0 & 0xff)); } - const _200: rt.Result = second(data, rt.byteSliceFirst(data)); + const _200: rt.Result = second(data.data, data.start, data.length, rt.byteSliceFirst(data)); if (_200.ok) { rt.byteVecPush(out, _200.value); } else if (_200.error === undefined) { diff --git a/ts/fixtures/lang/expected/statics.ts b/ts/fixtures/lang/expected/statics.ts index 236f014e8..ce829adac 100644 --- a/ts/fixtures/lang/expected/statics.ts +++ b/ts/fixtures/lang/expected/statics.ts @@ -97,7 +97,7 @@ export function next(reset: boolean): rt.u8 { export const NEXT$next: rt.Atomic = /* @__PURE__ */ new rt.Atomic(1); -export const COUNTER: Counter.Counter = /* @__PURE__ */ { name: "hits", hits: new rt.Atomic(4294967294), limit: 3, steps: Uint8Array.of(1, 2, 4), state: [9, 122] }; +export const COUNTER: Counter.Counter = { name: "hits", hits: new rt.Atomic(4294967294), limit: 3, steps: Uint8Array.of(1, 2, 4), state: [9, 122] }; export const SHARED: rt.LazyCell> = /* @__PURE__ */ new rt.LazyCell((): rt.Atomic => { return LATER; diff --git a/ts/fixtures/lang/expected/strs.ts b/ts/fixtures/lang/expected/strs.ts index 8f0b26ea8..9c8642c4b 100644 --- a/ts/fixtures/lang/expected/strs.ts +++ b/ts/fixtures/lang/expected/strs.ts @@ -2,9 +2,9 @@ import * as rt from "./rt.ts"; import { then$0havnzo } from "./core/bool.ts"; -import { fromStr$1d7pnbk as nonzero_fromStr$1d7pnbk, fromStrRadix$1ae2pnm as nonzero_fromStrRadix$1ae2pnm, fromStr$15isx69 as nonzero_fromStr$15isx69, fromStrRadix$1mr00o6 as nonzero_fromStrRadix$1mr00o6, fromStr$04uijf8 as nonzero_fromStr$04uijf8, fromStrRadix$1wqmb68 as nonzero_fromStrRadix$1wqmb68, fromStr$0l2zu9x as nonzero_fromStr$0l2zu9x, fromStrRadix$0cd0jvv as nonzero_fromStrRadix$0cd0jvv, fromStr$0h0ptos as nonzero_fromStr$0h0ptos, fromStrRadix$10vntu7 as nonzero_fromStrRadix$10vntu7, fromStr$10svit2 as nonzero_fromStr$10svit2, fromStrRadix$0wc95fw as nonzero_fromStrRadix$0wc95fw, fromStr$19kbj04 as nonzero_fromStr$19kbj04, fromStrRadix$1o9c7gd as nonzero_fromStrRadix$1o9c7gd, fromStr$0br814e as nonzero_fromStr$0br814e, fromStrRadix$188cokx as nonzero_fromStrRadix$188cokx, fromStr$1471qz1 as nonzero_fromStr$1471qz1, fromStrRadix$0l5ymb0 as nonzero_fromStrRadix$0l5ymb0, fromStr$0k8sfhf as nonzero_fromStr$0k8sfhf, fromStrRadix$0fpnm5c as nonzero_fromStrRadix$0fpnm5c, fromStr$0b2xa80 as nonzero_fromStr$0b2xa80, fromStrRadix$1095n8m as nonzero_fromStrRadix$1095n8m, fromStr$17dd66m as nonzero_fromStr$17dd66m, fromStrRadix$1yrk04t as nonzero_fromStrRadix$1yrk04t } from "./core/num/nonzero.ts"; +import { fromStr$0evev4b as nonzero_fromStr$0evev4b, fromStrRadix$1dc3cul as nonzero_fromStrRadix$1dc3cul, fromStr$1lm2uzl as nonzero_fromStr$1lm2uzl, fromStrRadix$1cv6o7i as nonzero_fromStrRadix$1cv6o7i, fromStr$0gvyqp3 as nonzero_fromStr$0gvyqp3, fromStrRadix$18imw6k as nonzero_fromStrRadix$18imw6k, fromStr$19lq810 as nonzero_fromStr$19lq810, fromStrRadix$1u3fi38 as nonzero_fromStrRadix$1u3fi38, fromStr$1lyc2jq as nonzero_fromStr$1lyc2jq, fromStrRadix$0yvapq5 as nonzero_fromStrRadix$0yvapq5, fromStr$06k4xxy as nonzero_fromStr$06k4xxy, fromStrRadix$0rmwudb as nonzero_fromStrRadix$0rmwudb, fromStr$0xht6mx as nonzero_fromStr$0xht6mx, fromStrRadix$0qjnxek as nonzero_fromStrRadix$0qjnxek, fromStr$021o7ki as nonzero_fromStr$021o7ki, fromStrRadix$0dk3w71 as nonzero_fromStrRadix$0dk3w71, fromStr$1myv2t6 as nonzero_fromStr$1myv2t6, fromStrRadix$0o6ntrm as nonzero_fromStrRadix$0o6ntrm, fromStr$10p52cj as nonzero_fromStr$10p52cj, fromStrRadix$0ebk8xe as nonzero_fromStrRadix$0ebk8xe, fromStr$081k88g as nonzero_fromStr$081k88g, fromStrRadix$17xzbib as nonzero_fromStrRadix$17xzbib, fromStr$1gsgexo as nonzero_fromStr$1gsgexo, fromStrRadix$0k1ynqn as nonzero_fromStrRadix$0k1ynqn } from "./core/num/nonzero.ts"; import { unwrapOr$1iemzn8 as option_unwrapOr$1iemzn8, unwrapOr$1rbuegs as option_unwrapOr$1rbuegs, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$0gl6wke as option_map$0gl6wke, mapOr$16umieg as option_mapOr$16umieg, mapOr$147z9gi as option_mapOr$147z9gi } from "./core/option.ts"; -import { parse$0vh4cry, parse$0ub96so, parse$1ogkfqt, parse$1n7pf37, parse$1xm5283, parse$0xeilg3, parse$0eefxsx, parse$0bwhuel, parse$0zy5dnc, parse$1o8vfr6, parse$0l0cs1u, parse$0zrdgp4, parse$0s8xu45 } from "./core/str.ts"; +import { parse$0vh4cry, parse$1bh1yup, parse$034rhh2, parse$1wp6z3o, parse$00wf0ig, parse$1bfudtm, parse$16jvjal, parse$0y8gj7z, parse$0y6waa4, parse$1s5pqso, parse$129b0a7, parse$150tkxc, parse$02m155k } from "./core/str.ts"; import { fromStr$05d44vn as traits_fromStr$05d44vn } from "./core/str/traits.ts"; import { put as fmt_put } from "./fmt.ts"; import * as strs_Counted from "./strs.Counted.ts"; @@ -632,15 +632,15 @@ export function edit(s: rt.Place, op: rt.u8, a: rt.u8, b: rt.u8, out: rt * through a `&mut String`, on a local, and on a field, each printed after each edit. * An offset off a char boundary or out of bounds panics as std's does. */ -export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const mid: number = rt.min(data.length, rt.u8Rem(kind, 8) as rt.usize); - if (mid > data.length) { +export function edits(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const mid: number = rt.min(dataLen, rt.u8Rem(kind, 8) as rt.usize); + if (mid > dataLen) { rt.panic("mid > len"); } - const head: rt.ByteSlice = new rt.ByteSlice(data.data, data.start, mid); + const head: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, mid); let s: string = text(head); const named: strs_Named.Named = { name: text(head) }; - const iter: rt.Iter = rt.byteSliceChunks(new rt.ByteSlice(data.data, data.start + mid, data.length - mid), 3); + const iter: rt.Iter = rt.byteSliceChunks(new rt.ByteSlice(dataData, dataStart + mid, dataLen - mid), 3); while (true) { const _18: rt.ByteSlice | rt.Done = iter.next(); if (_18 === rt.DONE) { @@ -756,7 +756,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.charFromStr(_49); } else if (_53 === 2) { const radix2: rt.u32 = radix; - const iter5: rt.Iter> = rt.iterSlice([parse$0zrdgp4(_49), nonzero_fromStr$1d7pnbk(_49)]); + const iter5: rt.Iter> = rt.iterSlice([parse$150tkxc(_49), nonzero_fromStr$0evev4b(_49)]); while (true) { const _149: rt.Result | rt.Done = iter5.next(); if (_149 === rt.DONE) { @@ -773,13 +773,13 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args12[0], "|", args12[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args12[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args12[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args12[1]), "|", rt.fmtSpec({ alternate: true }, args12[1])])); } } - const _139: rt.Result = parse$0zrdgp4(_49); + const _139: rt.Result = parse$150tkxc(_49); if (!_139.ok) { const part12 = _139.error.kind; const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part12)]; fmt_put(out, rt.fmtFormat([args14[0]])); } - const _195: rt.Result = nonzero_fromStrRadix$1ae2pnm(_49, radix2); + const _195: rt.Result = nonzero_fromStrRadix$1dc3cul(_49, radix2); if (_195.ok) { const arg24 = _195.value; const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg24, f)]; @@ -791,7 +791,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } else if (_53 === 3) { const radix3: rt.u32 = radix; - const iter6: rt.Iter> = rt.iterSlice([parse$0zy5dnc(_49), nonzero_fromStr$15isx69(_49)]); + const iter6: rt.Iter> = rt.iterSlice([parse$0y6waa4(_49), nonzero_fromStr$1lm2uzl(_49)]); while (true) { const _236: rt.Result | rt.Done = iter6.next(); if (_236 === rt.DONE) { @@ -808,13 +808,13 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args22[0], "|", args22[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args22[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args22[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args22[1]), "|", rt.fmtSpec({ alternate: true }, args22[1])])); } } - const _226: rt.Result = parse$0zy5dnc(_49); + const _226: rt.Result = parse$0y6waa4(_49); if (!_226.ok) { const part11 = _226.error.kind; const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part11)]; fmt_put(out, rt.fmtFormat([args24[0]])); } - const _282: rt.Result = nonzero_fromStrRadix$1mr00o6(_49, radix3); + const _282: rt.Result = nonzero_fromStrRadix$1cv6o7i(_49, radix3); if (_282.ok) { const arg22 = _282.value; const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(arg22, f)]; @@ -826,7 +826,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } else if (_53 === 4) { const radix4: rt.u32 = radix; - const iter7: rt.Iter> = rt.iterSlice([parse$1o8vfr6(_49), nonzero_fromStr$04uijf8(_49)]); + const iter7: rt.Iter> = rt.iterSlice([parse$1s5pqso(_49), nonzero_fromStr$0gvyqp3(_49)]); while (true) { const _323: rt.Result | rt.Done = iter7.next(); if (_323 === rt.DONE) { @@ -843,13 +843,13 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args32[0], "|", args32[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args32[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args32[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args32[1]), "|", rt.fmtSpec({ alternate: true }, args32[1])])); } } - const _313: rt.Result = parse$1o8vfr6(_49); + const _313: rt.Result = parse$1s5pqso(_49); if (!_313.ok) { const part10 = _313.error.kind; const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part10)]; fmt_put(out, rt.fmtFormat([args34[0]])); } - const _369: rt.Result = nonzero_fromStrRadix$1wqmb68(_49, radix4); + const _369: rt.Result = nonzero_fromStrRadix$18imw6k(_49, radix4); if (_369.ok) { const arg20 = _369.value; const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg20, f)]; @@ -861,7 +861,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } else if (_53 === 5) { const radix5: rt.u32 = radix; - const iter8: rt.Iter> = rt.iterSlice([parse$0l0cs1u(_49), nonzero_fromStr$0l2zu9x(_49)]); + const iter8: rt.Iter> = rt.iterSlice([parse$129b0a7(_49), nonzero_fromStr$19lq810(_49)]); while (true) { const _410: rt.Result | rt.Done = iter8.next(); if (_410 === rt.DONE) { @@ -878,13 +878,13 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args42[0], "|", args42[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args42[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args42[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args42[1]), "|", rt.fmtSpec({ alternate: true }, args42[1])])); } } - const _400: rt.Result = parse$0l0cs1u(_49); + const _400: rt.Result = parse$129b0a7(_49); if (!_400.ok) { const part9 = _400.error.kind; const args44: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part9)]; fmt_put(out, rt.fmtFormat([args44[0]])); } - const _456: rt.Result = nonzero_fromStrRadix$0cd0jvv(_49, radix5); + const _456: rt.Result = nonzero_fromStrRadix$1u3fi38(_49, radix5); if (_456.ok) { const arg18 = _456.value; const args46: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(arg18, f)]; @@ -896,7 +896,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } else if (_53 === 6) { const radix6: rt.u32 = radix; - const iter9: rt.Iter> = rt.iterSlice([parse$0bwhuel(_49), nonzero_fromStr$0h0ptos(_49)]); + const iter9: rt.Iter> = rt.iterSlice([parse$0y8gj7z(_49), nonzero_fromStr$1lyc2jq(_49)]); while (true) { const _497: rt.Result | rt.Done = iter9.next(); if (_497 === rt.DONE) { @@ -913,13 +913,13 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args52[0], "|", args52[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args52[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args52[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args52[1]), "|", rt.fmtSpec({ alternate: true }, args52[1])])); } } - const _487: rt.Result = parse$0bwhuel(_49); + const _487: rt.Result = parse$0y8gj7z(_49); if (!_487.ok) { const part8 = _487.error.kind; const args54: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part8)]; fmt_put(out, rt.fmtFormat([args54[0]])); } - const _543: rt.Result = nonzero_fromStrRadix$10vntu7(_49, radix6); + const _543: rt.Result = nonzero_fromStrRadix$0yvapq5(_49, radix6); if (_543.ok) { const arg16 = _543.value; const args56: rt.Fmt[] = [(f: rt.Formatter) => rt.u128Display(arg16, f)]; @@ -931,7 +931,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } else if (_53 === 7) { const radix7: rt.u32 = radix; - const iter10: rt.Iter> = rt.iterSlice([parse$0s8xu45(_49), nonzero_fromStr$10svit2(_49)]); + const iter10: rt.Iter> = rt.iterSlice([parse$02m155k(_49), nonzero_fromStr$06k4xxy(_49)]); while (true) { const _584: rt.Result | rt.Done = iter10.next(); if (_584 === rt.DONE) { @@ -948,13 +948,13 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args62[0], "|", args62[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args62[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args62[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args62[1]), "|", rt.fmtSpec({ alternate: true }, args62[1])])); } } - const _574: rt.Result = parse$0s8xu45(_49); + const _574: rt.Result = parse$02m155k(_49); if (!_574.ok) { const part7 = _574.error.kind; const args64: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part7)]; fmt_put(out, rt.fmtFormat([args64[0]])); } - const _630: rt.Result = nonzero_fromStrRadix$0wc95fw(_49, radix7); + const _630: rt.Result = nonzero_fromStrRadix$0rmwudb(_49, radix7); if (_630.ok) { const arg14 = _630.value; const args66: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg14, f)]; @@ -966,7 +966,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } else if (_53 === 8) { const radix8: rt.u32 = radix; - const iter11: rt.Iter> = rt.iterSlice([parse$0xeilg3(_49), nonzero_fromStr$19kbj04(_49)]); + const iter11: rt.Iter> = rt.iterSlice([parse$1bfudtm(_49), nonzero_fromStr$0xht6mx(_49)]); while (true) { const _671: rt.Result | rt.Done = iter11.next(); if (_671 === rt.DONE) { @@ -983,13 +983,13 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args72[0], "|", args72[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args72[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args72[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args72[1]), "|", rt.fmtSpec({ alternate: true }, args72[1])])); } } - const _661: rt.Result = parse$0xeilg3(_49); + const _661: rt.Result = parse$1bfudtm(_49); if (!_661.ok) { const part6 = _661.error.kind; const args74: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part6)]; fmt_put(out, rt.fmtFormat([args74[0]])); } - const _717: rt.Result = nonzero_fromStrRadix$1o9c7gd(_49, radix8); + const _717: rt.Result = nonzero_fromStrRadix$0qjnxek(_49, radix8); if (_717.ok) { const arg12 = _717.value; const args76: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(arg12, f)]; @@ -1001,7 +1001,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } else if (_53 === 9) { const radix9: rt.u32 = radix; - const iter12: rt.Iter> = rt.iterSlice([parse$1ogkfqt(_49), nonzero_fromStr$0br814e(_49)]); + const iter12: rt.Iter> = rt.iterSlice([parse$034rhh2(_49), nonzero_fromStr$021o7ki(_49)]); while (true) { const _758: rt.Result | rt.Done = iter12.next(); if (_758 === rt.DONE) { @@ -1018,13 +1018,13 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args82[0], "|", args82[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args82[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args82[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args82[1]), "|", rt.fmtSpec({ alternate: true }, args82[1])])); } } - const _748: rt.Result = parse$1ogkfqt(_49); + const _748: rt.Result = parse$034rhh2(_49); if (!_748.ok) { const part5 = _748.error.kind; const args84: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part5)]; fmt_put(out, rt.fmtFormat([args84[0]])); } - const _804: rt.Result = nonzero_fromStrRadix$188cokx(_49, radix9); + const _804: rt.Result = nonzero_fromStrRadix$0dk3w71(_49, radix9); if (_804.ok) { const arg10 = _804.value; const args86: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Display(arg10, f)]; @@ -1036,7 +1036,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } else if (_53 === 10) { const radix10: rt.u32 = radix; - const iter13: rt.Iter> = rt.iterSlice([parse$1n7pf37(_49), nonzero_fromStr$1471qz1(_49)]); + const iter13: rt.Iter> = rt.iterSlice([parse$1wp6z3o(_49), nonzero_fromStr$1myv2t6(_49)]); while (true) { const _845: rt.Result | rt.Done = iter13.next(); if (_845 === rt.DONE) { @@ -1053,13 +1053,13 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args92[0], "|", args92[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args92[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args92[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args92[1]), "|", rt.fmtSpec({ alternate: true }, args92[1])])); } } - const _835: rt.Result = parse$1n7pf37(_49); + const _835: rt.Result = parse$1wp6z3o(_49); if (!_835.ok) { const part4 = _835.error.kind; const args94: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part4)]; fmt_put(out, rt.fmtFormat([args94[0]])); } - const _891: rt.Result = nonzero_fromStrRadix$0l5ymb0(_49, radix10); + const _891: rt.Result = nonzero_fromStrRadix$0o6ntrm(_49, radix10); if (_891.ok) { const arg8 = _891.value; const args96: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(arg8, f)]; @@ -1071,7 +1071,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } else if (_53 === 11) { const radix11: rt.u32 = radix; - const iter14: rt.Iter> = rt.iterSlice([parse$1xm5283(_49), nonzero_fromStr$0k8sfhf(_49)]); + const iter14: rt.Iter> = rt.iterSlice([parse$00wf0ig(_49), nonzero_fromStr$10p52cj(_49)]); while (true) { const _932: rt.Result | rt.Done = iter14.next(); if (_932 === rt.DONE) { @@ -1088,13 +1088,13 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args102[0], "|", args102[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args102[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args102[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args102[1]), "|", rt.fmtSpec({ alternate: true }, args102[1])])); } } - const _922: rt.Result = parse$1xm5283(_49); + const _922: rt.Result = parse$00wf0ig(_49); if (!_922.ok) { const part3 = _922.error.kind; const args104: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part3)]; fmt_put(out, rt.fmtFormat([args104[0]])); } - const _978: rt.Result = nonzero_fromStrRadix$0fpnm5c(_49, radix11); + const _978: rt.Result = nonzero_fromStrRadix$0ebk8xe(_49, radix11); if (_978.ok) { const arg6 = _978.value; const args106: rt.Fmt[] = [(f: rt.Formatter) => rt.i64Display(arg6, f)]; @@ -1106,7 +1106,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } else if (_53 === 12) { const radix12: rt.u32 = radix; - const iter15: rt.Iter> = rt.iterSlice([parse$0ub96so(_49), nonzero_fromStr$0b2xa80(_49)]); + const iter15: rt.Iter> = rt.iterSlice([parse$1bh1yup(_49), nonzero_fromStr$081k88g(_49)]); while (true) { const _1019: rt.Result | rt.Done = iter15.next(); if (_1019 === rt.DONE) { @@ -1123,13 +1123,13 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args112[0], "|", args112[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args112[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args112[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args112[1]), "|", rt.fmtSpec({ alternate: true }, args112[1])])); } } - const _1009: rt.Result = parse$0ub96so(_49); + const _1009: rt.Result = parse$1bh1yup(_49); if (!_1009.ok) { const part2 = _1009.error.kind; const args114: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part2)]; fmt_put(out, rt.fmtFormat([args114[0]])); } - const _1065: rt.Result = nonzero_fromStrRadix$1095n8m(_49, radix12); + const _1065: rt.Result = nonzero_fromStrRadix$17xzbib(_49, radix12); if (_1065.ok) { const arg4 = _1065.value; const args116: rt.Fmt[] = [(f: rt.Formatter) => rt.i128Display(arg4, f)]; @@ -1141,7 +1141,7 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } else { const radix13: rt.u32 = radix; - const iter16: rt.Iter> = rt.iterSlice([parse$0eefxsx(_49), nonzero_fromStr$17dd66m(_49)]); + const iter16: rt.Iter> = rt.iterSlice([parse$16jvjal(_49), nonzero_fromStr$1gsgexo(_49)]); while (true) { const _1106: rt.Result | rt.Done = iter16.next(); if (_1106 === rt.DONE) { @@ -1158,13 +1158,13 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, rt.fmtFormat([args122[0], "|", args122[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args122[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args122[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args122[1]), "|", rt.fmtSpec({ alternate: true }, args122[1])])); } } - const _1096: rt.Result = parse$0eefxsx(_49); + const _1096: rt.Result = parse$16jvjal(_49); if (!_1096.ok) { const part = _1096.error.kind; const args124: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part)]; fmt_put(out, rt.fmtFormat([args124[0]])); } - const _1152: rt.Result = nonzero_fromStrRadix$1yrk04t(_49, radix13); + const _1152: rt.Result = nonzero_fromStrRadix$0k1ynqn(_49, radix13); if (_1152.ok) { const arg2 = _1152.value; const args126: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDisplay(arg2, f)]; @@ -1356,15 +1356,15 @@ export function drainBy(s: rt.Place, form: rt.u8, a: rt.u8, b: rt.u8, st * `&mut String`, on a local, and on a field, each printed after each drain. An offset off * a char boundary or out of bounds panics as std's does. */ -export function drains(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const mid: number = rt.min(data.length, rt.u8Rem(kind, 8) as rt.usize); - if (mid > data.length) { +export function drains(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const mid: number = rt.min(dataLen, rt.u8Rem(kind, 8) as rt.usize); + if (mid > dataLen) { rt.panic("mid > len"); } - const head: rt.ByteSlice = new rt.ByteSlice(data.data, data.start, mid); + const head: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, mid); let s: string = text(head); const named: strs_Named.Named = { name: text(head) }; - const iter: rt.Iter = rt.byteSliceChunks(new rt.ByteSlice(data.data, data.start + mid, data.length - mid), 4); + const iter: rt.Iter = rt.byteSliceChunks(new rt.ByteSlice(dataData, dataStart + mid, dataLen - mid), 4); while (true) { const _18: rt.ByteSlice | rt.Done = iter.next(); if (_18 === rt.DONE) { diff --git a/ts/fixtures/lang/expected/wrappers.ts b/ts/fixtures/lang/expected/wrappers.ts index 50ec0c951..5ddae29d1 100644 --- a/ts/fixtures/lang/expected/wrappers.ts +++ b/ts/fixtures/lang/expected/wrappers.ts @@ -3,7 +3,7 @@ import * as rt from "./rt.ts"; import { unwrapOr$1tvry1i as option_unwrapOr$1tvry1i, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$02k4ito as option_mapOr$02k4ito } from "./core/option.ts"; import { put as fmt_put } from "./fmt.ts"; -import * as Scale from "./wrappers.Scale.ts"; +import * as wrappers_Scale from "./wrappers.Scale.ts"; import * as wrappers_Tally from "./wrappers.Tally.ts"; export function putU64(out: rt.ByteVec, v: rt.u64): void { @@ -245,7 +245,7 @@ export function boundOf(kind: rt.u8, a: rt.u64): rt.RangeBound { } export function wrappers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let scale!: Scale.Scale; + let scale!: wrappers_Scale.Scale; let name!: string; const _5: (a0: rt.u8) => rt.u64 = (b3: rt.u8): rt.u64 => { const _3: rt.u8 = rt.u8Rem(b3, 4); @@ -507,8 +507,8 @@ export function wrappers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void name = "one"; } fmt_put(out, name); - rt.byteVecPush(out, Scale.eq$cmp_PartialEq(scale, { _0: 1000 }) ? 1 : 0); - rt.byteVecPush(out, Scale.partialCmp$cmp_PartialOrd(scale, { _0: { hi: 0xffffffff, lo: 0xffffffff } as rt.u64 }) === -1 ? 1 : 0); + rt.byteVecPush(out, wrappers_Scale.eq$cmp_PartialEq(scale, { _0: 1000 }) ? 1 : 0); + rt.byteVecPush(out, wrappers_Scale.partialCmp$cmp_PartialOrd(scale, { _0: { hi: 0xffffffff, lo: 0xffffffff } as rt.u64 }) === -1 ? 1 : 0); putU64(out, scale._0); } } diff --git a/ts/fixtures/lang/expected/zeros.ts b/ts/fixtures/lang/expected/zeros.ts index cf38948c9..ab922d66c 100644 --- a/ts/fixtures/lang/expected/zeros.ts +++ b/ts/fixtures/lang/expected/zeros.ts @@ -508,9 +508,9 @@ export function raw(tag: rt.u32): rt.Place { * Writes through a `&mut` or a pointer to a value of no bytes, which have nothing to * read or write but still run their operands. */ -export function writes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function writes(kind: rt.u8, _dataData: Uint8Array, _dataStart: number, dataLen: number, out: rt.ByteVec): void { rt.atomicStore(LOG, 0, 0); - const n: rt.u8 = data.length & 0xff; + const n: rt.u8 = dataLen & 0xff; const _9: rt.u8 = rt.u8Rem(kind, 5); if (_9 === 0) { leaked(1); diff --git a/ts/fixtures/lang/src/args.rs b/ts/fixtures/lang/src/args.rs new file mode 100644 index 000000000..a462f7ce0 --- /dev/null +++ b/ts/fixtures/lang/src/args.rs @@ -0,0 +1,202 @@ +//! Byte slices passed to the crate's own functions, which take them as their parts unless +//! their bodies make them whole all the same. + +/// A use that needs the slice itself. +#[inline(never)] +fn opaque(s: &[u8]) -> u8 { + s.iter().fold(s.len() as u8, |a, b| (a ^ (a >> 3)).wrapping_add(*b)) +} + +/// A parameter reassigned from its own tail. +fn sum(mut data: &[u8]) -> u8 { + let mut sum = 0u8; + while let Some((&b, rest)) = data.split_first() { + sum = sum.wrapping_add(b); + data = rest; + } + sum +} + +/// A parameter only measured. +fn len(data: &[u8]) -> usize { + data.len() +} + +/// A parameter borrowed, which takes it whole. +fn by_ref(data: &[u8]) -> usize { + let r = &data; + len_of(r) +} + +fn len_of(data: &&[u8]) -> usize { + data.len() +} + +/// A parameter made whole in a loop, which takes it whole. +fn kept(data: &[u8], n: u8) -> Vec<&[u8]> { + let mut all = Vec::new(); + for _ in 0..n % 4 { + all.push(data); + } + all +} + +/// A reference to an array of bytes. +fn word(w: &[u8; 4]) -> u32 { + u32::from_be_bytes(*w) +} + +/// Two slices, perhaps the same. +fn both(a: &[u8], b: &[u8]) -> u8 { + opaque(a) ^ len(b) as u8 +} + +/// A recursive count of the bytes before a zero. +fn depth(data: &[u8]) -> u8 { + match data.split_first() { + Some((&b, rest)) if b != 0 => 1 + depth(rest), + _ => 0, + } +} + +/// Passed along to one that takes it whole, so taken whole too. +fn relay(data: &[u8]) -> u8 { + opaque(data) +} + +/// Passed along to one that takes its parts, so taken as parts too. +fn relay_sum(data: &[u8]) -> u8 { + sum(data) +} + +/// Recursive, and made whole at the bottom, so taken whole all the way down. +fn last_run(data: &[u8]) -> u8 { + match data.split_first() { + Some((&b, rest)) if b != 0 => last_run(rest), + _ => opaque(data), + } +} + +/// Mutually recursive, each reading bytes, so both take parts. +fn evens(data: &[u8]) -> u8 { + match data.split_first() { + Some((&b, rest)) => b.wrapping_add(odds(rest)), + None => 0, + } +} + +fn odds(data: &[u8]) -> u8 { + match data.split_first() { + Some((_, rest)) => evens(rest), + None => 0, + } +} + +/// Mutually recursive, where `ping` makes its slice whole and `pong` only splits its own. +fn ping(data: &[u8]) -> u8 { + match data.split_first() { + Some((&b, rest)) if b % 3 != 0 => pong(rest), + _ => opaque(data), + } +} + +fn pong(data: &[u8]) -> u8 { + match data.split_first() { + Some((&b, rest)) => b ^ ping(rest), + None => 0, + } +} + +/// A slice chosen by a call that does something. +fn pick<'a>(out: &mut Vec, data: &'a [u8]) -> &'a [u8] { + out.push(0xbb); + &data[data.len() / 2..] +} + +fn code(out: &mut Vec, n: u8) -> u8 { + out.push(0xee); + n +} + +fn pair(n: u8, s: &[u8]) -> u8 { + n ^ opaque(s) +} + +trait Weigh { + fn weigh(&self, data: &[u8]) -> u8; +} + +struct Scale(u8); + +impl Weigh for Scale { + fn weigh(&self, data: &[u8]) -> u8 { + data.iter().fold(self.0, |a, b| a.wrapping_add(*b ^ 0x5a)) + } +} + +fn weigh(w: &W, data: &[u8]) -> u8 { + w.weigh(data) +} + +pub fn args(kind: u8, data: &[u8], out: &mut Vec) { + match kind % 8 { + 0 => { + out.push(sum(data)); + out.push(len(data) as u8); + out.push(by_ref(data) as u8); + out.push(kept(data, kind).iter().map(|s| opaque(s)).fold(0, u8::wrapping_add)); + } + 1 => { + if let Some((w, rest)) = data.split_first_chunk::<4>() { + out.extend_from_slice(&word(w).wrapping_add(1).to_be_bytes()); + out.push(both(rest, rest)); + out.push(both(w, rest)); + } + out.push(depth(&data[..data.len().min(64)])); + } + 2 => { + // As values: a function item, and a pointer to it. + out.extend(data.split_first().map(|(_, rest)| rest).map(opaque)); + let f: fn(&[u8]) -> u8 = if data.len() % 2 == 0 { opaque } else { sum }; + out.push(f(data)); + out.push(data.split_first().map(|(_, rest)| rest).map_or(0, len) as u8); + } + 3 => { + // The earlier argument runs first. + let n = pair(code(out, 1), pick(out, data)); + out.push(n); + } + 4 => { + // Captured by a closure. + let mut seen = Vec::new(); + let mut note = |b: u8| seen.push(b ^ opaque(data)); + for &b in data.iter().take(3) { + note(b); + } + out.extend_from_slice(&seen); + } + 6 => { + let data = &data[..data.len().min(64)]; + out.push(relay(data)); + out.push(relay_sum(data)); + out.push(last_run(data)); + out.push(evens(data)); + out.push(ping(data)); + out.push(pong(data)); + } + 7 => { + // Callers holding the slice whole, and ones holding its parts, of one callee. + let halves = [data.split_at(data.len() / 2).0, data.split_at(data.len() / 2).1]; + for half in halves.iter() { + out.push(sum(half)); + out.push(relay(half)); + } + out.push(relay_sum(halves[1])); + out.push(sum(data)); + } + _ => { + out.push(weigh(&Scale(kind), data)); + out.push(Scale(3).weigh(&data[data.len().min(2)..])); + } + } +} diff --git a/ts/fixtures/lang/src/harness.rs b/ts/fixtures/lang/src/harness.rs index 4c5f244ff..218b7f7d8 100644 --- a/ts/fixtures/lang/src/harness.rs +++ b/ts/fixtures/lang/src/harness.rs @@ -2,10 +2,11 @@ //! case and the rest is its input. use crate::{ - arrays, ascii, atomics, borrows, bounds, boxes, captures, cells, chars, chunks, clones, collections, combinators, - counts, cows, cycles, defaults, durations, dyns, edits, errors, floats, fmt, folds, generics, hashes, hints, holds, - ints, iters, joins, keys, lengths, lists, locals, locks, methods, nested, objects, orders, pointers, refs, - saturates, separated, shapes, singles, slices, splits, statics, strs, tuples, utf8, wrappers, wraps, zeros, + args, arrays, ascii, atomics, borrows, bounds, boxes, captures, cells, chars, chunks, clones, collections, + combinators, counts, cows, cycles, defaults, durations, dyns, edits, errors, floats, fmt, folds, generics, hashes, + hints, holds, ints, iters, joins, keys, lengths, lists, locals, locks, methods, nested, objects, orders, pointers, + refs, returns, saturates, separated, shapes, singles, slices, splits, statics, strs, tuples, utf8, wrappers, wraps, + zeros, }; /// The native side's entry: [`run`], except that a case starting with 0xff prints a @@ -262,6 +263,8 @@ fn cases() -> Vec<(&'static str, Case)> { pointers::part_written(data, out) }), ("arrays::flattened", arrays::flattened), + ("args::args", args::args), + ("returns::returns", returns::returns), ] } diff --git a/ts/fixtures/lang/src/lib.rs b/ts/fixtures/lang/src/lib.rs index b7d37569a..0499de34f 100644 --- a/ts/fixtures/lang/src/lib.rs +++ b/ts/fixtures/lang/src/lib.rs @@ -1,6 +1,7 @@ //! The language the driver translates, exercised against native Rust: every integer //! width's arithmetic, casts, and inherent methods, `f64`, `char`s and the `str` methods over them, -//! `Cow`, boxed slices and text, `Duration`, control flow, patterns, byte slices split apart, `Copy` +//! `Cow`, boxed slices and text, `Duration`, control flow, patterns, byte slices split apart, +//! passed as their parts, and returned in a slot, `Copy` //! aggregates, closures and what they write of what they captured, traits, generic //! types, formatting, collections, `LinkedList`s, UTF-8 decoding, `&mut` to values JS copies, whole //! writes through a `&mut` to an object, the standard library calls it maps, `Option`'s @@ -25,6 +26,7 @@ #![feature(iter_order_by, split_as_slice, wrapping_int_impl, wrapping_next_power_of_two)] +mod args; mod arrays; mod ascii; mod atomics; @@ -68,6 +70,7 @@ mod objects; mod orders; mod pointers; mod refs; +mod returns; mod saturates; mod separated; mod shapes; diff --git a/ts/fixtures/lang/src/returns.rs b/ts/fixtures/lang/src/returns.rs new file mode 100644 index 000000000..0d2c92d4c --- /dev/null +++ b/ts/fixtures/lang/src/returns.rs @@ -0,0 +1,294 @@ +//! Results of byte slices returned by the crate's own functions, which hand back an +//! `Ok`'s parts in a slot their caller reads at once. + +#[derive(Debug, Clone, Copy, PartialEq)] +enum Error { + Short(usize), + Bad, +} + +impl Error { + fn code(self) -> u8 { + match self { + Error::Short(n) => n as u8, + Error::Bad => 0xff, + } + } +} + +/// A slice alone, with returns from several places. +fn take(data: &[u8], n: usize) -> Result<&[u8], Error> { + if n > 200 { + return Err(Error::Bad); + } + match data.split_at_checked(n) { + Some((head, _)) => Ok(head), + None => Err(Error::Short(n - data.len())), + } +} + +/// The same slice type through another function, which shares its slot. +fn tail(data: &[u8], n: usize) -> Result<&[u8], Error> { + (n <= data.len()).then(|| &data[n..]).ok_or(Error::Short(n)) +} + +/// A number past 2^31 and the rest. +fn wide(data: &[u8]) -> Result<(u64, &[u8]), Error> { + let (head, rest) = data.split_first_chunk::<8>().ok_or(Error::Short(8))?; + Ok((u64::from_be_bytes(*head), rest)) +} + +fn narrow(data: &[u8]) -> Result<(u64, &[u8]), Error> { + let (&b, rest) = data.split_first().ok_or(Error::Short(1))?; + match b { + 0xff => Err(Error::Bad), + _ => Ok((b as u64, rest)), + } +} + +/// What either returns, returned as is. +fn number(data: &[u8], wide_: bool) -> Result<(u64, &[u8]), Error> { + if wide_ { + return wide(data); + } + narrow(data) +} + +/// Each byte before a zero counted, recursively. +fn count(data: &[u8]) -> Result<(u64, &[u8]), Error> { + match data.split_first() { + Some((0, rest)) => Ok((0, rest)), + Some((_, rest)) => { + let (n, rest) = count(rest)?; + Ok((n + 1, rest)) + } + None => Err(Error::Short(1)), + } +} + +/// Two slices, and a reference to an array. +fn halves(data: &[u8]) -> Result<(&[u8], &[u8; 2], &[u8]), u8> { + let (tag, rest) = data.split_first_chunk::<2>().ok_or(data.len() as u8)?; + let (a, b) = rest.split_at(rest.len() / 2); + Ok((a, tag, b)) +} + +/// Calls whose results are both held while the slot is written again between them. +fn both(data: &[u8]) -> Result<(u64, u64, &[u8]), Error> { + let (a, rest) = narrow(data)?; + let (b, rest) = number(rest, a % 2 == 1)?; + let rest = tail(rest, (a % 3) as usize)?; + let head = take(rest, (b % 4) as usize)?; + Ok((a, b ^ head.len() as u64, rest)) +} + +/// A guard whose drop writes the slot after its function's call did. +struct Guard<'a>(&'a [u8], u8); + +impl Drop for Guard<'_> { + fn drop(&mut self) { + let _ = narrow(&self.0[self.1 as usize % 2..]); + } +} + +fn guarded<'a>(data: &'a [u8], other: &[u8]) -> Result<(u64, &'a [u8]), Error> { + let _guard = Guard(other, data.len() as u8); + narrow(data) +} + +/// Errors that are no single value: `()`, and an `Option`. +fn unit_err(data: &[u8]) -> Result<&[u8], ()> { + data.split_first().map(|(_, rest)| rest).ok_or(()) +} + +fn none_err(data: &[u8]) -> Result<&[u8], Option> { + match data.first() { + Some(0) => Err(None), + Some(&b) if b > 0xf0 => Err(Some(b)), + _ => data.split_first().map(|(_, rest)| rest).ok_or(None), + } +} + +trait Split { + fn split<'a>(&self, data: &'a [u8]) -> Result<(&'a [u8], &'a [u8]), Error>; +} + +struct At(usize); + +impl Split for At { + fn split<'a>(&self, data: &'a [u8]) -> Result<(&'a [u8], &'a [u8]), Error> { + data.split_at_checked(self.0).ok_or(Error::Short(self.0)) + } +} + +// Two instances, of two `Ok` types, so two slots of one function. +fn lead>(data: &[u8]) -> Result<(T, &[u8]), Error> { + let (&first, rest) = data.split_first().ok_or(Error::Short(1))?; + Ok((T::from(first), rest)) +} + +fn split_with<'a, S: Split>(s: &S, data: &'a [u8]) -> Result<(&'a [u8], &'a [u8]), Error> { + s.split(data) +} + +fn push(out: &mut Vec, r: Result<&[u8], Error>) { + match r { + Ok(s) => { + out.push(s.len() as u8); + out.extend_from_slice(&s[..s.len().min(4)]); + } + Err(e) => out.extend_from_slice(&[0xee, e.code()]), + } +} + +fn push_number(out: &mut Vec, r: Result<(u64, &[u8]), Error>) { + match r { + Ok((n, rest)) => { + out.extend_from_slice(&n.to_be_bytes()); + out.push(rest.len() as u8); + } + Err(e) => out.extend_from_slice(&[0xee, e.code()]), + } +} + +/// A slice that takes no argument. +#[inline(never)] +fn fixed() -> Result<&'static [u8], Error> { + Ok(b"abc") +} + +/// Takes `fixed`'s result apart, so it is held as parts. +fn after_fixed(data: &[u8]) -> Result<&[u8], Error> { + let s = fixed()?; + Ok(&s[..data.len().min(s.len())]) +} + +/// An error converted from a residual of a slice and a byte. +#[derive(Debug, Clone, Copy, PartialEq)] +struct Wrapped(u8, u8); + +impl From<(&[u8], u8)> for Wrapped { + fn from((s, n): (&[u8], u8)) -> Self { + Wrapped(s.len() as u8 ^ s.first().copied().unwrap_or(0x5a), n) + } +} + +/// `?` on a residual whose error is a slice and a byte, converted. +fn wrapped(data: &[u8]) -> Result<(u8, &[u8]), Wrapped> { + let r: Result = match data.split_first() { + Some((&b, _)) if b % 2 == 0 => Ok(b), + Some((&b, rest)) => Err((rest, b)), + None => Err((data, 0)), + }; + let v = r?; + Ok((v, data)) +} + +pub fn returns(kind: u8, data: &[u8], out: &mut Vec) { + match kind % 7 { + 0 => { + push(out, take(data, kind as usize % 7)); + push(out, take(data, 201)); + push(out, tail(data, 3)); + push_number(out, number(data, kind % 2 == 0)); + push_number(out, count(data)); + } + 1 => { + // Kept whole: in a collection, and read later, after other calls wrote the slot. + let kept: Vec> = (0..4).map(|n| take(data, n * 3)).collect(); + let last = tail(data, 1); + for r in kept { + push(out, r); + } + push(out, last); + match both(data) { + Ok((a, b, rest)) => { + out.extend_from_slice(&a.to_be_bytes()); + out.extend_from_slice(&b.to_be_bytes()); + out.push(rest.len() as u8); + } + Err(e) => out.push(e.code()), + } + } + 2 => { + // As values: a function item, and a pointer to it. + let f: fn(&[u8]) -> Result<(u64, &[u8]), Error> = if data.len() % 2 == 0 { wide } else { narrow }; + push_number(out, f(data)); + let all: Vec<_> = [data, &data[data.len().min(3)..]].into_iter().map(count).collect(); + for r in all { + push_number(out, r); + } + out.extend( + data.split_first() + .map(|(_, rest)| rest) + .map(|s| tail(s, 2).map_or(0, <[u8]>::len) as u8), + ); + } + 3 => { + match halves(data) { + Ok((a, tag, b)) => { + out.extend_from_slice(tag); + out.push(a.len() as u8); + out.extend_from_slice(b); + } + Err(n) => out.push(n), + } + let other = [0xff, 1, 2]; + push_number(out, guarded(data, &other)); + push_number(out, guarded(data, &other[1..])); + } + 4 => { + match unit_err(data) { + Ok(s) => out.push(s.len() as u8), + Err(()) => out.push(0xee), + } + match none_err(data) { + Ok(s) => out.push(s.len() as u8), + Err(e) => out.extend_from_slice(&[0xee, e.unwrap_or(0)]), + } + match (lead::(data), lead::(&data[data.len().min(1)..])) { + (Ok((a, _)), Ok((b, rest))) => { + out.extend_from_slice(&a.to_be_bytes()); + out.extend_from_slice(&b.to_be_bytes()); + out.push(rest.len() as u8); + } + (a, b) => out.extend_from_slice(&[a.is_ok() as u8, b.is_ok() as u8]), + } + } + 5 => { + match after_fixed(data) { + Ok(s) => out.extend_from_slice(s), + Err(e) => out.push(e.code()), + } + match wrapped(data) { + Ok((v, rest)) => out.extend_from_slice(&[v, rest.len() as u8]), + Err(Wrapped(a, b)) => out.extend_from_slice(&[0xee, a, b]), + } + } + _ => { + let at = At(kind as usize % 5); + match split_with(&at, data) { + Ok((a, b)) => out.extend_from_slice(&[a.len() as u8, b.len() as u8]), + Err(e) => out.push(e.code()), + } + // Through a trait object. + let dynamic: &dyn Split = &at; + match dynamic.split(data) { + Ok((a, b)) => out.extend_from_slice(&[b.len() as u8, a.len() as u8]), + Err(e) => out.push(e.code()), + } + match at.split(data).and_then(|(a, b)| take(b, a.len())) { + Ok(s) => out.push(s.len() as u8), + Err(e) => out.push(e.code()), + } + // A loop that calls again while the last result is still read. + let mut rest = data; + let mut sum = 0u64; + while let Ok((n, more)) = narrow(rest) { + sum = sum.wrapping_mul(31).wrapping_add(n); + rest = more; + } + out.extend_from_slice(&sum.to_be_bytes()); + } + } +} diff --git a/ts/fixtures/stock/expected/buf.Pieces.ts b/ts/fixtures/stock/expected/buf.Pieces.ts index 674c21adb..18705c868 100644 --- a/ts/fixtures/stock/expected/buf.Pieces.ts +++ b/ts/fixtures/stock/expected/buf.Pieces.ts @@ -14,11 +14,11 @@ export interface Pieces { } /** `input` in two parts, cut at `cut`. */ -function new_(input: rt.ByteSlice, cut: rt.usize): Pieces { - if (cut > input.length) { +function new_(inputData: Uint8Array, inputStart: number, inputLen: number, cut: rt.usize): Pieces { + if (cut > inputLen) { rt.panic("mid > len"); } - const parts: rt.ByteVec[] = [rt.byteSliceToByteVec(new rt.ByteSlice(input.data, input.start, cut)), rt.byteSliceToByteVec(new rt.ByteSlice(input.data, input.start + cut, input.length - cut))]; + const parts: rt.ByteVec[] = [rt.byteSliceToByteVec(new rt.ByteSlice(inputData, inputStart, cut)), rt.byteSliceToByteVec(new rt.ByteSlice(inputData, inputStart + cut, inputLen - cut))]; rt.vecRetain(parts, (part: rt.ByteVec): boolean => { return !((part.length === 0)); }); diff --git a/ts/fixtures/stock/expected/buf.ts b/ts/fixtures/stock/expected/buf.ts index cc03bd968..5b3f996cb 100644 --- a/ts/fixtures/stock/expected/buf.ts +++ b/ts/fixtures/stock/expected/buf.ts @@ -394,14 +394,14 @@ export function read$ref_slice_u8(buf: rt.Place, n: rt.usize): rt. * it, and shared storage grows up to it. Only the inputs `caller.ts` names reach these, * as each allocates that much. */ -export function reserves(data: rt.ByteSlice, out: rt.ByteVec): void { - if (data.length === 6) { - if (data.data[data.start] === 101) { - if (data.data[data.start + 1] === 100) { - if (data.data[data.start + 2] === 103) { - if (data.data[data.start + 3] === 101) { - const kind: rt.u8 = data.data[data.start + 4]; - const read: rt.u8 = data.data[data.start + 5]; +export function reserves(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + if (dataLen === 6) { + if (dataData[dataStart] === 101) { + if (dataData[dataStart + 1] === 100) { + if (dataData[dataStart + 2] === 103) { + if (dataData[dataStart + 3] === 101) { + const kind: rt.u8 = dataData[dataStart + 4]; + const read: rt.u8 = dataData[dataStart + 5]; const buf: rt.BytesMut = rt.bytesMutFrom(rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of(101, 100, 103, 101, 115)), 0)); const read2: rt.usize = rt.usizeRem(read as rt.usize, 5); rt.bytesMutAdvance(buf, read2); @@ -423,44 +423,44 @@ export function reserves(data: rt.ByteSlice, out: rt.ByteVec): void { * The same reads off a `Bytes`, a `BytesMut`, a `&[u8]`, buffers in pieces, and each * through the impl forwarding through a `&mut`: each scalar, and what remains. */ -export function reads(data: rt.ByteSlice, out: rt.ByteVec): void { +export function reads(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let rest!: rt.ByteVec; - if (data.length >= 2) { - const mid: number = rt.usizeDiv(data.length - 2, 2); - if (mid > data.length - 2) { + if (dataLen >= 2) { + const mid: number = rt.usizeDiv(dataLen - 2, 2); + if (mid > dataLen - 2) { rt.panic("mid > len"); } - const input: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + 2 + mid, data.length - 2 - mid); - const cut: rt.usize = rt.usizeRem(data.data[data.start + 1] as rt.usize, rt.usizeAdd(input.length, 1)); - const _22: rt.u8 = rt.u8Rem(data.data[data.start], 8); + const input: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 2 + mid, dataLen - 2 - mid); + const cut: rt.usize = rt.usizeRem(dataData[dataStart + 1] as rt.usize, rt.usizeAdd(input.length, 1)); + const _22: rt.u8 = rt.u8Rem(dataData[dataStart], 8); if (_22 === 0) { let _24: rt.ByteSlice = rt.bytesCopyFromSlice(input); - rest = readAll$bytes_Bytes(rt.place(() => _24, (value7) => _24 = value7), new rt.ByteSlice(data.data, data.start + 2, mid), read$bytes_Bytes, out); + rest = readAll$bytes_Bytes(rt.place(() => _24, (value7) => _24 = value7), new rt.ByteSlice(dataData, dataStart + 2, mid), read$bytes_Bytes, out); } else if (_22 === 1) { - rest = readAll$bytes_BytesMut(rt.bytesMutFrom(input), new rt.ByteSlice(data.data, data.start + 2, mid), read$bytes_BytesMut, out); + rest = readAll$bytes_BytesMut(rt.bytesMutFrom(input), new rt.ByteSlice(dataData, dataStart + 2, mid), read$bytes_BytesMut, out); } else if (_22 === 2) { - rest = readAll$buf_Pieces(Pieces.new(input, cut), new rt.ByteSlice(data.data, data.start + 2, mid), readPieces$buf_Pieces, out); + rest = readAll$buf_Pieces(Pieces.new(input.data, input.start, input.length, cut), new rt.ByteSlice(dataData, dataStart + 2, mid), readPieces$buf_Pieces, out); } else if (_22 === 3) { let _33: rt.ByteSlice = rt.byteSliceRange(input, 0); - rest = readAll$ref_slice_u8(rt.place(() => _33, (value6) => _33 = value6), new rt.ByteSlice(data.data, data.start + 2, mid), read$ref_slice_u8, out); + rest = readAll$ref_slice_u8(rt.place(() => _33, (value6) => _33 = value6), new rt.ByteSlice(dataData, dataStart + 2, mid), read$ref_slice_u8, out); } else if (_22 === 4) { - const _37: Provided.Provided = { _0: Pieces.new(input, cut) }; - rest = readAll$buf_Provided(_37, new rt.ByteSlice(data.data, data.start + 2, mid), readPieces$buf_Provided, out); + const _37: Provided.Provided = { _0: Pieces.new(input.data, input.start, input.length, cut) }; + rest = readAll$buf_Provided(_37, new rt.ByteSlice(dataData, dataStart + 2, mid), readPieces$buf_Provided, out); } else if (_22 === 5) { let _42: rt.ByteSlice = rt.bytesCopyFromSlice(input); let _41: rt.Place = rt.place(() => _42, (value4) => _42 = value4); - rest = readAll$mut_bytes_Bytes(rt.place(() => _41, (value5) => _41 = value5), new rt.ByteSlice(data.data, data.start + 2, mid), read$mut_bytes_Bytes, out); + rest = readAll$mut_bytes_Bytes(rt.place(() => _41, (value5) => _41 = value5), new rt.ByteSlice(dataData, dataStart + 2, mid), read$mut_bytes_Bytes, out); } else if (_22 === 6) { let _46: rt.ByteSlice = rt.byteSliceRange(input, 0); let _45: rt.Place = rt.place(() => _46, (value2) => _46 = value2); - rest = readAll$mut_ref_slice_u8(rt.place(() => _45, (value3) => _45 = value3), new rt.ByteSlice(data.data, data.start + 2, mid), read$mut_ref_slice_u8, out); + rest = readAll$mut_ref_slice_u8(rt.place(() => _45, (value3) => _45 = value3), new rt.ByteSlice(dataData, dataStart + 2, mid), read$mut_ref_slice_u8, out); } else { - let _50: Pieces.Pieces = Pieces.new(input, cut); - rest = readAll$mut_buf_Pieces(rt.place(() => _50, (value) => _50 = value), new rt.ByteSlice(data.data, data.start + 2, mid), readPieces$mut_buf_Pieces, out); + let _50: Pieces.Pieces = Pieces.new(input.data, input.start, input.length, cut); + rest = readAll$mut_buf_Pieces(rt.place(() => _50, (value) => _50 = value), new rt.ByteSlice(dataData, dataStart + 2, mid), readPieces$mut_buf_Pieces, out); } rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rest)); const vec: rt.ByteVec = new rt.ByteVec(); - const _59: Pieces.Pieces = Pieces.new(input, cut); + const _59: Pieces.Pieces = Pieces.new(input.data, input.start, input.length, cut); rt.byteVecPutBuf(vec, _59, Pieces.hasRemaining$bytes_Buf, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined); rt.byteVecExtendFromSlice(out, rt.byteVecSlice(vec)); const slice: rt.ByteSlice = input; @@ -628,18 +628,18 @@ export function readAll$ref_slice_u8(buf: rt.Place, ops: rt.ByteSl * The same writes into a `Vec` and a `BytesMut`, which must match, and through the * impl forwarding through a `&mut`. */ -export function writes(data: rt.ByteSlice, out: rt.ByteVec): void { +export function writes(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { const vec: rt.ByteVec = new rt.ByteVec(); const buf: rt.BytesMut = rt.bytesMutWithCapacity(0); - writeAll$Vec_u8(vec, data); - writeAll$bytes_BytesMut(buf, data); + writeAll$Vec_u8(vec, dataData, dataStart, dataLen); + writeAll$bytes_BytesMut(buf, dataData, dataStart, dataLen); const _11: [rt.ByteVec, rt.BytesMut] = [new rt.ByteVec(), rt.bytesMutWithCapacity(0)]; const throughVec: rt.ByteVec = _11[0]; const throughBuf: rt.BytesMut = _11[1]; let _16: rt.ByteVec = throughVec; - writeThrough$mut_Vec_u8(rt.place(() => _16, (value) => _16 = value), data); + writeThrough$mut_Vec_u8(rt.place(() => _16, (value) => _16 = value), dataData, dataStart, dataLen); let _19: rt.BytesMut = throughBuf; - writeThrough$mut_bytes_BytesMut(rt.place(() => _19, (value2) => _19 = value2), data); + writeThrough$mut_bytes_BytesMut(rt.place(() => _19, (value2) => _19 = value2), dataData, dataStart, dataLen); rt.byteVecExtendFromSlice(out, rt.byteVecSlice(throughVec)); rt.byteVecExtendFromSlice(out, rt.bytesMutView(throughBuf)); rt.byteVecPush(out, rt.byteSliceEq(rt.byteVecSlice(vec), rt.bytesMutView(buf)) ? 1 : 0); @@ -649,19 +649,19 @@ export function writes(data: rt.ByteSlice, out: rt.ByteVec): void { } /** A write by each pair of `data`'s bytes. */ -export function writeAll$Vec_u8(buf: rt.ByteVec, data: rt.ByteSlice): void { - let dataData: Uint8Array = data.data; - let dataStart: number = data.start; - let dataLen: number = data.length; - while (dataLen >= 2) { - const op: rt.u8 = dataData[dataStart]; - const n: rt.u8 = dataData[dataStart + 1]; - const restData: Uint8Array = dataData; - const restStart: number = dataStart + 2; - const restLen: number = dataLen - 2; - dataData = restData; - dataStart = restStart; - dataLen = restLen; +export function writeAll$Vec_u8(buf: rt.ByteVec, dataData: Uint8Array, dataStart: number, dataLen: number): void { + let dataData2: Uint8Array = dataData; + let dataStart2: number = dataStart; + let dataLen2: number = dataLen; + while (dataLen2 >= 2) { + const op: rt.u8 = dataData2[dataStart2]; + const n: rt.u8 = dataData2[dataStart2 + 1]; + const restData: Uint8Array = dataData2; + const restStart: number = dataStart2 + 2; + const restLen: number = dataLen2 - 2; + dataData2 = restData; + dataStart2 = restStart; + dataLen2 = restLen; const op2: rt.u8 = op; const n2: rt.u8 = n; const v: rt.u64 = rt.u64Mul(n2 as rt.u64, { hi: 0x1010101, lo: 0x1010101 } as rt.u64); @@ -706,19 +706,19 @@ export function writeAll$Vec_u8(buf: rt.ByteVec, data: rt.ByteSlice): void { } /** A write by each pair of `data`'s bytes. */ -export function writeAll$bytes_BytesMut(buf: rt.BytesMut, data: rt.ByteSlice): void { - let dataData: Uint8Array = data.data; - let dataStart: number = data.start; - let dataLen: number = data.length; - while (dataLen >= 2) { - const op: rt.u8 = dataData[dataStart]; - const n: rt.u8 = dataData[dataStart + 1]; - const restData: Uint8Array = dataData; - const restStart: number = dataStart + 2; - const restLen: number = dataLen - 2; - dataData = restData; - dataStart = restStart; - dataLen = restLen; +export function writeAll$bytes_BytesMut(buf: rt.BytesMut, dataData: Uint8Array, dataStart: number, dataLen: number): void { + let dataData2: Uint8Array = dataData; + let dataStart2: number = dataStart; + let dataLen2: number = dataLen; + while (dataLen2 >= 2) { + const op: rt.u8 = dataData2[dataStart2]; + const n: rt.u8 = dataData2[dataStart2 + 1]; + const restData: Uint8Array = dataData2; + const restStart: number = dataStart2 + 2; + const restLen: number = dataLen2 - 2; + dataData2 = restData; + dataStart2 = restStart; + dataLen2 = restLen; const op2: rt.u8 = op; const n2: rt.u8 = n; const v: rt.u64 = rt.u64Mul(n2 as rt.u64, { hi: 0x1010101, lo: 0x1010101 } as rt.u64); @@ -766,19 +766,19 @@ export function writeAll$bytes_BytesMut(buf: rt.BytesMut, data: rt.ByteSlice): v * A write by each pair of `data`'s bytes, of those that `&mut T` forwards, and of those * whose provided body calls only those. */ -export function writeThrough$mut_Vec_u8(buf: rt.Place, data: rt.ByteSlice): void { - let dataData: Uint8Array = data.data; - let dataStart: number = data.start; - let dataLen: number = data.length; - while (dataLen >= 2) { - const op: rt.u8 = dataData[dataStart]; - const n: rt.u8 = dataData[dataStart + 1]; - const restData: Uint8Array = dataData; - const restStart: number = dataStart + 2; - const restLen: number = dataLen - 2; - dataData = restData; - dataStart = restStart; - dataLen = restLen; +export function writeThrough$mut_Vec_u8(buf: rt.Place, dataData: Uint8Array, dataStart: number, dataLen: number): void { + let dataData2: Uint8Array = dataData; + let dataStart2: number = dataStart; + let dataLen2: number = dataLen; + while (dataLen2 >= 2) { + const op: rt.u8 = dataData2[dataStart2]; + const n: rt.u8 = dataData2[dataStart2 + 1]; + const restData: Uint8Array = dataData2; + const restStart: number = dataStart2 + 2; + const restLen: number = dataLen2 - 2; + dataData2 = restData; + dataStart2 = restStart; + dataLen2 = restLen; const op2: rt.u8 = op; const n2: rt.u8 = n; const v: rt.u64 = rt.u64Mul(n2 as rt.u64, { hi: 0x1010101, lo: 0x1010101 } as rt.u64); @@ -810,19 +810,19 @@ export function writeThrough$mut_Vec_u8(buf: rt.Place, data: rt.Byte * A write by each pair of `data`'s bytes, of those that `&mut T` forwards, and of those * whose provided body calls only those. */ -export function writeThrough$mut_bytes_BytesMut(buf: rt.Place, data: rt.ByteSlice): void { - let dataData: Uint8Array = data.data; - let dataStart: number = data.start; - let dataLen: number = data.length; - while (dataLen >= 2) { - const op: rt.u8 = dataData[dataStart]; - const n: rt.u8 = dataData[dataStart + 1]; - const restData: Uint8Array = dataData; - const restStart: number = dataStart + 2; - const restLen: number = dataLen - 2; - dataData = restData; - dataStart = restStart; - dataLen = restLen; +export function writeThrough$mut_bytes_BytesMut(buf: rt.Place, dataData: Uint8Array, dataStart: number, dataLen: number): void { + let dataData2: Uint8Array = dataData; + let dataStart2: number = dataStart; + let dataLen2: number = dataLen; + while (dataLen2 >= 2) { + const op: rt.u8 = dataData2[dataStart2]; + const n: rt.u8 = dataData2[dataStart2 + 1]; + const restData: Uint8Array = dataData2; + const restStart: number = dataStart2 + 2; + const restLen: number = dataLen2 - 2; + dataData2 = restData; + dataStart2 = restStart; + dataLen2 = restLen; const op2: rt.u8 = op; const n2: rt.u8 = n; const v: rt.u64 = rt.u64Mul(n2 as rt.u64, { hi: 0x1010101, lo: 0x1010101 } as rt.u64); @@ -851,12 +851,12 @@ export function writeThrough$mut_bytes_BytesMut(buf: rt.Place, data } /** `Bytes`' own edits, through a `&mut`, and `slice_ref` of a part of it. */ -export function edits(data: rt.ByteSlice, out: rt.ByteVec): void { +export function edits(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let part!: rt.ByteSlice; - if (data.length >= 2) { - let bytes: rt.ByteSlice = rt.bytesCopyFromSlice(new rt.ByteSlice(data.data, data.start + 2, data.length - 2)); - const a: rt.usize = rt.usizeRem(data.data[data.start + 1] as rt.usize, rt.usizeAdd(data.length - 2, 2)); - const _17: rt.u8 = rt.u8Rem(data.data[data.start], 6); + if (dataLen >= 2) { + let bytes: rt.ByteSlice = rt.bytesCopyFromSlice(new rt.ByteSlice(dataData, dataStart + 2, dataLen - 2)); + const a: rt.usize = rt.usizeRem(dataData[dataStart + 1] as rt.usize, rt.usizeAdd(dataLen - 2, 2)); + const _17: rt.u8 = rt.u8Rem(dataData[dataStart], 6); if (_17 === 0) { part = rt.bytesSplitTo(rt.place(() => bytes, (value6) => bytes = value6), a); } else if (_17 === 1) { @@ -868,7 +868,7 @@ export function edits(data: rt.ByteSlice, out: rt.ByteVec): void { rt.bytesTruncate(rt.place(() => bytes, (value3) => bytes = value3), 0); part = rt.bytesNew(); } else if (_17 === 4) { - const sub: rt.ByteSlice = rt.byteSliceRange(bytes, rt.min(a, data.length - 2)); + const sub: rt.ByteSlice = rt.byteSliceRange(bytes, rt.min(a, dataLen - 2)); part = rt.bytesSliceRef(bytes, sub); } else { rt.bytesAdvance(rt.place(() => bytes, (value) => bytes = value), a); diff --git a/ts/fixtures/stock/expected/harness.ts b/ts/fixtures/stock/expected/harness.ts index 793b1d401..4209af111 100644 --- a/ts/fixtures/stock/expected/harness.ts +++ b/ts/fixtures/stock/expected/harness.ts @@ -9,7 +9,21 @@ import * as Owner from "./harness.Owner.ts"; * case added at the end moves no other. */ export function cases(): [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined][] { - return [["slices", slices as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["made", made as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["events", events as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["random", random as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::bytes_mut", bytesMut as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::reads", reads as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::writes", writes as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::edits", edits as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::reserves", reserves as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined]]; + return [["slices", (a0: rt.ByteSlice, a1: rt.ByteVec): undefined => { + slices(a0.data, a0.start, a0.length, a1); + }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["made", (a02: rt.ByteSlice, a12: rt.ByteVec): undefined => { + made(a02.data, a02.start, a02.length, a12); + }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["events", events as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["random", (a04: rt.ByteSlice, a14: rt.ByteVec): undefined => { + random(a04.data, a04.start, a04.length, a14); + }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::bytes_mut", bytesMut as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::reads", (a06: rt.ByteSlice, a16: rt.ByteVec): undefined => { + reads(a06.data, a06.start, a06.length, a16); + }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::writes", (a07: rt.ByteSlice, a17: rt.ByteVec): undefined => { + writes(a07.data, a07.start, a07.length, a17); + }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::edits", (a08: rt.ByteSlice, a18: rt.ByteVec): undefined => { + edits(a08.data, a08.start, a08.length, a18); + }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::reserves", (a09: rt.ByteSlice, a19: rt.ByteVec): undefined => { + reserves(a09.data, a09.start, a09.length, a19); + }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined]]; } /** Run one case. */ @@ -41,19 +55,19 @@ export function op(name: string): rt.u8 { * `Bytes`'s slices by every kind of range, out of bounds included, which panic as * `bytes` does, and what they compare equal to. */ -export function slices(data: rt.ByteSlice, out: rt.ByteVec): void { +export function slices(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let part!: rt.ByteSlice; let range!: rt.RangeInclusive; - if (data.length >= 3) { - const bytes: rt.ByteSlice = rt.bytesCopyFromSlice(new rt.ByteSlice(data.data, data.start + 3, data.length - 3)); - const past: boolean = data.data[data.start + 2] === 255; - const _14: [rt.usize, rt.usize] = [rt.usizeRem(data.data[data.start + 1] as rt.usize, rt.usizeAdd(data.length - 3, 2)), rt.usizeRem(data.data[data.start + 2] as rt.usize, rt.usizeAdd(data.length - 3, 2))]; + if (dataLen >= 3) { + const bytes: rt.ByteSlice = rt.bytesCopyFromSlice(new rt.ByteSlice(dataData, dataStart + 3, dataLen - 3)); + const past: boolean = dataData[dataStart + 2] === 255; + const _14: [rt.usize, rt.usize] = [rt.usizeRem(dataData[dataStart + 1] as rt.usize, rt.usizeAdd(dataLen - 3, 2)), rt.usizeRem(dataData[dataStart + 2] as rt.usize, rt.usizeAdd(dataLen - 3, 2))]; const a: rt.usize = _14[0]; const b: rt.usize = _14[1]; - if ((data.data[data.start] & 128) !== 0) { + if ((dataData[dataStart] & 128) !== 0) { rt.bytesSlice(bytes, b); } - const _35: rt.u8 = rt.u8Rem(data.data[data.start], 7); + const _35: rt.u8 = rt.u8Rem(dataData[dataStart], 7); if (_35 === 0) { part = rt.bytesSlice(bytes, a, b); } else if (_35 === 1) { @@ -91,16 +105,16 @@ export function slices(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, part); rt.byteVecPush(out, rt.byteSliceEq(part, bytes) ? 1 : 0); rt.byteVecPush(out, rt.byteSliceEq(part, rt.byteSliceRange(part, 0)) ? 1 : 0); - rt.byteVecPush(out, rt.byteSliceEq(rt.bytesSlice(rt.bytesSlice(bytes, rt.min(a, data.length - 3)), 0, 0), rt.bytesNew()) ? 1 : 0); + rt.byteVecPush(out, rt.byteSliceEq(rt.bytesSlice(rt.bytesSlice(bytes, rt.min(a, dataLen - 3)), 0, 0), rt.bytesNew()) ? 1 : 0); rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.byteSliceToByteVec(part))); } } /** `Bytes` made each way, printed with `Debug`. */ -export function made(data: rt.ByteSlice, out: rt.ByteVec): void { - if (data.length !== 0) { - const skip: rt.u8 = data.data[data.start]; - const rest: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + 1, data.length - 1); +export function made(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + if (dataLen !== 0) { + const skip: rt.u8 = dataData[dataStart]; + const rest: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); const made: rt.ByteSlice[] = [rt.byteVecSlice(rt.byteSliceToByteVec(rest)), rt.byteSliceFrom(Uint8Array.of(0, 9, 13, 10, 92, 34, 39, 126, 127, 128, 255)), rt.stringAsBytes("string"), rt.stringAsBytes("text"), rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of(115, 116, 97, 116, 105, 99)), 0), rt.bytesNew(), Owner.asRef$convert_AsRef_slice_u8({ data: rt.byteSliceToByteVec(rest), skip: skip as rt.usize })]; const source: rt.ByteVec = rt.byteSliceToByteVec(rest); const copied: rt.ByteSlice = rt.bytesCopyFromSlice(rt.byteVecSlice(source)); @@ -134,12 +148,12 @@ export function events(data: rt.ByteSlice, out: rt.ByteVec): void { * `rand::rng()`'s values: each in its range, an empty range panicking as `rand`'s does, * and every value of a small range drawn. */ -export function random(data: rt.ByteSlice, out: rt.ByteVec): void { +export function random(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { let inRange!: boolean; - if (data.length >= 3) { - const kind: rt.u8 = data.data[data.start]; - const a: rt.u8 = data.data[data.start + 1]; - const b: rt.u8 = data.data[data.start + 2]; + if (dataLen >= 3) { + const kind: rt.u8 = dataData[dataStart]; + const a: rt.u8 = dataData[dataStart + 1]; + const b: rt.u8 = dataData[dataStart + 2]; rt.randRng(); b1: { const _10: rt.u8 = rt.u8Rem(kind, 10); diff --git a/ts/src/lower/body.rs b/ts/src/lower/body.rs index 68b41295a..d6a0cdb59 100644 --- a/ts/src/lower/body.rs +++ b/ts/src/lower/body.rs @@ -13,6 +13,12 @@ pub struct Body<'b, 'a, 'tcx> { pub t: &'b mut Translator<'a, 'tcx>, /// Every name in the function, so none shadows another. names: FxHashSet, + /// Which of the function's parameters are byte slices it takes as their parts, by + /// [`Translator::parted`], until its own body takes them. + pub parted: Vec, + /// Where the function hands back its `Ok`'s parts, by [`Translator::slotted`], until + /// its own body takes it. + pub slotted: Option>, } impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { @@ -20,6 +26,8 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { Body { t, names: FxHashSet::default(), + parted: Vec::new(), + slotted: None, } } @@ -112,8 +120,7 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { if let Some(class) = super::mir::coroutine::of_async_fn(self.t, instance, span) { return Expr::New(Box::new(Expr::Sym(class)), values); } - let sym = self.t.callee(instance, span); - let call = Expr::Sym(sym).call(values); + let call = self.direct_call(instance, values, span, out); // The crate's own `next` returns an item or `rt.DONE`, and its caller an `Option`. if super::iter::is_next(tcx, did) { let option = self.t.sig(did, instance.args).output(); @@ -124,6 +131,17 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { let none = self.t.none_arg(option_args.type_at(0)); return Expr::rt("iterToOption", [call].into_iter().chain(none).collect()); } + // One that hands back its `Ok`'s parts, made whole here, before anything else can + // write its slot. + if let Some(slotted) = self.t.slotted(instance) { + let ret = self.fresh(if slotted.returned { "part" } else { "err" }); + out.push(StmtKind::decl(false, ret.clone(), None, Some(call)).at(None)); + let value = slotted.rebuild(self.t, &ret, span); + let result = self.fresh("result"); + let ty = self.t.ty(slotted.ret, span); + out.push(StmtKind::decl(false, result.clone(), Some(ty), Some(value)).at(None)); + return Expr::ident(result); + } return call; } if let Some(referent) = library::referent(tcx, def_id, gargs, instance) { @@ -225,6 +243,63 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { } } + /// A call of `instance`, whose body translates, with `values`, each byte slice it takes + /// as its parts split into them. + pub fn direct_call( + &mut self, + instance: Instance<'tcx>, + values: Vec, + span: Span, + out: &mut Vec, + ) -> Expr { + let parted = self.t.parted(instance); + let values = match parted.is_empty() { + true => values, + false => self.slice_args(values, &parted, out), + }; + Expr::Sym(self.t.callee(instance, span)).call(values) + } + + /// `values`, with each byte slice `parted` marks as its `data`, `start`, and `length`, + /// evaluated in the order `values` are: a slice made in place gives its parts, and a + /// path or a tuple's part is read three times, but anything else is held first, after + /// what comes before it. + fn slice_args(&mut self, values: Vec, parted: &[bool], out: &mut Vec) -> Vec { + let mut args: Vec = Vec::with_capacity(values.len() + 2); + for (value, &parted) in values.into_iter().zip(parted) { + if !parted { + args.push(value); + continue; + } + let mut made = &value; + while let Expr::Located(_, e) | Expr::As(e, _) = made { + made = e; + } + if let Some(parts) = super::mir::made_slice(made) { + args.extend(parts.iter().cloned()); + continue; + } + let slice = match &value { + Expr::Index(base, i) if base.is_path() && i.is_constant() => value, + _ if value.is_path() => value, + _ => { + for arg in &mut args { + if !arg.is_constant() { + let name = self.fresh("arg"); + let value = std::mem::replace(arg, Expr::ident(&name)); + out.push(StmtKind::decl(false, name, None, Some(value)).at(None)); + } + } + let name = self.fresh("slice"); + out.push(StmtKind::decl(false, name.clone(), None, Some(value)).at(None)); + Expr::ident(name) + } + }; + args.extend(["data", "start", "length"].map(|key| slice.clone().member(key))); + } + args + } + /// A value of one of std's types made of zero-sized `values`, which MIR reads as a /// constant rather than from what made it, or `values` back for another type. pub fn zero_sized_std(&mut self, ty: Ty<'tcx>, values: Vec, span: Span) -> Result> { @@ -278,10 +353,12 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { { let sym = match self.t.bound_fn(instance, span) { Some(sym) => Some(sym), - None => self - .t - .lowers(self.t.typing_env_pub(), instance) - .then(|| self.t.callee(instance, span)), + // One that takes byte slices as their parts, or hands back its `Ok`'s, is wrapped + // to take and return them whole. + None => (self.t.lowers(self.t.typing_env_pub(), instance) + && self.t.parted(instance).is_empty() + && self.t.slotted(instance).is_none()) + .then(|| self.t.callee(instance, span)), }; if let Some(sym) = sym { return match sig.output().is_unit() { diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index 50251f339..2f43d18f0 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -29,6 +29,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { out: &mut Vec, ) { let tcx = self.tcx; + if self.forwards(dest) { + self.forward_call(args, span, out); + return; + } if let Some(local) = dest.as_local() && self.scalars.contains_key(&local) { @@ -161,7 +165,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { /// first, but for a `Copy` aggregate std `keeps`, copied unless moved out of a local's /// own value, which the analysis then made the local's own. Each argument `pointees` /// marks is what an `rt.Place` it is reads, as std's mappings take a `&mut` parameter. - fn operands( + pub(super) fn operands( &mut self, translated: bool, pointees: &[bool], diff --git a/ts/src/lower/mir/mod.rs b/ts/src/lower/mir/mod.rs index 0ff05de7f..1af37b33c 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -32,7 +32,8 @@ use rustc_middle::ty::{self, EarlyBinder, Instance, Ty, TyCtxt, TypingEnv}; use rustc_span::{Span, Spanned}; use self::cfg::Exit; -pub use self::place::{slice_member, writes_captures}; +pub use self::place::{made_slice, slice_member, writes_captures}; +pub use self::scalar::Slotted; use super::Translator; use super::body::Body; use super::copy::field_ty; @@ -50,15 +51,21 @@ 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 parted = t.parted(instance); + let slotted = t.slotted(instance); let mut b = Body::new(t); + b.parted = parted; + b.slotted = slotted.clone(); let mut fx = Fx::new(&mut b, &mir, Env::Plain, span); - let params = fx.params(); + let mut params = fx.params(); let body = fx.lower(); + fx.mark_unread_parts(&mut params, &body); let ret_span = fx.local_span(mir::RETURN_PLACE); let ret = match (next, ret_ty.kind()) { (true, ty::Adt(_, args)) => { Type::Union(vec![fx.b.t.ty(args.type_at(0), ret_span), Type::Rt("Done", Vec::new())]) } + (_, ty::Adt(..)) if let Some(slotted) = &slotted => fx.b.t.slot_ret_ty(slotted, ret_span), _ => fx.b.t.ret_ty(ret_ty, ret_span), }; Some(ts::Function { @@ -370,6 +377,21 @@ pub struct Fx<'m, 'b, 'a, 'tcx> { steady: FxHashSet, /// Those slices, with their types, which need declarations. scalar_binds: Vec<(String, Type)>, + /// The parameters that are byte slices passed as their parts. + parted: FxHashSet, + /// Those not held as their parts, each made from its parts on entry: its name, then + /// its parts'. + rebuilt: Vec<(Local, String, [String; 3])>, + /// Those held as their parts whose object some read makes from them all the same. + remade: FxHashSet, + /// The names of the parameters that are parts. + part_params: Vec, + /// Where this function hands back its `Ok`'s parts, if it does. + slot: Option>, + /// The calls, by block, of functions that hand back theirs. + slotted_calls: FxHashMap, Slotted<'tcx>)>, + /// The assignments of the result that return right where they are. + returning: FxHashSet, /// The tests and payload reads TypeScript may have narrowed stale. narrowing: decided::Narrowing<'tcx>, /// The statement or terminator being lowered. @@ -380,6 +402,16 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { pub fn new(b: &'m mut Body<'b, 'a, 'tcx>, mir: &'m mir::Body<'tcx>, env: Env, span: Span) -> Self { let tcx = b.t.tcx; let n = mir.local_decls.len(); + let (parted, slot) = match env { + Env::Plain => (std::mem::take(&mut b.parted), b.slotted.take()), + _ => (Vec::new(), None), + }; + let parted = mir + .args_iter() + .zip(parted) + .filter(|&(_, p)| p) + .map(|(l, _)| l) + .collect(); let narrowing = decided::narrowing(tcx, &b.t.crates, mir); let mut fx = Fx { b, @@ -430,6 +462,13 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { scalars: FxHashMap::default(), steady: FxHashSet::default(), scalar_binds: Vec::new(), + parted, + rebuilt: Vec::new(), + remade: FxHashSet::default(), + part_params: Vec::new(), + slot, + slotted_calls: FxHashMap::default(), + returning: FxHashSet::default(), narrowing, at: mir::START_BLOCK.start_location(), }; @@ -597,7 +636,9 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { self.find_stepped(); self.unborrow_passed(); self.find_halves(); + self.find_slotted_calls(); self.find_scalars(); + self.find_returning(); for local in mir.local_decls.indices() { let ty = mir.local_decls[local].ty; let slot = if self.zero_sized(ty) { @@ -1442,6 +1483,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { Slot::Var(name) => name.clone(), _ => self.b.fresh("_"), }; + if self.parted.contains(&local) { + params.extend(self.part_params(local, name)); + continue; + } let ty = self.b.t.ty(ty, self.local_span(local)); params.push(Param { name, ty: Some(ty) }); } @@ -1452,6 +1497,12 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { pub fn lower(&mut self) -> Vec { // A parameter changed in place gets its own copy, since the caller's may be shared. let mut entry = Vec::new(); + // A slice passed as its parts that isn't held so, made from them. + for (local, name, parts) in std::mem::take(&mut self.rebuilt) { + let slice = Expr::New(Box::new(Expr::Rt("ByteSlice".into())), parts.map(Expr::ident).to_vec()); + let ty = Type::Rt("ByteSlice", Vec::new()); + entry.push(StmtKind::decl(self.defs[local] > 0, name, Some(ty), Some(slice)).at(None)); + } for local in self.mir.args_iter() { let ty = self.mir.local_decls[local].ty; if self.mutated[local] @@ -2239,6 +2290,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { statement_index: i, }; self.statement(stmt, out); + if self.returning.contains(&self.at) { + self.flush(out); + return Exit::End; + } } } if let Some(&to) = self.redirect.get(&bb) { @@ -2494,6 +2549,11 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { TerminatorKind::FalseEdge { real_target, .. } | TerminatorKind::FalseUnwind { real_target, .. } => { Exit::Goto(real_target.as_usize()) } + TerminatorKind::Return if let Some(slot) = self.slot.clone() => { + self.slot_return(&slot, span, out); + self.flush(out); + Exit::End + } TerminatorKind::Return if !self.mir.local_decls[mir::RETURN_PLACE].ty.is_never() => { let ret = self.mir.local_decls[mir::RETURN_PLACE].ty; let value = match self.zero_sized(ret) { @@ -2566,6 +2626,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } => { self.call(func, args, *destination, *fn_span, out); match target { + Some(_) if self.returning.contains(&self.at) => { + self.flush(out); + Exit::End + } Some(target) => Exit::Goto(target.as_usize()), None => { self.flush(out); @@ -3559,7 +3623,7 @@ fn place_declaration(stmts: &mut [Stmt], name: &str, ty: &Type, total: usize, mu } /// How many times the statements name `name`, read or assigned. -fn list_names(stmts: &[Stmt], name: &str) -> usize { +pub(super) fn list_names(stmts: &[Stmt], name: &str) -> usize { stmts.iter().map(|s| stmt_names(s, name)).sum() } diff --git a/ts/src/lower/mir/scalar.rs b/ts/src/lower/mir/scalar.rs index a533dbf16..b3eea8221 100644 --- a/ts/src/lower/mir/scalar.rs +++ b/ts/src/lower/mir/scalar.rs @@ -7,7 +7,10 @@ //! other read makes the object there. A local whose object would be made more than once //! on a path, or in a loop that doesn't make its parts again, stays an object, so //! nothing is made more often than before, as does one only ever assigned an object's -//! parts, which saves none. +//! parts, which saves none. A function that hands back a `Result` in a slot holds its +//! result so, to hand back the `Ok`'s parts, and its callers read them back as parts. A +//! byte slice parameter is passed as its parts when its body holds it so and never makes +//! its object. use rustc_abi::VariantIdx; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; @@ -26,7 +29,7 @@ use crate::ts::{Expr, Key, Stmt, StmtKind, Type}; /// How a local held as its parts lays them out. #[derive(Clone, Debug)] -pub(super) enum Shape<'tcx> { +pub enum Shape<'tcx> { /// No JS value: `()`. Unit, /// One JS value, held whole: a number, a reference to one, or an error. @@ -180,6 +183,420 @@ fn uninhabited(ty: Ty<'_>) -> bool { ty.is_never() || matches!(ty.kind(), ty::Adt(adt, _) if adt.is_enum() && adt.variants().is_empty()) } +impl<'tcx> crate::lower::Translator<'_, 'tcx> { + /// The function of `instance` if only translated code calls it directly, so it can + /// take and return what the outside can't: a function or method, not a closure or a + /// `const`, and not a root, an `async fn`, or the crate's own `next`; and not in a + /// census, which writes nothing. + fn inside(&self, instance: ty::Instance<'tcx>) -> Option { + let tcx = self.tcx; + let ty::InstanceKind::Item(did) = instance.def else { + return None; + }; + let outside = !matches!( + tcx.def_kind(did), + rustc_hir::def::DefKind::Fn | rustc_hir::def::DefKind::AssocFn + ) || self.census + || self.roots.contains(&instance) + || !self.lowers(self.typing_env(), instance) + || tcx.asyncness(did).is_async() + || crate::lower::iter::is_next(tcx, did); + (!outside).then_some(did) + } + + /// `instance`'s parameter types, then its result's, their regions erased and their + /// types normalized. + fn inside_sig(&self, did: rustc_hir::def_id::DefId, instance: ty::Instance<'tcx>) -> (Vec>, Ty<'tcx>) { + let tcx = self.tcx; + let sig = tcx.fn_sig(did).instantiate(tcx, instance.args).skip_norm_wip(); + let sig = tcx.instantiate_bound_regions_with_erased(sig); + let normalize = |ty: Ty<'tcx>| { + tcx.try_normalize_erasing_regions(self.typing_env_pub(), ty::Unnormalized::new_wip(ty)) + .unwrap_or(ty) + }; + ( + sig.inputs().iter().map(|&ty| normalize(ty)).collect(), + normalize(sig.output()), + ) + } + + /// Which of `instance`'s parameters it takes as a byte slice's parts, its `data`, + /// `start`, and `length`, rather than an `rt.ByteSlice`: each `&[u8]` or `&[u8; N]` of a + /// function only translated code calls directly, that its body holds as its parts and + /// never makes the object of. One it would make takes the object its caller has, or + /// makes once. Empty if none. + /// + /// A body holding a slice as parts depends on whether its callees take theirs so, so + /// each instance a call reaches while this settles starts at every slice and drops those + /// its body would make, until none changes: the most parts every body agrees on, through + /// recursion too. + pub(crate) fn parted(&mut self, instance: ty::Instance<'tcx>) -> Vec { + if let Some(parted) = self.parted.get(&instance) { + return parted.clone(); + } + let Some(did) = self.inside(instance) else { + return Vec::new(); + }; + let slices: Vec = self.inside_sig(did, instance).0.into_iter().map(slice_ref).collect(); + if !slices.contains(&true) { + self.parted.insert(instance, Vec::new()); + return Vec::new(); + } + if let Some(parting) = &mut self.parting { + return parting.entry(instance).or_insert(slices).clone(); + } + self.parting = Some([(instance, slices)].into_iter().collect()); + let mut i = 0; + let mut changed = false; + loop { + let parting = self.parting.as_ref().expect("settling"); + if i == parting.len() { + if !std::mem::take(&mut changed) { + break; + } + i = 0; + continue; + } + let (&at, guess) = parting.get_index(i).expect("in range"); + let guess = guess.clone(); + let held = self.held_parts(at, &guess); + if held != guess { + self.parting.as_mut().expect("settling")[i] = held; + changed = true; + } + i += 1; + } + for (at, parted) in self.parting.take().expect("settling") { + let parted = if parted.contains(&true) { parted } else { Vec::new() }; + self.parted.insert(at, parted); + } + self.parted[&instance].clone() + } + + /// Which of the slices `guess` passes `instance` as parts its body holds as parts and + /// never makes the object of, given its callees take theirs as [`Self::parted`] guesses + /// now. What lowering it refuses is left to its lowering to report. + fn held_parts(&mut self, instance: ty::Instance<'tcx>, guess: &[bool]) -> Vec { + let span = self.tcx.def_span(instance.def_id()); + let refusals = self.refusals.replace(Vec::new()); + let failed = self.failed; + let lowered = self.lowered.contains(&instance); + let held = match super::instance_mir(self, instance, span) { + Some(mir) => { + let slotted = self.slotted(instance); + let mut b = crate::lower::body::Body::new(self); + b.parted = guess.to_vec(); + b.slotted = slotted; + let fx = Fx::new(&mut b, &mir, super::Env::Plain, span); + mir.args_iter() + .zip(guess) + .map(|(local, &parted)| parted && fx.scalars.contains_key(&local) && !fx.remade.contains(&local)) + .collect() + } + None => guess.to_vec(), + }; + self.refusals = refusals; + self.failed = failed; + if !lowered { + self.lowered.remove(&instance); + } + held + } + + /// Where `instance` hands back its `Ok`'s parts, if it does: a function of the crate's + /// that only translated code calls directly, and that returns a `Result` of byte slices + /// and scalars whose error is one value that is never `undefined`, such as + /// `Result<(u64, &[u8]), E>`, writes the `Ok`'s parts into a module-level slot its + /// caller reads at once, and returns its error or `undefined`. One whose first part is + /// a number returns that, or `undefined` for an error, and writes the error into the + /// slot instead. + pub(crate) fn slotted(&mut self, instance: ty::Instance<'tcx>) -> Option> { + if let Some(slotted) = self.slotted.get(&instance) { + return slotted.clone(); + } + let slotted = self.find_slot(instance); + self.slotted.insert(instance, slotted.clone()); + slotted + } + + fn find_slot(&mut self, instance: ty::Instance<'tcx>) -> Option> { + let did = self.inside(instance)?; + // Std's are small, and their callers take the result apart as they are. + if !self.crates.translates(did) { + return None; + } + let ret = self.inside_sig(did, instance).1; + let ty::Adt(adt, args) = ret.kind() else { + return None; + }; + if Std::of(self.tcx, adt.did()) != Some(Std::Result) || self.drops(ret) { + return None; + } + let (ok, err) = (args.type_at(0), args.type_at(1)); + if uninhabited(ok) || uninhabited(err) || matches!(err.kind(), ty::FnDef(..)) { + return None; + } + let shape = self.shape(ok)?; + if !shape.has_slice() || shape.has_enum() || !matches!(self.shape(err), Some(Shape::Leaf(_))) { + return None; + } + let mut parts = Vec::new(); + shape.parts("", &mut parts); + let erased = self.erases_to(err); + if erased.undefined || erased.none || erased.param || erased.pending || erased.outer_pending { + return None; + } + // A number is returned rather than written to the long-lived slot, where V8 boxes + // one past 2^31 that a function too big to inline writes; the error then goes in + // the slot. + let returned = matches!(parts[0].1, Part::Value(first) if first.is_numeric()); + let fields: Vec = parts.iter().map(|(suffix, _)| format!("p{suffix}")).collect(); + let sym = match self.slots.get(&ok) { + Some(&sym) => sym, + None => self.slot(ok, instance, &parts, &fields, returned), + }; + self.place_slot(sym, instance); + Some(Slotted { + sym, + ret, + err, + ok: shape, + fields, + returned, + }) + } + + /// The slot of `Ok` payloads of type `ok`, which every function returning one shares: + /// each of `fields`, or if the first part is `returned`, the error, of any of their + /// error types, and the rest. Each starts `undefined`, so V8 keeps it tagged. + fn slot( + &mut self, + ok: Ty<'tcx>, + instance: ty::Instance<'tcx>, + parts: &[(String, Part<'tcx>)], + fields: &[String], + returned: bool, + ) -> crate::ts::SymId { + let span = self.tcx.def_span(instance.def_id()); + let sym = self.program.sym(crate::program::Symbol { + module: Vec::new(), + base: String::new(), + suffix: String::new(), + owner: None, + kind: crate::program::SymKind::Value, + order: u32::MAX, + span, + instance: String::new(), + name: String::new(), + alias: None, + }); + let tys: Vec = parts.iter().map(|(_, part)| self.part_ty(*part, span)).collect(); + let never = Expr::As(Box::new(Expr::undefined()), Type::Builtin("never")); + let held = usize::from(returned); + let err = returned.then(|| (ERR.to_string(), Type::Builtin("unknown"), Expr::undefined())); + let held = std::iter::zip(&fields[held..], tys.into_iter().skip(held)) + .map(|(field, ty)| (field.clone(), ty, never.clone())); + let fields: Vec<(String, Type, Expr)> = err.into_iter().chain(held).collect(); + self.program.items.push(crate::ts::Item::Value { + sym, + ty: Type::Object( + fields + .iter() + .map(|(field, ty, _)| (field.clone(), ty.clone())) + .collect(), + ), + doc: None, + value: Expr::Object( + (fields.into_iter()) + .map(|(field, _, value)| (Key::Name(field), value)) + .collect(), + ), + }); + self.slots.insert(ok, sym); + sym + } + + /// Put the slot `sym` beside `instance`, named for it and suffixed as it is, if it comes + /// first in the source of the functions that share it, whatever order translation + /// reaches them in. + fn place_slot(&mut self, sym: crate::ts::SymId, instance: ty::Instance<'tcx>) { + let owner = self.instance(instance); + let owner = &self.program.syms[owner]; + let (order, module, suffix) = (owner.order, owner.module.clone(), owner.suffix.clone()); + let slot = &self.program.syms[sym]; + if !slot.base.is_empty() && (order, &module, &suffix) >= (slot.order, &slot.module, &slot.suffix) { + return; + } + let base = crate::lower::names::slot_base(self.tcx, instance.def_id()); + let slot = &mut self.program.syms[sym]; + (slot.order, slot.module, slot.base, slot.suffix) = (order, module, base, suffix); + } + + /// What a function that hands back its `Ok`'s parts in `slotted` returns: the first + /// part, if it does, or its error, or else `undefined`. + pub(crate) fn slot_ret_ty(&mut self, slotted: &Slotted<'tcx>, span: Span) -> Type { + let ty = match slotted.returned { + true => { + let mut parts = Vec::new(); + slotted.ok.parts("", &mut parts); + self.part_ty(parts[0].1, span) + } + false => self.ty(slotted.err, span), + }; + Type::Union(vec![ty, Type::Builtin("undefined")]) + } + + /// The type of a variable or field that holds `part`. + fn part_ty(&mut self, part: Part<'tcx>, span: Span) -> Type { + match part { + Part::Flag => Type::Builtin("boolean"), + Part::Data => Type::Builtin("Uint8Array"), + Part::Number => Type::Builtin("number"), + Part::Value(ty) => self.held_ty(ty, span), + } + } + + /// How a local of `ty` is laid out as its parts, if it can be. + pub(crate) fn shape(&self, ty: Ty<'tcx>) -> Option> { + let tcx = self.tcx; + match ty.kind() { + _ if slice_ref(ty) => Some(Shape::Slice), + ty::Tuple(tys) if tys.is_empty() => Some(Shape::Unit), + ty::Tuple(tys) => { + let fields = tys.iter().map(|t| self.shape(t)).collect::>>()?; + Some(Shape::Tuple(ty, fields)) + } + ty::Adt(adt, args) + if matches!( + Std::of(tcx, adt.did()), + Some(Std::Option | Std::Result | Std::ControlFlow) + ) => + { + let variant = |v: usize| -> Option>>> { + let tys: Vec> = adt + .variant(VariantIdx::from_usize(v)) + .fields + .iter() + .map(|f| f.ty(tcx, args).skip_norm_wip()) + .collect(); + if tys.iter().any(|t| uninhabited(*t)) { + return Some(None); + } + Some(Some( + tys.into_iter().map(|t| self.shape(t)).collect::>>()?, + )) + }; + Some(Shape::Enum(ty, [variant(0)?, variant(1)?])) + } + ty::Ref(_, _, rustc_ast::Mutability::Mut) | ty::RawPtr(..) => None, + _ if self.needs_copy(ty) => None, + _ => Some(Shape::Leaf(ty)), + } + } +} + +/// The slot's field that holds an error. +const ERR: &str = "err"; + +/// Where a function hands back its `Ok`'s parts: it writes them into a module-level slot +/// and returns its error or `undefined`, or, if the first part is `returned`, it returns +/// that or `undefined` for an error, and writes the rest, or the error, into the slot. +#[derive(Clone, Debug)] +pub struct Slotted<'tcx> { + pub sym: crate::ts::SymId, + /// The `Result` the function returns in Rust. + pub ret: Ty<'tcx>, + /// Its error type. + pub err: Ty<'tcx>, + /// The `Ok` payload's layout, which has no enum. + pub ok: Shape<'tcx>, + /// Each part's field in the slot, in order. + pub fields: Vec, + /// Whether the first part, a number, is returned rather than written. + pub returned: bool, +} + +impl<'tcx> Slotted<'tcx> { + /// The slot's field of part `i`, read or written. + pub fn field(&self, i: usize) -> Expr { + assert!(i > 0 || !self.returned, "the first part is returned"); + Expr::Sym(self.sym).member(self.fields[i].clone()) + } + + /// Where the parts the slot holds start. + fn held(&self) -> usize { + usize::from(self.returned) + } + + /// The slot's field of the error. + pub fn err_field(&self) -> Expr { + Expr::Sym(self.sym).member(ERR) + } + + /// What a caller that keeps the result whole makes of what the call returned, `ret` + /// (a name), read at once: the `Ok` of the slot's parts, or the `Err`. + pub fn rebuild(&self, t: &mut crate::lower::Translator<'_, 'tcx>, ret: &str, span: Span) -> Expr { + let first = self.returned.then(|| Expr::ident(ret)); + let parts: Vec = first + .into_iter() + .chain((self.held()..self.fields.len()).map(|i| self.field(i))) + .collect(); + let ok = build_plain(t, &self.ok, &parts, span); + let err_ty = t.ty(self.err, span); + let (failed, err) = match self.returned { + true => (Expr::ident(ret).binary("===", Expr::undefined()), self.err_field()), + false => (Expr::ident(ret).binary("!==", Expr::undefined()), Expr::ident(ret)), + }; + Expr::Cond( + Box::new(failed), + Box::new(Expr::rt("Err", vec![Expr::As(Box::new(err), err_ty)])), + Box::new(Expr::rt("Ok", vec![ok])), + ) + } +} + +/// The value of `shape`, which has no enum, its `parts` make. +fn build_plain<'tcx>( + t: &mut crate::lower::Translator<'_, 'tcx>, + shape: &Shape<'tcx>, + parts: &[Expr], + span: Span, +) -> Expr { + match shape { + Shape::Unit => Expr::undefined(), + Shape::Leaf(_) => parts[0].clone(), + Shape::Slice => Expr::New(Box::new(Expr::Rt("ByteSlice".into())), parts.to_vec()), + Shape::Tuple(ty, fields) => { + let mut at = 0; + let mut items = Vec::with_capacity(fields.len()); + for field in fields { + items.push(build_plain(t, field, &parts[at..at + field.size()], span)); + at += field.size(); + } + Expr::As(Box::new(Expr::Array(items)), t.ty(*ty, span)) + } + Shape::Enum(..) => unreachable!("a slot's payload has no enum"), + } +} + +/// Return the error `err` from a function that hands back its `Ok`'s parts, or +/// `undefined` with `err` in the slot, if it returns its first part. +fn slot_fail(slot: &Slotted<'_>, err: Expr, loc: Option) -> Vec { + match slot.returned { + true => vec![ + StmtKind::Expr(slot.err_field().assign(err)).at(None), + StmtKind::Return(Some(Expr::undefined())).at(loc), + ], + false => vec![StmtKind::Return(Some(err)).at(loc)], + } +} + +/// Whether `ty` is a `&[u8]` or `&[u8; N]`, which is an `rt.ByteSlice`. +fn slice_ref(ty: Ty<'_>) -> bool { + matches!(ty.kind(), ty::Ref(_, inner, rustc_ast::Mutability::Not) + if super::place::byte_slice(*inner) || crate::lower::byte_array(*inner)) +} + /// A local held as its parts. #[derive(Debug)] pub(super) struct Scalar<'tcx> { @@ -253,9 +670,15 @@ fn walk<'s, 'tcx>(shape: &'s Shape<'tcx>, elems: &[PlaceElem<'tcx>]) -> (Node<'s enum Producer { SplitFirst, SplitFirstChunk(u64), - SplitAt { checked: bool }, + SplitAt { + checked: bool, + }, OkOr, Branch, + /// `?`'s `Err` of a `Result`'s residual, its error converted. + FromResidual, + /// A function that hands back its `Ok`'s parts in its slot. + Slotted, } /// A part of a local, by index, and the part of another held local it copies, if any. @@ -271,56 +694,24 @@ struct Made { impl<'tcx> Fx<'_, '_, '_, 'tcx> { /// How a local of `ty` is laid out as its parts, if it can be. fn shape(&self, ty: Ty<'tcx>) -> Option> { - let tcx = self.tcx; - match ty.kind() { - ty::Ref(_, inner, rustc_ast::Mutability::Not) - if super::place::byte_slice(*inner) || crate::lower::byte_array(*inner) => - { - Some(Shape::Slice) - } - ty::Tuple(tys) if tys.is_empty() => Some(Shape::Unit), - ty::Tuple(tys) => { - let fields = tys.iter().map(|t| self.shape(t)).collect::>>()?; - Some(Shape::Tuple(ty, fields)) - } - ty::Adt(adt, args) - if matches!( - Std::of(tcx, adt.did()), - Some(Std::Option | Std::Result | Std::ControlFlow) - ) => - { - let variant = |v: usize| -> Option>>> { - let tys: Vec> = adt - .variant(VariantIdx::from_usize(v)) - .fields - .iter() - .map(|f| f.ty(tcx, args).skip_norm_wip()) - .collect(); - if tys.iter().any(|t| uninhabited(*t)) { - return Some(None); - } - Some(Some( - tys.into_iter().map(|t| self.shape(t)).collect::>>()?, - )) - }; - Some(Shape::Enum(ty, [variant(0)?, variant(1)?])) - } - ty::Ref(_, _, rustc_ast::Mutability::Mut) | ty::RawPtr(..) => None, - _ if self.b.t.needs_copy(ty) => None, - _ => Some(Shape::Leaf(ty)), - } + self.b.t.shape(ty) } - /// The std call `func` makes into a local of `shape`, if its parts can be made from - /// its arguments': a split of bytes, `ok_or` of an `Option`, or `?` on a `Result` or - /// `Option`, each of a local held as its parts. + /// The call `func`, ending `block`, makes into a local of `shape`, if its parts can be + /// made from its arguments': a split of bytes, `ok_or` of an `Option`, or `?` on a + /// `Result` or `Option`, each of a local held as its parts, or the `Err` that `?` + /// returns; or from a slot. fn producer( &self, + block: BasicBlock, func: &Operand<'tcx>, args: &[Spanned>], shape: &Shape<'tcx>, shapes: &FxHashMap>, ) -> Option { + if self.slotted_calls.contains_key(&block) { + return Some(Producer::Slotted); + } let tcx = self.tcx; let ty::FnDef(def_id, gargs) = *func.ty(&self.mir.local_decls, tcx).kind() else { return None; @@ -365,6 +756,15 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { { Some(Producer::Branch) } + ("FromResidual", "from_residual") + if matches!(shape, Shape::Enum(ty, [Some(_), Some(_)]) if self.b.t.std_of(*ty) == Some(Std::Result)) + && gargs + .types() + .nth(1) + .is_some_and(|t| self.b.t.std_of(t) == Some(Std::Result)) => + { + Some(Producer::FromResidual) + } _ => None, } } @@ -469,14 +869,78 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { } } + /// Find the calls of functions that hand back their `Ok`'s parts in a slot. + pub(super) fn find_slotted_calls(&mut self) { + for (bb, data) in self.mir.basic_blocks.iter_enumerated() { + if let TerminatorKind::Call { func, .. } = &data.terminator().kind + && let ty::FnDef(def_id, args) = *func.ty(&self.mir.local_decls, self.tcx).kind() + && let Ok(Some(instance)) = + ty::Instance::try_resolve(self.tcx, self.b.t.typing_env_pub(), def_id, args.skip_binder()) + && let Some(slotted) = self.b.t.slotted(instance) + { + self.slotted_calls.insert(bb, (instance, slotted)); + } + } + } + + /// Which arguments a call of `func` takes as a byte slice's parts, as + /// [`Translator::parted`](crate::lower::Translator::parted) says. + pub(super) fn parted_call(&mut self, func: &Operand<'tcx>) -> Vec { + let ty::FnDef(def_id, args) = *func.ty(&self.mir.local_decls, self.tcx).kind() else { + return Vec::new(); + }; + match ty::Instance::try_resolve(self.tcx, self.b.t.typing_env_pub(), def_id, args.skip_binder()) { + Ok(Some(instance)) => self.b.t.parted(instance), + _ => Vec::new(), + } + } + + /// The parameters a byte slice `local`, named `name`, is passed as: its parts' variables + /// if it is held as its parts, or else names for them, from which it is made on entry. + pub(super) fn part_params(&mut self, local: Local, name: String) -> Vec { + let names: [String; 3] = match self.scalars.get(&local) { + Some(scalar) => <[String; 3]>::try_from(scalar.vars.clone()).expect("a slice's three parts"), + None => { + let names = ["Data", "Start", "Len"].map(|key| self.b.fresh(&format!("{name}{key}"))); + self.rebuilt.push((local, name, names.clone())); + names + } + }; + self.part_params.extend(names.iter().cloned()); + let tys = [ + Type::Builtin("Uint8Array"), + Type::Builtin("number"), + Type::Builtin("number"), + ]; + names + .into_iter() + .zip(tys) + .map(|(name, ty)| crate::ts::Param { name, ty: Some(ty) }) + .collect() + } + + /// Mark the parameters that are parts `body` never reads, as `noUnusedParameters` + /// wants: a slice of which only the length is read, say. + pub(super) fn mark_unread_parts(&mut self, params: &mut [crate::ts::Param], body: &[Stmt]) { + for param in params { + if self.part_params.contains(¶m.name) + && !param.name.starts_with('_') + && super::list_names(body, ¶m.name) == 0 + { + param.name = self.b.fresh(&format!("_{}", param.name)); + } + } + } + /// Find the locals to hold as their parts. pub(super) fn find_scalars(&mut self) { let mir = self.mir; let mut shapes: FxHashMap> = FxHashMap::default(); for local in mir.local_decls.indices() { - if self.is_arg(local) - || local == mir::RETURN_PLACE - || self.defs[local] == 0 + let parted = self.parted.contains(&local); + if self.is_arg(local) && !parted + || local == mir::RETURN_PLACE && self.slot.is_none() + || self.defs[local] == 0 && !parted || self.borrowed[local] || self.stepped.contains(&local) || self.next_results.contains(&local) @@ -495,9 +959,16 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { shapes.insert(local, shape); } } + let mut parted_calls: FxHashMap> = FxHashMap::default(); + for (bb, data) in mir.basic_blocks.iter_enumerated() { + if let TerminatorKind::Call { func, .. } = &data.terminator().kind { + parted_calls.insert(bb, self.parted_call(func)); + } + } while !shapes.is_empty() { - let bad = self.unheld(&shapes); + let (bad, remade) = self.unheld(&shapes, &parted_calls); if bad.is_empty() { + self.remade = remade; break; } shapes.retain(|l, _| !bad.contains(l)); @@ -519,8 +990,13 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { /// The locals of `shapes` that can't be held as their parts, given the others are: one /// assigned other than by what makes its parts, or written into, or whose object would - /// be made more often than now. - fn unheld(&self, shapes: &FxHashMap>) -> FxHashSet { + /// be made more often than now. Then the parameters passed as parts whose object some + /// read makes. `parted_calls` holds which arguments each call takes as parts. + fn unheld( + &self, + shapes: &FxHashMap>, + parted_calls: &FxHashMap>, + ) -> (FxHashSet, FxHashSet) { let mir = self.mir; let tcx = self.tcx; let mut bad = FxHashSet::default(); @@ -529,6 +1005,8 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { let mut copies: Vec = Vec::new(); // Statements and terminators that take their reads of these apart. let mut taken: FxHashSet = FxHashSet::default(); + // And the slices calls take as their parts. + let mut passed: FxHashSet<(Location, Place<'tcx>)> = FxHashSet::default(); // Those some def gives parts that are not one object's already. let mut parted: FxHashSet = FxHashSet::default(); for (bb, data) in mir.basic_blocks.iter_enumerated() { @@ -588,12 +1066,12 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { if let Some(local) = destination.as_local().filter(|l| shapes.contains_key(l)) { def_blocks.entry(local).or_default().insert(bb); taken.insert(at); - match self.producer(func, args, &shapes[&local], shapes) { + match self.producer(bb, func, args, &shapes[&local], shapes) { Some(producer) => { parted.insert(local); let size = shapes[&local].size(); for part in 0..size { - copies.push((local, part, self.produced_copy(producer, part, &args[0].node, shapes))); + copies.push((local, part, self.produced_copy(producer, part, args, shapes))); } } None => { @@ -601,6 +1079,17 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { } } } + // A slice passed as its parts. + for (arg, &parted) in args.iter().zip(&parted_calls[&bb]) { + if let (Operand::Copy(p) | Operand::Move(p), true) = (&arg.node, parted) + && let Some(shape) = shapes.get(&p.local) + && let (node, n) = walk(shape, p.projection) + && n == p.projection.len() + && matches!(node.shape, Shape::Slice) + { + passed.insert((at, *p)); + } + } // A slice's length, read by std. if let ty::FnDef(def_id, _) = *func.ty(&mir.local_decls, tcx).kind() && library::is_std(tcx, def_id) @@ -611,12 +1100,22 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { } } } - // Held as the parts of the one object it is, a local saves nothing. - bad.extend(shapes.keys().filter(|l| !parted.contains(l))); + // Held as the parts of the one object it is, a local saves nothing, but for the + // result, whose parts go to the slot; a parameter passed as its parts is made on + // entry. + bad.extend( + shapes + .keys() + .filter(|&&l| !parted.contains(&l) && !self.parted.contains(&l) && l != mir::RETURN_PLACE), + ); + for &local in shapes.keys().filter(|l| self.parted.contains(l)) { + copies.extend((0..3).map(|part| (local, part, None))); + } // What reads them otherwise, and which reads make their objects. struct Reads<'s, 'tcx> { shapes: &'s FxHashMap>, taken: &'s FxHashSet, + passed: &'s FxHashSet<(Location, Place<'tcx>)>, made: Vec, bad: FxHashSet, } @@ -640,7 +1139,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { } PlaceContext::NonMutatingUse(_) => {} } - if self.taken.contains(&at) { + if self.taken.contains(&at) || self.passed.contains(&(at, *place)) { return; } let (node, n) = walk(shape, place.projection); @@ -670,6 +1169,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { let mut reads = Reads { shapes, taken: &taken, + passed: &passed, made: Vec::new(), bad: FxHashSet::default(), }; @@ -733,7 +1233,12 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { } } } - bad + let remade = made + .iter() + .flat_map(|(_, objects)| objects.iter().map(|&(l, _)| l)) + .filter(|l| self.parted.contains(l)) + .collect(); + (bad, remade) } /// For each part of `local` that its definition `rvalue` copies from another local held @@ -799,15 +1304,20 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { &self, producer: Producer, part: usize, - arg: &Operand<'tcx>, + args: &[Spanned>], shapes: &FxHashMap>, ) -> Option<(Local, usize)> { - let (Operand::Copy(p) | Operand::Move(p)) = arg else { + // A slotted call may take no argument, and copies none. + let (Operand::Copy(p) | Operand::Move(p)) = &args.first()?.node else { return None; }; let (node, _) = walk(shapes.get(&p.local)?, p.projection); match producer { - Producer::SplitFirst | Producer::SplitFirstChunk(_) | Producer::SplitAt { .. } => None, + Producer::SplitFirst + | Producer::SplitFirstChunk(_) + | Producer::SplitAt { .. } + | Producer::FromResidual + | Producer::Slotted => None, // The `Option`'s flag, then its value, then the error. Producer::OkOr => (part >= 1 && part < node.shape.size()).then_some((p.local, node.at + part)), Producer::Branch => { @@ -877,6 +1387,11 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { ) } + /// Whether `local` is assigned once, and not a parameter, which its caller assigns first. + fn once(&self, local: Local) -> bool { + self.defs[local] == 1 && !self.is_arg(local) + } + /// Name the variables of `local`'s parts, from its own name `base`. pub(super) fn name_scalar(&mut self, local: Local, base: &str) { let Some(scalar) = self.scalars.get(&local) else { @@ -884,10 +1399,15 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { }; let mut parts = Vec::new(); scalar.shape.parts("", &mut parts); - let vars = parts + let vars: Vec = parts .iter() .map(|(suffix, _)| self.b.fresh(&format!("{base}{suffix}"))) .collect(); + // A parameter's parts are the parameters, which hold the same until assigned. + if self.parted.contains(&local) && self.defs[local] == 0 { + self.steady.extend(vars.iter().cloned()); + self.scalars.get_mut(&local).expect("checked above").held = Some(vars.iter().map(Expr::ident).collect()); + } self.scalars.get_mut(&local).expect("checked above").vars = vars; } @@ -897,7 +1417,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { let mut locals: Vec = self .scalars .iter() - .filter(|(_, s)| s.assigned) + .filter(|(l, s)| s.assigned && !self.is_arg(**l)) .map(|(l, _)| *l) .collect(); locals.sort(); @@ -907,12 +1427,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { self.scalars[&local].shape.parts("", &mut parts); let vars = self.scalars[&local].vars.clone(); for ((_, part), name) in parts.into_iter().zip(vars) { - let ty = match part { - Part::Flag => Type::Builtin("boolean"), - Part::Data => Type::Builtin("Uint8Array"), - Part::Number => Type::Builtin("number"), - Part::Value(ty) => self.b.t.held_ty(ty, span), - }; + let ty = self.b.t.part_ty(part, span); out.push(StmtKind::Declare { name, ty }.at(None)); } } @@ -929,7 +1444,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { let scalar = &self.scalars[&local]; match &scalar.held { Some(held) => held[parts].iter().map(|e| (e.clone(), true)).collect(), - None if self.defs[local] == 1 => { + None if self.once(local) => { let n = parts.len(); self.err(span, "a local held as its parts read before its assignment"); vec![(Expr::undefined(), true); n] @@ -1044,7 +1559,16 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { Rvalue::Aggregate(kind, ops) => self.scalar_aggregate(&shape, kind, ops, span, out), _ => unreachable!("checked by find_scalars"), }; - self.set_scalar(local, parts, out); + self.set_or_return(local, parts, span, out); + } + + /// Set `local`'s parts to `parts`, or return them, if this assigns the result right + /// before a return. + fn set_or_return(&mut self, local: Local, parts: Vec>, span: Span, out: &mut Vec) { + match local == mir::RETURN_PLACE && self.returning.contains(&self.at) { + true => self.slot_return_parts(parts.into_iter().map(|p| p.map(|(e, _)| e)).collect(), span, out), + false => self.set_scalar(local, parts, out), + } } /// Assign `local`, held as its parts, the result of the std call `func`. @@ -1058,7 +1582,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { ) { let shapes: FxHashMap> = self.scalars.iter().map(|(l, s)| (*l, s.shape.clone())).collect(); let producer = self - .producer(func, args, &shapes[&local], &shapes) + .producer(self.at.block, func, args, &shapes[&local], &shapes) .expect("checked by find_scalars"); let shape = shapes[&local].clone(); let pure = |e: Expr, steady: bool| Some((e, steady)); @@ -1138,6 +1662,75 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { parts.extend(err.into_iter().map(Some)); parts } + Producer::Slotted => self.slotted_call(local, args, span, out), + // The `Err` of the residual's error, converted. + Producer::FromResidual => { + let residual = args[0].node.ty(&self.mir.local_decls, self.tcx); + let (ty::Adt(_, from), Shape::Enum(ty, _)) = (residual.kind(), &shape) else { + unreachable!("checked by producer") + }; + let ty::Adt(_, to) = ty.kind() else { + unreachable!("a `Result` is an ADT") + }; + let (from, to) = (from.type_at(1), to.type_at(1)); + let error = match &args[0].node { + // Held as its parts: its `Err`'s, made whole. + Operand::Copy(p) | Operand::Move(p) if self.scalar_enum(*p) => { + let shape = self.scalars[&p.local].shape.clone(); + let node = walk(&shape, p.projection).0.shape; + let Shape::Enum(_, [_, Some(fields)]) = node else { + unreachable!("checked by producer") + }; + let [field] = fields.as_slice() else { + unreachable!("a residual holds one error") + }; + let at = node.variant_at(1); + let parts: Vec = self + .held_arg(&args[0].node, span, out) + .into_iter() + .map(|(e, _)| e) + .collect(); + self.build(field, None, &parts[at..at + field.size()], span) + } + op => match self.operand(op, span, out) { + // Held back, and read here, where folding it would read it. + Expr::Ident(name) + if let Some(i) = self.pending.iter().position(|p| p.name == name) + && let p = &self.pending[i] + && !p.effect + && !p.copy + && let Expr::Call(f, items) = &p.value + && matches!(&**f, Expr::Rt(n) if n == "Err") + && items.len() == 1 => + { + let Expr::Call(_, mut items) = self.pending.remove(i).value else { + unreachable!("checked above") + }; + items.pop().expect("checked above") + } + // 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 = Type::Object(vec![ + ("ok".into(), Type::Builtin("false")), + ("error".into(), self.b.t.ty(from, span)), + ]); + Expr::As(Box::new(value), err).member("error") + } + }, + }; + let mut pre = Vec::new(); + let error = self.b.convert(error, from, to, span, &mut pre); + self.emit(pre, false, out); + let mut parts = vec![None; shape.size()]; + parts[0] = Some((Expr::lit("true"), true)); + *parts.last_mut().expect("an error") = Some(self.leaf(error)); + parts + } // The parts of what it was applied to, whose `Some` continues, where the flag is // whether it breaks. Producer::Branch => { @@ -1151,7 +1744,229 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { parts } }; - self.set_scalar(local, parts, out); + self.set_or_return(local, parts, span, out); + } + + /// The parts of what a function that hands back its `Ok`'s parts returns into `local`: + /// whether it is an error, then the first part it returned, if it does, and the slot's + /// fields, read now before anything else can write them, then the error. + fn slotted_call( + &mut self, + local: Local, + args: &[Spanned>], + span: Span, + out: &mut Vec, + ) -> Vec> { + let slotted = self.slotted_calls[&self.at.block].1.clone(); + let call = self.slotted_raw(local, args, span, out); + let mut kinds = Vec::new(); + slotted.ok.parts("", &mut kinds); + let err_ty = self.b.t.ty(slotted.err, span); + let ret_ty = self.b.t.slot_ret_ty(&slotted, span); + let ret = self.b.fresh(if slotted.returned { "part" } else { "err" }); + self.steady.insert(ret.clone()); + self.scalar_binds.push((ret.clone(), ret_ty)); + let stmt = StmtKind::Expr(Expr::ident(&ret).assign(call)).at(None); + self.emit(vec![stmt], false, out); + // The error, read before the rest: V8 runs frame decode about 7% faster so. + let err = match slotted.returned { + true => { + let err = Expr::Cond( + Box::new(Expr::ident(&ret).binary("===", Expr::undefined())), + Box::new(Expr::As(Box::new(slotted.err_field()), err_ty.clone())), + Box::new(Expr::undefined()), + ); + let ty = Type::Union(vec![err_ty.clone(), Type::Builtin("undefined")]); + self.steady_value(err, "err", ty, out).0 + } + false => Expr::ident(&ret), + }; + let mut parts = vec![Some((err.clone().binary("!==", Expr::undefined()), true))]; + if slotted.returned { + let first_ty = self.b.t.part_ty(kinds[0].1, span); + parts.push(Some((Expr::As(Box::new(Expr::ident(&ret)), first_ty), true))); + } + for (i, (_, part)) in kinds.into_iter().enumerate().skip(slotted.held()) { + let ty = self.b.t.part_ty(part, span); + parts.push(Some(self.steady_value(slotted.field(i), "part", ty, out))); + } + parts.push(Some((Expr::As(Box::new(err), err_ty), true))); + parts + } + + /// The call, ending the block being lowered, of a function that hands back its `Ok`'s + /// parts, into `local`: what it returns, its `Ok`'s first part or its error, or `undefined`. + fn slotted_raw(&mut self, local: Local, args: &[Spanned>], span: Span, out: &mut Vec) -> Expr { + let instance = self.slotted_calls[&self.at.block].0; + let result = self.mir.local_decls[local].ty; + let values = self.operands(true, &[], args, result, span, out); + let values = values.into_iter().map(Expr::typed).collect(); + let mut pre = Vec::new(); + let call = self.b.direct_call(instance, values, span, &mut pre); + self.emit(pre, false, out); + match self.b.t.loc(span) { + Some(loc) => Expr::Located(loc, Box::new(call)), + None => call, + } + } + + /// Whether the call ending the block being lowered returns what it returns as is, as a + /// function's result right before a return, through the same slot. + pub(super) fn forwards(&self, dest: Place<'tcx>) -> bool { + dest.as_local() == Some(mir::RETURN_PLACE) + && self.returning.contains(&self.at) + && (self.slotted_calls.get(&self.at.block).zip(self.slot.as_ref())) + .is_some_and(|((_, callee), slot)| callee.sym == slot.sym) + } + + /// Return what the call ending the block being lowered returns, its `Ok`'s parts left + /// in the slot it shares. + pub(super) fn forward_call(&mut self, args: &[Spanned>], span: Span, out: &mut Vec) { + let call = self.slotted_raw(mir::RETURN_PLACE, args, span, out); + let loc = self.b.t.loc(span); + self.emit(vec![StmtKind::Return(Some(call)).at(loc)], false, out); + } + + /// The assignments of the result, a statement's or a call's, after which nothing runs + /// before a return: each returns there, and its block ends. Those that only make the + /// result's parts can if it is held as them, and a call that forwards the slot always. + pub(super) fn find_returning(&mut self) { + if self.slot.is_none() { + return; + } + let held = self.scalars.contains_key(&mir::RETURN_PLACE); + let mir = self.mir; + for (bb, data) in mir.basic_blocks.iter_enumerated() { + if data.is_cleanup { + continue; + } + let n = data.statements.len(); + let def = match &data.terminator().kind { + TerminatorKind::Call { + destination, + target: Some(target), + .. + } if destination.as_local() == Some(mir::RETURN_PLACE) => { + let forwards = (self.slotted_calls.get(&bb).zip(self.slot.as_ref())) + .is_some_and(|((_, callee), slot)| callee.sym == slot.sym); + ((held || forwards) && self.reaches_return(*target)).then_some(n) + } + TerminatorKind::Goto { .. } | TerminatorKind::Return if held => (0..n) + .rev() + .find(|&i| !self.idle(bb, i)) + .filter( + |&i| matches!(&data.statements[i].kind, StatementKind::Assign(a) if a.0.as_local() == Some(mir::RETURN_PLACE)), + ) + .filter(|_| match data.terminator().kind { + TerminatorKind::Goto { target, .. } => self.reaches_return(target), + _ => true, + }), + _ => None, + }; + if let Some(i) = def { + self.returning.insert(Location { + block: bb, + statement_index: i, + }); + } + } + } + + /// Whether statement `i` of `bb` does nothing. + fn idle(&self, bb: BasicBlock, i: usize) -> bool { + matches!( + self.mir.basic_blocks[bb].statements[i].kind, + StatementKind::StorageDead(_) | StatementKind::StorageLive(_) | StatementKind::Nop + ) || self.noops.contains(&(bb, i)) + } + + /// Whether `bb` returns, through blocks that do nothing but go on. + fn reaches_return(&self, mut bb: BasicBlock) -> bool { + let mut seen = FxHashSet::default(); + while seen.insert(bb) { + let data = &self.mir.basic_blocks[bb]; + if data.is_cleanup || !(0..data.statements.len()).all(|i| self.idle(bb, i)) { + return false; + } + match data.terminator().kind { + TerminatorKind::Return => return true, + TerminatorKind::Goto { target, .. } => bb = target, + _ => return false, + } + } + false + } + + /// Return from a function that hands back its `Ok`'s parts, at a `Return`. + pub(super) fn slot_return(&mut self, slot: &Slotted<'tcx>, span: Span, out: &mut Vec) { + let n = slot.fields.len(); + if self.scalars.contains_key(&mir::RETURN_PLACE) { + let parts = (self.scalar_parts(mir::RETURN_PLACE, 0..n + 2, span).into_iter()) + .map(|(e, _)| Some(e)) + .collect(); + return self.slot_return_parts(parts, span, out); + } + // A result made whole, as another call returns it, taken apart here. + let loc = self.b.t.loc(span); + let mut pre = Vec::new(); + let value = self.place_expr(Place::return_place(), span, &mut pre); + self.emit(pre, false, out); + let ty = self.b.t.ty(slot.ret, span); + let (result, _) = self.steady_value(value, "result", ty, out); + let check = StmtKind::If { + cond: result.clone().member("ok").not(), + then: slot_fail(slot, result.clone().member("error"), loc), + els: Vec::new(), + }; + self.emit(vec![check.at(None)], false, out); + let parts = self.take_apart(result.member("value"), &slot.ok, span, out); + self.slot_write(slot, parts.into_iter().map(|(e, _)| Some(e)).collect(), span, out); + } + + /// Return the result's `parts`: its error, if the flag says it is one, or else what the + /// slot doesn't hold, once it holds the rest. + fn slot_return_parts(&mut self, parts: Vec>, span: Span, out: &mut Vec) { + let slot = self.slot.clone().expect("a function with a slot"); + let loc = self.b.t.loc(span); + let n = slot.fields.len(); + let flag = parts[0].clone().expect("a result's flag"); + let err = parts[n + 1].clone().unwrap_or_else(Expr::undefined); + match &flag { + Expr::Lit(t) if t == "false" => {} + Expr::Lit(t) if t == "true" => { + self.emit(slot_fail(&slot, err, loc), false, out); + return; + } + _ => { + let check = StmtKind::If { + cond: flag, + then: slot_fail(&slot, err, loc), + els: Vec::new(), + }; + self.emit(vec![check.at(None)], false, out); + } + } + self.slot_write(&slot, parts[1..=n].to_vec(), span, out); + } + + /// Write the `Ok`'s parts `ok` the slot holds into it, and return the first part, if the + /// slot doesn't hold it, or else `undefined`. + fn slot_write(&mut self, slot: &Slotted<'tcx>, ok: Vec>, span: Span, out: &mut Vec) { + let loc = self.b.t.loc(span); + let mut ok = ok.into_iter(); + let ret = match slot.returned { + true => ok.next().flatten(), + false => None, + }; + let mut stmts: Vec = ok + .enumerate() + .map(|(i, part)| { + let field = slot.field(i + slot.held()); + StmtKind::Expr(field.assign(part.unwrap_or_else(Expr::undefined))).at(None) + }) + .collect(); + stmts.push(StmtKind::Return(Some(ret.unwrap_or_else(Expr::undefined))).at(loc)); + self.emit(stmts, false, out); } /// The parts of `op`, a local held as its parts read whole, as `ok_or` and `?` take it. @@ -1350,7 +2165,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { /// Set `local`'s parts to `parts`, leaving those of a variant it isn't as they are. fn set_scalar(&mut self, local: Local, parts: Vec>, out: &mut Vec) { let vars = self.scalars[&local].vars.clone(); - if self.defs[local] == 1 { + if self.once(local) { let mut held = Vec::with_capacity(parts.len()); for (part, var) in parts.into_iter().zip(&vars) { held.push(match part { diff --git a/ts/src/lower/mod.rs b/ts/src/lower/mod.rs index 8ece3f813..01386e905 100644 --- a/ts/src/lower/mod.rs +++ b/ts/src/lower/mod.rs @@ -50,6 +50,8 @@ pub fn translate<'tcx>(tcx: TyCtxt<'tcx>, config: &Config) -> Option { for path in &config.printable { t.printable(path); } + // What the outside calls takes its arguments whole. + t.roots = t.instances.keys().copied().collect(); t.drain(); })?; for (span, msg) in t.refusals.take().unwrap_or_default() { @@ -250,6 +252,16 @@ pub struct Translator<'a, 'tcx> { site: Option<(Span, DefId)>, /// The hand-written TypeScript the config binds items to. bindings: bind::Bindings<'tcx>, + /// The instances the config's roots name, which the outside calls. + roots: rustc_data_structures::fx::FxHashSet>, + /// Which parameters each instance takes as a byte slice's parts, by [`Self::parted`]. + parted: rustc_data_structures::fx::FxHashMap, Vec>, + /// While [`Self::parted`] settles, each instance it reached, with its guess so far. + parting: Option, Vec>>, + /// Where each instance hands back its `Ok`'s parts, if it does, by [`Self::slotted`]. + slotted: rustc_data_structures::fx::FxHashMap, Option>>, + /// The slot of each `Ok` payload type, which every function returning one shares. + slots: rustc_data_structures::fx::FxHashMap, SymId>, } /// The crates that translate as one program: the package, and every crate it depends on @@ -457,6 +469,11 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { sites: Default::default(), site: None, bindings: Default::default(), + roots: Default::default(), + parted: Default::default(), + parting: None, + slotted: Default::default(), + slots: Default::default(), }) } diff --git a/ts/src/lower/names.rs b/ts/src/lower/names.rs index 6ff3be017..32692b453 100644 --- a/ts/src/lower/names.rs +++ b/ts/src/lower/names.rs @@ -127,7 +127,10 @@ impl<'tcx> Translator<'_, 'tcx> { let tcx = self.tcx; let module = || self.module_of(def_id); match tcx.def_kind(def_id) { - DefKind::Fn => importable(names, &escape(&fn_base(tcx, def_id)), module()), + DefKind::Fn => { + importable(names, &escape(&fn_base(tcx, def_id)), module()); + self.slot_names(def_id, names); + } DefKind::Const | DefKind::Static { .. } | DefKind::AssocConst => { importable(names, &escape(tcx.item_name(def_id).as_str()), module()) } @@ -145,6 +148,7 @@ impl<'tcx> Translator<'_, 'tcx> { }; if named { importable(names, &escape(&camel(tcx.item_name(def_id).as_str())), module()); + self.slot_names(def_id, names); } } // A coroutine's class, beside the function it is of. @@ -158,6 +162,15 @@ impl<'tcx> Translator<'_, 'tcx> { } } + /// The slot of `Ok` parts beside the function `def_id`, if it returns a `Result`. + fn slot_names(&self, def_id: DefId, names: &mut Names) { + let output = self.tcx.fn_sig(def_id).skip_binder().output().skip_binder(); + if matches!(output.kind(), ty::Adt(adt, _) if library::Std::of(self.tcx, adt.did()) == Some(library::Std::Result)) + { + importable(names, &slot_base(self.tcx, def_id), self.module_of(def_id)); + } + } + /// A type's module, which importers bind whole by the type's name. fn namespace(&self, def_id: DefId, names: &mut Names) { let name = self.tcx.item_name(def_id); @@ -181,6 +194,11 @@ pub fn fn_base(tcx: TyCtxt<'_>, def_id: DefId) -> String { } } +/// The name of the slot the function `def_id` hands back its `Ok`'s parts in. +pub fn slot_base(tcx: TyCtxt<'_>, def_id: DefId) -> String { + format!("{}Out", camel(tcx.item_name(def_id).as_str())) +} + /// The name of the class of a coroutine of the function `name`. pub fn future_base(name: &str) -> String { format!("{}Future", camel(name)) diff --git a/ts/src/print.rs b/ts/src/print.rs index 111e6361f..2662e3ab2 100644 --- a/ts/src/print.rs +++ b/ts/src/print.rs @@ -624,7 +624,13 @@ impl Printer<'_> { None => "export const", }; let ty = self.ty(ty); - self.write(&format!("{decl} {name}: {ty} = /* @__PURE__ */ ")); + // Only a call or `new` takes the mark: a literal is pure already, and Rollup + // warns of a mark anywhere else. + let pure = match value { + Expr::Call(..) | Expr::New(..) => "/* @__PURE__ */ ", + _ => "", + }; + self.write(&format!("{decl} {name}: {ty} = {pure}")); self.expr(value, 2); self.write(";\n"); } diff --git a/ts/src/ts.rs b/ts/src/ts.rs index ccb35497a..d716fd299 100644 --- a/ts/src/ts.rs +++ b/ts/src/ts.rs @@ -664,7 +664,8 @@ pub enum Item { }, Function(Function), /// A module's value that every use shares, made with no effect but itself, so that a - /// bundler drops it unused: `export const NAME: T = /* @__PURE__ */ value`. + /// bundler drops it unused: `export const NAME: T = /* @__PURE__ */ new ...`, or a + /// literal. Value { sym: SymId, ty: Type, diff --git a/ts/tests/fixtures.rs b/ts/tests/fixtures.rs index 9567fcd52..41e37c162 100644 --- a/ts/tests/fixtures.rs +++ b/ts/tests/fixtures.rs @@ -257,7 +257,6 @@ fn shake(out: &Path) { "Panic", "byteSliceFrom", "checked", - "idx", "max", "panic", "saturate", @@ -267,6 +266,7 @@ fn shake(out: &Path) { "usizeSub", // The translation's, and the caller. "new_", + "sliceOut", "run", "short", "slice",