From c445c593d851c3fc728527827247061e6502e865 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Tue, 27 Oct 2026 13:32:42 -0700 Subject: [PATCH 1/5] chore(quest): claim quest/m2/ts-byte-views/locals.md Quest-Claim: 1232aad8171877d6 From b9a167743c7dc9916bace349a364f87d35c5cf75 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Tue, 27 Oct 2026 15:00:00 -0700 Subject: [PATCH 2/5] perf(ts): hold byte slice locals as their parts A local built of byte slices and scalars, in tuples, Options, Results, and ControlFlows, that nothing borrows or writes into and only std's splits, ok_or, ?, aggregates, and copies assign, is a JS value per part. It makes its object only where one escapes, and stays an object where that would happen more often than before. Chrome's varint decode takes 0.49x the time and frame decode 0.61x. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HRfpGSuhrqBv8bAxEvpXi3 --- quest/m2/ts-byte-views/README.md | 1 - quest/m2/ts-byte-views/locals.md | 28 - quest/m2/ts-byte-views/returns.md | 8 +- ts/README.md | 13 +- ts/fixtures/codec/expected/bench.ts | 34 +- .../codec/expected/coding/decode.Decoder.ts | 8 +- ts/fixtures/codec/expected/coding/varint.ts | 138 +- ts/fixtures/codec/expected/harness.ts | 95 +- ts/fixtures/lang/expected/chunks.ts | 52 +- ts/fixtures/lang/expected/harness.ts | 114 +- ts/fixtures/lang/expected/iters.ts | 11 +- ts/fixtures/lang/expected/shapes.ts | 19 +- ts/fixtures/lang/expected/splits.Short.ts | 8 + ts/fixtures/lang/expected/splits.ts | 199 +++ ts/fixtures/lang/src/harness.rs | 5 +- ts/fixtures/lang/src/lib.rs | 3 +- ts/fixtures/lang/src/splits.rs | 138 ++ ts/src/lower/library.rs | 4 +- ts/src/lower/mir/call.rs | 6 + ts/src/lower/mir/mod.rs | 83 +- ts/src/lower/mir/place.rs | 103 +- ts/src/lower/mir/rvalue.rs | 9 +- ts/src/lower/mir/scalar.rs | 1429 +++++++++++++++++ ts/tests/fixtures.rs | 1 - 24 files changed, 2214 insertions(+), 295 deletions(-) delete mode 100644 quest/m2/ts-byte-views/locals.md create mode 100644 ts/fixtures/lang/expected/splits.Short.ts create mode 100644 ts/fixtures/lang/expected/splits.ts create mode 100644 ts/fixtures/lang/src/splits.rs create mode 100644 ts/src/lower/mir/scalar.rs diff --git a/quest/m2/ts-byte-views/README.md b/quest/m2/ts-byte-views/README.md index 83ad79484..00ad7206a 100644 --- a/quest/m2/ts-byte-views/README.md +++ b/quest/m2/ts-byte-views/README.md @@ -30,6 +30,5 @@ Public API: the translator's output for byte slices. ## Required -- [Byte slices in locals](/quest/m2/ts-byte-views/locals.md) - a slice local never borrowed mutably is three values - [Byte slices returned](/quest/m2/ts-byte-views/returns.md) - a function 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/locals.md b/quest/m2/ts-byte-views/locals.md deleted file mode 100644 index 8527322fc..000000000 --- a/quest/m2/ts-byte-views/locals.md +++ /dev/null @@ -1,28 +0,0 @@ -# [M] Byte slices in locals - -## Goal - -rust2-ts keeps a byte slice local, and a tuple, `Option`, `Result`, or `ControlFlow` of byte -slices and scalars, as separate JS values, so std's splits, `ok_or`, and `?` on it make no -object. Chrome's varint and frame decode on `just ts bench` are faster than A/A's spread, -and every differential test still passes. - -## Plan - -The [epic's](/quest/m2/ts-byte-views/README.md) hand edit of locals alone measured Chrome -1.40x on varint decode and 1.30x on frames, Firefox 1.8x, Node and Bun 1.4-1.6x. - -- A MIR local qualifies when it has no `&mut` borrow, whole or in part, and every - definition is a known producer (`split_first`, `split_first_chunk`, - `split_at(_checked)`, `Option::ok_or`, `Try::branch`), an aggregate, or a copy of - another qualifying local. A shared borrow materializes the slice, which is safe while it - is borrowed. -- Any other use (an unknown call, a field store, an aggregate that does not qualify) - materializes the object at that use. A local that would materialize more than once on a - path, or inside a loop, stays an object, so nothing allocates more than today. -- An error part stays one opaque value; a local with a `Drop` terminator drops its error - part when the variant is `Err`, or is left out of the first cut. -- Build `ok_or`'s error only on the `Err` path when it is a pure aggregate. -- Leave out locals saved across an `.await`. - -Public API: the translator's output for byte slices. diff --git a/quest/m2/ts-byte-views/returns.md b/quest/m2/ts-byte-views/returns.md index ace74d45f..957a6e2bb 100644 --- a/quest/m2/ts-byte-views/returns.md +++ b/quest/m2/ts-byte-views/returns.md @@ -4,8 +4,8 @@ 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 -[locals](/quest/m2/ts-byte-views/locals.md) alone, with every differential test passing. +varint and frame decode on `just ts bench` are faster than with slices held as parts in +locals alone, with every differential test passing. ## Plan @@ -25,7 +25,3 @@ sites, and module `let`s measured 0.93x in Chrome. never delays that read. Public API: the translator's output for byte slices. - -## Required - -- [Byte slices in locals](/quest/m2/ts-byte-views/locals.md) - the representation returns hand on diff --git a/ts/README.md b/ts/README.md index df72cc199..2e4d542f3 100644 --- a/ts/README.md +++ b/ts/README.md @@ -288,8 +288,17 @@ they need. and encode no slower. A `&[u8; N]`, such as `split_first_chunk`'s chunk, is an `rt.ByteSlice` too, its bytes read in place: the decode workloads then took 0.72 times a view's time in Chrome, 0.67 in Firefox, 0.87 in Node, and 0.71 in Bun at the - geometric mean, with the A/A route within 0.03, and encode no slower. Each split still - makes a `ByteSlice` ([byte slices without objects](/quest/m2/ts-byte-views/README.md)). + geometric mean, with the A/A route within 0.03, and encode no slower. +- A local built of byte slices and scalars, in tuples, `Option`s, `Result`s, and + `ControlFlow`s, is a JS value per part: a slice's `data`, `start`, and `length`, and an + enum's variant as a flag, when nothing borrows or writes into it and only std's splits, + `ok_or`, `?`, aggregates, and copies assign it. A read that takes it apart reads its + parts; any other makes its object there, and a local whose object would be made more + 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)). - 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/bench.ts b/ts/fixtures/codec/expected/bench.ts index 428131e06..a2f9b4be2 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -16,36 +16,34 @@ import type * as Version from "./lite/version.Version.ts"; /** Run one workload. */ export function run(input: rt.ByteSlice): rt.ByteVec { const out: rt.ByteVec = new rt.ByteVec(); - const _5: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(input); - if (_5 !== undefined) { - const op: rt.u8 = _5[0]; - const _9: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(_5[1]); - if (_9 !== undefined) { - const selector: rt.u8 = _9[0]; + if (input.length !== 0) { + const op: rt.u8 = input.data[input.start]; + if (input.length - 1 !== 0) { + const selector: rt.u8 = input.data[input.start + 1]; if (op === 0) { - encoded(encodeVarints(_9[1], form(selector), out), out); + encoded(encodeVarints(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), form(selector), out), out); } else if (op === 1) { - decoded(decodeVarints(_9[1], form(selector), out), out); + decoded(decodeVarints(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), form(selector), out), out); } else if (op === 2) { - encoded(encodeFrames(_9[1], liteVersion(selector), out), out); + encoded(encodeFrames(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), liteVersion(selector), out), out); } else if (op === 3) { - decoded(decodeFrames(_9[1], liteVersion(selector), out), out); + decoded(decodeFrames(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), liteVersion(selector), out), out); } else if (op === 4) { - encoded(encodeGroup(_9[1], liteVersion(selector), out), out); + encoded(encodeGroup(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), liteVersion(selector), out), out); } else if (op === 6) { - iterate(selector, _9[1], out); + iterate(selector, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (op === 7) { - decoded(decodeSplit(_9[1], liteVersion(selector), out), out); + decoded(decodeSplit(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), liteVersion(selector), out), out); } else if (op === 8) { - ordered(_9[1], out); + ordered(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (op === 9) { - rescale(selector, _9[1], out); + rescale(selector, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (op === 10) { - stamp(_9[1], out); + stamp(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (op === 11) { - interleave(_9[1], out); + interleave(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else { - decoded(decodeGroup(_9[1], liteVersion(selector), out), out); + decoded(decodeGroup(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), liteVersion(selector), out), out); } return out; } diff --git a/ts/fixtures/codec/expected/coding/decode.Decoder.ts b/ts/fixtures/codec/expected/coding/decode.Decoder.ts index 61c6c7814..311093202 100644 --- a/ts/fixtures/codec/expected/coding/decode.Decoder.ts +++ b/ts/fixtures/codec/expected/coding/decode.Decoder.ts @@ -61,10 +61,10 @@ export function isEmpty(self: Decoder): boolean { /** Read `len` raw bytes. */ export function slice(self: Decoder, len: rt.usize): rt.Result { - const _6: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.byteSliceSplitAtChecked(self.buf, len); - if (_6 !== undefined) { - self.buf = _6[1]; - return rt.Ok(_6[0]); + 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)); } return rt.Err(short(self, len)); } diff --git a/ts/fixtures/codec/expected/coding/varint.ts b/ts/fixtures/codec/expected/coding/varint.ts index 907ebc23a..2ffb29fe2 100644 --- a/ts/fixtures/codec/expected/coding/varint.ts +++ b/ts/fixtures/codec/expected/coding/varint.ts @@ -199,115 +199,119 @@ export function read(buf: rt.ByteSlice, form: Form.Form): rt.Result<[rt.u64, rt. } export function readQuic(buf: rt.ByteSlice): rt.Result<[rt.u64, rt.ByteSlice], DecodeError.DecodeError> { - const _5: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(buf); - if (_5 !== undefined) { - const first: rt.u8 = _5[0]; + if (buf.length !== 0) { + const first: rt.u8 = buf.data[buf.start]; if (!(first < 64)) { if (!(first < 128)) { if (!(first < 192)) { - const _54: rt.Result<[rt.ByteSlice, rt.ByteSlice], DecodeError.DecodeError> = rt.optionOkOr(rt.byteSliceSplitFirstChunk(buf, 8), { tag: "Short" } as DecodeError.DecodeError); - if (_54.ok) { - const val3: [rt.ByteSlice, rt.ByteSlice] = _54.value; - return rt.Ok([fromHalves((((val3[0].data[val3[0].start] & 63) << 24) | (val3[0].data[val3[0].start + 1] << 16) | (val3[0].data[val3[0].start + 2] << 8) | val3[0].data[val3[0].start + 3]) >>> 0, ((val3[0].data[val3[0].start + 4] << 24) | (val3[0].data[val3[0].start + 5] << 16) | (val3[0].data[val3[0].start + 6] << 8) | val3[0].data[val3[0].start + 7]) >>> 0), val3[1]] as [rt.u64, rt.ByteSlice]); + 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]); } - return _54; + return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } - const _33: rt.Result<[rt.ByteSlice, rt.ByteSlice], DecodeError.DecodeError> = rt.optionOkOr(rt.byteSliceSplitFirstChunk(buf, 4), { tag: "Short" } as DecodeError.DecodeError); - if (_33.ok) { - const val2: [rt.ByteSlice, rt.ByteSlice] = _33.value; - return rt.Ok([(((val2[0].data[val2[0].start] & 63) << 24) | (val2[0].data[val2[0].start + 1] << 16) | (val2[0].data[val2[0].start + 2] << 8) | val2[0].data[val2[0].start + 3]) >>> 0 as rt.u64, val2[1]] as [rt.u64, rt.ByteSlice]); + 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]); } - return _33; + return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } - const _14: rt.Result<[rt.ByteSlice, rt.ByteSlice], DecodeError.DecodeError> = rt.optionOkOr(rt.byteSliceSplitFirstChunk(buf, 2), { tag: "Short" } as DecodeError.DecodeError); - if (_14.ok) { - const val: [rt.ByteSlice, rt.ByteSlice] = _14.value; - return rt.Ok([(((val[0].data[val[0].start] & 63) << 8) | val[0].data[val[0].start + 1]) as rt.u64, val[1]] as [rt.u64, rt.ByteSlice]); + 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]); } - return _14; + return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } - return rt.Ok([first as rt.u64, _5[1]] as [rt.u64, rt.ByteSlice]); + return rt.Ok([first as rt.u64, new rt.ByteSlice(buf.data, buf.start + 1, buf.length - 1)] as [rt.u64, rt.ByteSlice]); } return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } export function readLeadingOnes(buf: rt.ByteSlice, seven: boolean): rt.Result<[rt.u64, rt.ByteSlice], DecodeError.DecodeError> { - let _8!: [rt.u64, rt.ByteSlice]; - const _6: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(buf); - if (_6 !== undefined) { - const first: rt.u8 = _6[0]; + 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]; const _9: rt.u32 = rt.u8LeadingOnes(first); if (_9 === 0) { - _8 = [first as rt.u64, _6[1]] as [rt.u64, rt.ByteSlice]; + _8_0 = first as rt.u64; + _8_1Data = buf.data; + _8_1Start = buf.start + 1; + _8_1Len = buf.length - 1; } else if (_9 === 1) { - const _14: rt.Result<[rt.ByteSlice, rt.ByteSlice], DecodeError.DecodeError> = rt.optionOkOr(rt.byteSliceSplitFirstChunk(buf, 2), { tag: "Short" } as DecodeError.DecodeError); - if (_14.ok) { - const val: [rt.ByteSlice, rt.ByteSlice] = _14.value; - _8 = [(((val[0].data[val[0].start] & 63) << 8) | val[0].data[val[0].start + 1]) as rt.u64, val[1]] as [rt.u64, rt.ByteSlice]; + 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; } else { - return _14; + return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } } else if (_9 === 2) { - const _30: rt.Result<[rt.ByteSlice, rt.ByteSlice], DecodeError.DecodeError> = rt.optionOkOr(rt.byteSliceSplitFirstChunk(buf, 3), { tag: "Short" } as DecodeError.DecodeError); - if (_30.ok) { - const val2: [rt.ByteSlice, rt.ByteSlice] = _30.value; - _8 = [(((val2[0].data[val2[0].start] & 31) << 16) | (val2[0].data[val2[0].start + 1] << 8) | val2[0].data[val2[0].start + 2]) as rt.u64, val2[1]] as [rt.u64, rt.ByteSlice]; + 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; } else { - return _30; + return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } } else if (_9 === 3) { - const _48: rt.Result<[rt.ByteSlice, rt.ByteSlice], DecodeError.DecodeError> = rt.optionOkOr(rt.byteSliceSplitFirstChunk(buf, 4), { tag: "Short" } as DecodeError.DecodeError); - if (_48.ok) { - const val3: [rt.ByteSlice, rt.ByteSlice] = _48.value; - _8 = [(((val3[0].data[val3[0].start] & 15) << 24) | (val3[0].data[val3[0].start + 1] << 16) | (val3[0].data[val3[0].start + 2] << 8) | val3[0].data[val3[0].start + 3]) >>> 0 as rt.u64, val3[1]] as [rt.u64, rt.ByteSlice]; + 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; } else { - return _48; + return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } } else if (_9 === 4) { - const _65: rt.Result<[rt.ByteSlice, rt.ByteSlice], DecodeError.DecodeError> = rt.optionOkOr(rt.byteSliceSplitFirstChunk(buf, 5), { tag: "Short" } as DecodeError.DecodeError); - if (_65.ok) { - const val4: [rt.ByteSlice, rt.ByteSlice] = _65.value; - _8 = [fromHalves(((val4[0].data[val4[0].start] & 7)) as rt.u32, ((val4[0].data[val4[0].start + 1] << 24) | (val4[0].data[val4[0].start + 2] << 16) | (val4[0].data[val4[0].start + 3] << 8) | val4[0].data[val4[0].start + 4]) >>> 0), val4[1]] as [rt.u64, rt.ByteSlice]; + 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; } else { - return _65; + return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } } else if (_9 === 5) { - const _81: rt.Result<[rt.ByteSlice, rt.ByteSlice], DecodeError.DecodeError> = rt.optionOkOr(rt.byteSliceSplitFirstChunk(buf, 6), { tag: "Short" } as DecodeError.DecodeError); - if (_81.ok) { - const val5: [rt.ByteSlice, rt.ByteSlice] = _81.value; - _8 = [fromHalves(((val5[0].data[val5[0].start] & 3) << 8) | val5[0].data[val5[0].start + 1], ((val5[0].data[val5[0].start + 2] << 24) | (val5[0].data[val5[0].start + 3] << 16) | (val5[0].data[val5[0].start + 4] << 8) | val5[0].data[val5[0].start + 5]) >>> 0), val5[1]] as [rt.u64, rt.ByteSlice]; + 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; } else { - return _81; + return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } } else if (_9 === 6) { if (!seven) { return rt.Err({ tag: "InvalidValue" } as DecodeError.DecodeError); } - const _101: rt.Result<[rt.ByteSlice, rt.ByteSlice], DecodeError.DecodeError> = rt.optionOkOr(rt.byteSliceSplitFirstChunk(buf, 7), { tag: "Short" } as DecodeError.DecodeError); - if (_101.ok) { - const val6: [rt.ByteSlice, rt.ByteSlice] = _101.value; - _8 = [fromHalves(((val6[0].data[val6[0].start] & 1) << 16) | (val6[0].data[val6[0].start + 1] << 8) | val6[0].data[val6[0].start + 2], ((val6[0].data[val6[0].start + 3] << 24) | (val6[0].data[val6[0].start + 4] << 16) | (val6[0].data[val6[0].start + 5] << 8) | val6[0].data[val6[0].start + 6]) >>> 0), val6[1]] as [rt.u64, rt.ByteSlice]; + 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; } else { - return _101; + return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } } else if (_9 === 7) { - const _121: rt.Result<[rt.ByteSlice, rt.ByteSlice], DecodeError.DecodeError> = rt.optionOkOr(rt.byteSliceSplitFirstChunk(buf, 8), { tag: "Short" } as DecodeError.DecodeError); - if (_121.ok) { - const val7: [rt.ByteSlice, rt.ByteSlice] = _121.value; - _8 = [fromHalves((val7[0].data[val7[0].start + 1] << 16) | (val7[0].data[val7[0].start + 2] << 8) | val7[0].data[val7[0].start + 3], ((val7[0].data[val7[0].start + 4] << 24) | (val7[0].data[val7[0].start + 5] << 16) | (val7[0].data[val7[0].start + 6] << 8) | val7[0].data[val7[0].start + 7]) >>> 0), val7[1]] as [rt.u64, rt.ByteSlice]; + 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; } else { - return _121; + return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } + } 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 { - const _142: rt.Result<[rt.ByteSlice, rt.ByteSlice], DecodeError.DecodeError> = rt.optionOkOr(rt.byteSliceSplitFirstChunk(buf, 9), { tag: "Short" } as DecodeError.DecodeError); - if (_142.ok) { - const val8: [rt.ByteSlice, rt.ByteSlice] = _142.value; - _8 = [fromHalves(((val8[0].data[val8[0].start + 1] << 24) | (val8[0].data[val8[0].start + 2] << 16) | (val8[0].data[val8[0].start + 3] << 8) | val8[0].data[val8[0].start + 4]) >>> 0, ((val8[0].data[val8[0].start + 5] << 24) | (val8[0].data[val8[0].start + 6] << 16) | (val8[0].data[val8[0].start + 7] << 8) | val8[0].data[val8[0].start + 8]) >>> 0), val8[1]] as [rt.u64, rt.ByteSlice]; - } else { - return _142; - } + return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } - return rt.Ok(_8); + return rt.Ok([_8_0, new rt.ByteSlice(_8_1Data, _8_1Start, _8_1Len)] as [rt.u64, rt.ByteSlice]); } return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } diff --git a/ts/fixtures/codec/expected/harness.ts b/ts/fixtures/codec/expected/harness.ts index 0d3a074a7..0de0b22f2 100644 --- a/ts/fixtures/codec/expected/harness.ts +++ b/ts/fixtures/codec/expected/harness.ts @@ -18,27 +18,26 @@ import type * as Version from "./lite/version.Version.ts"; /** Run one case. */ export function run(input: rt.ByteSlice): rt.ByteVec { const out: rt.ByteVec = new rt.ByteVec(); - const _5: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(input); - if (_5 !== undefined) { - const _8: rt.u8 = rt.u8Rem(_5[0], 9); + if (input.length !== 0) { + const _8: rt.u8 = rt.u8Rem(input.data[input.start], 9); if (_8 === 0) { - decodeScript(_5[1], out); + decodeScript(new rt.ByteSlice(input.data, input.start + 1, input.length - 1), out); } else if (_8 === 1) { - encodeScript(_5[1], out); + encodeScript(new rt.ByteSlice(input.data, input.start + 1, input.length - 1), out); } else if (_8 === 2) { - zigzag(_5[1], out); + zigzag(new rt.ByteSlice(input.data, input.start + 1, input.length - 1), out); } else if (_8 === 3) { - sizes(_5[1], out); + sizes(new rt.ByteSlice(input.data, input.start + 1, input.length - 1), out); } else if (_8 === 4) { - roundtrip$Versions(_5[1], out); + roundtrip$Versions(new rt.ByteSlice(input.data, input.start + 1, input.length - 1), out); } else if (_8 === 5) { - roundtripLite$Group(_5[1], out); + roundtripLite$Group(new rt.ByteSlice(input.data, input.start + 1, input.length - 1), out); } else if (_8 === 6) { - roundtripLite$Probe(_5[1], out); + roundtripLite$Probe(new rt.ByteSlice(input.data, input.start + 1, input.length - 1), out); } else if (_8 === 7) { - encodeMessages(_5[1], out); + encodeMessages(new rt.ByteSlice(input.data, input.start + 1, input.length - 1), out); } else { - errors(_5[1], out); + errors(new rt.ByteSlice(input.data, input.start + 1, input.length - 1), out); } return out; } @@ -191,14 +190,15 @@ export function encodeError(out: rt.ByteVec, err: EncodeError.EncodeError): void * `data[1]` bytes after the form selector, and the wire is everything after it. */ export function decodeScript(data: rt.ByteSlice, out: rt.ByteVec): void { - const _5: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(data); - if (_5 !== undefined) { - const selector: rt.u8 = _5[0]; - const _9: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(_5[1]); - if (_9 !== undefined) { - const _13: [rt.ByteSlice, rt.ByteSlice] = rt.byteSliceSplitAt(_9[1], rt.min(_9[1].length, _9[0] as rt.usize)); - const r: Decoder.Decoder = Decoder.new(_13[1], form(selector)); - for (const _21 of rt.byteSliceView(_13[0])) { + 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) { + 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 _26: rt.Result = decodeStep(r, _21, out); if (_26.ok) { rt.byteVecPush(out, 0); @@ -305,18 +305,19 @@ export function encodeScript(data: rt.ByteSlice, out: rt.ByteVec): void { let result!: rt.Result; let _47!: rt.u64 | undefined; let _74!: Prefix.Prefix; - const _5: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(data); - if (_5 !== undefined) { - const selector: rt.u8 = _5[0]; - const _9: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(_5[1]); - if (_9 !== undefined) { - const _13: [rt.ByteSlice, rt.ByteSlice] = rt.byteSliceSplitAt(_9[1], rt.min(_9[1].length, _9[0] as rt.usize)); - let values: rt.ByteSlice = _13[1]; + 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) { + rt.panic("mid > len"); + } + let values: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + 2 + mid, data.length - 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(_13[0])) { + for (const step of rt.byteSliceView(new rt.ByteSlice(data.data, data.start + 2, mid))) { const _30: [rt.u64, rt.ByteSlice] = takeU64(values); const value: rt.u64 = _30[0]; values = _30[1]; @@ -423,10 +424,9 @@ export function sizes(data: rt.ByteSlice, out: rt.ByteVec): void { /** Decode a `T` from the wire, then encode what came out. */ export function roundtrip$Versions(data: rt.ByteSlice, out: rt.ByteVec): void { - const _5: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(data); - if (_5 !== undefined) { - const form_: Form.Form = form(_5[0]); - const _8: rt.Result<[Versions.Versions, rt.usize], DecodeError.DecodeError> = Versions.decodeSlice$Decode_Form(_5[1], form_); + 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$Decode_Form(new rt.ByteSlice(data.data, data.start + 1, data.length - 1), form_); if (_8.ok) { const value: Versions.Versions = _8.value[0]; putUsize(out, _8.value[1]); @@ -445,10 +445,9 @@ export function roundtrip$Versions(data: rt.ByteSlice, out: rt.ByteVec): void { /** [`roundtrip`] for a lite message, size-prefixed at a lite version. */ export function roundtripLite$Group(data: rt.ByteSlice, out: rt.ByteVec): void { - const _5: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(data); - if (_5 !== undefined) { - const version: Version.Version = liteVersion(_5[0]); - const _8: rt.Result<[Group.Group, rt.usize], DecodeError.DecodeError> = Group.decodeSlice$Decode_Version(_5[1], version); + if (data.length !== 0) { + const version: Version.Version = liteVersion(data.data[data.start]); + const _8: rt.Result<[Group.Group, rt.usize], DecodeError.DecodeError> = Group.decodeSlice$Decode_Version(new rt.ByteSlice(data.data, data.start + 1, data.length - 1), version); if (_8.ok) { const value: Group.Group = _8.value[0]; putUsize(out, _8.value[1]); @@ -468,10 +467,9 @@ export function roundtripLite$Group(data: rt.ByteSlice, out: rt.ByteVec): void { /** [`roundtrip`] for a lite message, size-prefixed at a lite version. */ export function roundtripLite$Probe(data: rt.ByteSlice, out: rt.ByteVec): void { - const _5: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(data); - if (_5 !== undefined) { - const version: Version.Version = liteVersion(_5[0]); - const _8: rt.Result<[Probe.Probe, rt.usize], DecodeError.DecodeError> = Probe.decodeSlice$Decode_Version(_5[1], version); + if (data.length !== 0) { + const version: Version.Version = liteVersion(data.data[data.start]); + const _8: rt.Result<[Probe.Probe, rt.usize], DecodeError.DecodeError> = Probe.decodeSlice$Decode_Version(new rt.ByteSlice(data.data, data.start + 1, data.length - 1), version); if (_8.ok) { const value: Probe.Probe = _8.value[0]; putUsize(out, _8.value[1]); @@ -491,10 +489,9 @@ export function roundtripLite$Probe(data: rt.ByteSlice, out: rt.ByteVec): void { /** Encode messages built from the data, at a lite version. */ export function encodeMessages(data: rt.ByteSlice, out: rt.ByteVec): void { - const _5: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(data); - if (_5 !== undefined) { - const version: Version.Version = liteVersion(_5[0]); - const _10: [rt.u64, rt.ByteSlice] = takeU64(_5[1]); + if (data.length !== 0) { + const 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)); const subscribe: rt.u64 = _10[0]; const _13: [rt.u64, rt.ByteSlice] = takeU64(_10[1]); const sequence: rt.u64 = _13[0]; @@ -548,11 +545,11 @@ export function encodeMessage$Probe(msg: Probe.Probe, version: Version.Version, /** Each error the codec can return, built from the data, as callers see it. */ export function errors(data: rt.ByteSlice, out: rt.ByteVec): void { let err!: DecodeError.DecodeError; - const _5: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(data); b0: { - if (_5 !== undefined) { - const selector: rt.u8 = _5[0]; - const value: rt.u64 = takeU64(_5[1])[0]; + 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); + const value: rt.u64 = takeU64(data2)[0]; const _10: rt.u8 = rt.u8Rem(selector, 8); if (_10 === 0) { err = { tag: "InvalidMessage", _0: value } as DecodeError.DecodeError; @@ -563,7 +560,7 @@ export function errors(data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_10 === 3) { err = { tag: "Session", _0: { tag: "ProtocolViolation" } as SessionError.SessionError } as DecodeError.DecodeError; } else if (_10 === 4) { - const _20: rt.Result = rt.stringFromUtf8(rt.byteSliceToByteVec(_5[1])); + const _20: rt.Result = rt.stringFromUtf8(rt.byteSliceToByteVec(data2)); if (_20.ok) { err = { tag: "Missing" } as DecodeError.DecodeError; } else { diff --git a/ts/fixtures/lang/expected/chunks.ts b/ts/fixtures/lang/expected/chunks.ts index b97338907..21e93de38 100644 --- a/ts/fixtures/lang/expected/chunks.ts +++ b/ts/fixtures/lang/expected/chunks.ts @@ -4,16 +4,14 @@ import * as rt from "./rt.ts"; import type * as Header from "./chunks.Header.ts"; export function header(data: rt.ByteSlice): Header.Header | undefined { - const _4: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.byteSliceSplitFirstChunk(data, 2); - if (_4 !== undefined) { - const val: [rt.ByteSlice, rt.ByteSlice] = _4; - return { tag: val[0], rest: val[1] }; + 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) }; } return undefined; } export function take4(data: rt.ByteSlice): rt.Result<[rt.ByteSlice, rt.ByteSlice], rt.u8> { - return rt.optionOkOr(rt.byteSliceSplitFirstChunk(data, 4), data.length & 0xff); + return rt.optionOkOr((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 word(chunk: rt.ByteSlice): rt.u32 { @@ -44,9 +42,7 @@ export function bump(chunk: rt.ByteSlice): void { } export function ends(chunk: rt.ByteSlice): [rt.u8, rt.ByteSlice, rt.u8] { - const _5: rt.u8 = chunk.data[chunk.start]; - const _6: rt.u8 = chunk.data[chunk.start + 3]; - return [_5, rt.byteSliceRange(chunk, 1, 3), _6] as [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 chunks(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { @@ -99,20 +95,19 @@ export function chunks(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { bump(rt.byteSliceFrom(pair)); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(pair)); } else if (_4 === 2) { - const _101: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.byteSliceSplitFirstChunk(data, 2); - if (_101 !== undefined) { - const b: rt.ByteSlice = rt.optionMapOr(rt.byteSliceSplitFirstChunk(_101[1], 2), _101[0], (_22: [rt.ByteSlice, rt.ByteSlice]): rt.ByteSlice => { + if (data.length >= 2) { + const a: rt.ByteSlice = new rt.ByteSlice(data.data, data.start, 2); + const b: rt.ByteSlice = rt.optionMapOr((data.length - 2 >= 2 ? [new rt.ByteSlice(data.data, data.start + 2, 2), new rt.ByteSlice(data.data, data.start + 4, data.length - 4)] as [rt.ByteSlice, rt.ByteSlice] : undefined) as [rt.ByteSlice, rt.ByteSlice] | undefined, a, (_22: [rt.ByteSlice, rt.ByteSlice]): rt.ByteSlice => { return _22[0]; }); - const part2 = _101[0]; - const part3 = _101[1]; - const read: (a0: rt.usize) => rt.u8 = reader(pick(part2, b, rt.usizeRem(data.length, 2) === 0)); + const part2 = new rt.ByteSlice(data.data, data.start + 2, data.length - 2); + const read: (a0: rt.usize) => rt.u8 = reader(pick(a, b, rt.usizeRem(data.length, 2) === 0)); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(read(0), read(1), read(3)))); const both: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { if (!(i2 < 2)) { rt.panic("index out of bounds: the len is " + 2 + " but the index is " + i2); } - const _3: rt.u8 = _101[0].data[_101[0].start + i2]; + const _3: rt.u8 = a.data[a.start + i2]; if (!(i2 < 2)) { rt.panic("index out of bounds: the len is " + 2 + " but the index is " + i2); } @@ -120,7 +115,7 @@ export function chunks(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }; rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(both(0), both(1)))); rt.byteVecExtendFromSlice(out, b); - rt.byteVecPush(out, part3.length & 0xff); + rt.byteVecPush(out, part2.length & 0xff); } } else if (_4 === 3) { const lit: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(97, 98, 99)); @@ -138,9 +133,8 @@ export function chunks(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, chosen2.data[chosen2.start + 1]); const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(chosen2), f, rt.u8Display), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(lit), f, rt.u8Display)]; rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1]]))); - const _170: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.byteSliceSplitFirstChunk(data, 3); - if (_170 !== undefined) { - const chunk: rt.ByteSlice = _170[0]; + 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.u8Display), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(chunk), f, rt.u8Display)]; rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); } @@ -182,20 +176,26 @@ export function chunks(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return p2.data[p2.start + 1]; }))); } else { - let rest: rt.ByteSlice = data; + let restData2: Uint8Array = data.data; + let restStart2: number = data.start; + let restLen2: number = data.length; let sum: rt.u32 = 0; while (true) { - const _260: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.byteSliceSplitFirstChunk(rest, 3); - if (_260 !== undefined) { - sum = rt.u32WrappingAdd((((sum << 5) >>> 0) | (sum >>> 27)) >>> 0, ((_260[0].data[_260[0].start] << 8) | _260[0].data[_260[0].start + 2]) as rt.u32); - rt.byteVecPush(out, _260[0].data[_260[0].start + 1]); - rest = _260[1]; + const _261Data: Uint8Array = restData2; + const _261Start: number = restStart2; + const _261Len: number = restLen2; + 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; } else { break; } } rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(sum))); - rt.byteVecExtendFromSlice(out, rest); + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(restData2, restStart2, restLen2)); } } diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 20cb1d2cb..ad8bb4620 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -11,6 +11,7 @@ import { u8Op, u16Op, u32Op, u64Op, u128Op, usizeOp, i8Op, i16Op, i32Op, i64Op, import { adaptors, consumers, ranges, options, own, values } from "./iters.ts"; import { keys } from "./keys.ts"; import { copies, order, discriminants, loops, patterns, closures, library, flows } from "./shapes.ts"; +import { splits } from "./splits.ts"; import { strs, slices } from "./strs.ts"; /** Run one case. */ @@ -22,119 +23,120 @@ export function run(input: rt.ByteSlice): rt.ByteVec { const _10: [rt.u8, rt.u8] = [input.data[input.start], input.data[input.start + 1]]; const op: rt.u8 = _10[0]; const kind: rt.u8 = _10[1]; - const _14: rt.u8 = rt.u8Rem(op, 47); + const _14: rt.u8 = rt.u8Rem(op, 48); if (_14 === 0) { - u8Op(kind, rt.byteSliceRange(input, 2), out); + u8Op(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 1) { - u16Op(kind, rt.byteSliceRange(input, 2), out); + u16Op(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 2) { - u32Op(kind, rt.byteSliceRange(input, 2), out); + u32Op(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 3) { - u64Op(kind, rt.byteSliceRange(input, 2), out); + u64Op(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 4) { - u128Op(kind, rt.byteSliceRange(input, 2), out); + u128Op(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 5) { - usizeOp(kind, rt.byteSliceRange(input, 2), out); + usizeOp(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 6) { - i8Op(kind, rt.byteSliceRange(input, 2), out); + i8Op(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 7) { - i16Op(kind, rt.byteSliceRange(input, 2), out); + i16Op(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 8) { - i32Op(kind, rt.byteSliceRange(input, 2), out); + i32Op(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 9) { - i64Op(kind, rt.byteSliceRange(input, 2), out); + i64Op(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 10) { - i128Op(kind, rt.byteSliceRange(input, 2), out); + i128Op(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 11) { - isizeOp(kind, rt.byteSliceRange(input, 2), out); + isizeOp(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 12) { const _28: rt.u8 = rt.u8Rem(kind, 6); if (_28 === 0) { - i8Neg(rt.byteSliceRange(input, 2), out); + i8Neg(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_28 === 1) { - i16Neg(rt.byteSliceRange(input, 2), out); + i16Neg(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_28 === 2) { - i32Neg(rt.byteSliceRange(input, 2), out); + i32Neg(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_28 === 3) { - i64Neg(rt.byteSliceRange(input, 2), out); + i64Neg(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_28 === 4) { - i128Neg(rt.byteSliceRange(input, 2), out); + i128Neg(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else { - isizeNeg(rt.byteSliceRange(input, 2), out); + isizeNeg(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } } else if (_14 === 13) { - const _36: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(rt.byteSliceRange(input, 2)); - if (_36 === undefined) { - cast(kind, rt.u8Div(kind, 12), rt.byteSliceRange(input, 2), out); + if (input.length - 2 === 0) { + cast(kind, rt.u8Div(kind, 12), new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else { - cast(kind, _36[0], _36[1], out); + cast(kind, input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); } } else if (_14 === 14) { - convert(rt.byteSliceRange(input, 2), out); + convert(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 15) { - copies(rt.byteSliceRange(input, 2), out); + copies(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 16) { - loops(rt.byteSliceRange(input, 2), out); + loops(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 17) { - patterns(rt.byteSliceRange(input, 2), out); + patterns(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 18) { - closures(rt.byteSliceRange(input, 2), out); + closures(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 19) { - discriminants(rt.byteSliceRange(input, 2), out); + discriminants(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 20) { - library(rt.byteSliceRange(input, 2), out); + library(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 21) { - ints(kind, rt.byteSliceRange(input, 2), out); + ints(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 22) { - strings(rt.byteSliceRange(input, 2), out); + strings(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 23) { - derived(rt.byteSliceRange(input, 2), out); + derived(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 24) { - written(rt.byteSliceRange(input, 2), out); + written(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 25) { - panics(kind, rt.byteSliceRange(input, 2), out); + panics(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 26) { - methods(rt.byteSliceRange(input, 2), out); + methods(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 27) { - adaptors(kind, rt.byteSliceRange(input, 2), out); + adaptors(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 28) { - consumers(kind, rt.byteSliceRange(input, 2), out); + consumers(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 29) { - ranges(rt.byteSliceRange(input, 2), out); + ranges(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 30) { - options(rt.byteSliceRange(input, 2), out); + options(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 31) { - own(rt.byteSliceRange(input, 2), out); + own(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 32) { - values(rt.byteSliceRange(input, 2), out); + values(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 33) { - order(rt.byteSliceRange(input, 2), out); + order(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 34) { - hashMaps(kind, rt.byteSliceRange(input, 2), out); + hashMaps(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 35) { - sets(kind, rt.byteSliceRange(input, 2), out); + sets(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 36) { - btreeMaps(kind, rt.byteSliceRange(input, 2), out); + btreeMaps(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 37) { - deques(rt.byteSliceRange(input, 2), out); + deques(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 38) { - flows(rt.byteSliceRange(input, 2), out); + flows(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 39) { - keys(kind, rt.byteSliceRange(input, 2), out); + keys(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 40) { - chars(kind, rt.byteSliceRange(input, 2), out); + chars(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 41) { - strs(kind, rt.byteSliceRange(input, 2), out); + strs(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 42) { - vecs(rt.byteSliceRange(input, 2), out); + vecs(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 43) { - slices(kind, rt.byteSliceRange(input, 2), out); + slices(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 44) { - stores(rt.byteSliceRange(input, 2), out); + stores(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 45) { - chunks(kind, rt.byteSliceRange(input, 2), out); + chunks(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + } else if (_14 === 46) { + splits(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else { - cows(kind, rt.byteSliceRange(input, 2), out); + cows(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } return out; } diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index b6e473738..b09c5cfe6 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -51,11 +51,16 @@ export function adaptors(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } } if (_4 === 2) { - const _56: [rt.ByteSlice, rt.ByteSlice] = rt.byteSliceSplitAt(data, rt.usizeDiv(data.length, 2)); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterMap(rt.iterZip(rt.iterSlice(rt.byteSliceView(_56[0])), rt.iterRev(rt.iterSlice(rt.byteSliceView(_56[1])))), (_216: [rt.u8, rt.u8]): rt.u8 => { + const mid: number = rt.usizeDiv(data.length, 2); + if (mid > data.length) { + rt.panic("mid > len"); + } + const front: rt.ByteSlice = new rt.ByteSlice(data.data, data.start, mid); + const back: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + mid, data.length - mid); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterMap(rt.iterZip(rt.iterSlice(rt.byteSliceView(front)), rt.iterRev(rt.iterSlice(rt.byteSliceView(back)))), (_216: [rt.u8, rt.u8]): rt.u8 => { return _216[0] ^ _216[1]; })))); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterRev(rt.iterChain(rt.iterSlice(rt.byteSliceView(_56[0])), rt.iterSlice(rt.byteSliceView(_56[1]))))))); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterRev(rt.iterChain(rt.iterSlice(rt.byteSliceView(front)), rt.iterSlice(rt.byteSliceView(back))))))); } else if (_4 === 3) { const taken: rt.ByteVec = rt.iterToByteVec(rt.iterTakeWhile(rt.iterSlice(rt.byteSliceView(data)), (_213: rt.u8): boolean => { return _213 !== 0; diff --git a/ts/fixtures/lang/expected/shapes.ts b/ts/fixtures/lang/expected/shapes.ts index 231ad86a1..5f567009e 100644 --- a/ts/fixtures/lang/expected/shapes.ts +++ b/ts/fixtures/lang/expected/shapes.ts @@ -71,11 +71,11 @@ export function dir(byte: rt.u8): Dir.Dir | undefined { } export function shape(data: rt.ByteSlice): Shape.Shape { - const _4: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(data); - if (_4 !== undefined) { - const kind: rt.u8 = _4[0]; + 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); const at: (a0: rt.usize) => rt.i32 = (i: rt.usize): rt.i32 => { - return rt.i32Sub(rt.optionUnwrapOr(rt.byteSliceGet(_4[1], i), 0) as rt.i32, 128); + return rt.i32Sub(rt.optionUnwrapOr(rt.byteSliceGet(rest, i), 0) as rt.i32, 128); }; const _7: rt.u8 = rt.u8Rem(kind, 3); if (_7 === 0) { @@ -84,7 +84,7 @@ export function shape(data: rt.ByteSlice): Shape.Shape { if (_7 === 1) { return { tag: "Line", _0: Point.new(at(0), at(1)), _1: Point.new(at(2), at(3)) } as Shape.Shape; } - return { tag: "Rect", corner: Point.new(at(0), at(1)), width: rt.u16Mul(rt.optionUnwrapOr(rt.byteSliceGet(_4[1], 2), 0) as rt.u16, 300), height: rt.optionUnwrapOr(rt.byteSliceGet(_4[1], 3), 0) as rt.u16 } as Shape.Shape; + return { tag: "Rect", corner: Point.new(at(0), at(1)), width: rt.u16Mul(rt.optionUnwrapOr(rt.byteSliceGet(rest, 2), 0) as rt.u16, 300), height: rt.optionUnwrapOr(rt.byteSliceGet(rest, 3), 0) as rt.u16 } as Shape.Shape; } return { tag: "Dot" } as Shape.Shape; } @@ -630,8 +630,11 @@ export function indexed(data: rt.ByteSlice, out: rt.ByteVec): void { const after: rt.u8 = rt.u8WrappingSub(increment(rt.byteSliceFrom(m)), before); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(first, second, called, f(1), slots[0], n, after))); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(bytes)); - const _89: [rt.ByteSlice, rt.ByteSlice] = rt.byteSliceSplitAt(data, rt.usizeDiv(data.length, 2)); - ends([_89[0], _89[1]], out); + const mid: number = rt.usizeDiv(data.length, 2); + if (mid > data.length) { + rt.panic("mid > len"); + } + ends([new rt.ByteSlice(data.data, data.start, mid), new rt.ByteSlice(data.data, data.start + mid, data.length - mid)], out); if (rt.u8Rem(at(7), 4) === 0) { const _106: [rt.u8, rt.u8, rt.u8] = [at(8), at(9), at(10)]; const x: rt.u8 = _106[0]; @@ -1262,7 +1265,7 @@ export function patterns(data: rt.ByteSlice, out: rt.ByteVec): void { rt.unreachable(undefined); } else if (!((data.data[data.start] === data.data[data.start + (data.length - 1)]))) { rt.byteVecPush(out, data.data[data.start] ^ data.data[data.start + 1]); - rt.byteVecPush(out, rt.byteSliceRange(data, 2).length & 0xff); + rt.byteVecPush(out, (data.length - 2) & 0xff); } else { rt.byteVecPush(out, 2); } diff --git a/ts/fixtures/lang/expected/splits.Short.ts b/ts/fixtures/lang/expected/splits.Short.ts new file mode 100644 index 000000000..e41481882 --- /dev/null +++ b/ts/fixtures/lang/expected/splits.Short.ts @@ -0,0 +1,8 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; + +/** Why a read came up short. */ +export type Short = { tag: "Empty" } | { tag: "Need"; _0: rt.usize }; + +//# sourceMappingURL=splits.Short.ts.map diff --git a/ts/fixtures/lang/expected/splits.ts b/ts/fixtures/lang/expected/splits.ts new file mode 100644 index 000000000..e5ceea70a --- /dev/null +++ b/ts/fixtures/lang/expected/splits.ts @@ -0,0 +1,199 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.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]); + } + return rt.Err({ tag: "Need", _0: 2 } as Short.Short); + } + return rt.Err({ tag: "Empty" } as Short.Short); +} + +/** 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]; + } + return undefined; + } + return undefined; +} + +/** `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 rt.optionOkOr((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); +} + +/** 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); + }); +} + +/** An error made by a call that does something, which runs even when it isn't needed. */ +export function code(out: rt.ByteVec, n: rt.u8): rt.u8 { + rt.byteVecPush(out, 238); + return n; +} + +export function splits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + let _58!: rt.u8; + let _139!: rt.u8; + const _4: rt.u8 = rt.u8Rem(kind, 8); + if (_4 === 0) { + let restData: Uint8Array = data.data; + let restStart: number = data.start; + let restLen: number = data.length; + let sum: rt.u8 = 0; + while (true) { + const _9Data: Uint8Array = restData; + const _9Start: number = restStart; + const _9Len: number = restLen; + if (_9Len !== 0) { + const b: rt.u8 = _9Data[_9Start]; + sum = rt.u8WrappingAdd(sum, b); + restData = _9Data; + restStart = _9Start + 1; + restLen = _9Len - 1; + if (b === 0) { + break; + } + } else { + break; + } + } + rt.byteVecPush(out, sum); + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(restData, restStart, restLen)); + } else if (_4 === 1) { + const mid3: number = rt.u8Rem(rt.optionUnwrapOr(rt.byteSliceFirst(data), 0), 8) as rt.usize; + if (mid3 > data.length) { + rt.panic("mid > len"); + } + rt.byteVecPush(out, mid3 & 0xff); + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(data.data, data.start + mid3, data.length - mid3)); + } 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]; + 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, 240); + } else { + rt.byteVecPush(out, 241 ^ (_33.error._0 & 0xff)); + } + } else if (_4 === 3) { + const mid2: number = rt.usizeDiv(data.length, 2); + if (mid2 > data.length) { + rt.panic("mid > len"); + } + const head: rt.ByteSlice = new rt.ByteSlice(data.data, data.start, mid2); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = 3; + while ((_58 = iterStart++) < iterEnd) { + rt.byteVecPush(out, opaque(head) ^ _58); + } + rt.byteVecPush(out, opaque(new rt.ByteSlice(data.data, data.start + mid2, data.length - mid2))); + } else if (_4 === 4) { + const mid: number = rt.usizeDiv(data.length, 3); + if (mid > data.length) { + rt.panic("mid > len"); + } + let pair_0Data: Uint8Array = data.data; + let pair_0Start: number = data.start; + let pair_0Len: number = mid; + let pair_1Data: Uint8Array = data.data; + let pair_1Start: number = data.start + mid; + let pair_1Len: number = data.length - mid; + const _73: rt.usize = rt.usizeRem(data.length, 3); + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = _73; + while (iterStart2++ < iterEnd2) { + const _80Data: Uint8Array = pair_1Data; + const _80Start: number = pair_1Start; + const _80Len: number = pair_1Len; + const _81Data: Uint8Array = pair_0Data; + const _81Start: number = pair_0Start; + const _81Len: number = pair_0Len; + pair_0Data = _80Data; + pair_0Start = _80Start; + pair_0Len = _80Len; + pair_1Data = _81Data; + pair_1Start = _81Start; + pair_1Len = _81Len; + } + rt.byteVecPush(out, pair_0Len & 0xff); + if (!((pair_1Len === 0))) { + const _170Len: number = pair_1Len; + if (0 >= _170Len) { + rt.panic("index out of bounds: the len is " + _170Len + " but the index is " + 0); + } + rt.byteVecPush(out, pair_1Data[pair_1Start]); + } + rt.byteVecExtendFromSlice(out, new rt.ByteSlice(pair_0Data, pair_0Start, pair_0Len)); + } else if (_4 === 5) { + let rest2: rt.ByteSlice = data; + while (true) { + const _94: [rt.u8, rt.u8, rt.ByteSlice] | undefined = two(rest2); + if (_94 !== undefined) { + rt.byteVecPush(out, _94[0] ^ _94[1]); + rest2 = _94[2]; + } else { + break; + } + } + rt.byteVecPush(out, rest2.length & 0xff); + } else if (_4 === 6) { + const split: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.byteSliceSplitFirstChunk(data, 4); + b2: { + if (split !== undefined) { + const _173: rt.ByteSlice = split[0]; + if ((_173.data[_173.start] & 1) === 0) { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32WrappingAdd(((split[0].data[split[0].start] << 24) | (split[0].data[split[0].start + 1] << 16) | (split[0].data[split[0].start + 2] << 8) | split[0].data[split[0].start + 3]) >>> 0, 3)))); + rt.byteVecPush(out, split[1].length & 0xff); + break b2; + } + } + rt.byteVecPush(out, rt.optionMapOr(split, 255, (_2: [rt.ByteSlice, rt.ByteSlice]): rt.u8 => { + return _2[0].data[_2[0].start + 3] ^ (_2[1].length & 0xff); + })); + } + const _129: rt.Result<[rt.ByteSlice, rt.ByteSlice], Short.Short> = take(data, 3); + if (_129.ok) { + rt.byteVecPush(out, opaque(_129.value[0])); + rt.byteVecPush(out, _129.value[1].length & 0xff); + } else { + const e: Short.Short = _129.error; + if (e.tag === "Empty") { + _139 = 0; + } else { + _139 = e._0 & 0xff; + } + rt.byteVecPush(out, _139); + } + } else { + const first2: rt.u8 = code(out, 7); + if (data.length !== 0) { + rt.byteVecPush(out, data.data[data.start]); + rt.byteVecPush(out, (data.length - 1) & 0xff); + } else { + rt.byteVecPush(out, first2); + } + if (2 <= data.length) { + rt.byteVecPush(out, data.data[data.start + 1] ^ ((data.length - 2) & 0xff)); + } + } +} + +//# sourceMappingURL=splits.ts.map diff --git a/ts/fixtures/lang/src/harness.rs b/ts/fixtures/lang/src/harness.rs index 7ed64b1e9..3c9192fa3 100644 --- a/ts/fixtures/lang/src/harness.rs +++ b/ts/fixtures/lang/src/harness.rs @@ -1,7 +1,7 @@ //! The entry point both sides of the differential test run. The first byte picks a //! case and the rest is its input. -use crate::{chars, chunks, collections, cows, fmt, generics, ints, iters, keys, shapes, strs}; +use crate::{chars, chunks, collections, cows, fmt, generics, ints, iters, keys, shapes, splits, strs}; /// The native side's entry: [`run`], except that a case starting with 0xff prints a /// [`fmt::Fault`], which the translated side prints from TypeScript in `caller.ts`. @@ -19,7 +19,7 @@ pub fn run(input: &[u8]) -> Vec { return out; }; let (op, kind) = (*op, *kind); - match op % 47 { + match op % 48 { 0 => ints::u8_op(kind, data, &mut out), 1 => ints::u16_op(kind, data, &mut out), 2 => ints::u32_op(kind, data, &mut out), @@ -76,6 +76,7 @@ pub fn run(input: &[u8]) -> Vec { 43 => strs::slices(kind, data, &mut out), 44 => collections::stores(data, &mut out), 45 => chunks::chunks(kind, data, &mut out), + 46 => splits::splits(kind, data, &mut out), _ => cows::cows(kind, data, &mut out), } out diff --git a/ts/fixtures/lang/src/lib.rs b/ts/fixtures/lang/src/lib.rs index aaf82f5f3..8383b64b0 100644 --- a/ts/fixtures/lang/src/lib.rs +++ b/ts/fixtures/lang/src/lib.rs @@ -1,6 +1,6 @@ //! The language the driver translates, exercised against native Rust: every integer //! width's arithmetic and casts, `char`s and the `str` methods over them, `Cow`, -//! control flow, patterns, `Copy` aggregates, closures, traits, generic types, formatting, +//! control flow, patterns, byte slices split apart, `Copy` aggregates, closures, traits, generic types, formatting, //! collections, and the standard library calls it maps. //! //! `harness::run` is the entry point both sides of the differential test run, and @@ -17,6 +17,7 @@ mod ints; mod iters; mod keys; mod shapes; +mod splits; mod strs; #[cfg(target_arch = "wasm32")] #[path = "../../wasm.rs"] diff --git a/ts/fixtures/lang/src/splits.rs b/ts/fixtures/lang/src/splits.rs new file mode 100644 index 000000000..bd5f6889d --- /dev/null +++ b/ts/fixtures/lang/src/splits.rs @@ -0,0 +1,138 @@ +//! Byte slices split by std, and the tuples, `Option`s, and `Result`s of them a body +//! takes apart, passes on, or keeps whole. + +/// Why a read came up short. +#[derive(Debug)] +enum Short { + Empty, + Need(usize), +} + +/// The first byte, then a big-endian `u16`, by `?` on `ok_or`. +fn header(data: &[u8]) -> Result<(u8, u16, &[u8]), Short> { + let (&a, rest) = data.split_first().ok_or(Short::Empty)?; + let (b, rest) = rest.split_first_chunk::<2>().ok_or(Short::Need(2))?; + Ok((a, u16::from_be_bytes(*b), rest)) +} + +/// Two bytes, by `?` on an `Option`. +fn two(data: &[u8]) -> Option<(u8, u8, &[u8])> { + let (&a, rest) = data.split_first()?; + let (&b, rest) = rest.split_first()?; + Some((a, b, rest)) +} + +/// `n` bytes, or how many it needed. +fn take(data: &[u8], n: usize) -> Result<(&[u8], &[u8]), Short> { + data.split_at_checked(n).ok_or(Short::Need(n)) +} + +/// 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)) +} + +/// An error made by a call that does something, which runs even when it isn't needed. +fn code(out: &mut Vec, n: u8) -> u8 { + out.push(0xee); + n +} + +pub fn splits(kind: u8, data: &[u8], out: &mut Vec) { + match kind % 8 { + 0 => { + // A slice reassigned from its own tail, in a loop. + let mut rest = data; + let mut sum = 0u8; + while let Some((&b, tail)) = rest.split_first() { + sum = sum.wrapping_add(b); + rest = tail; + if b == 0 { + break; + } + } + out.push(sum); + out.extend_from_slice(rest); + } + 1 => { + // Panics past the end. + let (a, b) = data.split_at(usize::from(data.first().copied().unwrap_or(0) % 8)); + out.push(a.len() as u8); + out.extend_from_slice(b); + } + 2 => match header(data) { + Ok((a, b, rest)) => { + out.push(a); + out.extend_from_slice(&b.to_be_bytes()); + out.push(opaque(rest)); + } + Err(Short::Empty) => out.push(0xf0), + Err(Short::Need(n)) => out.push(0xf1 ^ n as u8), + }, + 3 => { + // Made whole in a loop, which keeps it an object. + let (head, tail) = data.split_at(data.len() / 2); + for i in 0..3u8 { + out.push(opaque(head) ^ i); + } + out.push(opaque(tail)); + } + 4 => { + // A swap, each part assigned another's at once. + let mut pair = data.split_at(data.len() / 3); + for _ in 0..data.len() % 3 { + pair = (pair.1, pair.0); + } + out.push(pair.0.len() as u8); + if !pair.1.is_empty() { + out.push(pair.1[0]); + } + out.extend_from_slice(pair.0); + } + 5 => { + let mut rest = data; + while let Some((a, b, tail)) = two(rest) { + out.push(a ^ b); + rest = tail; + } + out.push(rest.len() as u8); + } + 6 => { + // Kept whole on one path, read apart on the other. + let split = data.split_first_chunk::<4>(); + match split { + Some((word, rest)) if word[0] & 1 == 0 => { + out.extend_from_slice(&u32::from_be_bytes(*word).wrapping_add(3).to_be_bytes()); + out.push(rest.len() as u8); + } + _ => out.push(split.map_or(0xff, |(w, r)| w[3] ^ r.len() as u8)), + } + match take(data, 3) { + Ok((front, back)) => { + out.push(opaque(front)); + out.push(back.len() as u8); + } + Err(e) => out.push(match e { + Short::Empty => 0, + Short::Need(n) => n as u8, + }), + } + } + _ => { + // The error is made before the split is looked at. + let first = data.split_first().ok_or(code(out, 7)); + match first { + Ok((&b, rest)) => { + out.push(b); + out.push(rest.len() as u8); + } + Err(n) => out.push(n), + } + let found: Result<(&[u8], &[u8]), u8> = data.split_at_checked(2).ok_or(1); + if let Ok((front, back)) = found { + out.push(front[1] ^ back.len() as u8); + } + } + } +} diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index e6242ba6a..190545512 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -715,8 +715,8 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Vec ("bool", "then") => Expr::rt("boolThen", args), // Slices, whose byte functions take an `rt.ByteSlice`. - ("slice", "len") => args.pop()?.member("length"), - ("slice", "is_empty") => args.pop()?.member("length").binary("===", Expr::lit("0")), + ("slice", "len") => super::mir::slice_member(args.pop()?, "length"), + ("slice", "is_empty") => super::mir::slice_member(args.pop()?, "length").binary("===", Expr::lit("0")), ("slice", "split_first" | "split_at" | "split_at_checked" | "first" | "get") if name != "get" || Int::of(targ(gargs, 1)).is_some() => { diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index cde8f76db..c62a251c8 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -28,6 +28,12 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { out: &mut Vec, ) { let tcx = self.tcx; + if let Some(local) = dest.as_local() + && self.scalars.contains_key(&local) + { + self.scalar_call(local, func, args, span, out); + return; + } let fn_ty = func.ty(&self.mir.local_decls, tcx); let result = dest.ty(&self.mir.local_decls, tcx).ty; let mut pre = Vec::new(); diff --git a/ts/src/lower/mir/mod.rs b/ts/src/lower/mir/mod.rs index 542533661..33174a84c 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -17,6 +17,7 @@ pub mod glue; mod inline; mod place; mod rvalue; +mod scalar; mod step; mod unwind; mod vec; @@ -28,6 +29,7 @@ use rustc_middle::ty::{self, EarlyBinder, Instance, Ty, TyCtxt}; use rustc_span::{Span, Spanned}; use self::cfg::Exit; +pub use self::place::slice_member; use super::Translator; use super::body::Body; @@ -105,6 +107,9 @@ enum Slot<'tcx> { Alias(Option), /// A discriminant only a `switchInt` reads: tested as the place's variant. Discr(Option<(Expr, Ty<'tcx>)>), + /// A discriminant only a `switchInt` reads, of a local held as its parts: its flag, + /// whether it is its second variant. + Flag(Option), } /// A temporary's value, held back to fold into the one expression that reads it. @@ -237,6 +242,13 @@ pub struct Fx<'m, 'b, 'a, 'tcx> { tested: IndexVec, /// The names of those that hold a value TypeScript would narrow by what it is assigned. widened: FxHashSet, + /// Locals held as their parts, by `scalar`. + scalars: FxHashMap>, + /// Names nothing assigns again that `scalar` reads in place: variables of parts assigned + /// once, and the slices it took apart. + steady: FxHashSet, + /// Those slices, with their types, which need declarations. + scalar_binds: Vec<(String, Type)>, } impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { @@ -295,6 +307,9 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { switched: FxHashSet::default(), tested: IndexVec::from_elem_n(false, n), widened: FxHashSet::default(), + scalars: FxHashMap::default(), + steady: FxHashSet::default(), + scalar_binds: Vec::new(), }; fx.analyze(); fx @@ -457,14 +472,19 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { self.unborrow_passed(); self.find_halves(); self.find_place_opts(); + self.find_scalars(); for local in mir.local_decls.indices() { let ty = mir.local_decls[local].ty; let slot = if self.zero_sized(ty) { Slot::Unit + } else if self.scalars.contains_key(&local) { + Slot::Var(String::new()) } else if let Some(value) = self.unassigned(local, ty) { Slot::Alias(Some(value)) - } else if self.alias(local) { + } else if self.alias(local) && !self.reads_scalar_object(local) { Slot::Alias(None) + } else if self.discr_only(local) && self.scalar_discr(local) { + Slot::Flag(None) } else if self.discr_only(local) { Slot::Discr(None) } else { @@ -511,6 +531,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { if self.stepped.contains(&local) { self.name_stepped(local, &base); } + self.name_scalar(local, &base); let owned = match mir.local_decls[local].ty.kind() { ty::Tuple(_) | ty::Array(..) => true, ty::Adt(adt, _) => { @@ -522,7 +543,9 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } _ => false, }; - if owned && !self.is_arg(local) && !self.borrowed[local] && !self.mutated[local] { + // A byte slice's fields are readonly, so its parts are frozen even in a parameter. + let bytes = matches!(mir.local_decls[local].ty.kind(), ty::Ref(_, inner, ty::Mutability::Not) if place::byte_slice(*inner)); + if (bytes || owned && !self.is_arg(local)) && !self.borrowed[local] && !self.mutated[local] { self.frozen_names.insert(name.clone()); } self.slots[local] = Slot::Var(name); @@ -1381,6 +1404,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { out.push(StmtKind::Declare { name, ty }.at(None)); } } + self.scalar_decls(&mut out); let mut flags: Vec = self.range_flags.values().cloned().collect(); flags.sort(); for name in flags { @@ -2012,7 +2036,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { self.emit(vec![StmtKind::Expr(value).at(None)], None, false, out); } } - Slot::Alias(_) | Slot::Discr(_) => unreachable!("set by their own assignment"), + Slot::Alias(_) | Slot::Discr(_) | Slot::Flag(_) => unreachable!("set by their own assignment"), } } @@ -2080,6 +2104,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { if self.joined.contains(&local) { return; } + if self.scalars.contains_key(&local) { + self.scalar_assign(local, rvalue, span, out); + return; + } match self.slots[local] { Slot::Alias(_) => { let target = match rvalue { @@ -2119,6 +2147,14 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { self.slots[local] = Slot::Discr(Some((target, ty))); return; } + Slot::Flag(_) => { + let Rvalue::Discriminant(p) = rvalue else { + unreachable!("checked by scalar_discr") + }; + let flag = self.scalar_flag(*p, span); + self.slots[local] = Slot::Flag(Some(flag)); + return; + } _ => {} } } @@ -2210,6 +2246,8 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { /// already is. pub(super) fn slice_path(&mut self, slice: Expr, out: &mut Vec) -> Expr { match &slice { + // A local's parts, which do nothing. + _ if place::made_slice(&slice).is_some() => slice, Expr::Index(base, i) if base.is_path() && i.is_constant() => { self.materialize(&slice, out); slice @@ -2367,6 +2405,21 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { }; conds.into_iter().zip(arms.iter().map(|&(_, t)| t)).collect() } + // The discriminants of `Option`, `Result`, and `ControlFlow` are their variants'. + Some(Slot::Flag(Some(flag))) => { + let tests: Vec = arms + .iter() + .map(|&(value, _)| match value { + 0 => flag.clone().not(), + _ => flag.clone(), + }) + .collect(); + let conds = match tests.len() { + 1 => self.fold_exprs(Vec::new(), tests, false, out), + _ => tests, + }; + conds.into_iter().zip(arms.iter().map(|&(_, t)| t)).collect() + } _ => { let ty = discr.ty(&self.mir.local_decls, self.tcx); let mut pre = Vec::new(); @@ -2447,6 +2500,26 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let mut pre = Vec::new(); let slice = self.place_expr(slice, span, &mut pre); let index = self.operand(index, span, &mut pre); + // A slice held as its parts is tested by its length, so none is made to test. + if let Some([_, _, length]) = place::made_slice(&slice) { + let length = length.clone(); + let index = self.path(index, "index", &mut pre); + let failed = fold(index.clone().binary(">=", length.clone())); + if !matches!(&failed, Expr::Lit(t) if t == "false") + && let Some(panic) = self.assert_panic(msg, vec![length, index], span) + { + pre.push( + StmtKind::If { + cond: failed, + then: vec![StmtKind::Expr(panic).at(None)], + els: Vec::new(), + } + .at(self.b.t.loc(span)), + ); + } + self.emit(pre, None, false, out); + return; + } pre.push(StmtKind::Expr(Expr::rt("idx", vec![slice, index])).at(self.b.t.loc(span))); self.emit(pre, None, false, out); return; @@ -2842,6 +2915,10 @@ fn scan(e: &Expr, reads: &mut Vec, lazy: bool) { scan(index, reads, lazy); reads.push(field(base)); } + // A byte slice made of its parts only holds them. + Expr::New(f, args) if matches!(&**f, Expr::Rt(name) if name == "ByteSlice") => { + args.iter().for_each(|e| scan(e, reads, lazy)) + } Expr::Call(f, args) | Expr::New(f, args) => { // A method's lookup reads no data the arguments could change: only its receiver. match &**f { diff --git a/ts/src/lower/mir/place.rs b/ts/src/lower/mir/place.rs index 437add783..2a256d94b 100644 --- a/ts/src/lower/mir/place.rs +++ b/ts/src/lower/mir/place.rs @@ -37,13 +37,22 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { Slot::Unit => Expr::undefined(), Slot::Alias(Some(target)) => target.clone(), Slot::Alias(None) => self.err(span, "a reference read before its borrow"), - Slot::Discr(_) => self.err(span, "a discriminant read other than by a switch"), + Slot::Discr(_) | Slot::Flag(_) => self.err(span, "a discriminant read other than by a switch"), } } /// The JS expression of `place`, read without a copy. pub fn place_expr(&mut self, place: Place<'tcx>, span: Span, out: &mut Vec) -> Expr { let tcx = self.tcx; + // A local held as its parts reads them, as far as they go. + if self.scalars.contains_key(&place.local) { + let (e, n) = self.scalar_place(place, span); + let mut pty = PlaceTy::from_ty(self.mir.local_decls[place.local].ty); + for elem in &place.projection[..n] { + pty = pty.projection_ty(tcx, *elem); + } + return self.project(e, pty, &place.projection[n..], place.local, span, out); + } let decls = &self.mir.local_decls; let mut pty = PlaceTy::from_ty(decls[place.local].ty); let mut projection = place.projection.iter().peekable(); @@ -54,7 +63,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { _ => None, }; // A closure's captures, and a coroutine's state, are `_1`'s fields. - let mut e = match (&self.env, place.local.as_u32()) { + let e = match (&self.env, place.local.as_u32()) { (Env::Closure(captures), 1) => { let captures = captures.clone(); if matches!(projection.peek(), Some(ProjectionElem::Deref)) { @@ -111,10 +120,26 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { _ => unreachable!("a checked pair is a tuple"), }); } + let rest: Vec>> = projection.collect(); + self.project(e, pty, &rest, place.local, span, out) + } + + /// `e`, the value of a place of type `pty` in `local`, projected by `elems`. + fn project( + &mut self, + mut e: Expr, + mut pty: PlaceTy<'tcx>, + elems: &[ProjectionElem>], + local: Local, + span: Span, + out: &mut Vec, + ) -> Expr { + let tcx = self.tcx; + let place = Place::from(local); // Whether `e` is an `rt.ByteSlice` of the place's bytes: a `[u8]`, or a `[u8; N]` // behind a reference. let mut in_bytes = false; - for elem in projection { + for &elem in elems { let ty = pty.ty; in_bytes = in_bytes || byte_slice(ty); match elem { @@ -157,7 +182,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { }; let i = match from_end { false => Expr::lit(offset.to_string()), - true => base.clone().member("length").binary("-", Expr::lit(offset.to_string())), + true => super::scalar::sub(slice_member(base.clone(), "length"), Expr::lit(offset.to_string())), }; e = match in_bytes { true => byte_at(base, i), @@ -171,11 +196,18 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { from_end: true, } if byte_slice(ty) => { let base = self.slice_path(e, out); - let mut values = vec![base.clone(), Expr::lit(from.to_string())]; - if to != 0 { - values.push(base.member("length").binary("-", Expr::lit(to.to_string()))); + // A range of parts, which the pattern that took it checked the length for. + if let Some([data, start, length]) = made_slice(&base) { + let len = super::scalar::sub(length.clone(), Expr::lit((from + to).to_string())); + let start = super::scalar::add(start.clone(), Expr::lit(from.to_string())); + e = Expr::New(Box::new(Expr::Rt("ByteSlice".into())), vec![data.clone(), start, len]); + } else { + let mut values = vec![base.clone(), Expr::lit(from.to_string())]; + if to != 0 { + values.push(base.member("length").binary("-", Expr::lit(to.to_string()))); + } + e = Expr::rt("byteSliceRange", values); } - e = Expr::rt("byteSliceRange", values); } // Part of a `[u8; N]` behind a reference, as `[a, rest @ ..]` of a `&[u8; N]`. ProjectionElem::Subslice { from, to, from_end } if in_bytes => { @@ -185,8 +217,21 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { _ => return self.err(span, format!("a subslice of `{ty}`")), }; let base = self.slice_path(e, out); - let values = vec![base, Expr::lit(from.to_string()), Expr::lit(end.to_string())]; - e = Expr::rt("byteSliceRange", values); + e = match made_slice(&base) { + // In bounds of the array's. + Some([data, start, _]) => Expr::New( + Box::new(Expr::Rt("ByteSlice".into())), + vec![ + data.clone(), + super::scalar::add(start.clone(), Expr::lit(from.to_string())), + Expr::lit((end - from).to_string()), + ], + ), + None => { + let values = vec![base, Expr::lit(from.to_string()), Expr::lit(end.to_string())]; + Expr::rt("byteSliceRange", values) + } + }; } ProjectionElem::Subslice { from, to, from_end } => { let elem_ty = match ty.kind() { @@ -782,8 +827,13 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } let slice = slice.clone(); let p = self.pending.remove(i); - // A path, or a subslice of one in bounds, reads only bytes nothing changed since. - let path = |e: &Expr| e.is_path() || matches!(e, Expr::Index(base, i) if base.is_path() && i.is_constant()); + // A path, a subslice of one in bounds, or a local's parts, reads only bytes nothing + // changed since. + let path = |e: &Expr| { + e.is_path() + || made_slice(e).is_some() + || matches!(e, Expr::Index(base, i) if base.is_path() && i.is_constant()) + }; let stable = match &slice { Expr::Call(f, args) if matches!(&**f, Expr::Rt(name) if name == "byteSliceRange") => { matches!(args.as_slice(), [base, Expr::Lit(_), ..] if path(base)) @@ -839,11 +889,30 @@ pub fn byte_slice(ty: Ty<'_>) -> bool { /// Byte `i` of `slice`, an `rt.ByteSlice` that reading twice reads the same. pub fn byte_at(slice: Expr, i: Expr) -> Expr { - let at = match &i { - Expr::Lit(text) if text == "0" => slice.clone().member("start"), - _ => slice.clone().member("start").binary("+", i), - }; - slice.member("data").index(at) + let at = super::scalar::add(slice_member(slice.clone(), "start"), i); + slice_member(slice, "data").index(at) +} + +/// The field `key` of `slice`, an `rt.ByteSlice`: its part, if it is made in place of parts +/// that do nothing, as a local held as its parts reads. +pub fn slice_member(slice: Expr, key: &str) -> Expr { + if let Some([data, start, length]) = made_slice(&slice) { + return match key { + "data" => data.clone(), + "start" => start.clone(), + "length" => length.clone(), + _ => unreachable!("a field of a byte slice"), + }; + } + slice.member(key) +} + +/// The parts of `slice`, if it is an `rt.ByteSlice` made in place. +pub fn made_slice(slice: &Expr) -> Option<&[Expr; 3]> { + match slice { + Expr::New(f, args) if matches!(&**f, Expr::Rt(name) if name == "ByteSlice") => args.as_slice().try_into().ok(), + _ => None, + } } /// Whether `ty` is a struct of one field that JS represents as that field: a wrapper diff --git a/ts/src/lower/mir/rvalue.rs b/ts/src/lower/mir/rvalue.rs index 1b9e441ae..f4d0d86ac 100644 --- a/ts/src/lower/mir/rvalue.rs +++ b/ts/src/lower/mir/rvalue.rs @@ -101,11 +101,18 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { UnOp::Not | UnOp::Neg => num::unary(self.b, *op, value, aty, span), UnOp::PtrMetadata => match aty.builtin_deref(true).map(|t| t.kind()) { Some(ty::Str) => Expr::rt("stringLen", vec![value]), - Some(ty::Slice(_)) => value.member("length"), + Some(ty::Slice(_)) => super::place::slice_member(value, "length"), _ => self.err(span, format!("the metadata of `{aty}`")), }, } } + // A local held as its parts has its flag. + Rvalue::Discriminant(place) if self.scalars.contains_key(&place.local) => { + let flag = self.scalar_flag(*place, span); + let pty = place.ty(&self.mir.local_decls, tcx).ty; + let int = Int::of(pty.discriminant_ty(tcx)).expect("an enum's discriminant is an integer"); + Expr::Cond(Box::new(flag), Box::new(int.lit(1)), Box::new(int.lit(0))) + } Rvalue::Discriminant(place) => { let pty = place.ty(&self.mir.local_decls, tcx).ty; let scrut = self.place_expr(*place, span, out); diff --git a/ts/src/lower/mir/scalar.rs b/ts/src/lower/mir/scalar.rs new file mode 100644 index 000000000..7e532a0c7 --- /dev/null +++ b/ts/src/lower/mir/scalar.rs @@ -0,0 +1,1429 @@ +//! Locals of byte slices held as their parts. A `&[u8]` is an `rt.ByteSlice`, so each +//! split, and each tuple, `Option`, `Result`, or `ControlFlow` around one, makes objects +//! V8 doesn't remove. A local built of them that nothing borrows or writes into, and +//! that only splits, `ok_or`, `?`, aggregates, and copies assign, is instead a value per +//! part: a slice's bytes, start, and length, a flag for which variant an enum is, and +//! anything else, as an error, whole. A read that takes it apart reads its parts; any +//! 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. + +use rustc_abi::VariantIdx; +use rustc_data_structures::fx::{FxHashMap, FxHashSet}; +use rustc_middle::mir::visit::{MutatingUseContext, NonMutatingUseContext, PlaceContext, Visitor}; +use rustc_middle::mir::{ + self, AggregateKind, BasicBlock, CastKind, Local, Location, Operand, Place, PlaceElem, ProjectionElem, Rvalue, + StatementKind, TerminatorKind, +}; +use rustc_middle::ty::adjustment::PointerCoercion; +use rustc_middle::ty::{self, Ty}; +use rustc_span::{Span, Spanned}; + +use super::Fx; +use crate::lower::library::{self, Std}; +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> { + /// No JS value: `()`. + Unit, + /// One JS value, held whole: a number, a reference to one, or an error. + Leaf(Ty<'tcx>), + /// `&[u8]` or `&[u8; N]`: its bytes, start, and length. + Slice, + Tuple(Ty<'tcx>, Vec>), + /// An `Option`, `Result`, or `ControlFlow`: whether it is its second variant, if both + /// can be, then the fields of each variant that can be, in order. + Enum(Ty<'tcx>, [Option>>; 2]), +} + +impl<'tcx> Shape<'tcx> { + fn size(&self) -> usize { + match self { + Shape::Unit => 0, + Shape::Leaf(_) => 1, + Shape::Slice => 3, + Shape::Tuple(_, fields) => fields.iter().map(Shape::size).sum(), + Shape::Enum(_, variants) => { + let flag = usize::from(variants.iter().all(Option::is_some)); + flag + variants.iter().flatten().flatten().map(Shape::size).sum::() + } + } + } + + fn has_slice(&self) -> bool { + match self { + Shape::Slice => true, + Shape::Unit | Shape::Leaf(_) => false, + Shape::Tuple(_, fields) => fields.iter().any(Shape::has_slice), + Shape::Enum(_, variants) => variants.iter().flatten().flatten().any(Shape::has_slice), + } + } + + fn has_enum(&self) -> bool { + match self { + Shape::Enum(..) => true, + Shape::Unit | Shape::Leaf(_) | Shape::Slice => false, + Shape::Tuple(_, fields) => fields.iter().any(Shape::has_enum), + } + } + + /// Whether it has a flag, as an enum both of whose variants can be. + fn flagged(&self) -> bool { + matches!(self, Shape::Enum(_, [Some(_), Some(_)])) + } + + /// Where the fields of variant `v` of an enum start. + fn variant_at(&self, v: usize) -> usize { + let Shape::Enum(_, variants) = self else { + unreachable!("a variant of an enum") + }; + let before: usize = variants[..v].iter().flatten().flatten().map(Shape::size).sum(); + usize::from(self.flagged()) + before + } + + /// Each part: its name's suffix, and what it holds. + fn parts(&self, suffix: &str, out: &mut Vec<(String, Part<'tcx>)>) { + match self { + Shape::Unit => {} + Shape::Leaf(ty) => out.push((suffix.to_string(), Part::Value(*ty))), + Shape::Slice => { + for (key, part) in [("Data", Part::Data), ("Start", Part::Number), ("Len", Part::Number)] { + out.push((format!("{suffix}{key}"), part)); + } + } + Shape::Tuple(_, fields) => { + for (i, field) in fields.iter().enumerate() { + field.parts(&format!("{suffix}_{i}"), out); + } + } + Shape::Enum(ty, variants) => { + if self.flagged() { + out.push((format!("{suffix}{}", flag_name(*ty)), Part::Flag)); + } + for fields in variants.iter().flatten() { + for (i, field) in fields.iter().enumerate() { + let suffix = match fields.len() { + 1 => suffix.to_string(), + _ => format!("{suffix}_{i}"), + }; + field.parts(&suffix, out); + } + } + } + } + } + + /// The parts that are JS objects as the local's object holds them: each slice, by its + /// bytes, and each value held whole that is no number. + fn objects(&self, at: usize, out: &mut Vec) { + match self { + Shape::Unit => {} + Shape::Leaf(ty) => { + if !number(*ty) { + out.push(at); + } + } + Shape::Slice => out.push(at), + Shape::Tuple(_, fields) => { + let mut at = at; + for field in fields { + field.objects(at, out); + at += field.size(); + } + } + Shape::Enum(_, variants) => { + let mut at = at + usize::from(self.flagged()); + for field in variants.iter().flatten().flatten() { + field.objects(at, out); + at += field.size(); + } + } + } + } +} + +/// What a part holds, which types its variable. +#[derive(Clone, Copy, Debug)] +enum Part<'tcx> { + Flag, + Value(Ty<'tcx>), + Data, + Number, +} + +/// The name of the flag of an enum, for which variant it is its second. +fn flag_name(ty: Ty<'_>) -> &'static str { + match ty.kind() { + ty::Adt(adt, _) if adt.variants().len() == 2 => match adt.variant(VariantIdx::from_usize(1)).name.as_str() { + "Some" => "Some", + "Err" => "Err", + _ => "Break", + }, + _ => "Flag", + } +} + +/// Whether a `ty`'s JS value is a number or flag, which making its object makes nothing of. +fn number(ty: Ty<'_>) -> bool { + match ty.kind() { + ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) => true, + ty::Ref(_, inner, _) => number(*inner), + _ => false, + } +} + +/// Whether no value of `ty` can be made. +fn uninhabited(ty: Ty<'_>) -> bool { + ty.is_never() || matches!(ty.kind(), ty::Adt(adt, _) if adt.is_enum() && adt.variants().is_empty()) +} + +/// A local held as its parts. +#[derive(Debug)] +pub(super) struct Scalar<'tcx> { + shape: Shape<'tcx>, + /// Each part's variable, which each assignment sets. + vars: Vec, + /// For a local assigned once, once its assignment is lowered, each part's value, which + /// reads the same wherever its local is read: a variable assigned only there, or what + /// it was assigned. + held: Option>, + /// Whether some statement assigns a variable, which then needs a declaration. + assigned: bool, +} + +/// The part of a shape a place reaches: where its parts start, and the variant it was +/// cast to, if it is an enum. +#[derive(Clone, Copy)] +struct Node<'s, 'tcx> { + shape: &'s Shape<'tcx>, + at: usize, + variant: Option, +} + +impl Node<'_, '_> { + fn parts(&self) -> std::ops::Range { + self.at..self.at + self.shape.size() + } +} + +/// The part of `shape` the projections `elems` reach, and how many of them that takes: +/// fields and casts to a variant, up to a slice's bytes, a value held whole, or the end. +fn walk<'s, 'tcx>(shape: &'s Shape<'tcx>, elems: &[PlaceElem<'tcx>]) -> (Node<'s, 'tcx>, usize) { + let mut node = Node { + shape, + at: 0, + variant: None, + }; + for (i, elem) in elems.iter().enumerate() { + match (node.shape, elem) { + (Shape::Enum(..), ProjectionElem::Downcast(_, v)) => node.variant = Some(v.as_usize()), + (Shape::Tuple(_, fields), ProjectionElem::Field(f, _)) => { + let f = f.as_usize(); + node = Node { + shape: &fields[f], + at: node.at + fields[..f].iter().map(Shape::size).sum::(), + variant: None, + }; + } + (Shape::Enum(_, variants), ProjectionElem::Field(f, _)) => { + let Some(v) = node.variant else { + return (node, i); + }; + let Some(fields) = &variants[v] else { + return (node, i); + }; + let f = f.as_usize(); + node = Node { + shape: &fields[f], + at: node.at + node.shape.variant_at(v) + fields[..f].iter().map(Shape::size).sum::(), + variant: None, + }; + } + _ => return (node, i), + } + } + (node, elems.len()) +} + +/// A std call whose result a local holds as its parts. +#[derive(Clone, Copy, Debug)] +enum Producer { + SplitFirst, + SplitFirstChunk(u64), + SplitAt { checked: bool }, + OkOr, + Branch, +} + +/// A part of a local, by index, and the part of another held local it copies, if any. +type PartCopy = (Local, usize, Option<(Local, usize)>); + +/// A read of a local that makes its object, or part of it. +struct Made { + block: BasicBlock, + local: Local, + parts: std::ops::Range, +} + +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)), + } + } + + /// 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. + fn producer( + &self, + func: &Operand<'tcx>, + args: &[Spanned>], + shape: &Shape<'tcx>, + shapes: &FxHashMap>, + ) -> Option { + let tcx = self.tcx; + let ty::FnDef(def_id, gargs) = *func.ty(&self.mir.local_decls, tcx).kind() else { + return None; + }; + if !library::is_std(tcx, def_id) { + return None; + } + let gargs = gargs.skip_binder(); + let (owner, name) = library::key(tcx, def_id)?; + // What `ok_or` and `?` take apart: a local held as its parts, read whole, an enum + // whose variants both can be, as the result's. + let held = |op: &Operand<'tcx>| match op { + Operand::Copy(p) | Operand::Move(p) => shapes.get(&p.local).is_some_and(|source| { + let (node, n) = walk(source, p.projection); + n == p.projection.len() && node.shape.flagged() && shape.flagged() + }), + _ => false, + }; + let bytes = || { + gargs + .types() + .next() + .is_some_and(|t| matches!(t.kind(), ty::Uint(ty::UintTy::U8))) + }; + match (owner.as_str(), name.as_str()) { + ("slice", "split_first") if bytes() => Some(Producer::SplitFirst), + ("slice", "split_first_chunk") if bytes() => { + let n = gargs.consts().next()?.try_to_target_usize(tcx)?; + Some(Producer::SplitFirstChunk(n)) + } + ("slice", "split_at") if bytes() => Some(Producer::SplitAt { checked: false }), + ("slice", "split_at_checked") if bytes() => Some(Producer::SplitAt { checked: true }), + ("Option", "ok_or") if held(&args[0].node) => Some(Producer::OkOr), + ("Try", "branch") + if held(&args[0].node) + && gargs + .types() + .next() + .is_some_and(|t| matches!(self.b.t.std_of(t), Some(Std::Option | Std::Result))) => + { + Some(Producer::Branch) + } + _ => None, + } + } + + /// Whether `local`'s definition `rvalue` can assign its parts. + fn def_ok(&self, local: Local, rvalue: &Rvalue<'tcx>, shapes: &FxHashMap>) -> bool { + let shape = &shapes[&local]; + // A value of `shape` from `op`: a local held as its parts, read whole, or else one + // without an enum, which reading its fields takes apart. + let source = |op: &Operand<'tcx>, shape: &Shape<'tcx>| match op { + Operand::Copy(p) | Operand::Move(p) => { + shapes + .get(&p.local) + .is_some_and(|s| walk(s, p.projection).1 == p.projection.len()) + || !shape.has_enum() + } + Operand::Constant(_) => !shape.has_enum(), + Operand::RuntimeChecks(_) => false, + }; + match rvalue { + // A local that is a constant is read as one, as `format_args!` reads its template, + // and holding it as its parts saves no object. + Rvalue::Use(Operand::Constant(_), _) => false, + Rvalue::Use(op, _) => source(op, shape), + Rvalue::CopyForDeref(p) => source(&Operand::Copy(*p), shape), + Rvalue::Cast(CastKind::PointerCoercion(PointerCoercion::Unsize, _), op, _) => { + matches!(shape, Shape::Slice) && crate::lower::bytes_ref(op.ty(&self.mir.local_decls, self.tcx)) + } + Rvalue::Ref(_, mir::BorrowKind::Shared, p) => matches!(shape, Shape::Slice) && self.reborrow(*p).is_some(), + Rvalue::Aggregate(kind, ops) => match (&**kind, shape) { + (AggregateKind::Tuple, Shape::Tuple(_, fields)) => ops.iter().zip(fields).all(|(op, f)| source(op, f)), + (AggregateKind::Adt(_, v, ..), Shape::Enum(_, variants)) => variants[v.as_usize()] + .as_ref() + .is_some_and(|fields| ops.iter().zip(fields).all(|(op, f)| source(op, f))), + _ => false, + }, + _ => false, + } + } + + /// Whether `rvalue` gives parts that are not those of one object: a variant, whose + /// flag stands for one, a subslice, or a copy of a local held as its parts, alone or + /// in a tuple. A tuple of objects alone already folds into its reads. + fn parts_def(&self, rvalue: &Rvalue<'tcx>, shapes: &FxHashMap>) -> bool { + let held = |p: &Place<'tcx>| { + shapes + .get(&p.local) + .is_some_and(|s| walk(s, p.projection).1 == p.projection.len()) + }; + match rvalue { + Rvalue::Use(Operand::Copy(p) | Operand::Move(p), _) | Rvalue::CopyForDeref(p) => held(p), + Rvalue::Ref(_, _, p) => self + .reborrow(*p) + .is_some_and(|(base, range)| range.is_some() || held(&base)), + Rvalue::Aggregate(kind, ops) => { + matches!(**kind, AggregateKind::Adt(..)) + || ops + .iter() + .any(|op| matches!(op, Operand::Copy(p) | Operand::Move(p) if held(p))) + } + _ => false, + } + } + + /// What a shared borrow of bytes through a reference to them borrows: the reference, + /// and the range of them, as `&*s` or `&s[a..b]` of an array or slice pattern make it. + fn reborrow(&self, p: Place<'tcx>) -> Option<(Place<'tcx>, Option>)> { + let (base, range) = match p.projection.as_slice() { + [.., ProjectionElem::Deref] => (p.projection.len() - 1, None), + [.., ProjectionElem::Deref, elem @ ProjectionElem::Subslice { .. }] => { + (p.projection.len() - 2, Some(*elem)) + } + _ => return None, + }; + let base = Place { + local: p.local, + projection: self.tcx.mk_place_elems(&p.projection[..base]), + }; + let ty = base.ty(&self.mir.local_decls, self.tcx).ty; + match ty.kind() { + ty::Ref(_, inner, _) if super::place::byte_slice(*inner) || crate::lower::byte_array(*inner) => { + Some((base, range)) + } + _ => None, + } + } + + /// 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 + || self.borrowed[local] + || self.stepped.contains(&local) + || self.next_results.contains(&local) + || self.place_opts.contains(&local) + || self.checked.contains(&local) + || self.joined.contains(&local) + { + continue; + } + let ty = mir.local_decls[local].ty; + if self.b.t.drops(ty) { + continue; + } + if let Some(shape) = self.shape(ty) + && shape.has_slice() + { + shapes.insert(local, shape); + } + } + while !shapes.is_empty() { + let bad = self.unheld(&shapes); + if bad.is_empty() { + break; + } + shapes.retain(|l, _| !bad.contains(l)); + } + let mut shapes: Vec<(Local, Shape<'tcx>)> = shapes.into_iter().collect(); + shapes.sort_by_key(|(l, _)| *l); + for (local, shape) in shapes { + self.scalars.insert( + local, + Scalar { + shape, + vars: Vec::new(), + held: None, + assigned: false, + }, + ); + } + } + + /// 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 { + let mir = self.mir; + let tcx = self.tcx; + let mut bad = FxHashSet::default(); + // Where each is assigned, and, per part, the parts it copies there. + let mut def_blocks: FxHashMap> = FxHashMap::default(); + let mut copies: Vec = Vec::new(); + // Statements and terminators that take their reads of these apart. + let mut taken: FxHashSet = 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() { + for (i, stmt) in data.statements.iter().enumerate() { + if self.noops.contains(&(bb, i)) { + continue; + } + let at = Location { + block: bb, + statement_index: i, + }; + let StatementKind::Assign(assign) = &stmt.kind else { + continue; + }; + let (place, rvalue) = &**assign; + match place.as_local().filter(|l| shapes.contains_key(l)) { + Some(local) => { + def_blocks.entry(local).or_default().insert(bb); + taken.insert(at); + if self.parts_def(rvalue, shapes) { + parted.insert(local); + } + match self.def_ok(local, rvalue, shapes) { + true => self.def_copies(local, rvalue, shapes, &mut copies), + false => { + bad.insert(local); + } + } + } + None => { + if let Rvalue::Discriminant(_) = rvalue { + taken.insert(at); + } + // A length. + if let Rvalue::UnaryOp(mir::UnOp::PtrMetadata, Operand::Copy(p) | Operand::Move(p)) = rvalue + && let Some(shape) = shapes.get(&p.local) + && let (node, n) = walk(shape, p.projection) + && n == p.projection.len() + && matches!(node.shape, Shape::Slice) + { + taken.insert(at); + } + } + } + } + let at = Location { + block: bb, + statement_index: data.statements.len(), + }; + if let TerminatorKind::Call { + func, + args, + destination, + .. + } = &data.terminator().kind + { + 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) { + 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))); + } + } + None => { + bad.insert(local); + } + } + } + // 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) + && library::key(tcx, def_id) + .is_some_and(|(o, n)| o == "slice" && matches!(n.as_str(), "len" | "is_empty")) + { + taken.insert(at); + } + } + } + // Held as the parts of the one object it is, a local saves nothing. + bad.extend(shapes.keys().filter(|l| !parted.contains(l))); + // What reads them otherwise, and which reads make their objects. + struct Reads<'s, 'tcx> { + shapes: &'s FxHashMap>, + taken: &'s FxHashSet, + made: Vec, + bad: FxHashSet, + } + impl<'tcx> Visitor<'tcx> for Reads<'_, 'tcx> { + fn visit_place(&mut self, place: &Place<'tcx>, cx: PlaceContext, at: Location) { + let Some(shape) = self.shapes.get(&place.local) else { + return; + }; + match cx { + PlaceContext::NonUse(_) + | PlaceContext::NonMutatingUse( + NonMutatingUseContext::Inspect | NonMutatingUseContext::PlaceMention, + ) + | PlaceContext::MutatingUse(MutatingUseContext::Drop) => return, + // Assigned whole, as checked above, or written into. + PlaceContext::MutatingUse(_) => { + if !place.projection.is_empty() { + self.bad.insert(place.local); + } + return; + } + PlaceContext::NonMutatingUse(_) => {} + } + if self.taken.contains(&at) { + return; + } + let (node, n) = walk(shape, place.projection); + let rest = &place.projection[n..]; + let part = match (node.shape, rest) { + (Shape::Unit | Shape::Leaf(_), _) => true, + // A byte, read where it is. + ( + Shape::Slice, + [ + ProjectionElem::Deref, + ProjectionElem::Index(_) | ProjectionElem::ConstantIndex { .. }, + .., + ], + ) => true, + _ => false, + }; + if !part { + self.made.push(Made { + block: at.block, + local: place.local, + parts: node.parts(), + }); + } + } + } + let mut reads = Reads { + shapes, + taken: &taken, + made: Vec::new(), + bad: FxHashSet::default(), + }; + reads.visit_body(mir); + bad.extend(reads.bad); + // Each part's origins: the parts whose assignment made what it may hold, through + // copies, each made again only where its local is assigned. + let mut origins: FxHashMap<(Local, usize), FxHashSet<(Local, usize)>> = FxHashMap::default(); + for &(local, part, from) in &copies { + if from.is_none() { + origins.entry((local, part)).or_default().insert((local, part)); + } + } + let mut changed = true; + while std::mem::take(&mut changed) { + for &(local, part, from) in &copies { + let Some(from) = from else { + continue; + }; + let more: Vec<(Local, usize)> = origins.get(&from).into_iter().flatten().copied().collect(); + let set = origins.entry((local, part)).or_default(); + for o in more { + changed |= set.insert(o); + } + } + } + let none = FxHashSet::default(); + let objects = |made: &Made| -> FxHashSet<(Local, usize)> { + let mut parts = Vec::new(); + shapes[&made.local].objects(0, &mut parts); + parts + .into_iter() + .filter(|p| made.parts.contains(p)) + .flat_map(|p| origins.get(&(made.local, p)).unwrap_or(&none).iter().copied()) + .collect() + }; + let made: Vec<(&Made, FxHashSet<(Local, usize)>)> = reads.made.iter().map(|m| (m, objects(m))).collect(); + let barrier = |locals: &mut dyn Iterator| -> FxHashSet { + locals + .flat_map(|l| def_blocks.get(&l).into_iter().flatten().copied()) + .collect() + }; + for (i, (m, objects)) in made.iter().enumerate() { + // In a loop that doesn't make what it makes an object of again. + for &(origin, _) in objects { + let defs = barrier(&mut std::iter::once(origin)); + if !defs.contains(&m.block) && self.flows(m.block, m.block, &defs) { + bad.insert(m.local); + } + } + // Twice on a path, of the same parts. + for (n, others) in &made[i + 1..] { + let common: Vec = objects.intersection(others).map(|&(l, _)| l).collect(); + if common.is_empty() { + continue; + } + let defs = barrier(&mut common.into_iter()); + if m.block == n.block || self.flows(m.block, n.block, &defs) || self.flows(n.block, m.block, &defs) { + bad.insert(m.local); + bad.insert(n.local); + } + } + } + bad + } + + /// For each part of `local` that its definition `rvalue` copies from another local held + /// as its parts, which one; `None` for each it makes. + fn def_copies( + &self, + local: Local, + rvalue: &Rvalue<'tcx>, + shapes: &FxHashMap>, + out: &mut Vec, + ) { + let shape = &shapes[&local]; + let from = |op: &Operand<'tcx>| -> Option<(Local, usize)> { + let (Operand::Copy(p) | Operand::Move(p)) = op else { + return None; + }; + let (node, n) = walk(shapes.get(&p.local)?, p.projection); + (n == p.projection.len()).then_some((p.local, node.at)) + }; + let mut parts: Vec> = vec![None; shape.size()]; + let copy = |op: &Operand<'tcx>, at: usize, size: usize, parts: &mut Vec>| { + if let Some((l, start)) = from(op) { + for i in 0..size { + parts[at + i] = Some((l, start + i)); + } + } + }; + match (rvalue, shape) { + (Rvalue::Use(op, _), _) => copy(op, 0, shape.size(), &mut parts), + (Rvalue::CopyForDeref(p), _) => copy(&Operand::Copy(*p), 0, shape.size(), &mut parts), + (Rvalue::Cast(_, op, _), _) => copy(op, 0, 3, &mut parts), + // A reborrow is the same slice; a range of it is another. + (Rvalue::Ref(_, _, p), _) => { + if let Some((base, None)) = self.reborrow(*p) { + copy(&Operand::Copy(base), 0, 3, &mut parts); + } + } + (Rvalue::Aggregate(_, ops), Shape::Tuple(_, fields)) => { + let mut at = 0; + for (op, field) in ops.iter().zip(fields) { + copy(op, at, field.size(), &mut parts); + at += field.size(); + } + } + (Rvalue::Aggregate(kind, ops), Shape::Enum(_, variants)) => { + let AggregateKind::Adt(_, v, ..) = **kind else { + unreachable!("checked by def_ok") + }; + let mut at = shape.variant_at(v.as_usize()); + for (op, field) in ops.iter().zip(variants[v.as_usize()].iter().flatten()) { + copy(op, at, field.size(), &mut parts); + at += field.size(); + } + } + _ => {} + } + out.extend(parts.into_iter().enumerate().map(|(i, p)| (local, i, p))); + } + + /// The part of its argument a producer's `part` copies, if any: `ok_or`'s value, and + /// all `?` branches on but an `Option`'s flag. + fn produced_copy( + &self, + producer: Producer, + part: usize, + arg: &Operand<'tcx>, + shapes: &FxHashMap>, + ) -> Option<(Local, usize)> { + let (Operand::Copy(p) | Operand::Move(p)) = arg else { + return None; + }; + let (node, _) = walk(shapes.get(&p.local)?, p.projection); + match producer { + Producer::SplitFirst | Producer::SplitFirstChunk(_) | Producer::SplitAt { .. } => 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 => { + let option = matches!(node.shape, Shape::Enum(ty, _) if self.b.t.std_of(*ty) == Some(Std::Option)); + (part >= usize::from(option)).then_some((p.local, node.at + part)) + } + } + } + + /// Whether `to` can run after `from` without passing a block of `barrier`. + fn flows(&self, from: BasicBlock, to: BasicBlock, barrier: &FxHashSet) -> bool { + let mut seen = FxHashSet::default(); + let mut stack = self.successors(self.mir.basic_blocks[from].terminator()); + while let Some(bb) = stack.pop() { + if bb == to { + return true; + } + if !seen.insert(bb) || barrier.contains(&bb) || self.mir.basic_blocks[bb].is_cleanup { + continue; + } + stack.extend(self.successors(self.mir.basic_blocks[bb].terminator())); + } + false + } + + /// Whether `local`, which a switch reads alone, holds the discriminant of a local held + /// as its parts, which its flag is. + pub(super) fn scalar_discr(&self, local: Local) -> bool { + matches!(self.def_rvalue(local), Some(Rvalue::Discriminant(p)) if self.scalars.contains_key(&p.local)) + } + + /// Whether `local`'s one assignment reads a part of a local held as its parts that + /// makes an object, so it is no alias: each read would make it again. + pub(super) fn reads_scalar_object(&self, local: Local) -> bool { + let place = match self.def_rvalue(local) { + Some( + Rvalue::Use(Operand::Copy(p) | Operand::Move(p), _) | Rvalue::CopyForDeref(p) | Rvalue::Ref(_, _, p), + ) => *p, + Some(Rvalue::Cast(_, Operand::Copy(p) | Operand::Move(p), _)) => *p, + _ => return false, + }; + let Some(scalar) = self.scalars.get(&place.local) else { + return false; + }; + let (node, n) = walk(&scalar.shape, place.projection); + let rest = &place.projection[n..]; + !matches!( + (node.shape, rest), + (Shape::Unit | Shape::Leaf(_), _) + | ( + Shape::Slice, + [ + ProjectionElem::Deref, + ProjectionElem::Index(_) | ProjectionElem::ConstantIndex { .. }, + .. + ] + ) + ) + } + + /// 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 { + return; + }; + let mut parts = Vec::new(); + scalar.shape.parts("", &mut parts); + let vars = parts + .iter() + .map(|(suffix, _)| self.b.fresh(&format!("{base}{suffix}"))) + .collect(); + self.scalars.get_mut(&local).expect("checked above").vars = vars; + } + + /// The declarations of the variables of the parts of locals held so that statements + /// assign, and of the slices bound to take apart. + pub(super) fn scalar_decls(&mut self, out: &mut Vec) { + let mut locals: Vec = self + .scalars + .iter() + .filter(|(_, s)| s.assigned) + .map(|(l, _)| *l) + .collect(); + locals.sort(); + for local in locals { + let span = self.local_span(local); + let mut parts = Vec::new(); + 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), + }; + out.push(StmtKind::Declare { name, ty }.at(None)); + } + } + for (name, ty) in std::mem::take(&mut self.scalar_binds) { + out.push(StmtKind::Declare { name, ty }.at(None)); + } + } + + // Lowering + + /// Each part of `local` in `parts`, as last assigned, and whether reading it later reads + /// the same. + fn scalar_parts(&mut self, local: Local, parts: std::ops::Range, span: Span) -> Vec<(Expr, bool)> { + 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 => { + let n = parts.len(); + self.err(span, "a local held as its parts read before its assignment"); + vec![(Expr::undefined(), true); n] + } + None => scalar.vars[parts].iter().map(|v| (Expr::ident(v), false)).collect(), + } + } + + /// The value of `place`, a place in a local held as its parts, as far as its parts go: + /// a part's own, or the object they make; and how many of its projections that took. + pub(super) fn scalar_place(&mut self, place: Place<'tcx>, span: Span) -> (Expr, usize) { + let shape = self.scalars[&place.local].shape.clone(); + let (node, n) = walk(&shape, place.projection); + let parts: Vec = self + .scalar_parts(place.local, node.parts(), span) + .into_iter() + .map(|(e, _)| e) + .collect(); + (self.build(node.shape, node.variant, &parts, span), n) + } + + /// The flag of the enum at `place`, in a local held as its parts: whether it is its + /// second variant. + pub(super) fn scalar_flag(&mut self, place: Place<'tcx>, span: Span) -> Expr { + let shape = self.scalars[&place.local].shape.clone(); + let (node, _) = walk(&shape, place.projection); + match node.shape { + Shape::Enum(_, [None, Some(_)]) => Expr::lit("true"), + Shape::Enum(_, [_, None]) => Expr::lit("false"), + _ => self.scalar_parts(place.local, node.at..node.at + 1, span).remove(0).0, + } + } + + /// The object of `shape` its `parts` make, of `variant` if it is an enum known to be one. + fn build(&mut self, shape: &Shape<'tcx>, variant: Option, parts: &[Expr], span: Span) -> Expr { + match shape { + Shape::Unit => Expr::undefined(), + Shape::Leaf(_) => parts[0].clone(), + // The parts of a slice bound whole are that slice. + Shape::Slice => match members(parts) { + Some(slice) => Expr::ident(slice), + None => 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(self.build(field, None, &parts[at..at + field.size()], span)); + at += field.size(); + } + let ts_ty = self.b.t.ty(*ty, span); + Expr::As(Box::new(Expr::Array(items)), ts_ty) + } + Shape::Enum(ty, variants) => { + let ty::Adt(adt, args) = ty.kind() else { + unreachable!("an enum's shape is of an enum") + }; + let known = variant.or(match variants { + [None, Some(_)] => Some(1), + [_, None] => Some(0), + _ => match &parts[0] { + Expr::Lit(t) if t == "true" => Some(1), + Expr::Lit(t) if t == "false" => Some(0), + _ => None, + }, + }); + let make = |fx: &mut Self, v: usize| { + let mut at = shape.variant_at(v); + let mut values = Vec::new(); + for field in variants[v].iter().flatten() { + values.push(fx.build(field, None, &parts[at..at + field.size()], span)); + at += field.size(); + } + fx.adt(adt.did(), VariantIdx::from_usize(v), args, values, *ty, span) + }; + match known { + Some(v) => make(self, v), + None => { + let second = make(self, 1); + let first = make(self, 0); + let ts_ty = self.b.t.ty(*ty, span); + Expr::As( + Box::new(Expr::Cond( + Box::new(parts[0].clone()), + Box::new(second), + Box::new(first), + )), + ts_ty, + ) + } + } + } + } + } + + /// Assign `local`, held as its parts, `rvalue`. + pub(super) fn scalar_assign(&mut self, local: Local, rvalue: &Rvalue<'tcx>, span: Span, out: &mut Vec) { + let shape = self.scalars[&local].shape.clone(); + let parts: Vec> = match rvalue { + Rvalue::Use(op, _) => self + .scalar_operand(op, &shape, span, out) + .into_iter() + .map(Some) + .collect(), + Rvalue::CopyForDeref(p) => self + .scalar_source(*p, &shape, span, out) + .into_iter() + .map(Some) + .collect(), + Rvalue::Cast(_, op, _) => self.slice_parts(op, span, out).into_iter().map(Some).collect(), + Rvalue::Ref(_, _, p) => self.borrowed_parts(*p, span, out).into_iter().map(Some).collect(), + Rvalue::Aggregate(kind, ops) => self.scalar_aggregate(&shape, kind, ops, span, out), + _ => unreachable!("checked by find_scalars"), + }; + self.set_scalar(local, parts, out); + } + + /// Assign `local`, held as its parts, the result of the std call `func`. + pub(super) fn scalar_call( + &mut self, + local: Local, + func: &Operand<'tcx>, + args: &[Spanned>], + span: Span, + out: &mut Vec, + ) { + let shapes: FxHashMap> = self.scalars.iter().map(|(l, s)| (*l, s.shape.clone())).collect(); + let producer = self + .producer(func, args, &shapes[&local], &shapes) + .expect("checked by find_scalars"); + let shape = shapes[&local].clone(); + let pure = |e: Expr, steady: bool| Some((e, steady)); + let parts: Vec> = match producer { + Producer::SplitFirst | Producer::SplitFirstChunk(_) | Producer::SplitAt { .. } => { + let [(d, ds), (s, ss), (n, ns)] = self.slice_parts(&args[0].node, span, out); + let (first, rest) = match producer { + Producer::SplitFirst => (None, Expr::lit("1")), + Producer::SplitFirstChunk(k) => (Some(Expr::lit(k.to_string())), Expr::lit(k.to_string())), + Producer::SplitAt { .. } => { + let mid = self.operand(&args[1].node, span, out); + let (mid, _) = self.steady_value(mid, "mid", Type::Builtin("number"), out); + (Some(mid.clone()), mid) + } + _ => unreachable!(), + }; + let steady = ds && ss && ns; + let tail = vec![ + pure(d.clone(), ds), + pure(add(s.clone(), rest.clone()), ss), + pure(sub(n.clone(), rest.clone()), ns), + ]; + match (producer, first) { + (Producer::SplitFirst, _) => { + let mut parts = vec![ + pure(n.clone().binary("!==", Expr::lit("0")), ns), + pure(d.clone().index(s.clone()), ds && ss), + ]; + parts.extend(tail); + parts + } + (Producer::SplitFirstChunk(_), Some(k)) => { + let mut parts = vec![ + pure(n.clone().binary(">=", k.clone()), ns), + pure(d.clone(), ds), + pure(s.clone(), ss), + pure(k, true), + ]; + parts.extend(tail); + parts + } + (Producer::SplitAt { checked }, Some(mid)) => { + let mut parts = Vec::new(); + match checked { + true => parts.push(pure(mid.clone().binary("<=", n.clone()), ns)), + false => { + let loc = self.b.t.loc(span); + let check = StmtKind::If { + cond: mid.clone().binary(">", n.clone()), + then: vec![ + StmtKind::Expr(Expr::rt("panic", vec![Expr::Str("mid > len".into())])).at(loc), + ], + els: Vec::new(), + } + .at(None); + self.emit(vec![check], None, false, out); + } + } + parts.extend([pure(d.clone(), ds), pure(s.clone(), ss), pure(mid, steady)]); + parts.extend(tail); + parts + } + _ => unreachable!(), + } + } + // The `Option`'s flag, whether it is `Some`, is whether the `Result` is `Ok`; then + // its value, then the error. + Producer::OkOr => { + let Shape::Enum(_, [_, Some(err)]) = &shape else { + unreachable!("ok_or makes a Result") + }; + let mut parts = self.held_arg(&args[0].node, span, out).into_iter(); + let err = self.scalar_operand(&args[1].node, &err[0], span, out); + let (some, steady) = parts.next().expect("an `Option`'s flag"); + let mut parts: Vec> = + std::iter::once((some.not(), steady)).chain(parts).map(Some).collect(); + parts.extend(err.into_iter().map(Some)); + parts + } + // The parts of what it was applied to, whose `Some` continues, where the flag is + // whether it breaks. + Producer::Branch => { + let option = matches!(&args[0].node, Operand::Copy(p) | Operand::Move(p) + if self.b.t.std_of(p.ty(&self.mir.local_decls, self.tcx).ty) == Some(Std::Option)); + let mut parts: Vec> = + self.held_arg(&args[0].node, span, out).into_iter().map(Some).collect(); + if option && let Some(Some((flag, _))) = parts.first_mut() { + *flag = std::mem::replace(flag, Expr::undefined()).not(); + } + parts + } + }; + self.set_scalar(local, parts, out); + } + + /// The parts of `op`, a local held as its parts read whole, as `ok_or` and `?` take it. + fn held_arg(&mut self, op: &Operand<'tcx>, span: Span, out: &mut Vec) -> Vec<(Expr, bool)> { + let (Operand::Copy(p) | Operand::Move(p)) = op else { + unreachable!("checked by find_scalars") + }; + self.scalar_source(*p, &Shape::Unit, span, out) + } + + /// The parts of `op`, a value of `shape`. + fn scalar_operand( + &mut self, + op: &Operand<'tcx>, + shape: &Shape<'tcx>, + span: Span, + out: &mut Vec, + ) -> Vec<(Expr, bool)> { + match op { + Operand::Copy(p) | Operand::Move(p) => self.scalar_source(*p, shape, span, out), + Operand::Constant(c) => { + let value = self.constant(c, span); + self.take_apart(value, shape, span, out) + } + Operand::RuntimeChecks(_) => unreachable!("checked by find_scalars"), + } + } + + /// The parts of the value at `place`, of `shape`: a local's held as its parts, or those + /// its fields hold. + fn scalar_source( + &mut self, + place: Place<'tcx>, + shape: &Shape<'tcx>, + span: Span, + out: &mut Vec, + ) -> Vec<(Expr, bool)> { + if let Some(scalar) = self.scalars.get(&place.local) { + let source = scalar.shape.clone(); + let (node, n) = walk(&source, place.projection); + if n == place.projection.len() { + return self.scalar_parts(place.local, node.parts(), span); + } + } + let value = self.place_expr(place, span, out); + self.take_apart(value, shape, span, out) + } + + /// The parts of `value`, of a `shape` without an enum, read from its fields, each of + /// which reads the same later if it is a slice's: a slice is no object anything + /// changes. + fn take_apart(&mut self, value: Expr, shape: &Shape<'tcx>, span: Span, out: &mut Vec) -> Vec<(Expr, bool)> { + match shape { + Shape::Unit => Vec::new(), + Shape::Leaf(_) => vec![self.leaf(value)], + Shape::Slice => { + let (slice, _) = self.steady_value(value, "slice", Type::Rt("ByteSlice", Vec::new()), out); + ["data", "start", "length"] + .into_iter() + .map(|key| (super::place::slice_member(slice.clone(), key), true)) + .collect() + } + Shape::Tuple(ty, fields) => { + let ts_ty = self.b.t.ty(*ty, span); + let (tuple, _) = self.steady_value(value, "tuple", ts_ty, out); + let mut parts = Vec::new(); + for (i, field) in fields.iter().enumerate() { + let item = tuple.clone().index(Expr::lit(i.to_string())); + // A tuple's element can change, so it is read now. + let item = self.take_apart(item, field, span, out); + parts.extend( + item.into_iter() + .map(|(e, steady)| (e, steady && !matches!(field, Shape::Leaf(_)))), + ); + } + parts + } + Shape::Enum(..) => unreachable!("checked by find_scalars"), + } + } + + /// The parts a slice operand is taken apart into: a slice held as its parts, or one + /// read from a value that reads the same later. + fn slice_parts(&mut self, op: &Operand<'tcx>, span: Span, out: &mut Vec) -> [(Expr, bool); 3] { + let parts = self.scalar_operand(op, &Shape::Slice, span, out); + <[(Expr, bool); 3]>::try_from(parts).expect("a slice's three parts") + } + + /// The parts of the slice a shared borrow of bytes makes: the slice it reborrows, or a + /// range of it, which its place's projection keeps in bounds. + fn borrowed_parts(&mut self, place: Place<'tcx>, span: Span, out: &mut Vec) -> [(Expr, bool); 3] { + let (base, range) = self.reborrow(place).expect("checked by find_scalars"); + let ty = base.ty(&self.mir.local_decls, self.tcx).ty; + let [d, (s, ss), (n, ns)] = self.slice_parts(&Operand::Copy(base), span, out); + let Some(ProjectionElem::Subslice { from, to, from_end }) = range else { + return [d, (s, ss), (n, ns)]; + }; + let start = add(s, Expr::lit(from.to_string())); + let len = match (from_end, ty.peel_refs().kind()) { + (false, _) => Expr::lit((to - from).to_string()), + (true, ty::Array(_, len)) if let Some(len) = len.try_to_target_usize(self.tcx) => { + Expr::lit((len - to - from).to_string()) + } + (true, _) => sub(n, Expr::lit((from + to).to_string())), + }; + [d, (start, ss), (len, ns)] + } + + /// The parts of an aggregate of `shape`: a tuple's operands, or a variant's, with the + /// enum's flag. + fn scalar_aggregate( + &mut self, + shape: &Shape<'tcx>, + kind: &AggregateKind<'tcx>, + ops: &rustc_index::IndexVec>, + span: Span, + out: &mut Vec, + ) -> Vec> { + match (shape, kind) { + (Shape::Tuple(_, fields), _) => { + let mut parts = Vec::new(); + for (op, field) in ops.iter().zip(fields) { + parts.extend(self.scalar_operand(op, field, span, out).into_iter().map(Some)); + } + parts + } + (Shape::Enum(_, variants), AggregateKind::Adt(_, v, ..)) => { + let v = v.as_usize(); + let mut parts = vec![None; shape.size()]; + if shape.flagged() { + parts[0] = Some((Expr::lit((v == 1).to_string()), true)); + } + let mut at = shape.variant_at(v); + for (op, field) in ops.iter().zip(variants[v].iter().flatten()) { + for part in self.scalar_operand(op, field, span, out) { + parts[at] = Some(part); + at += 1; + } + } + parts + } + _ => unreachable!("checked by find_scalars"), + } + } + + /// A value held whole as a part, and whether reading it later reads the same: one + /// held back that does and reads nothing is taken from where it is held, to build + /// only where it is read, as an error `ok_or` makes in place. + fn leaf(&mut self, value: Expr) -> (Expr, bool) { + if let Expr::Ident(name) = &value + && let Some(i) = self.pending.iter().position(|p| p.name == *name) + { + let p = &self.pending[i]; + if !p.effect && !p.memory && !p.copy && self.steady_expr(&p.value) { + return (self.pending.remove(i).value, true); + } + return (value, false); + } + let steady = self.steady_expr(&value); + (value, steady) + } + + /// Whether `e` reads the same wherever it is read later, and does nothing: a constant, + /// a name assigned once and not held back, or what is made of those without reading + /// memory, as a cast, a comparison, or an object literal. + fn steady_expr(&self, e: &Expr) -> bool { + match e { + Expr::Lit(_) | Expr::Str(_) | Expr::Rt(_) => true, + Expr::Ident(name) => { + !self.pending.iter().any(|p| p.name == *name) && (self.steady.contains(name) || self.stable_name(e)) + } + Expr::As(e, _) | Expr::Unary("!", e) => self.steady_expr(e), + Expr::Binary(l, _, r) => self.steady_expr(l) && self.steady_expr(r), + Expr::Object(props) => props.iter().all(|(_, v)| self.steady_expr(v)), + Expr::Array(items) => items.iter().all(|v| self.steady_expr(v)), + _ => false, + } + } + + /// `value`, held where reading it later reads the same: in place if it does, or else + /// in a variable named after `base` of type `ty` assigned it now. + fn steady_value(&mut self, value: Expr, base: &str, ty: Type, out: &mut Vec) -> (Expr, bool) { + let made = + matches!(&value, Expr::New(f, args) if matches!(&**f, Expr::Rt(n) if n == "ByteSlice") && args.len() == 3); + if made || self.steady_expr(&value) { + return (value, true); + } + let name = self.b.fresh(base); + self.steady.insert(name.clone()); + self.scalar_binds.push((name.clone(), ty)); + let stmt = StmtKind::Expr(Expr::ident(&name).assign(value)).at(None); + self.emit(vec![stmt], Some(&name), false, out); + (Expr::ident(name), true) + } + + /// 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 { + let mut held = Vec::with_capacity(parts.len()); + for (part, var) in parts.into_iter().zip(&vars) { + held.push(match part { + Some((value, true)) => value, + Some((value, false)) => { + self.assign_part(local, var, value, out); + self.steady.insert(var.clone()); + Expr::ident(var) + } + None => Expr::undefined(), + }); + } + self.scalars.get_mut(&local).expect("a local held as its parts").held = Some(held); + return; + } + // Each value is read before any variable is assigned, as they all are at once. + let own: FxHashSet<&str> = vars.iter().map(String::as_str).collect(); + let mut values: Vec> = Vec::with_capacity(parts.len()); + for (part, var) in parts.into_iter().zip(&vars) { + let value = part.map(|(value, _)| value); + let value = match value { + Some(Expr::Ident(name)) if name == *var => None, + Some(value) => { + let mut names = Vec::new(); + super::reads_of(&value, &mut names); + match names.iter().any(|n| own.contains(n.as_str())) { + true => { + let name = self.b.fresh("part"); + let stmt = StmtKind::decl(false, name.clone(), None, Some(value)).at(None); + self.emit(vec![stmt], None, false, out); + Some(Expr::ident(name)) + } + false => Some(value), + } + } + None => None, + }; + values.push(value); + } + for (value, var) in values.into_iter().zip(&vars) { + if let Some(value) = value { + self.assign_part(local, var, value, out); + } + } + } + + fn assign_part(&mut self, local: Local, var: &str, value: Expr, out: &mut Vec) { + self.scalars + .get_mut(&local) + .expect("a local held as its parts") + .assigned = true; + let stmt = StmtKind::Expr(Expr::ident(var).assign(value)).at(None); + self.emit(vec![stmt], Some(var), false, out); + } +} + +/// `e + k`, with literal offsets summed. +pub(super) fn add(e: Expr, k: Expr) -> Expr { + let lit = |e: &Expr| match e { + Expr::Lit(t) => t.parse::().ok(), + _ => None, + }; + match (e, lit(&k)) { + (e, Some(0)) => e, + (Expr::Binary(base, "+", a), Some(b)) if let Some(a) = lit(&a) => { + Expr::Binary(base, "+", Box::new(Expr::lit((a + b).to_string()))) + } + (e, _) => e.binary("+", k), + } +} + +/// `e - k`, a literal `k` folded into one `e` already subtracts. +pub(super) fn sub(e: Expr, k: Expr) -> Expr { + let lit = |e: &Expr| match e { + Expr::Lit(t) => t.parse::().ok(), + _ => None, + }; + match (e, lit(&k)) { + (e, Some(0)) => e, + (Expr::Binary(base, "-", a), Some(b)) if let Some(a) = lit(&a) => { + Expr::Binary(base, "-", Box::new(Expr::lit((a + b).to_string()))) + } + (e, _) => e.binary("-", k), + } +} + +/// The name of the slice whose `data`, `start`, and `length` `parts` read, in order. +fn members(parts: &[Expr]) -> Option<&str> { + let mut name = None; + for (part, key) in parts.iter().zip(["data", "start", "length"]) { + let Expr::Member(base, Key::Name(k)) = part else { + return None; + }; + let Expr::Ident(base) = &**base else { + return None; + }; + if k != key || name.is_some_and(|n| n != base) { + return None; + } + name = Some(base.as_str()); + } + name +} diff --git a/ts/tests/fixtures.rs b/ts/tests/fixtures.rs index d30e57711..3f4473d6e 100644 --- a/ts/tests/fixtures.rs +++ b/ts/tests/fixtures.rs @@ -256,7 +256,6 @@ fn shake(out: &Path) { "Ok", "Panic", "byteSliceFrom", - "byteSliceSplitAtChecked", "checked", "clamp", "idx", From a31650f6b01b2a74af1dfec4db5e4850a90d1728 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Tue, 27 Oct 2026 15:11:12 -0700 Subject: [PATCH 3/5] fix(ts): test only a held enum's own discriminant by its flag A discriminant of an enum a part holds whole, such as an error, read the part itself as a flag. And ok_or's error with an enum in it reached an unreachable take-apart; that ok_or now stays an object. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HRfpGSuhrqBv8bAxEvpXi3 --- ts/fixtures/lang/src/splits.rs | 21 +++++++ ts/rustc-ice-2026-10-27T22_10_28-1632761.txt | 65 ++++++++++++++++++++ ts/src/lower/mir/rvalue.rs | 2 +- ts/src/lower/mir/scalar.rs | 32 +++++++++- 4 files changed, 117 insertions(+), 3 deletions(-) create mode 100644 ts/rustc-ice-2026-10-27T22_10_28-1632761.txt diff --git a/ts/fixtures/lang/src/splits.rs b/ts/fixtures/lang/src/splits.rs index bd5f6889d..8ea337d68 100644 --- a/ts/fixtures/lang/src/splits.rs +++ b/ts/fixtures/lang/src/splits.rs @@ -27,6 +27,12 @@ fn take(data: &[u8], n: usize) -> Result<(&[u8], &[u8]), Short> { data.split_at_checked(n).ok_or(Short::Need(n)) } +/// The byte after the first, or an error that is itself an enum, held whole. +fn second(data: &[u8], e: Option) -> Result> { + let (_, rest) = data.split_at_checked(1).ok_or(e)?; + Ok(rest.first().copied().unwrap_or(0)) +} + /// A use that needs the slice itself. #[inline(never)] fn opaque(s: &[u8]) -> u8 { @@ -129,6 +135,21 @@ pub fn splits(kind: u8, data: &[u8], out: &mut Vec) { } Err(n) => out.push(n), } + // An error enum held whole, matched by its own variants. + let err = match data.len() % 2 { + 0 => Short::Empty, + _ => Short::Need(data.len()), + }; + match data.split_first().ok_or(err) { + Ok((&b, _)) => out.push(b), + Err(Short::Empty) => out.push(0xe0), + Err(Short::Need(n)) => out.push(0xe1 ^ n as u8), + } + match second(data, data.first().copied()) { + Ok(b) => out.push(b), + Err(Some(b)) => out.push(b ^ 0x55), + Err(None) => out.push(0xaa), + } let found: Result<(&[u8], &[u8]), u8> = data.split_at_checked(2).ok_or(1); if let Ok((front, back)) = found { out.push(front[1] ^ back.len() as u8); diff --git a/ts/rustc-ice-2026-10-27T22_10_28-1632761.txt b/ts/rustc-ice-2026-10-27T22_10_28-1632761.txt new file mode 100644 index 000000000..9785cad6d --- /dev/null +++ b/ts/rustc-ice-2026-10-27T22_10_28-1632761.txt @@ -0,0 +1,65 @@ +thread 'rustc' panicked at src/lower/mir/scalar.rs:1205:32: +internal error: entered unreachable code: checked by find_scalars +stack backtrace: + 0: 0x7d3225c28975 - ::create + 1: 0x7d3225c288c5 - ::force_capture + 2: 0x7d32249df9ea - std[76053f7ab5f7f410]::panicking::update_hook::>::{closure#0} + 3: 0x7d3225c3ea82 - std[76053f7ab5f7f410]::panicking::panic_with_hook + 4: 0x7d3225c1c264 - std[76053f7ab5f7f410]::panicking::panic_handler::{closure#0} + 5: 0x7d3225c128d9 - std[76053f7ab5f7f410]::sys::backtrace::__rust_end_short_backtrace:: + 6: 0x7d3225c1df5d - __rustc[f82961561223361d]::rust_begin_unwind + 7: 0x7d3221a4d1ec - core[68f4be281c81bf45]::panicking::panic_fmt + 8: 0x595d60df85b8 - ::take_apart + at /home/kixelated/work/rust2/.claude/worktrees/ts-byte-views-locals/ts/src/lower/mir/scalar.rs:1205:23 + 9: 0x595d60dff676 - ::scalar_source + at /home/kixelated/work/rust2/.claude/worktrees/ts-byte-views-locals/ts/src/lower/mir/scalar.rs:1173:8 + 10: 0x595d60e00390 - ::scalar_operand + at /home/kixelated/work/rust2/.claude/worktrees/ts-byte-views-locals/ts/src/lower/mir/scalar.rs:1147:48 + 11: 0x595d60dfbc6a - ::scalar_call + at /home/kixelated/work/rust2/.claude/worktrees/ts-byte-views-locals/ts/src/lower/mir/scalar.rs:1107:20 + 12: 0x595d60dc61b7 - ::call + at /home/kixelated/work/rust2/.claude/worktrees/ts-byte-views-locals/ts/src/lower/mir/call.rs:34:9 + 13: 0x595d60da53e1 - ::terminator + at /home/kixelated/work/rust2/.claude/worktrees/ts-byte-views-locals/ts/src/lower/mir/mod.rs:2340:10 + 14: 0x595d60db0929 - ::block + at /home/kixelated/work/rust2/.claude/worktrees/ts-byte-views-locals/ts/src/lower/mir/mod.rs:2070:8 + 15: 0x595d60e151ff - ::node + at /home/kixelated/work/rust2/.claude/worktrees/ts-byte-views-locals/ts/src/lower/mir/mod.rs:2637:8 + 16: 0x595d60ffe6fe - >::within + at /home/kixelated/work/rust2/.claude/worktrees/ts-byte-views-locals/ts/src/lower/mir/cfg.rs:314:20 + 17: 0x595d60ffda05 - >::tree + at /home/kixelated/work/rust2/.claude/worktrees/ts-byte-views-locals/ts/src/lower/mir/cfg.rs:266:18 + 18: 0x595d60ffe656 - >::branch + at /home/kixelated/work/rust2/.claude/worktrees/ts-byte-views-locals/ts/src/lower/mir/cfg.rs:341:9 + 19: 0x595d60ffe7e5 - >::within + at /home/kixelated/work/rust2/.claude/worktrees/ts-byte-views-locals/ts/src/lower/mir/cfg.rs:315:31 + 20: 0x595d60ffda05 - >::tree + at /home/kixelated/work/rust2/.claude/worktrees/ts-byte-views-locals/ts/src/lower/mir/cfg.rs:266:18 + 21: 0x595d60fd744e - rust2_ts[b900de6eacbf0c1]::lower::mir::cfg::structure:: + at /home/kixelated/work/rust2/.claude/worktrees/ts-byte-views-locals/ts/src/lower/mir/cfg.rs:224:6 + 22: 0x595d60db14fa - ::lower + at /home/kixelated/work/rust2/.claude/worktrees/ts-byte-views-locals/ts/src/lower/mir/mod.rs:1387:14 + 23: 0x595d60e12f34 - rust2_ts[b900de6eacbf0c1]::lower::mir::function + at /home/kixelated/work/rust2/.claude/worktrees/ts-byte-views-locals/ts/src/lower/mir/mod.rs:53:16 + 24: 0x595d6113f83e - ::function + at /home/kixelated/work/rust2/.claude/worktrees/ts-byte-views-locals/ts/src/lower/mod.rs:1197:28 + 25: 0x595d61135908 - ::drain + at /home/kixelated/work/rust2/.claude/worktrees/ts-byte-views-locals/ts/src/lower/mod.rs:256:10 + 26: 0x595d6116640c - rust2_ts[b900de6eacbf0c1]::lower::translate + at /home/kixelated/work/rust2/.claude/worktrees/ts-byte-views-locals/ts/src/lower/mod.rs:44:4 + 27: 0x595d610bd0df - ::after_expansion + at /home/kixelated/work/rust2/.claude/worktrees/ts-byte-views-locals/ts/src/driver.rs:80:30 + 28: 0x7d32275067e6 - rustc_interface[428b96e9abb7cc47]::interface::run_compiler::<(), rustc_driver_impl[ab3368f39572c260]::compiler_entrypoint::{closure#0}>::{closure#2} + 29: 0x7d3227530764 - std[76053f7ab5f7f410]::sys::backtrace::__rust_begin_short_backtrace::::{closure#2}, ()>::{closure#0}, ()>::{closure#0}::{closure#0}, ()> + 30: 0x7d32275304ff - ::{closure#2}, ()>::{closure#0}, ()>::{closure#0}::{closure#0}, ()>::{closure#1} as core[68f4be281c81bf45]::ops::function::FnOnce<()>>::call_once::{shim:vtable#0} + 31: 0x7d322752d81b - ::new::thread_start + 32: 0x7d322049f751 - start_thread + 33: 0x7d322052ba4c - __clone3 + 34: 0x0 - + + +rustc version: 1.101.0-nightly (7df81381d 2026-10-14) +platform: x86_64-unknown-linux-gnu + +query stack during panic: +end of query stack diff --git a/ts/src/lower/mir/rvalue.rs b/ts/src/lower/mir/rvalue.rs index f4d0d86ac..7f6204688 100644 --- a/ts/src/lower/mir/rvalue.rs +++ b/ts/src/lower/mir/rvalue.rs @@ -107,7 +107,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } } // A local held as its parts has its flag. - Rvalue::Discriminant(place) if self.scalars.contains_key(&place.local) => { + Rvalue::Discriminant(place) if self.scalar_enum(*place) => { let flag = self.scalar_flag(*place, span); let pty = place.ty(&self.mir.local_decls, tcx).ty; let int = Int::of(pty.discriminant_ty(tcx)).expect("an enum's discriminant is an integer"); diff --git a/ts/src/lower/mir/scalar.rs b/ts/src/lower/mir/scalar.rs index 7e532a0c7..a5cf5cf18 100644 --- a/ts/src/lower/mir/scalar.rs +++ b/ts/src/lower/mir/scalar.rs @@ -353,7 +353,9 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { } ("slice", "split_at") if bytes() => Some(Producer::SplitAt { checked: false }), ("slice", "split_at_checked") if bytes() => Some(Producer::SplitAt { checked: true }), - ("Option", "ok_or") if held(&args[0].node) => Some(Producer::OkOr), + ("Option", "ok_or") if held(&args[0].node) && self.ok_or_error(&args[1].node, shape, shapes) => { + Some(Producer::OkOr) + } ("Try", "branch") if held(&args[0].node) && gargs @@ -403,6 +405,23 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { } } + /// Whether `ok_or`'s error `op` can be the `Err` part of `shape`: a local held as its + /// parts, or a value with no enum in it to take apart. + fn ok_or_error(&self, op: &Operand<'tcx>, shape: &Shape<'tcx>, shapes: &FxHashMap>) -> bool { + let Shape::Enum(_, [_, Some(err)]) = shape else { + return false; + }; + let [err] = err.as_slice() else { + return false; + }; + match op { + Operand::Copy(p) | Operand::Move(p) if let Some(source) = shapes.get(&p.local) => { + walk(source, p.projection).1 == p.projection.len() || !err.has_enum() + } + _ => !err.has_enum(), + } + } + /// Whether `rvalue` gives parts that are not those of one object: a variant, whose /// flag stands for one, a subslice, or a copy of a local held as its parts, alone or /// in a tuple. A tuple of objects alone already folds into its reads. @@ -818,7 +837,16 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { /// Whether `local`, which a switch reads alone, holds the discriminant of a local held /// as its parts, which its flag is. pub(super) fn scalar_discr(&self, local: Local) -> bool { - matches!(self.def_rvalue(local), Some(Rvalue::Discriminant(p)) if self.scalars.contains_key(&p.local)) + matches!(self.def_rvalue(local), Some(Rvalue::Discriminant(p)) if self.scalar_enum(*p)) + } + + /// Whether `place` is an enum held as its parts, whose flag is its discriminant, rather + /// than one a part holds whole, such as an error. + pub(super) fn scalar_enum(&self, place: Place<'tcx>) -> bool { + self.scalars.get(&place.local).is_some_and(|scalar| { + let (node, n) = walk(&scalar.shape, place.projection); + n == place.projection.len() && matches!(node.shape, Shape::Enum(..)) + }) } /// Whether `local`'s one assignment reads a part of a local held as its parts that From d189ea3bfdf78a12eca07617ebd4b3dee128bc22 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Tue, 27 Oct 2026 16:07:14 -0700 Subject: [PATCH 4/5] fix(ts): send the named duration cases to durations' new opcode Adding splits at opcode 47 moved durations to 48, so its targeted overflow, carry, and precision inputs exercised splits instead. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HRfpGSuhrqBv8bAxEvpXi3 --- ts/fixtures/lang/caller.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ts/fixtures/lang/caller.ts b/ts/fixtures/lang/caller.ts index 48ff8bae3..ffa5aebd3 100644 --- a/ts/fixtures/lang/caller.ts +++ b/ts/fixtures/lang/caller.ts @@ -44,9 +44,9 @@ const edges = [0n, 1n, (1n << 53n) - 1n, 1n << 53n, (1n << 64n) - 1n].flatMap((s const factors = [0, 1, 3, 1000, 9_007_199, 1_000_000_000, 0xffffffff].map((n) => [n >>> 24, (n >>> 16) & 0xff, (n >>> 8) & 0xff, n & 0xff]); const durations = [ ...[0n, 1n, 1n << 32n, (1n << 53n) - 1n, 1n << 53n, (1n << 64n) - 2n, (1n << 64n) - 1n].flatMap((secs) => - [0, 1, 999_999_999, 1_000_000_000, 0xffffffff].flatMap((nanos) => [0, 1].map((kind) => Uint8Array.of(47, kind, ...duration(secs, nanos)))), + [0, 1, 999_999_999, 1_000_000_000, 0xffffffff].flatMap((nanos) => [0, 1].map((kind) => Uint8Array.of(48, kind, ...duration(secs, nanos)))), ), - ...edges.flatMap((a) => edges.flatMap((b) => factors.flatMap((n) => [2, 3, 4, 5, 6, 7, 8, 9].map((kind) => Uint8Array.of(47, kind, ...a, ...b, ...n))))), + ...edges.flatMap((a) => edges.flatMap((b) => factors.flatMap((n) => [2, 3, 4, 5, 6, 7, 8, 9].map((kind) => Uint8Array.of(48, kind, ...a, ...b, ...n))))), ]; export const cases: Uint8Array[] = [...loops, ...durations]; From 0639ccc3e039e85a2798954f12b61faeacaa755e Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Tue, 27 Oct 2026 16:32:01 -0700 Subject: [PATCH 5/5] style(ts): wrap the lang harness's imports Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HRfpGSuhrqBv8bAxEvpXi3 --- ts/fixtures/lang/src/harness.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/ts/fixtures/lang/src/harness.rs b/ts/fixtures/lang/src/harness.rs index 15854b3ca..8068a6e0d 100644 --- a/ts/fixtures/lang/src/harness.rs +++ b/ts/fixtures/lang/src/harness.rs @@ -1,7 +1,9 @@ //! The entry point both sides of the differential test run. The first byte picks a //! case and the rest is its input. -use crate::{chars, chunks, collections, combinators, cows, durations, fmt, generics, ints, iters, keys, shapes, splits, strs}; +use crate::{ + chars, chunks, collections, combinators, cows, durations, fmt, generics, ints, iters, keys, shapes, splits, strs, +}; /// The native side's entry: [`run`], except that a case starting with 0xff prints a /// [`fmt::Fault`], which the translated side prints from TypeScript in `caller.ts`.