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 d326c29aa..eab9740c7 100644 --- a/ts/README.md +++ b/ts/README.md @@ -365,8 +365,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 6d3d28124..5fedab81f 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -17,36 +17,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 efe7fe5c2..1dd9b473e 100644 --- a/ts/fixtures/codec/expected/coding/decode.Decoder.ts +++ b/ts/fixtures/codec/expected/coding/decode.Decoder.ts @@ -62,10 +62,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 af943c1eb..7ff15c5d0 100644 --- a/ts/fixtures/codec/expected/coding/varint.ts +++ b/ts/fixtures/codec/expected/coding/varint.ts @@ -4,7 +4,6 @@ import * as rt from "../rt.ts"; import type * as DecodeError from "../coding/decode.DecodeError.ts"; import type * as BoundsExceeded from "../coding/varint.BoundsExceeded.ts"; import type * as Form from "../coding/varint.Form.ts"; -import { okOr$Option_u8s_u8s_DecodeError } from "../core/option.ts"; /** The high and low 32 bits: the only place the codec splits a `u64`. */ export function toHalves(value: rt.u64): [rt.u32, rt.u32] { @@ -200,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> = okOr$Option_u8s_u8s_DecodeError(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> = okOr$Option_u8s_u8s_DecodeError(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> = okOr$Option_u8s_u8s_DecodeError(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> = okOr$Option_u8s_u8s_DecodeError(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> = okOr$Option_u8s_u8s_DecodeError(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> = okOr$Option_u8s_u8s_DecodeError(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> = okOr$Option_u8s_u8s_DecodeError(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> = okOr$Option_u8s_u8s_DecodeError(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> = okOr$Option_u8s_u8s_DecodeError(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> = okOr$Option_u8s_u8s_DecodeError(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> = okOr$Option_u8s_u8s_DecodeError(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/core/option.ts b/ts/fixtures/codec/expected/core/option.ts index d142187ab..72e9b323f 100644 --- a/ts/fixtures/codec/expected/core/option.ts +++ b/ts/fixtures/codec/expected/core/option.ts @@ -1,7 +1,6 @@ // Generated by rust2-ts. Do not edit. import * as rt from "../rt.ts"; -import type * as DecodeError from "../coding/decode.DecodeError.ts"; import type * as EncodeError from "../coding/encode.EncodeError.ts"; export function unwrapOr$Option_u32(self: rt.u32 | undefined, default_: rt.u32): rt.u32 { @@ -32,11 +31,4 @@ export function okOr$Option_u64_EncodeError(self: rt.u64 | undefined, err: Encod return rt.Ok(self); } -export function okOr$Option_u8s_u8s_DecodeError(self: [rt.ByteSlice, rt.ByteSlice] | undefined, err: DecodeError.DecodeError): rt.Result<[rt.ByteSlice, rt.ByteSlice], DecodeError.DecodeError> { - if (self === undefined) { - return rt.Err(err); - } - return rt.Ok(self); -} - //# sourceMappingURL=option.ts.map diff --git a/ts/fixtures/codec/expected/harness.ts b/ts/fixtures/codec/expected/harness.ts index 515884669..65ef06ba3 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 6b066dd30..4b2eeff47 100644 --- a/ts/fixtures/lang/expected/chunks.ts +++ b/ts/fixtures/lang/expected/chunks.ts @@ -5,16 +5,14 @@ import type * as Header from "./chunks.Header.ts"; import { mapOr$Option_u8s_u8s_u8s_chunks_closure0, okOr$Option_u8s_u8s_u8 } from "./core/option.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 okOr$Option_u8s_u8s_u8(rt.byteSliceSplitFirstChunk(data, 4), data.length & 0xff); + return okOr$Option_u8s_u8s_u8((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 { @@ -45,9 +43,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 { @@ -100,20 +96,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 = mapOr$Option_u8s_u8s_u8s_chunks_closure0(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 = mapOr$Option_u8s_u8s_u8s_chunks_closure0((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); } @@ -121,7 +116,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)); @@ -139,9 +134,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]]))); } @@ -183,20 +177,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/core/option.ts b/ts/fixtures/lang/expected/core/option.ts index ade8f2bba..b1e3cfd29 100644 --- a/ts/fixtures/lang/expected/core/option.ts +++ b/ts/fixtures/lang/expected/core/option.ts @@ -1,6 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rt from "../rt.ts"; +import { copy$u8s_u8s } from "../lib.ts"; import type * as Nibble from "../collections.Nibble.ts"; import type * as Rank from "../collections.Rank.ts"; import type * as Tally from "../collections.Tally.ts"; @@ -13,6 +14,7 @@ import type * as Dir from "../shapes.Dir.ts"; import type * as Meters from "../shapes.Meters.ts"; import type * as Point from "../shapes.Point.ts"; import type * as Shape from "../shapes.Shape.ts"; +import type * as Short from "../splits.Short.ts"; export function isSomeAnd$Option_u8_options_closure0(self: rt.u8 | undefined, f: (a0: rt.u8) => boolean): boolean { if (self === undefined) { @@ -322,6 +324,13 @@ export function mapOr$Option_u8_usize_shares_closure1(self: rt.u8 | undefined, d return f(self); } +export function mapOr$Option_u8s_u8s_u8_splits_closure0(self: [rt.ByteSlice, rt.ByteSlice] | undefined, default_: rt.u8, f: (a0: [rt.ByteSlice, rt.ByteSlice]) => rt.u8): rt.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + export function mapOr$Option_u8s_u8s_u8s_chunks_closure0(self: [rt.ByteSlice, rt.ByteSlice] | undefined, default_: rt.ByteSlice, f: (a0: [rt.ByteSlice, rt.ByteSlice]) => rt.ByteSlice): rt.ByteSlice { if (self === undefined) { return default_; @@ -385,6 +394,20 @@ export function okOr$Option_u8_u8(self: rt.u8 | undefined, err: rt.u8): rt.Resul return rt.Ok(self); } +export function okOr$Option_u8s_u8s_Option_u8(self: [rt.ByteSlice, rt.ByteSlice] | undefined, err: rt.u8 | undefined): rt.Result<[rt.ByteSlice, rt.ByteSlice], rt.u8 | undefined> { + if (self === undefined) { + return rt.Err(err); + } + return rt.Ok(self); +} + +export function okOr$Option_u8s_u8s_Short(self: [rt.ByteSlice, rt.ByteSlice] | undefined, err: Short.Short): rt.Result<[rt.ByteSlice, rt.ByteSlice], Short.Short> { + if (self === undefined) { + return rt.Err(err); + } + return rt.Ok(copy$u8s_u8s(self)); +} + export function okOr$Option_u8s_u8s_u8(self: [rt.ByteSlice, rt.ByteSlice] | undefined, err: rt.u8): rt.Result<[rt.ByteSlice, rt.ByteSlice], rt.u8> { if (self === undefined) { return rt.Err(err); diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 1cff013ca..832a9c971 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -14,6 +14,7 @@ import { adaptors, consumers, ranges, options, own, values } from "./iters.ts"; import { keys } from "./keys.ts"; import { refs } from "./refs.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. */ @@ -25,125 +26,126 @@ 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, 50); + const _14: rt.u8 = rt.u8Rem(op, 51); 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) { - cows(kind, rt.byteSliceRange(input, 2), out); + cows(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 47) { - durations(kind, rt.byteSliceRange(input, 2), out); + durations(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (_14 === 48) { - combinators(kind, rt.byteSliceRange(input, 2), out); + combinators(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + } else if (_14 === 49) { + splits(kind, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else { - refs(rt.byteSliceRange(input, 2), out); + refs(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 014f3bc5d..9f69940f2 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -52,11 +52,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/lib.ts b/ts/fixtures/lang/expected/lib.ts index d5e2a3d7d..b1670cb20 100644 --- a/ts/fixtures/lang/expected/lib.ts +++ b/ts/fixtures/lang/expected/lib.ts @@ -118,6 +118,10 @@ export function copy$Result_u32s_u16(v: rt.Result): rt.Result< return v.ok ? rt.Ok(copy$u32s(v.value)) : rt.Err(v.error); } +export function copy$Result_u8s_u8s_Option_u8(v: rt.Result<[rt.ByteSlice, rt.ByteSlice], rt.u8 | undefined>): rt.Result<[rt.ByteSlice, rt.ByteSlice], rt.u8 | undefined> { + return v.ok ? rt.Ok(copy$u8s_u8s(v.value)) : rt.Err(v.error); +} + export function copy$Shape(v: Shape.Shape): Shape.Shape { if (v.tag === "Line") { return { tag: "Line", _0: copy$Point(v._0), _1: copy$Point(v._1) }; @@ -184,4 +188,8 @@ export function copy$u8s(v: Uint8Array): Uint8Array { return v.slice(); } +export function copy$u8s_u8s(v: [rt.ByteSlice, rt.ByteSlice]): [rt.ByteSlice, rt.ByteSlice] { + return [v[0], v[1]]; +} + //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/expected/shapes.ts b/ts/fixtures/lang/expected/shapes.ts index b1e5ea86a..4e9f1cb1e 100644 --- a/ts/fixtures/lang/expected/shapes.ts +++ b/ts/fixtures/lang/expected/shapes.ts @@ -75,11 +75,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(unwrapOr$Option_u8(rt.byteSliceGet(_4[1], i), 0) as rt.i32, 128); + return rt.i32Sub(unwrapOr$Option_u8(rt.byteSliceGet(rest, i), 0) as rt.i32, 128); }; const _7: rt.u8 = rt.u8Rem(kind, 3); if (_7 === 0) { @@ -88,7 +88,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(unwrapOr$Option_u8(rt.byteSliceGet(_4[1], 2), 0) as rt.u16, 300), height: unwrapOr$Option_u8(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(unwrapOr$Option_u8(rt.byteSliceGet(rest, 2), 0) as rt.u16, 300), height: unwrapOr$Option_u8(rt.byteSliceGet(rest, 3), 0) as rt.u16 } as Shape.Shape; } return { tag: "Dot" } as Shape.Shape; } @@ -634,8 +634,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]; @@ -1266,7 +1269,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..8f52357aa --- /dev/null +++ b/ts/fixtures/lang/expected/splits.ts @@ -0,0 +1,232 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import { copy$Result_u8s_u8s_Option_u8 } from "./lib.ts"; +import { unwrapOr$Option_u8, mapOr$Option_u8s_u8s_u8_splits_closure0, okOr$Option_u8s_u8s_Option_u8, okOr$Option_u8s_u8s_Short } from "./core/option.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 okOr$Option_u8s_u8s_Short((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); +} + +/** The byte after the first, or an error that is itself an enum, held whole. */ +export function second(data: rt.ByteSlice, e: rt.u8 | undefined): rt.Result { + const _4: rt.Result<[rt.ByteSlice, rt.ByteSlice], rt.u8 | undefined> = copy$Result_u8s_u8s_Option_u8(okOr$Option_u8s_u8s_Option_u8((1 <= data.length ? [new rt.ByteSlice(data.data, data.start, 1), new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.ByteSlice, rt.ByteSlice] : undefined) as [rt.ByteSlice, rt.ByteSlice] | undefined, e)); + if (_4.ok) { + return rt.Ok(unwrapOr$Option_u8(rt.byteSliceFirst(_4.value[1]), 0)); + } + return _4; +} + +/** 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; + let err!: Short.Short; + 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(unwrapOr$Option_u8(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 _194Len: number = pair_1Len; + if (0 >= _194Len) { + rt.panic("index out of bounds: the len is " + _194Len + " 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); + b5: { + if (split !== undefined) { + const _197: rt.ByteSlice = split[0]; + if ((_197.data[_197.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 b5; + } + } + rt.byteVecPush(out, mapOr$Option_u8s_u8s_u8_splits_closure0(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 (rt.usizeRem(data.length, 2) === 0) { + err = { tag: "Empty" } as Short.Short; + } else { + err = { tag: "Need", _0: data.length } as Short.Short; + } + const _1602: Short.Short = err; + if (data.length !== 0) { + rt.byteVecPush(out, data.data[data.start]); + } else if (_1602.tag === "Empty") { + rt.byteVecPush(out, 224); + } else { + rt.byteVecPush(out, 225 ^ (_1602._0 & 0xff)); + } + const _170: rt.Result = second(data, rt.byteSliceFirst(data)); + if (_170.ok) { + rt.byteVecPush(out, _170.value); + } else if (_170.error === undefined) { + rt.byteVecPush(out, 170); + } else { + rt.byteVecPush(out, _170.error ^ 85); + } + 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 4f102eb36..4e8dd0de3 100644 --- a/ts/fixtures/lang/src/harness.rs +++ b/ts/fixtures/lang/src/harness.rs @@ -2,7 +2,8 @@ //! case and the rest is its input. use crate::{ - chars, chunks, collections, combinators, cows, durations, fmt, generics, ints, iters, keys, refs, shapes, strs, + chars, chunks, collections, combinators, cows, durations, fmt, generics, ints, iters, keys, refs, shapes, splits, + strs, }; /// The native side's entry: [`run`], except that a case starting with 0xff prints a @@ -21,7 +22,7 @@ pub fn run(input: &[u8]) -> Vec { return out; }; let (op, kind) = (*op, *kind); - match op % 50 { + match op % 51 { 0 => ints::u8_op(kind, data, &mut out), 1 => ints::u16_op(kind, data, &mut out), 2 => ints::u32_op(kind, data, &mut out), @@ -81,6 +82,7 @@ pub fn run(input: &[u8]) -> Vec { 46 => cows::cows(kind, data, &mut out), 47 => durations::durations(kind, data, &mut out), 48 => combinators::combinators(kind, data, &mut out), + 49 => splits::splits(kind, data, &mut out), _ => refs::refs(data, &mut out), } out diff --git a/ts/fixtures/lang/src/lib.rs b/ts/fixtures/lang/src/lib.rs index 55902cdab..25671b6a0 100644 --- a/ts/fixtures/lang/src/lib.rs +++ b/ts/fixtures/lang/src/lib.rs @@ -1,8 +1,9 @@ //! 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`, -//! `Duration`, control flow, patterns, `Copy` aggregates, closures, traits, generic types, -//! formatting, collections, `&mut` to values JS copies, the standard library calls it -//! maps, and `Option`'s and `Result`'s combinators from core's MIR. +//! `Duration`, control flow, patterns, byte slices split apart, `Copy` aggregates, +//! closures, traits, generic types, formatting, collections, `&mut` to values JS +//! copies, the standard library calls it maps, and `Option`'s and `Result`'s +//! combinators from core's MIR. //! //! `harness::run` is the entry point both sides of the differential test run, and //! `fmt::Fault` an error only `caller.ts` prints. @@ -21,6 +22,7 @@ mod iters; mod keys; mod refs; 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..8ea337d68 --- /dev/null +++ b/ts/fixtures/lang/src/splits.rs @@ -0,0 +1,159 @@ +//! 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)) +} + +/// 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 { + 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), + } + // 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/library.rs b/ts/src/lower/library.rs index 3ed9457c5..821154355 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -750,8 +750,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 4d5d3ebc2..5b00ecc0d 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 e3ad8ab2b..d081af9ae 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -18,6 +18,7 @@ pub mod glue; mod inline; mod place; mod rvalue; +mod scalar; mod step; mod unwind; mod vec; @@ -29,6 +30,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; @@ -158,6 +160,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. @@ -286,6 +291,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)>, /// The tests and payload reads TypeScript may have narrowed stale. narrowing: decided::Narrowing<'tcx>, /// The statement or terminator being lowered. @@ -347,6 +359,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(), narrowing: decided::narrowing(tcx, mir), at: mir::START_BLOCK.start_location(), }; @@ -510,14 +525,19 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { self.find_stepped(); self.unborrow_passed(); self.find_halves(); + 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 { @@ -564,6 +584,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, _) => { @@ -575,7 +596,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); @@ -1420,6 +1443,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 { @@ -2044,7 +2068,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"), } } @@ -2120,6 +2144,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 { @@ -2169,6 +2197,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; + } _ => {} } } @@ -2260,6 +2296,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 @@ -2440,6 +2478,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(); @@ -2520,6 +2573,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; @@ -2915,6 +2988,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 20f7010bc..2ce916c83 100644 --- a/ts/src/lower/mir/place.rs +++ b/ts/src/lower/mir/place.rs @@ -46,13 +46,22 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } 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, n, 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(); @@ -63,7 +72,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)) { @@ -140,10 +149,27 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { _ => unreachable!("a checked pair is a tuple"), }); } + let from = place.projection.len() - projection.len(); + self.project(e, pty, place, from, span, out) + } + + /// `e`, the value of `place` projected as far as `from`, a `pty`, projected the rest of + /// the way. + fn project( + &mut self, + mut e: Expr, + mut pty: PlaceTy<'tcx>, + place: Place<'tcx>, + from: usize, + span: Span, + out: &mut Vec, + ) -> Expr { + let tcx = self.tcx; + let decls = &self.mir.local_decls; // 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; - while let Some(elem) = projection.next() { + for (read, elem) in place.projection.iter().enumerate().skip(from) { let ty = pty.ty; in_bytes = in_bytes || byte_slice(ty); match elem { @@ -167,7 +193,6 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { e = self.field(e, ty, pty.variant_index, field, span); } ProjectionElem::Downcast(_, variant) => { - let read = place.projection.len() - projection.len() - 1; let base = Place { local: place.local, projection: tcx.mk_place_elems(&place.projection[..read]), @@ -199,7 +224,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), @@ -213,11 +238,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 => { @@ -227,8 +259,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() { @@ -1038,8 +1083,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)) @@ -1095,11 +1145,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 f8526f23f..b279b002b 100644 --- a/ts/src/lower/mir/rvalue.rs +++ b/ts/src/lower/mir/rvalue.rs @@ -106,11 +106,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.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"); + 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..8277b4032 --- /dev/null +++ b/ts/src/lower/mir/scalar.rs @@ -0,0 +1,1456 @@ +//! 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) && self.ok_or_error(&args[1].node, shape, shapes) => { + 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 `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. + 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.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.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 + /// 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 04a6bff75..e535faa9e 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",